From 8522061e956f0e535f62980020480ec56bed781e Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 24 Jun 2026 06:13:48 +0200
Subject: [PATCH 01/42] feat(bot): add rule engine with schedule and
 interactive buttons
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Introduced trigger, condition, and action concepts for configs, defaulting to classic message behavior.
- Added support for schedule triggers (cron) with timezone handling and button timeout functionality.
- Implemented Outlook calendar condition stub with environment‑based event source.
- Expanded configuration schema with new fields: trigger, schedule_cron, schedule_timezone, condition, condition_negate, outlook patterns, action, action_target, buttons, button_timeout, button_timeout_target.
- Added commands to set triggers, cron expressions, timezones, conditions, outlook patterns, actions, targets, button management, and immediate run.
- Implemented interactive button blocks, pending button tracking, timeout handling, and persistence cache.
- Developed scheduler to evaluate cron schedules, respect conditions, and execute actions.
- Updated README with usage details for the new features.
- Modified Helm chart deployment to expose new cache files via environment variables.
- Updated requirements to include `croniter` and added new `outlook.py` stub module.
- Extended tests to cover new setters, condition evaluation, actions, button handling, and scheduler behavior.
---
 README.md                               |  47 +-
 bot.py                                  | 687 +++++++++++++++++++++++-
 charts/hutbot/templates/deployment.yaml |   4 +
 outlook.py                              |  64 +++
 requirements.txt                        |   3 +-
 test_bot.py                             | 316 +++++++++++
 6 files changed, 1111 insertions(+), 10 deletions(-)
 create mode 100644 outlook.py

diff --git a/README.md b/README.md
index 6a27b4c..37c8ae0 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,42 @@ 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:
+  - `/hutbot [config] add button "<label>" <target-config>` — clicking the button runs
+    `<target-config>` (typically a `manual` rule).
+  - `/hutbot [config] clear buttons`
+  - `/hutbot [config] set button-timeout <minutes>` and
+    `/hutbot [config] set button-timeout-target <config>` — if no button is pressed within the
+    timeout, the target config runs. Pending button timeouts survive restarts.
+
+Use `/hutbot [config] run` to fire a configuration's action immediately (handy for testing).
+
 ## Step 1: Set Up the Slack App
 
 1. **Create a New Slack App**
@@ -81,7 +117,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 +132,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.
diff --git a/bot.py b/bot.py
index d93b8a4..2b99009 100644
--- a/bot.py
+++ b/bot.py
@@ -26,6 +26,12 @@
     normalize_real_name_with_diagraphs,
     normalize_user_name,
 )
+import outlook
+
+try:
+    from croniter import croniter
+except ImportError:  # pragma: no cover - dependency optional at runtime
+    croniter = None
 
 ScheduledReply = collections.namedtuple('ScheduledReply', ['task', 'user_id'])
 User = collections.namedtuple('User', ['id', 'name', 'real_name', 'team'])
@@ -39,6 +45,23 @@
 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"
+
 DEFAULT_CONFIG = {
     "wait_time": 30 * 60,
     "reply_message": "Anybody?",
@@ -58,11 +81,29 @@
     "pattern": None,
     "pattern_case_sensitive": False,
     "forward_channel": "",
-    "enabled": True
+    "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": "",
 }
 
 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',
@@ -80,6 +121,14 @@
 scheduled_messages = {}
 _scheduled_replies_cache: dict[tuple, dict] = {}
 
+# Pending interactive-button messages awaiting a press, keyed by (channel_id, message_ts).
+# Value: {'task': asyncio.Task, 'channel_id', 'message_ts', 'config_name', 'target', 'run_at'}.
+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
+
 user_id_cache = {}
 user_email_cache = {}
 id_user_cache = {}
@@ -183,6 +232,21 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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<target>\S+)')
+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>.+)')
+RUN_PATTERN = re.compile(r'^(run|fire)$', re.IGNORECASE)
 
 def log_debug(channel: Channel | None, *args: object) -> None:
     if channel and any(c.get('debug') for c in channel.configs.values()):
@@ -900,6 +964,36 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel: C
         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 (match := SET_TRIGGER_PATTERN.match(command_text)):
+        await set_trigger(app, channel, config_name, match.group("trigger"), user, thread_ts)
+    elif (match := SET_CRON_PATTERN.match(command_text)):
+        await set_schedule_cron(app, channel, config_name, match.group("cron"), user, thread_ts)
+    elif (match := SET_SCHEDULE_TIMEZONE_PATTERN.match(command_text)):
+        await set_schedule_timezone(app, channel, config_name, match.group("tz"), user, thread_ts)
+    elif (match := SET_CONDITION_PATTERN.match(command_text)):
+        await set_condition(app, channel, config_name, match.group("condition"), user, thread_ts)
+    elif (match := SET_OUTLOOK_SUBJECT_PATTERN.match(command_text)):
+        await set_outlook_pattern(app, channel, config_name, "outlook_subject_pattern", match.group("pattern"), user, thread_ts)
+    elif (match := SET_OUTLOOK_BODY_PATTERN.match(command_text)):
+        await set_outlook_pattern(app, channel, config_name, "outlook_body_pattern", match.group("pattern"), user, thread_ts)
+    elif ENABLE_CONDITION_NEGATE_PATTERN.match(command_text):
+        await set_condition_negate(app, channel, config_name, True, user, thread_ts)
+    elif DISABLE_CONDITION_NEGATE_PATTERN.match(command_text):
+        await set_condition_negate(app, channel, config_name, False, user, thread_ts)
+    elif (match := SET_ACTION_PATTERN.match(command_text)):
+        await set_action(app, channel, config_name, match.group("action"), user, thread_ts)
+    elif (match := SET_TARGET_PATTERN.match(command_text)):
+        await set_action_target(app, channel, config_name, match.group("target"), user, thread_ts)
+    elif (match := ADD_BUTTON_PATTERN.match(command_text)):
+        await add_button(app, channel, config_name, match.group("label"), match.group("target"), user, thread_ts)
+    elif CLEAR_BUTTONS_PATTERN.match(command_text):
+        await clear_buttons(app, channel, config_name, user, thread_ts)
+    elif (match := SET_BUTTON_TIMEOUT_TARGET_PATTERN.match(command_text)):
+        await set_button_timeout_target(app, channel, config_name, match.group("target"), user, thread_ts)
+    elif (match := SET_BUTTON_TIMEOUT_PATTERN.match(command_text)):
+        await set_button_timeout(app, channel, config_name, match.group("minutes"), user, thread_ts)
+    elif RUN_PATTERN.match(command_text):
+        await run_config_now(app, opsgenie_token, 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):
@@ -1284,6 +1378,150 @@ async def delete_config(app: AsyncApp, channel: Channel, config_name: str, user:
     await save_configuration()
     await send_message(app, channel, user, f"Configuration `{config_name}` has been deleted.", thread_ts)
 
+# ----- Setters for trigger / condition / action / button fields -----
+
+def _ensure_config(channel: 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_trigger(app: AsyncApp, channel: Channel, config_name: str, value: str, user: 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 send_message(app, channel, user, f"Invalid *trigger*. Must be one of {supported}.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['trigger'] = value
+    await save_configuration()
+    await send_message(app, channel, user, f"*Trigger* set to `{value}` in configuration `{config_name}`.", thread_ts)
+
+async def set_schedule_cron(app: AsyncApp, channel: Channel, config_name: str, cron_expr: str, user: User, thread_ts: str = "") -> None:
+    cron_expr = strip_quotes(cron_expr).strip()
+    if not cron_expr:
+        await 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 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 save_configuration()
+    note = "" if croniter is not None else " (not validated — `croniter` not installed)"
+    await 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: Channel, config_name: str, tz_name: str, user: User, thread_ts: str = "") -> None:
+    tz_name = strip_quotes(tz_name).strip()
+    if tz_name:
+        try:
+            ZoneInfo(tz_name)
+        except ZoneInfoNotFoundError:
+            await 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 save_configuration()
+    await 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: Channel, config_name: str, value: str, user: 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 send_message(app, channel, user, "Invalid *condition*. Must be `none` or `outlook`.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['condition'] = value
+    await save_configuration()
+    label = value or 'none'
+    await send_message(app, channel, user, f"*Condition* set to `{label}` in configuration `{config_name}`.", thread_ts)
+
+async def set_outlook_pattern(app: AsyncApp, channel: Channel, config_name: str, field: str, pattern_str: str, user: User, thread_ts: str = "") -> None:
+    pattern_str = strip_quotes(pattern_str)
+    try:
+        re.compile(pattern_str)
+    except re.error as e:
+        await send_message(app, channel, user, f"Invalid pattern: `{e}`", thread_ts)
+        return
+    _ensure_config(channel, config_name)[field] = pattern_str
+    await save_configuration()
+    which = "subject" if field == "outlook_subject_pattern" else "body"
+    await 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: Channel, config_name: str, enabled: bool, user: User, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['condition_negate'] = enabled
+    await save_configuration()
+    await 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: Channel, config_name: str, value: str, user: 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 send_message(app, channel, user, f"Invalid *action*. Must be one of {supported}.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['action'] = value
+    await save_configuration()
+    await send_message(app, channel, user, f"*Action* set to `{value}` in configuration `{config_name}`.", thread_ts)
+
+async def set_action_target(app: AsyncApp, channel: Channel, config_name: str, target: str, user: User, thread_ts: str = "") -> None:
+    target = strip_quotes(target).strip()
+    if not target:
+        await send_message(app, channel, user, "Invalid *target*. Must be non-empty.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['action_target'] = target
+    await save_configuration()
+    await send_message(app, channel, user, f"*Action target* set to `{target}` in configuration `{config_name}`.", thread_ts)
+
+async def add_button(app: AsyncApp, channel: Channel, config_name: str, label: str, target: str, user: User, thread_ts: str = "") -> None:
+    label = strip_quotes(label).strip()
+    target = strip_quotes(target).strip()
+    if not label:
+        await send_message(app, channel, user, "Invalid *button label*. Must be non-empty.", thread_ts)
+        return
+    if not target:
+        await send_message(app, channel, user, "Invalid *button target*. Must reference a configuration name.", thread_ts)
+        return
+    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, 'target': target}]
+    await save_configuration()
+    warning = "" if target in channel.configs else f" :warning: (configuration `{target}` does not exist yet)"
+    await send_message(app, channel, user, f"Added button `{label}` → `{target}` in configuration `{config_name}`{warning}.", thread_ts)
+
+async def clear_buttons(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['buttons'] = []
+    await save_configuration()
+    await send_message(app, channel, user, f"Cleared *buttons* in configuration `{config_name}`.", thread_ts)
+
+async def set_button_timeout(app: AsyncApp, channel: Channel, config_name: str, minutes_str: str, user: User, thread_ts: str = "") -> None:
+    try:
+        minutes = int(strip_quotes(minutes_str).strip())
+    except ValueError:
+        await 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 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 save_configuration()
+    label = f"`{minutes}` minutes" if minutes else "disabled"
+    await 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: Channel, config_name: str, target: str, user: User, thread_ts: str = "") -> None:
+    target = strip_quotes(target).strip()
+    if not target:
+        await 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 save_configuration()
+    warning = "" if target in channel.configs else f" :warning: (configuration `{target}` does not exist yet)"
+    await 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: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
+    config = channel.configs.get(config_name)
+    if not config:
+        await send_message(app, channel, user, f"Configuration `{config_name}` not found.", thread_ts)
+        return
+    await send_message(app, channel, user, f"Running configuration `{config_name}` now…", thread_ts)
+    await run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel.id, 'user': user})
+
 async def process_mentions(app: AsyncApp, message: str) -> tuple[bool, str, str]:
     # Regular expression to find @username patterns
     matches = MENTION_PATTERN.findall(message)
@@ -1456,8 +1694,11 @@ def format_table_value(value, key_width: int) -> str:
         datetime_locale = config.get('datetime_locale') or '<default>'
         opsgenie_priority = 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 opsgenie_configured else ' (not configured)')),
             ("OpsGenie schedule",  opsgenie_schedule_name),
             ("OpsGenie priority",  opsgenie_priority),
@@ -1473,6 +1714,27 @@ def format_table_value(value, key_width: int) -> str:
             ("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>'))
+        buttons = config.get('buttons') or []
+        if buttons:
+            rows.append(("Buttons", [f"{b.get('label')} → {b.get('target')}" for b in buttons]))
+            button_timeout_minutes = (config.get('button_timeout') or 0) // 60
+            if button_timeout_minutes:
+                rows.append(("Button timeout", f"{button_timeout_minutes} minutes → {config.get('button_timeout_target') or '<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>'}"
@@ -1572,6 +1834,21 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ("/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>\" <target-config>", "Add a button that runs <target-config>."),
+        ("/hutbot [config] clear buttons", "Remove all buttons."),
+        ("/hutbot [config] set button-timeout <minutes>", "Run a target if no button is pressed in time."),
+        ("/hutbot [config] set button-timeout-target <config>", "Config to run on button 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."),
@@ -2212,6 +2489,9 @@ async def handle_thread_response(app: AsyncApp, channel: Channel, reply_user: Us
 
 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 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
@@ -2306,6 +2586,389 @@ async def handle_command_event(app: AsyncApp, command: dict, opsgenie_token: str
     user = await get_user_by_id(app, user_id)
     await process_command(app, text, channel, user, opsgenie_token=opsgenie_token)
 
+# ---------------------------------------------------------------------------
+# Trigger / condition / action engine
+#
+# A "rule" is a named channel config. Its `trigger` decides how it starts
+# (message | schedule | manual), its `condition` optionally gates it, and its
+# `action` decides what it does. Buttons and button-timeouts reference other
+# named configs (trigger == manual) in the same channel as their targets.
+# ---------------------------------------------------------------------------
+
+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 get_user_by_id(app, ident[1:])
+    if re.match(r'^[UW][A-Z0-9]+$', target):
+        return await get_user_by_id(app, target)
+    if target.startswith('@'):
+        return await get_user_by_name(app, normalize_id(target[1:]))
+    if '@' in target:
+        return await get_user_by_email(app, target)
+    return await 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 get_usergroup_by_id(app, match.group(1))
+    if re.match(r'^S[A-Z0-9]+$', target):
+        return await get_usergroup_by_id(app, target)
+    handle = target[1:] if target.startswith('@') else target
+    return await get_usergroup_by_handle(app, handle)
+
+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 []
+
+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]
+        target = button.get('target') or ''
+        value = json.dumps({"channel": def_channel_id, "config": config_name, "index": i, "target": target})
+        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},
+    ]
+
+async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None) -> str:
+    template = config.get('reply_message') or ''
+    context = context or {}
+    user = context.get('user')
+    if user is None:
+        user = User(id=bot_user_id or '', name='hutbot', real_name='Hutbot', team=TEAM_UNKNOWN)
+    text = context.get('text', '')
+    ts = context.get('ts', '')
+    permalink = await get_message_permalink(app, channel, ts) if ts else ""
+    template_variables = find_template_variables(template)
+    variables = 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)),
+    )
+    return render_reply_message_template(template, variables, config)
+
+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
+    try:
+        response = await app.client.chat_postMessage(**kwargs)
+        return {"channel": channel_id, "ts": response.get("ts")}
+    except SlackApiError as e:
+        log_error(f"Failed to post message to {channel_id}:", e)
+        return None
+
+async def action_reply(app: AsyncApp, channel: Channel, config: dict, context: dict | None, text: str, blocks: list | None) -> dict | None:
+    context = context or {}
+    thread_ts = context.get('thread_ts', '') or context.get('message_ts', '')
+    return await _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 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 _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 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 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 _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 = parse_channel_ref(target)
+    if not channel_id:
+        log_error(f"Action post_channel: invalid channel target '{target}'.")
+        return None
+    return await _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 = build_button_blocks(config, channel.id, config_name, text)
+    log(f"Running action '{action}' for config '{config_name}' in #{channel.name}.")
+    if action == ACTION_REPLY:
+        posted = await action_reply(app, channel, config, context, text, blocks)
+    elif action == ACTION_DM_USER:
+        posted = await action_dm_user(app, channel, config, text, blocks)
+    elif action == ACTION_GROUP_DM:
+        posted = await action_group_dm(app, channel, config, text, blocks)
+    elif action == ACTION_POST_CHANNEL:
+        posted = await action_post_channel(app, channel, config, text, blocks)
+    else:
+        log_error(f"Unknown action '{action}' for config '{config_name}'.")
+        return None
+    if posted and posted.get('ts') and config.get('buttons'):
+        await register_pending_button(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config)
+    return posted
+
+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
+
+# ----- Button-press timeout tracking + persistence (mirrors scheduled replies) -----
+
+async def load_button_cache() -> None:
+    global _button_states_cache
+    try:
+        async with aiofiles.open(BUTTON_CACHE_FILE, 'r') as f:
+            entries = json.loads(await f.read())
+            _button_states_cache = {
+                (e['posted_channel_id'], e['message_ts']): e for e in entries
+            }
+            log(f"Loaded {len(_button_states_cache)} pending button states from cache.")
+    except FileNotFoundError:
+        _button_states_cache = {}
+    except Exception as e:
+        log_error("Failed to load button states cache:", e)
+        _button_states_cache = {}
+
+async def flush_button_cache() -> None:
+    try:
+        async with aiofiles.open(BUTTON_CACHE_FILE, 'w') as f:
+            await f.write(json.dumps(list(_button_states_cache.values()), indent=2))
+    except Exception as e:
+        log_error("Failed to flush button states cache:", e)
+
+async def register_pending_button(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, def_channel_id: str, config_name: str, config: dict) -> None:
+    timeout = config.get('button_timeout') or 0
+    target = config.get('button_timeout_target') or ''
+    if not message_ts or not posted_channel_id or timeout <= 0 or not target:
+        return
+    key = (posted_channel_id, message_ts)
+    run_at = (datetime.datetime.now() + datetime.timedelta(seconds=timeout)).isoformat()
+    entry = {
+        'posted_channel_id': posted_channel_id,
+        'message_ts': message_ts,
+        'def_channel_id': def_channel_id,
+        'config_name': config_name,
+        'target': target,
+        'run_at': run_at,
+    }
+    task = asyncio.create_task(_button_timeout_task(app, opsgenie_token, posted_channel_id, message_ts, def_channel_id, target, timeout))
+    pending_buttons[key] = {'task': task, **entry}
+    _button_states_cache[key] = entry
+    await flush_button_cache()
+
+async def _button_timeout_task(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, def_channel_id: str, target: str, timeout: float) -> None:
+    key = (posted_channel_id, message_ts)
+    try:
+        await asyncio.sleep(timeout)
+        channel = await get_channel_by_id(app, def_channel_id)
+        target_config = channel.configs.get(target)
+        if target_config:
+            log(f"Button on message {message_ts} not pressed within timeout; running '{target}' in #{channel.name}.")
+            await run_action(app, opsgenie_token, channel, target_config, target, context={'channel_id': posted_channel_id})
+        else:
+            log_warning(f"Button timeout target '{target}' not found in #{channel.name}.")
+    except asyncio.CancelledError:
+        return
+    except Exception as e:
+        log_error(f"Button timeout task failed for message {message_ts}:", e)
+    finally:
+        pending_buttons.pop(key, None)
+        _button_states_cache.pop(key, None)
+        await flush_button_cache()
+
+async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None:
+    key = (posted_channel_id, message_ts)
+    entry = pending_buttons.pop(key, None)
+    _button_states_cache.pop(key, None)
+    if entry:
+        entry['task'].cancel()
+        await flush_button_cache()
+
+async def restore_pending_buttons(app: AsyncApp, opsgenie_token: str) -> None:
+    entries = list(_button_states_cache.items())
+    invalid_keys = []
+    restored = 0
+    log(f"Restoring {len(entries)} pending button timeouts from cache...")
+    for key, entry in entries:
+        def_channel_id = entry.get('def_channel_id')
+        target = entry.get('target')
+        if not def_channel_id or def_channel_id not in channel_config or target not in channel_config.get(def_channel_id, {}):
+            log_warning(f"Skipping cached button state for message {entry.get('message_ts')}: target '{target}' no longer configured.")
+            invalid_keys.append(key)
+            continue
+        run_at = datetime.datetime.fromisoformat(entry['run_at'])
+        remaining = max(0.0, (run_at - datetime.datetime.now()).total_seconds())
+        task = asyncio.create_task(_button_timeout_task(app, opsgenie_token, entry['posted_channel_id'], entry['message_ts'], def_channel_id, target, remaining))
+        pending_buttons[key] = {'task': task, **entry}
+        restored += 1
+    for key in invalid_keys:
+        _button_states_cache.pop(key, None)
+    if invalid_keys:
+        await flush_button_cache()
+    log(f"Restored {restored} pending button timeouts.")
+
+# ----- Scheduler (cron triggers) -----
+
+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:
+    global _scheduler_last_check
+    if croniter is None:
+        log_warning("croniter is not installed; scheduled triggers are disabled.")
+        return
+    _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:
+    global _scheduler_last_check
+    now = datetime.datetime.now(datetime.timezone.utc)
+    last = _scheduler_last_check or now
+    _scheduler_last_check = now
+    for channel_id, configs in list(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 get_channel_by_id(app, channel_id)
+            if not await 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 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 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', '')
+    await cancel_pending_button(posted_channel_id, message_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
+    target = payload.get('target') or ''
+    presser_id = (body.get('user', {}) or {}).get('id', '')
+    presser = await get_user_by_id(app, presser_id) if presser_id else None
+    presser_name = presser.name if presser else '?'
+    if not target:
+        log_warning(f"Button pressed by @{presser_name} with no target; ignoring.")
+        return
+    channel = await get_channel_by_id(app, def_channel_id)
+    target_config = channel.configs.get(target)
+    if not target_config:
+        log_warning(f"Button target config '{target}' not found in #{channel.name}.")
+        return
+    log(f"Button pressed by @{presser_name}; running '{target}' in #{channel.name}.")
+    await run_action(app, opsgenie_token, channel, target_config, target, context={
+        'channel_id': posted_channel_id,
+        'user': presser,
+        'message_ts': message_ts,
+    })
+
 def register_app_handlers(app: AsyncApp, opsgenie_token: str = "") -> None:
 
     @app.event("message")
@@ -2321,6 +2984,11 @@ 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 handle_button_press(app, opsgenie_token, body, action)
+
 async def restore_scheduled_replies(app: AsyncApp, opsgenie_token: str) -> None:
     entries = list(_scheduled_replies_cache.items())
     invalid_keys = []
@@ -2377,6 +3045,7 @@ async def main() -> None:
 
     handler = None
     heartbeat_task = None
+    scheduler_task = None
     try:
         app = AsyncApp(token=slack_bot_token)
         await load_configuration(app)
@@ -2385,12 +3054,15 @@ async def main() -> None:
         await update_user_cache(app)
         await load_replies_cache()
         await restore_scheduled_replies(app, opsgenie_token)
+        await load_button_cache()
+        await restore_pending_buttons(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))
+        scheduler_task = asyncio.create_task(run_scheduler(app, opsgenie_token))
         await handler.start_async()
     except asyncio.CancelledError:
         pass
@@ -2403,12 +3075,13 @@ async def main() -> None:
         try:
             if handler:
                 await handler.close_async()
-            if heartbeat_task:
-                heartbeat_task.cancel()
-                try:
-                    await heartbeat_task
-                except asyncio.CancelledError:
-                    pass
+            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
 
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 60bc75c..96c1e17 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -31,6 +31,10 @@ spec:
               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" }}
           volumeMounts:
             - name: config
               mountPath: {{ .Values.persistence.mountPath }}
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/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
index cdf4c2d..db66eb5 100644
--- a/test_bot.py
+++ b/test_bot.py
@@ -1853,3 +1853,319 @@ async def test_process_command_disable_replies():
         await process_command(app, "disable", channel, user)
 
     assert channel.configs["default"]["enabled"] is False
+
+
+# ===========================================================================
+# Broader triggers / conditions / actions / buttons
+# ===========================================================================
+
+import asyncio
+import bot
+import outlook
+
+
+def _mk_channel(configs=None):
+    return Channel(id="C12345", name="general", configs=configs if configs is not None else {"default": DEFAULT_CONFIG.copy()})
+
+
+# ----- 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('bot.save_configuration'), patch('bot.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]
+
+
+@pytest.mark.asyncio
+async def test_set_action_normalizes_dashes():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('bot.save_configuration'), patch('bot.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_schedule_cron_valid_and_invalid():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('bot.save_configuration'), patch('bot.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]
+
+
+@pytest.mark.asyncio
+async def test_set_condition_aliases():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('bot.save_configuration'), patch('bot.send_message'):
+        await process_command(app, "set condition outlook", channel, user)
+        assert channel.configs["default"]["condition"] == bot.CONDITION_OUTLOOK
+        await process_command(app, "set condition none", channel, user)
+        assert channel.configs["default"]["condition"] == ""
+
+
+@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('bot.save_configuration'), patch('bot.send_message'):
+        await process_command(app, 'add button "Approve" approve-flow', channel, user)
+        assert channel.configs["default"]["buttons"] == [{"label": "Approve", "target": "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_set_button_timeout_minutes_to_seconds():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('bot.save_configuration'), patch('bot.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"
+
+
+# ----- 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('bot.is_work_day', return_value=True), \
+         patch('bot.flush_replies_cache'), \
+         patch('bot.schedule_reply') as mock_schedule:
+        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
+
+
+# ----- Conditions -----
+
+@pytest.mark.asyncio
+async def test_evaluate_condition_none_is_true():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    assert await bot.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"] = bot.CONDITION_OUTLOOK
+    config["outlook_subject_pattern"] = "standup"
+    config["condition_negate"] = True
+    with patch('bot.outlook.calendar_condition_met', new=AsyncMock(return_value=False)) as met:
+        result = await bot.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
+
+
+# ----- Actions -----
+
+def test_build_button_blocks_structure():
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [{"label": "Yes", "target": "yes-flow"}, {"label": "No", "target": "no-flow"}]
+    blocks = bot.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 = json.loads(elements[0]["value"])
+    assert payload == {"channel": "C12345", "config": "src", "index": 0, "target": "yes-flow"}
+
+
+@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"] = bot.ACTION_REPLY
+    config["reply_message"] = "Hi there"
+    config["buttons"] = [{"label": "Ok", "target": "tgt"}]
+    config["button_timeout"] = 0  # no timeout watch
+    channel = _mk_channel({"src": config})
+    posted = await bot.run_action(app, "token", channel, config, "src", context=None)
+    assert posted == {"channel": "C12345", "ts": "99.1"}
+    kwargs = app.client.chat_postMessage.call_args.kwargs
+    assert kwargs["channel"] == "C12345"
+    assert kwargs["text"] == "Hi there"
+    assert kwargs["blocks"][1]["type"] == "actions"
+
+
+@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"] = bot.ACTION_DM_USER
+    config["action_target"] = "<@U777>"
+    channel = _mk_channel({"src": config})
+    with patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U777", "alice", "Alice", "Team"))):
+        posted = await bot.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"] = bot.ACTION_GROUP_DM
+    config["action_target"] = "@oncall"
+    channel = _mk_channel({"src": config})
+    with patch('bot.get_usergroup_by_handle', new=AsyncMock(return_value=Usergroup("S1", "oncall", "On Call"))), \
+         patch('bot.get_usergroup_members', new=AsyncMock(return_value=["U1", "U2", "U3"])):
+        posted = await bot.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"
+
+
+# ----- 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"
+    channel = _mk_channel({"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, "target": "tgt"})}
+    with patch('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
+         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.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_register_and_cancel_pending_button():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [{"label": "Ok", "target": "tgt"}]
+    config["button_timeout"] = 3600
+    config["button_timeout_target"] = "escalate"
+    bot.pending_buttons.clear()
+    with patch('bot.flush_button_cache', new=AsyncMock()):
+        await bot.register_pending_button(app, "token", "C12345", "10.1", "C12345", "src", config)
+        assert ("C12345", "10.1") in bot.pending_buttons
+        await bot.cancel_pending_button("C12345", "10.1")
+        assert ("C12345", "10.1") not in bot.pending_buttons
+    await asyncio.sleep(0)  # let the cancelled task settle
+
+
+@pytest.mark.asyncio
+async def test_button_timeout_runs_target():
+    app = AsyncMock()
+    escalate = DEFAULT_CONFIG.copy()
+    escalate["trigger"] = "manual"
+    channel = _mk_channel({"escalate": escalate})
+    bot.pending_buttons.clear()
+    with patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.flush_button_cache', new=AsyncMock()), \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot._button_timeout_task(app, "token", "C12345", "10.1", "C12345", "escalate", 0)
+    assert run.await_count == 1
+    assert run.await_args.args[4] == "escalate"
+
+
+# ----- 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})
+    bot._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    with patch.dict('bot.channel_config', {"C12345": {"sched": sched}}, clear=True), \
+         patch('bot._cron_due', return_value=True), \
+         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.evaluate_condition', new=AsyncMock(return_value=True)), \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.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})
+    bot._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    with patch.dict('bot.channel_config', {"C12345": {"sched": sched}}, clear=True), \
+         patch('bot._cron_due', return_value=True), \
+         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.evaluate_condition', new=AsyncMock(return_value=False)), \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.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"
+    bot._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    with patch.dict('bot.channel_config', {"C12345": {"default": msg}}, clear=True), \
+         patch('bot._cron_due', return_value=True), \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.scheduler_tick(app, "token")
+    assert run.await_count == 0

From 30f871c828787e2b4fa3ae56ee1e305e12720273 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 24 Jun 2026 11:29:39 +0200
Subject: [PATCH 02/42] feat(bot): honor action/buttons in schedule_reply and
 limit threading
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- schedule_reply now respects `action` config and presence of `buttons`, delegating to `run_action` for non‑reply actions or when buttons are defined
- classic plain threaded reply retained for default `ACTION_REPLY` without buttons
- action_reply validates `thread_ts` against the target channel, preventing invalid thread references across conversations
- added comprehensive tests covering routing to actions, button handling, classic reply behavior, and channel‑specific threading constraints
---
 bot.py      | 24 ++++++++++++++++--
 test_bot.py | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+), 2 deletions(-)

diff --git a/bot.py b/bot.py
index 2b99009..a09dc25 100644
--- a/bot.py
+++ b/bot.py
@@ -2237,7 +2237,22 @@ async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel: Channel, c
             ),
             config,
         )
-        await send_message(app, channel, user, reply_message, ts)
+        action = config.get('action', ACTION_REPLY)
+        buttons = config.get('buttons') or []
+        if action == ACTION_REPLY and not buttons:
+            # Classic behavior: a plain threaded reply on the original message.
+            await send_message(app, channel, user, reply_message, ts)
+        else:
+            # Honor the configured action (dm_user/group_dm/post_channel) and/or
+            # buttons. The message context lets the action thread on / reference
+            # the original message and reuse its template variables.
+            await run_action(app, opsgenie_token, channel, config, config_name, context={
+                'user': user,
+                'text': text,
+                'ts': ts,
+                'thread_ts': ts,
+                'channel_id': channel.id,
+            })
         forward_channel_id = config.get('forward_channel')
         if forward_channel_id:
             try:
@@ -2692,7 +2707,12 @@ async def _post_message(app: AsyncApp, channel_id: str, text: str, blocks: list
 
 async def action_reply(app: AsyncApp, channel: Channel, config: dict, context: dict | None, text: str, blocks: list | None) -> dict | None:
     context = context or {}
-    thread_ts = context.get('thread_ts', '') or context.get('message_ts', '')
+    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 _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:
diff --git a/test_bot.py b/test_bot.py
index db66eb5..c4aae4f 100644
--- a/test_bot.py
+++ b/test_bot.py
@@ -2169,3 +2169,75 @@ async def test_scheduler_tick_ignores_message_trigger():
          patch('bot.run_action', new=AsyncMock()) as run:
         await bot.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"] = bot.ACTION_DM_USER
+    cfg["action_target"] = "<@U1>"
+    cfg["reply_message"] = "hi"
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
+         patch('bot.flush_replies_cache', new=AsyncMock()), \
+         patch('bot.send_message', new=AsyncMock()) as send, \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.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
+    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_routes_to_action_when_buttons_present():
+    app = AsyncMock()
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["action"] = bot.ACTION_REPLY
+    cfg["buttons"] = [{"label": "Ok", "target": "tgt"}]
+    cfg["reply_message"] = "hi"
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
+         patch('bot.flush_replies_cache', new=AsyncMock()), \
+         patch('bot.send_message', new=AsyncMock()) as send, \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
+    assert run.await_count == 1
+    assert send.await_count == 0
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_classic_when_plain_reply():
+    app = AsyncMock()
+    cfg = DEFAULT_CONFIG.copy()  # action reply, no buttons
+    cfg["reply_message"] = "hi"
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
+         patch('bot.flush_replies_cache', new=AsyncMock()), \
+         patch('bot.send_message', new=AsyncMock()) as send, \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
+    assert send.await_count == 1
+    assert run.await_count == 0
+
+
+# ----- 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 bot.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 bot.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

From 0803afc0ed42d79a68f1d23bbdb0167f81d60755 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 24 Jun 2026 12:51:17 +0200
Subject: [PATCH 03/42] feat(bot): add typed button actions, default button and
 escalation handling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Update .gitignore to include button state persistence file.
- Expand README with detailed button syntax, examples, and OpsGenie integration.
- Introduce new button action constants (config, ack, message, alert, delay) and escalation types.
- Extend DEFAULT_CONFIG with `default_button` and normalize legacy button format during migration.
- Refactor command parsing to support typed button specifications and default‑button commands.
- Implement add, clear, set, and clear default button commands with validation.
- Rewrite schedule_reply to always use the unified action engine and forward replies when configured.
- Add escalation registration, task handling, and auto‑press of default button on timeout.
- Enhance button press handling to support ack, message, alert, delay, and rescheduling.
- Provide helper functions for button normalization, finding buttons, and determining escalation kind.
- Update tests to cover new button actions, migration, default button behavior, and refactored logic.
---
 .gitignore  |   1 +
 README.md   |  37 ++++-
 bot.py      | 422 +++++++++++++++++++++++++++++++++++++++------------
 test_bot.py | 425 +++++++++++++++++++++++++++++++++++++++++++---------
 4 files changed, 710 insertions(+), 175 deletions(-)

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/README.md b/README.md
index 37c8ae0..327deb5 100644
--- a/README.md
+++ b/README.md
@@ -54,13 +54,38 @@ existing configs keep working unchanged.
     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:
-  - `/hutbot [config] add button "<label>" <target-config>` — clicking the button runs
-    `<target-config>` (typically a `manual` rule).
+- **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 (e.g. a `manual` rule).
+  - `/hutbot [config] add button "<label>" ack [text]` — acknowledge/dismiss: stop the escalation
+    (incl. a pending OpsGenie alert) and optionally post `text`.
+  - `/hutbot [config] add button "<label>" message <text>` — post a fixed message.
+  - `/hutbot [config] add button "<label>" alert` — send the OpsGenie alert now.
+  - `/hutbot [config] add button "<label>" delay <minutes>` — delay the escalation/alert by N minutes.
   - `/hutbot [config] clear buttons`
-  - `/hutbot [config] set button-timeout <minutes>` and
-    `/hutbot [config] set button-timeout-target <config>` — if no button is pressed within the
-    timeout, the target config runs. Pending button timeouts survive restarts.
+  - `/hutbot [config] set button-timeout <minutes>` — escalate if no button is pressed in time.
+  - `/hutbot [config] set default-button "<label>"` — on timeout, **auto-press** this button (e.g. a
+    "Yes" default). Otherwise `set button-timeout-target <config>` runs a config, or — if OpsGenie is
+    enabled — the escalation sends the OpsGenie alert. Pending escalations survive restarts.
+  - A bare `add button "<label>" <config>` (no action keyword) is still treated as `config <config>`.
+
+- **"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 + buttons workflow**: when a reply config has OpsGenie enabled **and** buttons, the alert
+  is no longer sent immediately — it becomes the button-gated escalation. A typical setup:
+  `set button-timeout 5`, plus buttons `Acknowledge (ack)`, `Help needed (alert)`, `Delay (delay 3)`.
+  Acknowledge cancels the alert, *Help needed* sends it now, *Delay* pushes it out, and if nobody
+  presses anything within 5 minutes the alert fires automatically. (A reply config with OpsGenie but
+  **no** buttons keeps alerting immediately, as before.)
 
 Use `/hutbot [config] run` to fire a configuration's action immediately (handy for testing).
 
diff --git a/bot.py b/bot.py
index a09dc25..dabcb5d 100644
--- a/bot.py
+++ b/bot.py
@@ -62,6 +62,20 @@
 
 BUTTON_ACTION_PREFIX = "hutbot_btn"
 
+# What a button does when pressed.
+BUTTON_ACTION_CONFIG = "config"    # run another named config
+BUTTON_ACTION_ACK = "ack"          # acknowledge/dismiss (cancel escalation), optional ack text
+BUTTON_ACTION_MESSAGE = "message"  # post a fixed inline message
+BUTTON_ACTION_ALERT = "alert"      # send the OpsGenie alert now
+BUTTON_ACTION_DELAY = "delay"      # delay the pending escalation by N minutes
+BUTTON_ACTIONS = {BUTTON_ACTION_CONFIG, BUTTON_ACTION_ACK, BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ALERT, BUTTON_ACTION_DELAY}
+
+# What a buttoned message escalates to if no button is pressed within the timeout.
+ESCALATION_NONE = "none"
+ESCALATION_CONFIG = "config"
+ESCALATION_ALERT = "alert"
+ESCALATION_BUTTON = "button"  # auto-press a named button (the "default" button)
+
 DEFAULT_CONFIG = {
     "wait_time": 30 * 60,
     "reply_message": "Anybody?",
@@ -98,6 +112,7 @@
     "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')
@@ -242,10 +257,12 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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<target>\S+)')
+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)
 
 def log_debug(channel: Channel | None, *args: object) -> None:
@@ -647,6 +664,16 @@ async def migrate_and_apply_defaults(app: AsyncApp, config: dict) -> dict:
             for key, value in 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
 
 
@@ -985,9 +1012,13 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel: C
     elif (match := SET_TARGET_PATTERN.match(command_text)):
         await set_action_target(app, channel, config_name, match.group("target"), user, thread_ts)
     elif (match := ADD_BUTTON_PATTERN.match(command_text)):
-        await add_button(app, channel, config_name, match.group("label"), match.group("target"), user, thread_ts)
+        await add_button(app, channel, config_name, match.group("label"), match.group("spec"), user, thread_ts)
     elif CLEAR_BUTTONS_PATTERN.match(command_text):
         await clear_buttons(app, channel, config_name, user, thread_ts)
+    elif CLEAR_DEFAULT_BUTTON_PATTERN.match(command_text):
+        await clear_default_button(app, channel, config_name, user, thread_ts)
+    elif (match := SET_DEFAULT_BUTTON_PATTERN.match(command_text)):
+        await set_default_button(app, channel, config_name, match.group("label"), user, thread_ts)
     elif (match := SET_BUTTON_TIMEOUT_TARGET_PATTERN.match(command_text)):
         await set_button_timeout_target(app, channel, config_name, match.group("target"), user, thread_ts)
     elif (match := SET_BUTTON_TIMEOUT_PATTERN.match(command_text)):
@@ -1469,27 +1500,70 @@ async def set_action_target(app: AsyncApp, channel: Channel, config_name: str, t
     await save_configuration()
     await send_message(app, channel, user, f"*Action target* set to `{target}` in configuration `{config_name}`.", thread_ts)
 
-async def add_button(app: AsyncApp, channel: Channel, config_name: str, label: str, target: str, user: User, thread_ts: str = "") -> None:
+async def add_button(app: AsyncApp, channel: Channel, config_name: str, label: str, spec: str, user: User, thread_ts: str = "") -> None:
     label = strip_quotes(label).strip()
-    target = strip_quotes(target).strip()
     if not label:
         await send_message(app, channel, user, "Invalid *button label*. Must be non-empty.", thread_ts)
         return
-    if not target:
-        await send_message(app, channel, user, "Invalid *button target*. Must reference a configuration name.", thread_ts)
+
+    # 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 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 send_message(app, channel, user, "Invalid *button*. `delay` needs a number of minutes.", thread_ts)
+            return
+        if minutes <= 0 or minutes > 1440:
+            await 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, 'target': target}]
+    config['buttons'] = list(config.get('buttons') or []) + [{'label': label, 'action': action, 'value': value}]
     await save_configuration()
-    warning = "" if target in channel.configs else f" :warning: (configuration `{target}` does not exist yet)"
-    await send_message(app, channel, user, f"Added button `{label}` → `{target}` in configuration `{config_name}`{warning}.", thread_ts)
+
+    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 send_message(app, channel, user, f"Added button `{label}` ({descriptor}) in configuration `{config_name}`{warning}.", thread_ts)
 
 async def clear_buttons(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
     _ensure_config(channel, config_name)['buttons'] = []
     await save_configuration()
     await send_message(app, channel, user, f"Cleared *buttons* in configuration `{config_name}`.", thread_ts)
 
+async def set_default_button(app: AsyncApp, channel: Channel, config_name: str, label: str, user: User, thread_ts: str = "") -> None:
+    label = strip_quotes(label).strip()
+    if not label:
+        await 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 save_configuration()
+    warning = "" if _find_button_index(config, label) is not None else f" :warning: (no button labelled `{label}` yet)"
+    await 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: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['default_button'] = ''
+    await save_configuration()
+    await send_message(app, channel, user, f"Cleared *default button* in configuration `{config_name}`.", thread_ts)
+
 async def set_button_timeout(app: AsyncApp, channel: Channel, config_name: str, minutes_str: str, user: User, thread_ts: str = "") -> None:
     try:
         minutes = int(strip_quotes(minutes_str).strip())
@@ -1731,10 +1805,24 @@ def format_table_value(value, key_width: int) -> str:
             rows.append(("Action target", config.get('action_target') or '<None>'))
         buttons = config.get('buttons') or []
         if buttons:
-            rows.append(("Buttons", [f"{b.get('label')} → {b.get('target')}" for b in 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 buttons]))
             button_timeout_minutes = (config.get('button_timeout') or 0) // 60
             if button_timeout_minutes:
-                rows.append(("Button timeout", f"{button_timeout_minutes} minutes → {config.get('button_timeout_target') or '<None>'}"))
+                kind, target = _escalation_kind(config)
+                if kind == ESCALATION_BUTTON:
+                    escalates_to = f"auto-press `{target}`"
+                elif kind == ESCALATION_CONFIG:
+                    escalates_to = f"run `{target}`"
+                elif kind == ESCALATION_ALERT:
+                    escalates_to = "OpsGenie alert"
+                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>'}"
@@ -1844,10 +1932,15 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ("/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>\" <target-config>", "Add a button that runs <target-config>."),
+        ("/hutbot [config] add button \"<label>\" config <config>", "Button runs another 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>\" alert", "Button sends the OpsGenie alert now."),
+        ("/hutbot [config] add button \"<label>\" delay <minutes>", "Button delays the OpsGenie alert/escalation."),
         ("/hutbot [config] clear buttons", "Remove all buttons."),
-        ("/hutbot [config] set button-timeout <minutes>", "Run a target if no button is pressed in time."),
+        ("/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}}."),
@@ -2220,47 +2313,29 @@ async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel: Channel, c
     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,
-        )
-        action = config.get('action', ACTION_REPLY)
-        buttons = config.get('buttons') or []
-        if action == ACTION_REPLY and not buttons:
-            # Classic behavior: a plain threaded reply on the original message.
-            await send_message(app, channel, user, reply_message, ts)
-        else:
-            # Honor the configured action (dm_user/group_dm/post_channel) and/or
-            # buttons. The message context lets the action thread on / reference
-            # the original message and reuse its template variables.
-            await run_action(app, opsgenie_token, channel, config, config_name, context={
-                'user': user,
-                'text': text,
-                'ts': ts,
-                'thread_ts': ts,
-                'channel_id': channel.id,
-            })
+        # 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 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:
+        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)
-        if opsgenie_configured and opsgenie_enabled:
+        # OpsGenie: fire immediately for a classic (button-less) reply. When buttons
+        # are configured, the alert is owned by the button escalation instead, so it
+        # can be acknowledged / sent now / delayed.
+        if opsgenie_configured and opsgenie_enabled and not (config.get('buttons') or []):
             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:
@@ -2656,6 +2731,25 @@ async def get_usergroup_members(app: AsyncApp, usergroup_id: str) -> list[str]:
         log_error(f"Failed to fetch members of usergroup {usergroup_id}:", e)
         return []
 
+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
+
 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:
@@ -2663,8 +2757,10 @@ def build_button_blocks(config: dict, def_channel_id: str, config_name: str, tex
     elements = []
     for i, button in enumerate(buttons):
         label = (button.get('label') or f'Button {i + 1}')[:75]
-        target = button.get('target') or ''
-        value = json.dumps({"channel": def_channel_id, "config": config_name, "index": i, "target": target})
+        # 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},
@@ -2684,7 +2780,9 @@ async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channe
         user = User(id=bot_user_id or '', name='hutbot', real_name='Hutbot', team=TEAM_UNKNOWN)
     text = context.get('text', '')
     ts = context.get('ts', '')
-    permalink = await get_message_permalink(app, channel, ts) if ts else ""
+    permalink = context.get('permalink')
+    if permalink is None:
+        permalink = await get_message_permalink(app, channel, ts) if ts else ""
     template_variables = find_template_variables(template)
     variables = await build_reply_template_variables(
         app, opsgenie_token, channel, config, config_name, user, text, ts, permalink,
@@ -2698,12 +2796,20 @@ async def _post_message(app: AsyncApp, channel_id: str, text: str, blocks: list
         kwargs["blocks"] = blocks
     if thread_ts:
         kwargs["thread_ts"] = thread_ts
-    try:
-        response = await app.client.chat_postMessage(**kwargs)
-        return {"channel": channel_id, "ts": response.get("ts")}
-    except SlackApiError as e:
-        log_error(f"Failed to post message to {channel_id}:", e)
-        return None
+    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 action_reply(app: AsyncApp, channel: Channel, config: dict, context: dict | None, text: str, blocks: list | None) -> dict | None:
     context = context or {}
@@ -2778,9 +2884,11 @@ async def run_action(app: AsyncApp, opsgenie_token: str, channel: Channel, confi
     else:
         log_error(f"Unknown action '{action}' for config '{config_name}'.")
         return None
-    if posted and posted.get('ts') and config.get('buttons'):
-        await register_pending_button(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config)
-    return posted
+    if not posted:
+        return None
+    if posted.get('ts') and config.get('buttons'):
+        await register_escalation(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config, context)
+    return {**posted, 'text': text}
 
 async def evaluate_condition(app: AsyncApp, config: dict) -> bool:
     condition = config.get('condition', CONDITION_NONE)
@@ -2819,41 +2927,126 @@ async def flush_button_cache() -> None:
     except Exception as e:
         log_error("Failed to flush button states cache:", e)
 
-async def register_pending_button(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, def_channel_id: str, config_name: str, config: dict) -> None:
-    timeout = config.get('button_timeout') or 0
+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 not message_ts or not posted_channel_id or timeout <= 0 or not target:
+    if target:
+        return ESCALATION_CONFIG, target
+    if opsgenie_configured and config.get('opsgenie'):
+        return ESCALATION_ALERT, ''
+    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) -> None:
+    """Record a buttoned message so ack/alert/delay/timeout can act on it later.
+
+    A record is stored for every buttoned message (it carries the original message
+    context an `alert` button needs); 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)
-    run_at = (datetime.datetime.now() + datetime.timedelta(seconds=timeout)).isoformat()
+    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,
-        'target': target,
-        'run_at': run_at,
+        '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(_button_timeout_task(app, opsgenie_token, posted_channel_id, message_ts, def_channel_id, target, timeout))
+    task = asyncio.create_task(_escalation_task(app, opsgenie_token, key, timeout)) if has_timer else None
     pending_buttons[key] = {'task': task, **entry}
     _button_states_cache[key] = entry
     await flush_button_cache()
 
-async def _button_timeout_task(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, def_channel_id: str, target: str, timeout: float) -> None:
-    key = (posted_channel_id, message_ts)
-    try:
-        await asyncio.sleep(timeout)
-        channel = await get_channel_by_id(app, def_channel_id)
+async def fire_opsgenie_from_orig(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict | None, orig: dict) -> None:
+    if not (opsgenie_configured and config and config.get('opsgenie')):
+        log_warning(f"OpsGenie alert requested in #{channel.name} but OpsGenie is not enabled/configured.")
+        return
+    orig = orig or {}
+    user_id = orig.get('user_id', '')
+    user = await get_user_by_id(app, user_id) if user_id else User(id='', name='hutbot', real_name='Hutbot', team=TEAM_UNKNOWN)
+    log(f"Sending OpsGenie alert in #{channel.name} (orig message {orig.get('ts', '')}).")
+    await post_opsgenie_alert(app, opsgenie_token, channel, config, user, orig.get('text', ''), orig.get('ts', ''), orig.get('permalink', ''))
+
+async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel: Channel, posted_channel_id: str, message_ts: str, src_config: dict | None, button: dict, entry: dict | None, presser: User | None = None) -> 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 run_action(app, opsgenie_token, channel, target_config, value, context={
+            'channel_id': posted_channel_id,
+            'user': presser,
+            'message_ts': message_ts,
+        })
+    elif action == BUTTON_ACTION_MESSAGE:
+        if value:
+            await _post_message(app, posted_channel_id, value, None, message_ts)
+    elif action == BUTTON_ACTION_ACK:
+        if value:
+            await _post_message(app, posted_channel_id, value, None, message_ts)
+    elif action == BUTTON_ACTION_ALERT:
+        await fire_opsgenie_from_orig(app, opsgenie_token, channel, src_config, (entry or {}).get('orig', {}))
+    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 get_channel_by_id(app, entry['def_channel_id'])
+    if kind == ESCALATION_BUTTON:
+        # Auto-press the configured default button.
+        src_config = channel.configs.get(entry.get('config_name'))
+        idx = _find_button_index(src_config, entry.get('escalation_target', ''))
+        if idx is None:
+            log_warning(f"Default button '{entry.get('escalation_target')}' not found in #{channel.name}.")
+            return
+        log(f"No button pressed on message {entry['message_ts']}: auto-pressing '{entry.get('escalation_target')}' in #{channel.name}.")
+        await dispatch_button_action(app, opsgenie_token, channel, entry['posted_channel_id'], entry['message_ts'], src_config, (src_config['buttons'])[idx], entry)
+    elif kind == ESCALATION_CONFIG:
+        target = entry.get('escalation_target', '')
         target_config = channel.configs.get(target)
         if target_config:
-            log(f"Button on message {message_ts} not pressed within timeout; running '{target}' in #{channel.name}.")
-            await run_action(app, opsgenie_token, channel, target_config, target, context={'channel_id': posted_channel_id})
+            log(f"Escalating button on message {entry['message_ts']}: running '{target}' in #{channel.name}.")
+            await run_action(app, opsgenie_token, channel, target_config, target, context={'channel_id': entry['posted_channel_id']})
         else:
-            log_warning(f"Button timeout target '{target}' not found in #{channel.name}.")
+            log_warning(f"Escalation target '{target}' not found in #{channel.name}.")
+    elif kind == ESCALATION_ALERT:
+        src_config = channel.configs.get(entry.get('config_name'))
+        await fire_opsgenie_from_orig(app, opsgenie_token, channel, src_config, entry.get('orig', {}))
+
+async def _escalation_task(app: AsyncApp, opsgenie_token: str, key: tuple, timeout: float) -> None:
+    try:
+        await asyncio.sleep(timeout)
+        entry = 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"Button timeout task failed for message {message_ts}:", e)
+        log_error(f"Escalation task failed for message {key[1]}:", e)
     finally:
         pending_buttons.pop(key, None)
         _button_states_cache.pop(key, None)
@@ -2864,31 +3057,52 @@ async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None
     entry = pending_buttons.pop(key, None)
     _button_states_cache.pop(key, None)
     if entry:
-        entry['task'].cancel()
+        if entry.get('task'):
+            entry['task'].cancel()
         await 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 = 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))
+    pending_buttons[key] = {'task': task, **record}
+    _button_states_cache[key] = record
+    await flush_button_cache()
+    return True
+
 async def restore_pending_buttons(app: AsyncApp, opsgenie_token: str) -> None:
     entries = list(_button_states_cache.items())
     invalid_keys = []
     restored = 0
-    log(f"Restoring {len(entries)} pending button timeouts from cache...")
+    log(f"Restoring {len(entries)} pending button escalations from cache...")
     for key, entry in entries:
         def_channel_id = entry.get('def_channel_id')
-        target = entry.get('target')
-        if not def_channel_id or def_channel_id not in channel_config or target not in channel_config.get(def_channel_id, {}):
-            log_warning(f"Skipping cached button state for message {entry.get('message_ts')}: target '{target}' no longer configured.")
+        if not def_channel_id or def_channel_id not in 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 = datetime.datetime.fromisoformat(entry['run_at'])
-        remaining = max(0.0, (run_at - datetime.datetime.now()).total_seconds())
-        task = asyncio.create_task(_button_timeout_task(app, opsgenie_token, entry['posted_channel_id'], entry['message_ts'], def_channel_id, target, remaining))
+        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
         pending_buttons[key] = {'task': task, **entry}
         restored += 1
     for key in invalid_keys:
         _button_states_cache.pop(key, None)
     if invalid_keys:
         await flush_button_cache()
-    log(f"Restored {restored} pending button timeouts.")
+    log(f"Restored {restored} pending button escalations.")
 
 # ----- Scheduler (cron triggers) -----
 
@@ -2960,7 +3174,6 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
     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', '')
-    await cancel_pending_button(posted_channel_id, message_ts)
 
     payload = {}
     raw_value = action.get('value', '')
@@ -2970,24 +3183,35 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
         except json.JSONDecodeError:
             payload = {}
     def_channel_id = payload.get('channel') or posted_channel_id
-    target = payload.get('target') or ''
+    src_config_name = payload.get('config') or ''
+    index = payload.get('index')
+
     presser_id = (body.get('user', {}) or {}).get('id', '')
     presser = await get_user_by_id(app, presser_id) if presser_id else None
     presser_name = presser.name if presser else '?'
-    if not target:
-        log_warning(f"Button pressed by @{presser_name} with no target; ignoring.")
-        return
+
     channel = await get_channel_by_id(app, def_channel_id)
-    target_config = channel.configs.get(target)
-    if not target_config:
-        log_warning(f"Button target config '{target}' not found in #{channel.name}.")
+    src_config = channel.configs.get(src_config_name)
+    buttons = (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
-    log(f"Button pressed by @{presser_name}; running '{target}' in #{channel.name}.")
-    await run_action(app, opsgenie_token, channel, target_config, target, context={
-        'channel_id': posted_channel_id,
-        'user': presser,
-        'message_ts': message_ts,
-    })
+    btn_action, btn_value = normalize_button(buttons[index])
+    entry = pending_buttons.get((posted_channel_id, message_ts))
+    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.
+    await cancel_pending_button(posted_channel_id, message_ts)
+    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, src_config, buttons[index], entry, presser)
 
 def register_app_handlers(app: AsyncApp, opsgenie_token: str = "") -> None:
 
diff --git a/test_bot.py b/test_bot.py
index c4aae4f..94da1ba 100644
--- a/test_bot.py
+++ b/test_bot.py
@@ -1045,6 +1045,7 @@ async def test_set_reply_message_rejects_unknown_arg_invalid_timezone_and_locale
 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()
@@ -1055,21 +1056,21 @@ async def test_schedule_reply_renders_template_variables():
         "Message={{message}} Link={{message_link}}"
     )
 
-    with patch('bot.send_message') as mock_send_message:
+    with patch('bot.flush_replies_cache', new=AsyncMock()):
         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"
-        )
+    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",
+    )
 
 @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()
@@ -1080,16 +1081,17 @@ async def test_schedule_reply_cleans_up_scheduled_message_after_send():
     scheduled_messages.clear()
     scheduled_messages[key] = ScheduledReply(task=AsyncMock(), user_id=user.id)
 
-    with patch('bot.send_message') as mock_send_message:
+    with patch('bot.flush_replies_cache', new=AsyncMock()):
         await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", ts)
 
-    mock_send_message.assert_called_once()
+    app.client.chat_postMessage.assert_awaited_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"}
+    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()
@@ -1101,16 +1103,15 @@ async def test_schedule_reply_renders_opsgenie_template_variables():
         "opsgenie_current_user": "<@U999>",
         "opsgenie_current_email": "oncall@example.com",
         "opsgenie_current_name": "On Call User",
-    })), patch('bot.send_message') as mock_send_message:
+    })), patch('bot.flush_replies_cache', new=AsyncMock()):
         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"
-        )
+    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():
@@ -1196,6 +1197,7 @@ def test_render_reply_message_template_datetime_args_override_config():
 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()
@@ -1207,21 +1209,21 @@ async def test_schedule_reply_uses_placeholder_for_unmapped_opsgenie_user():
         "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:
+    })), patch('bot.flush_replies_cache', new=AsyncMock()):
         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"
-        )
+    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_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()
@@ -1229,11 +1231,11 @@ async def test_schedule_reply_keeps_plain_message_unchanged():
     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:
+         patch('bot.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()
-        mock_send_message.assert_called_with(app, channel, user, "Anybody?", "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_post_opsgenie_alert_uses_configured_priority():
@@ -1341,6 +1343,7 @@ 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"}
+    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")
@@ -1555,6 +1558,7 @@ async def test_schedule_reply_removes_entry_from_cache():
     import bot
     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()
@@ -1679,14 +1683,16 @@ async def test_show_config_displays_none_for_missing_forward_channel():
 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('bot.send_message'):
+    with patch('bot.flush_replies_cache', new=AsyncMock()):
         await schedule_reply(app, "token", channel, config, "default", user, "Help needed", "1234.1")
 
-    app.client.chat_postMessage.assert_awaited_once_with(
+    # 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,
@@ -1697,14 +1703,16 @@ async def test_schedule_reply_forwards_to_configured_channel():
 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('bot.send_message'):
+    with patch('bot.flush_replies_cache', new=AsyncMock()):
         await schedule_reply(app, "token", channel, config, "default", user, "Help needed", "1234.1")
 
-    app.client.chat_postMessage.assert_not_awaited()
+    # 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
@@ -1928,13 +1936,46 @@ async def test_add_button_copy_on_write_and_clear():
     default_buttons_before = list(DEFAULT_CONFIG["buttons"])
     with patch('bot.save_configuration'), patch('bot.send_message'):
         await process_command(app, 'add button "Approve" approve-flow', channel, user)
-        assert channel.configs["default"]["buttons"] == [{"label": "Approve", "target": "approve-flow"}]
+        # 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('bot.save_configuration'), patch('bot.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 "Help" alert', 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": "Help", "action": "alert", "value": ""},
+        {"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"]) == 5
+
+
+@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()
@@ -2005,13 +2046,17 @@ async def test_outlook_stub_reads_env(monkeypatch):
 
 def test_build_button_blocks_structure():
     config = DEFAULT_CONFIG.copy()
-    config["buttons"] = [{"label": "Yes", "target": "yes-flow"}, {"label": "No", "target": "no-flow"}]
+    config["buttons"] = [
+        {"label": "Yes", "action": "config", "value": "yes-flow"},
+        {"label": "No", "action": "ack", "value": ""},
+    ]
     blocks = bot.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, "target": "yes-flow"}
+    assert payload == {"channel": "C12345", "config": "src", "index": 0}
 
 
 @pytest.mark.asyncio
@@ -2021,11 +2066,13 @@ async def test_run_action_reply_posts_with_buttons():
     config = DEFAULT_CONFIG.copy()
     config["action"] = bot.ACTION_REPLY
     config["reply_message"] = "Hi there"
-    config["buttons"] = [{"label": "Ok", "target": "tgt"}]
+    config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
     config["button_timeout"] = 0  # no timeout watch
     channel = _mk_channel({"src": config})
-    posted = await bot.run_action(app, "token", channel, config, "src", context=None)
-    assert posted == {"channel": "C12345", "ts": "99.1"}
+    with patch('bot.register_escalation', new=AsyncMock()) as reg:
+        posted = await bot.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"
@@ -2072,14 +2119,16 @@ async def test_handle_button_press_routes_to_target_and_cancels_timeout():
     app = AsyncMock()
     target_config = DEFAULT_CONFIG.copy()
     target_config["trigger"] = "manual"
-    channel = _mk_channel({"tgt": target_config})
+    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, "target": "tgt"})}
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
     with patch('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
          patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
          patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
@@ -2092,36 +2141,122 @@ async def test_handle_button_press_routes_to_target_and_cancels_timeout():
 
 
 @pytest.mark.asyncio
-async def test_register_and_cancel_pending_button():
+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('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
+         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('bot._post_message', new=AsyncMock()) as post, \
+         patch('bot.run_action', new=AsyncMock()) as run:
+        await bot.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_alert_fires_opsgenie_with_orig_context():
+    app = AsyncMock()
+    src_config = DEFAULT_CONFIG.copy()
+    src_config["opsgenie"] = True
+    src_config["buttons"] = [{"label": "Help needed", "action": "alert", "value": ""}]
+    channel = _mk_channel({"src": src_config})
+    bot.pending_buttons.clear()
+    bot.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('bot.cancel_pending_button', new=AsyncMock()), \
+         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('bot.fire_opsgenie_from_orig', new=AsyncMock()) as fire:
+        await bot.handle_button_press(app, "token", body, action)
+    fire.assert_awaited_once()
+    assert fire.await_args.args[3] is src_config
+    assert fire.await_args.args[4] == {"user_id": "U5", "text": "help", "ts": "9.9", "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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
+         patch('bot.reschedule_escalation', new=AsyncMock()) as resched:
+        await bot.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", "target": "tgt"}]
+    config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
     config["button_timeout"] = 3600
     config["button_timeout_target"] = "escalate"
     bot.pending_buttons.clear()
     with patch('bot.flush_button_cache', new=AsyncMock()):
-        await bot.register_pending_button(app, "token", "C12345", "10.1", "C12345", "src", config)
-        assert ("C12345", "10.1") in bot.pending_buttons
+        await bot.register_escalation(app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
+        entry = bot.pending_buttons.get(("C12345", "10.1"))
+        assert entry is not None
+        assert entry["escalation_kind"] == "config" and entry["escalation_target"] == "escalate"
         await bot.cancel_pending_button("C12345", "10.1")
         assert ("C12345", "10.1") not in bot.pending_buttons
     await asyncio.sleep(0)  # let the cancelled task settle
 
 
 @pytest.mark.asyncio
-async def test_button_timeout_runs_target():
+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")
     bot.pending_buttons.clear()
+    bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
          patch('bot.flush_button_cache', new=AsyncMock()), \
          patch('bot.run_action', new=AsyncMock()) as run:
-        await bot._button_timeout_task(app, "token", "C12345", "10.1", "C12345", "escalate", 0)
+        await bot._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_alert_fires_opsgenie():
+    app = AsyncMock()
+    src = DEFAULT_CONFIG.copy()
+    src["opsgenie"] = True
+    channel = _mk_channel({"src": src})
+    key = ("C12345", "10.1")
+    bot.pending_buttons.clear()
+    bot.pending_buttons[key] = {
+        "task": None, "posted_channel_id": "C12345", "message_ts": "10.1",
+        "def_channel_id": "C12345", "config_name": "src",
+        "escalation_kind": "alert", "escalation_target": "", "orig": {"user_id": "U5", "text": "t", "ts": "9.9", "permalink": "p"},
+    }
+    with patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.flush_button_cache', new=AsyncMock()), \
+         patch('bot.fire_opsgenie_from_orig', new=AsyncMock()) as fire:
+        await bot._escalation_task(app, "token", key, 0)
+    fire.assert_awaited_once()
+    assert fire.await_args.args[3] is src
+
+
 # ----- Scheduler -----
 
 @pytest.mark.asyncio
@@ -2184,49 +2319,30 @@ async def test_schedule_reply_routes_to_action_for_non_reply_action():
     user = User("U2", "x", "X", "T")
     with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
          patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.send_message', new=AsyncMock()) as send, \
-         patch('bot.run_action', new=AsyncMock()) as run:
+         patch('bot.run_action', new=AsyncMock(return_value={"channel": "C", "ts": "1", "text": "hi"})) as run:
         await bot.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
     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_routes_to_action_when_buttons_present():
+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["action"] = bot.ACTION_REPLY
-    cfg["buttons"] = [{"label": "Ok", "target": "tgt"}]
     cfg["reply_message"] = "hi"
     channel = _mk_channel({"src": cfg})
     user = User("U2", "x", "X", "T")
     with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
          patch('bot.flush_replies_cache', new=AsyncMock()), \
          patch('bot.send_message', new=AsyncMock()) as send, \
-         patch('bot.run_action', new=AsyncMock()) as run:
+         patch('bot.run_action', new=AsyncMock(return_value={"channel": "C", "ts": "1", "text": "hi"})) as run:
         await bot.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
     assert run.await_count == 1
     assert send.await_count == 0
 
 
-@pytest.mark.asyncio
-async def test_schedule_reply_classic_when_plain_reply():
-    app = AsyncMock()
-    cfg = DEFAULT_CONFIG.copy()  # action reply, no buttons
-    cfg["reply_message"] = "hi"
-    channel = _mk_channel({"src": cfg})
-    user = User("U2", "x", "X", "T")
-    with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.send_message', new=AsyncMock()) as send, \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
-    assert send.await_count == 1
-    assert run.await_count == 0
-
-
 # ----- action_reply threads only within the same channel -----
 
 @pytest.mark.asyncio
@@ -2241,3 +2357,172 @@ async def test_action_reply_threads_only_in_same_channel():
     app.client.chat_postMessage.reset_mock()
     await bot.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
+
+
+# ----- 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('bot.opsgenie_configured', True), \
+         patch('bot.flush_replies_cache', new=AsyncMock()), \
+         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await bot.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_schedule_reply_defers_opsgenie_when_buttons_present():
+    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
+    cfg["button_timeout"] = 600
+    cfg["buttons"] = [{"label": "Ack", "action": "ack", "value": ""}]
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('bot.opsgenie_configured', True), \
+         patch('bot.flush_replies_cache', new=AsyncMock()), \
+         patch('bot.flush_button_cache', new=AsyncMock()), \
+         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
+        bot.pending_buttons.clear()
+        await bot.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
+        # Alert is owned by the escalation, not fired inline. The escalation is
+        # keyed by the *posted reply* ts ("1" from the mock), not the original.
+        alert.assert_not_awaited()
+        entry = bot.pending_buttons.get(("C12345", "1"))
+        assert entry is not None and entry["escalation_kind"] == "alert"
+        # original message context captured for the deferred alert
+        assert entry["orig"]["text"] == "orig" and entry["orig"]["ts"] == "1.1"
+        await bot.cancel_pending_button("C12345", "1")
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_fire_opsgenie_from_orig():
+    app = AsyncMock()
+    channel = _mk_channel()
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["opsgenie"] = True
+    orig = {"user_id": "U5", "text": "help", "ts": "9.9", "permalink": "link"}
+    with patch('bot.opsgenie_configured', True), \
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
+         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await bot.fire_opsgenie_from_orig(app, "tok", channel, cfg, orig)
+    alert.assert_awaited_once()
+    args = alert.await_args.args
+    assert args[5] == "help" and args[6] == "9.9" and args[7] == "link"
+
+    # Disabled OpsGenie ⇒ no alert.
+    with patch('bot.opsgenie_configured', True), \
+         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert2:
+        await bot.fire_opsgenie_from_orig(app, "tok", channel, DEFAULT_CONFIG.copy(), orig)
+    alert2.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_register_escalation_alert_without_timeout_keeps_record():
+    # An `alert` button with no timeout still needs a record (carries orig context).
+    app = AsyncMock()
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["opsgenie"] = True
+    cfg["button_timeout"] = 0
+    cfg["buttons"] = [{"label": "Help", "action": "alert", "value": ""}]
+    bot.pending_buttons.clear()
+    with patch('bot.opsgenie_configured', True), patch('bot.flush_button_cache', new=AsyncMock()):
+        await bot.register_escalation(app, "tok", "C12345", "1.1", "C12345", "src", cfg, {"text": "t", "ts": "1.1"})
+    entry = bot.pending_buttons.get(("C12345", "1.1"))
+    assert entry is not None
+    assert entry["escalation_kind"] == "alert"
+    assert entry["task"] is None  # no timer, but record kept
+    assert entry["run_at"] == ""
+
+
+# ----- 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('bot.save_configuration'), patch('bot.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 bot._escalation_kind(cfg) == (bot.ESCALATION_BUTTON, "Yes")
+    # Unknown default-button label falls back to the config target.
+    cfg["default_button"] = "Nope"
+    assert bot._escalation_kind(cfg) == (bot.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")
+    bot.pending_buttons.clear()
+    bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.flush_button_cache', new=AsyncMock()), \
+         patch('bot._post_message', new=AsyncMock()) as post:
+        await bot._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_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('bot.save_configuration', new=AsyncMock()), patch('bot.send_message', new=AsyncMock()), \
+         patch('bot.flush_replies_cache', new=AsyncMock()), patch('bot.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).
+        bot.pending_buttons.clear()
+        await bot.schedule_reply(app, "tok", ch, cfg, "default", u, "orig", "M1", wait_time_override=0)
+        entry = bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=Channel("C1", "support", ch.configs))), \
+             patch('bot._post_message', new=AsyncMock()) as post:
+            await bot._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

From 346e034f8a874adfb2cda1940228da9ecceb2658 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 24 Jun 2026 15:22:23 +0200
Subject: [PATCH 04/42] feat(opsgenie): enable OpsGenie message template and
 make OpsGenie a config property
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Updated README to clarify button syntax, button‑gated OpsGenie workflow, and added docs for `opsgenie-message`.
- Added `opsgenie_message` field to default config and commands to set/clear it.
- Refactored button handling: removed the dedicated `alert` action, treated OpsGenie as a regular config property.
- Implemented `_render_template`, `maybe_post_opsgenie_alert`, and context handling so any config with OpsGenie enabled can fire alerts using the original message or a custom template.
- Adjusted escalation logic to use config‑level OpsGenie and pass original message context to target configs.
- Updated `show_config`, help output, and related UI messages to reflect new behavior.
- Modified tests to reflect removal of the `alert` button action and new context propagation for OpsGenie alerts.
---
 README.md   |  43 ++++++++++------
 bot.py      | 140 +++++++++++++++++++++++++++++++++-------------------
 test_bot.py | 124 ++++++++++++++++++++++++----------------------
 3 files changed, 183 insertions(+), 124 deletions(-)

diff --git a/README.md b/README.md
index 327deb5..f4d5fb7 100644
--- a/README.md
+++ b/README.md
@@ -56,18 +56,18 @@ existing configs keep working unchanged.
 
 - **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 (e.g. a `manual` rule).
-  - `/hutbot [config] add button "<label>" ack [text]` — acknowledge/dismiss: stop the escalation
-    (incl. a pending OpsGenie alert) and optionally post `text`.
+  - `/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>" alert` — send the OpsGenie alert now.
-  - `/hutbot [config] add button "<label>" delay <minutes>` — delay the escalation/alert by N minutes.
+  - `/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.
-  - `/hutbot [config] set default-button "<label>"` — on timeout, **auto-press** this button (e.g. a
-    "Yes" default). Otherwise `set button-timeout-target <config>` runs a config, or — if OpsGenie is
-    enabled — the escalation sends the OpsGenie alert. Pending escalations survive restarts.
+  - `/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
@@ -80,12 +80,25 @@ existing configs keep working unchanged.
   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 + buttons workflow**: when a reply config has OpsGenie enabled **and** buttons, the alert
-  is no longer sent immediately — it becomes the button-gated escalation. A typical setup:
-  `set button-timeout 5`, plus buttons `Acknowledge (ack)`, `Help needed (alert)`, `Delay (delay 3)`.
-  Acknowledge cancels the alert, *Help needed* sends it now, *Delay* pushes it out, and if nobody
-  presses anything within 5 minutes the alert fires automatically. (A reply config with OpsGenie but
-  **no** buttons keeps alerting immediately, as before.)
+- **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).
 
diff --git a/bot.py b/bot.py
index dabcb5d..506a2fc 100644
--- a/bot.py
+++ b/bot.py
@@ -63,17 +63,15 @@
 BUTTON_ACTION_PREFIX = "hutbot_btn"
 
 # What a button does when pressed.
-BUTTON_ACTION_CONFIG = "config"    # run another named config
+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_ALERT = "alert"      # send the OpsGenie alert now
 BUTTON_ACTION_DELAY = "delay"      # delay the pending escalation by N minutes
-BUTTON_ACTIONS = {BUTTON_ACTION_CONFIG, BUTTON_ACTION_ACK, BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ALERT, BUTTON_ACTION_DELAY}
+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_ALERT = "alert"
 ESCALATION_BUTTON = "button"  # auto-press a named button (the "default" button)
 
 DEFAULT_CONFIG = {
@@ -82,6 +80,7 @@
     "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": "",
@@ -224,6 +223,8 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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>.+)')
@@ -944,6 +945,10 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel: C
     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 CLEAR_OPSGENIE_MESSAGE_PATTERN.match(command_text):
+        await clear_opsgenie_message(app, channel, config_name, user, thread_ts)
+    elif (match := SET_OPSGENIE_MESSAGE_PATTERN.match(command_text)):
+        await set_opsgenie_message(app, channel, config_name, strip_quotes(match.group("message")), 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)):
@@ -1188,6 +1193,21 @@ async def set_opsgenie_priority(app: AsyncApp, channel: Channel, config_name: st
     await save_configuration()
     await 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: Channel, config_name: str, message: str, user: User, thread_ts: str = "") -> None:
+    message = message.strip()
+    validation_error = validate_template_expressions(message)
+    if validation_error:
+        await send_message(app, channel, user, "Invalid *OpsGenie message*: " + validation_error, thread_ts)
+        return
+    _ensure_config(channel, config_name)['opsgenie_message'] = message
+    await save_configuration()
+    await 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: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['opsgenie_message'] = ''
+    await save_configuration()
+    await 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: 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()
@@ -1776,6 +1796,7 @@ def format_table_value(value, key_width: int) -> str:
             ("OpsGenie",           ('enabled' if opsgenie_enabled else 'disabled') + ('' if 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),
@@ -1816,8 +1837,6 @@ def _button_label(b):
                     escalates_to = f"auto-press `{target}`"
                 elif kind == ESCALATION_CONFIG:
                     escalates_to = f"run `{target}`"
-                elif kind == ESCALATION_ALERT:
-                    escalates_to = "OpsGenie alert"
                 else:
                     escalates_to = "nothing"
                 rows.append(("Button timeout", f"{button_timeout_minutes} minutes → {escalates_to}"))
@@ -1901,6 +1920,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ("/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."),
@@ -1932,11 +1952,10 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ("/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."),
+        ("/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>\" alert", "Button sends the OpsGenie alert now."),
-        ("/hutbot [config] add button \"<label>\" delay <minutes>", "Button delays the OpsGenie alert/escalation."),
+        ("/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."),
@@ -2332,12 +2351,9 @@ async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel: Channel, c
                 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: fire immediately for a classic (button-less) reply. When buttons
-        # are configured, the alert is owned by the button escalation instead, so it
-        # can be acknowledged / sent now / delayed.
-        if opsgenie_configured and opsgenie_enabled and not (config.get('buttons') or []):
-            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)
+        # 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:
@@ -2772,8 +2788,8 @@ def build_button_blocks(config: dict, def_channel_id: str, config_name: str, tex
         {"type": "actions", "block_id": f"{BUTTON_ACTION_PREFIX}:{config_name}", "elements": elements},
     ]
 
-async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None) -> str:
-    template = config.get('reply_message') or ''
+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:
@@ -2790,6 +2806,26 @@ async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channe
     )
     return 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) -> 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 (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}.")
+    await post_opsgenie_alert(app, opsgenie_token, channel, config, user, alert_text, context.get('ts', ''), context.get('permalink', ''))
+
 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:
@@ -2888,6 +2924,8 @@ async def run_action(app: AsyncApp, opsgenie_token: str, channel: Channel, confi
         return None
     if posted.get('ts') and config.get('buttons'):
         await register_escalation(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config, context)
+    # 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)
     return {**posted, 'text': text}
 
 async def evaluate_condition(app: AsyncApp, config: dict) -> bool:
@@ -2935,16 +2973,14 @@ def _escalation_kind(config: dict) -> tuple[str, str]:
     target = config.get('button_timeout_target') or ''
     if target:
         return ESCALATION_CONFIG, target
-    if opsgenie_configured and config.get('opsgenie'):
-        return ESCALATION_ALERT, ''
     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) -> None:
-    """Record a buttoned message so ack/alert/delay/timeout can act on it later.
+    """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 an `alert` button needs); an escalation timer is started only when a
-    timeout is set and there is something to escalate to.
+    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
@@ -2975,17 +3011,27 @@ async def register_escalation(app: AsyncApp, opsgenie_token: str, posted_channel
     _button_states_cache[key] = entry
     await flush_button_cache()
 
-async def fire_opsgenie_from_orig(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict | None, orig: dict) -> None:
-    if not (opsgenie_configured and config and config.get('opsgenie')):
-        log_warning(f"OpsGenie alert requested in #{channel.name} but OpsGenie is not enabled/configured.")
-        return
-    orig = orig or {}
-    user_id = orig.get('user_id', '')
-    user = await get_user_by_id(app, user_id) if user_id else User(id='', name='hutbot', real_name='Hutbot', team=TEAM_UNKNOWN)
-    log(f"Sending OpsGenie alert in #{channel.name} (orig message {orig.get('ts', '')}).")
-    await post_opsgenie_alert(app, opsgenie_token, channel, config, user, orig.get('text', ''), orig.get('ts', ''), orig.get('permalink', ''))
+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 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: Channel, posted_channel_id: str, message_ts: str, src_config: dict | None, button: dict, entry: dict | None, presser: User | None = None) -> None:
+async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel: 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).
@@ -2996,25 +3042,19 @@ async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel: Ch
         if not target_config:
             log_warning(f"Button target config '{value}' not found in #{channel.name}.")
             return
-        await run_action(app, opsgenie_token, channel, target_config, value, context={
-            'channel_id': posted_channel_id,
-            'user': presser,
-            'message_ts': message_ts,
-        })
-    elif action == BUTTON_ACTION_MESSAGE:
+        await 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 _post_message(app, posted_channel_id, value, None, message_ts)
-    elif action == BUTTON_ACTION_ACK:
-        if value:
-            await _post_message(app, posted_channel_id, value, None, message_ts)
-    elif action == BUTTON_ACTION_ALERT:
-        await fire_opsgenie_from_orig(app, opsgenie_token, channel, src_config, (entry or {}).get('orig', {}))
     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 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.
         src_config = channel.configs.get(entry.get('config_name'))
@@ -3022,19 +3062,16 @@ async def _run_escalation(app: AsyncApp, opsgenie_token: str, entry: dict) -> No
         if idx is None:
             log_warning(f"Default button '{entry.get('escalation_target')}' not found in #{channel.name}.")
             return
-        log(f"No button pressed on message {entry['message_ts']}: auto-pressing '{entry.get('escalation_target')}' in #{channel.name}.")
-        await dispatch_button_action(app, opsgenie_token, channel, entry['posted_channel_id'], entry['message_ts'], src_config, (src_config['buttons'])[idx], entry)
+        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, src_config['buttons'][idx], run_context)
     elif kind == ESCALATION_CONFIG:
         target = entry.get('escalation_target', '')
         target_config = channel.configs.get(target)
         if target_config:
-            log(f"Escalating button on message {entry['message_ts']}: running '{target}' in #{channel.name}.")
-            await run_action(app, opsgenie_token, channel, target_config, target, context={'channel_id': entry['posted_channel_id']})
+            log(f"Escalating message {message_ts}: running '{target}' in #{channel.name}.")
+            await run_action(app, opsgenie_token, channel, target_config, target, context=run_context)
         else:
             log_warning(f"Escalation target '{target}' not found in #{channel.name}.")
-    elif kind == ESCALATION_ALERT:
-        src_config = channel.configs.get(entry.get('config_name'))
-        await fire_opsgenie_from_orig(app, opsgenie_token, channel, src_config, entry.get('orig', {}))
 
 async def _escalation_task(app: AsyncApp, opsgenie_token: str, key: tuple, timeout: float) -> None:
     try:
@@ -3210,8 +3247,9 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
         return
 
     # Every other button stops the pending escalation, then runs its action.
+    run_context = await _escalation_context(app, entry, posted_channel_id, message_ts, presser)
     await cancel_pending_button(posted_channel_id, message_ts)
-    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, src_config, buttons[index], entry, presser)
+    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[index], run_context)
 
 def register_app_handlers(app: AsyncApp, opsgenie_token: str = "") -> None:
 
diff --git a/test_bot.py b/test_bot.py
index 94da1ba..c4de620 100644
--- a/test_bot.py
+++ b/test_bot.py
@@ -1952,19 +1952,17 @@ async def test_add_button_typed_actions():
     with patch('bot.save_configuration'), patch('bot.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 "Help" alert', 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": "Help", "action": "alert", "value": ""},
         {"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"]) == 5
+    assert len(channel.configs["default"]["buttons"]) == 4
 
 
 @pytest.mark.asyncio
@@ -2160,24 +2158,28 @@ async def test_button_press_ack_cancels_without_running_config():
 
 
 @pytest.mark.asyncio
-async def test_button_press_alert_fires_opsgenie_with_orig_context():
+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["opsgenie"] = True
-    src_config["buttons"] = [{"label": "Help needed", "action": "alert", "value": ""}]
-    channel = _mk_channel({"src": src_config})
+    src_config["buttons"] = [{"label": "Help needed", "action": "config", "value": "oncall"}]
+    channel = _mk_channel({"src": src_config, "oncall": target_config})
     bot.pending_buttons.clear()
     bot.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('bot.cancel_pending_button', new=AsyncMock()), \
          patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
-         patch('bot.fire_opsgenie_from_orig', new=AsyncMock()) as fire:
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
+         patch('bot.run_action', new=AsyncMock()) as run:
         await bot.handle_button_press(app, "token", body, action)
-    fire.assert_awaited_once()
-    assert fire.await_args.args[3] is src_config
-    assert fire.await_args.args[4] == {"user_id": "U5", "text": "help", "ts": "9.9", "permalink": "p"}
+    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
@@ -2237,24 +2239,31 @@ async def test_escalation_task_runs_config_target():
 
 
 @pytest.mark.asyncio
-async def test_escalation_task_alert_fires_opsgenie():
+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()
-    src = DEFAULT_CONFIG.copy()
-    src["opsgenie"] = True
-    channel = _mk_channel({"src": src})
+    oncall = DEFAULT_CONFIG.copy()
+    oncall["trigger"] = "manual"
+    oncall["opsgenie"] = True
+    channel = _mk_channel({"oncall": oncall})
     key = ("C12345", "10.1")
     bot.pending_buttons.clear()
     bot.pending_buttons[key] = {
         "task": None, "posted_channel_id": "C12345", "message_ts": "10.1",
         "def_channel_id": "C12345", "config_name": "src",
-        "escalation_kind": "alert", "escalation_target": "", "orig": {"user_id": "U5", "text": "t", "ts": "9.9", "permalink": "p"},
+        "escalation_kind": "config", "escalation_target": "oncall",
+        "orig": {"user_id": "U5", "text": "DB down", "ts": "9.9", "permalink": "p"},
     }
     with patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
          patch('bot.flush_button_cache', new=AsyncMock()), \
-         patch('bot.fire_opsgenie_from_orig', new=AsyncMock()) as fire:
+         patch('bot.run_action', new=AsyncMock()) as run:
         await bot._escalation_task(app, "token", key, 0)
-    fire.assert_awaited_once()
-    assert fire.await_args.args[3] is src
+    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"
 
 
 # ----- Scheduler -----
@@ -2378,71 +2387,69 @@ async def test_schedule_reply_fires_opsgenie_inline_without_buttons():
 
 
 @pytest.mark.asyncio
-async def test_schedule_reply_defers_opsgenie_when_buttons_present():
+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_getPermalink.return_value = {"permalink": "p"}
     app.client.chat_postMessage.return_value = {"ts": "1"}
     cfg = DEFAULT_CONFIG.copy()
     cfg["opsgenie"] = True
-    cfg["button_timeout"] = 600
-    cfg["buttons"] = [{"label": "Ack", "action": "ack", "value": ""}]
+    cfg["reply_message"] = "ping"
     channel = _mk_channel({"src": cfg})
-    user = User("U2", "x", "X", "T")
+    ctx = {"channel_id": "C12345", "user": User("U5", "carol", "Carol", "T"), "text": "DB down", "ts": "9.9", "permalink": "link"}
     with patch('bot.opsgenie_configured', True), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.flush_button_cache', new=AsyncMock()), \
          patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
-        bot.pending_buttons.clear()
-        await bot.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
-        # Alert is owned by the escalation, not fired inline. The escalation is
-        # keyed by the *posted reply* ts ("1" from the mock), not the original.
-        alert.assert_not_awaited()
-        entry = bot.pending_buttons.get(("C12345", "1"))
-        assert entry is not None and entry["escalation_kind"] == "alert"
-        # original message context captured for the deferred alert
-        assert entry["orig"]["text"] == "orig" and entry["orig"]["ts"] == "1.1"
-        await bot.cancel_pending_button("C12345", "1")
-    await asyncio.sleep(0)
+        await bot.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_fire_opsgenie_from_orig():
+async def test_run_action_opsgenie_message_template_overrides():
     app = AsyncMock()
-    channel = _mk_channel()
+    app.client.chat_postMessage.return_value = {"ts": "1"}
     cfg = DEFAULT_CONFIG.copy()
     cfg["opsgenie"] = True
-    orig = {"user_id": "U5", "text": "help", "ts": "9.9", "permalink": "link"}
+    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('bot.opsgenie_configured', True), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
          patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
-        await bot.fire_opsgenie_from_orig(app, "tok", channel, cfg, orig)
+        await bot.run_action(app, "tok", channel, cfg, "src", context=ctx)
     alert.assert_awaited_once()
-    args = alert.await_args.args
-    assert args[5] == "help" and args[6] == "9.9" and args[7] == "link"
+    assert alert.await_args.args[5] == "Unanswered in #general: DB down"
+
 
-    # Disabled OpsGenie ⇒ no alert.
+@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('bot.opsgenie_configured', True), \
-         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert2:
-        await bot.fire_opsgenie_from_orig(app, "tok", channel, DEFAULT_CONFIG.copy(), orig)
-    alert2.assert_not_awaited()
+         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await bot.run_action(app, "tok", channel, cfg, "src", context={"channel_id": "C12345"})
+    alert.assert_not_awaited()
 
 
 @pytest.mark.asyncio
-async def test_register_escalation_alert_without_timeout_keeps_record():
-    # An `alert` button with no timeout still needs a record (carries orig context).
+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["opsgenie"] = True
     cfg["button_timeout"] = 0
-    cfg["buttons"] = [{"label": "Help", "action": "alert", "value": ""}]
+    cfg["buttons"] = [{"label": "Yes", "action": "config", "value": "flow"}]
     bot.pending_buttons.clear()
-    with patch('bot.opsgenie_configured', True), patch('bot.flush_button_cache', new=AsyncMock()):
-        await bot.register_escalation(app, "tok", "C12345", "1.1", "C12345", "src", cfg, {"text": "t", "ts": "1.1"})
+    with patch('bot.flush_button_cache', new=AsyncMock()):
+        await bot.register_escalation(app, "tok", "C12345", "1.1", "C12345", "src", cfg, {"text": "t", "ts": "1.1", "permalink": "p"})
     entry = bot.pending_buttons.get(("C12345", "1.1"))
     assert entry is not None
-    assert entry["escalation_kind"] == "alert"
-    assert entry["task"] is None  # no timer, but record kept
-    assert entry["run_at"] == ""
+    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 -----
@@ -2522,6 +2529,7 @@ async def test_need_help_yes_no_workflow_end_to_end():
 
         # No press within timeout ⇒ escalation auto-presses Yes ⇒ posts the help message.
         with patch('bot.get_channel_by_id', new=AsyncMock(return_value=Channel("C1", "support", ch.configs))), \
+             patch('bot.get_user_by_id', new=AsyncMock(return_value=u)), \
              patch('bot._post_message', new=AsyncMock()) as post:
             await bot._escalation_task(app, "tok", ("C1", "R1"), 0)
         post.assert_awaited_once_with(app, "C1", "Here is the help doc", None, "R1")

From b40415ba9f03c0cbe14fd887e6fb31b5f958f1fe Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 24 Jun 2026 16:44:25 +0200
Subject: [PATCH 05/42] feat(news): add schedule and button details to news
 message
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Updated the news message text to highlight new capabilities:
- Triggers, actions, and interactive buttons now supported.
- Rules can run on a schedule (cron), DM users or groups, post to channels, and include auto‑press defaults with timeout escalation.
- Provides users with a concise overview of these features directly in the `/hutbot help` output.
---
 bot.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bot.py b/bot.py
index 506a2fc..0511515 100644
--- a/bot.py
+++ b/bot.py
@@ -1894,6 +1894,8 @@ async def send_message(app: AsyncApp, channel: Channel, user: User, text: str, t
 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"

From ba1f338eb54d6fe37496307dee9f8c68167c160f Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 24 Jun 2026 18:28:29 +0200
Subject: [PATCH 06/42] feat(ui): add web configuration UI for rule management
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Expose HTTP port 8080 in Dockerfile and enable optional UI via env vars
- Document UI setup, endpoints, and Helm chart configuration in README
- Implement UI backend helpers in `bot.py` for validation, channel membership, and config CRUD
- Add `maybe_start_web_ui` to launch aiohttp UI when enabled
- Extend Helm chart (Chart.yaml bump to 0.1.3) with UI service, ingress, and network policy resources
- Include new Helm values under `ui:` to configure enablement, port, host, headers, service, and ingress
- Add `webui.py` aiohttp server with routes, security headers, and UI context bridging
- Provide static assets (`app.js`, `index.html`, `styles.css`) for the single‑page UI
- Add tests for UI helper functions and CRUD operations
- Adjust main loop to start and clean up the UI runner
- Minor updates to other files to integrate the new functionality.
---
 Dockerfile                                 |   2 +
 README.md                                  |  76 +++
 bot.py                                     | 415 ++++++++++++++
 charts/hutbot/Chart.yaml                   |   2 +-
 charts/hutbot/templates/deployment.yaml    |  35 +-
 charts/hutbot/templates/ingress.yaml       |  31 ++
 charts/hutbot/templates/networkpolicy.yaml |   9 +
 charts/hutbot/templates/service.yaml       |  17 +
 charts/hutbot/values.yaml                  |  16 +
 test_bot.py                                | 203 +++++++
 webui.py                                   | 225 ++++++++
 webui_static/app.js                        | 619 +++++++++++++++++++++
 webui_static/index.html                    |  46 ++
 webui_static/styles.css                    | 402 +++++++++++++
 14 files changed, 2096 insertions(+), 2 deletions(-)
 create mode 100644 charts/hutbot/templates/ingress.yaml
 create mode 100644 charts/hutbot/templates/service.yaml
 create mode 100644 webui.py
 create mode 100644 webui_static/app.js
 create mode 100644 webui_static/index.html
 create mode 100644 webui_static/styles.css

diff --git a/Dockerfile b/Dockerfile
index 4375039..daf2947 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,4 +8,6 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
+EXPOSE 8080
+
 ENTRYPOINT ["python", "bot.py"]
diff --git a/README.md b/README.md
index f4d5fb7..f034f35 100644
--- a/README.md
+++ b/README.md
@@ -102,6 +102,82 @@ existing configs keep working unchanged.
 
 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 bot.py
+```
+
+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.
+
 ## Step 1: Set Up the Slack App
 
 1. **Create a New Slack App**
diff --git a/bot.py b/bot.py
index 0511515..079cb6b 100644
--- a/bot.py
+++ b/bot.py
@@ -1,6 +1,8 @@
 import os
 import re
 import sys
+import copy
+import time
 import collections
 import asyncio
 import json
@@ -3317,6 +3319,415 @@ async def send_heartbeat(opsgenie_token: str, opsgenie_heartbeat_name: str) -> N
                 log_error(f"Exception while sending heartbeat:", e)
             await asyncio.sleep(60)
 
+# ===================================================================
+# Web UI backend — channel membership, validation, and config writes.
+# The aiohttp server itself lives in webui.py; these helpers are the
+# bridge to the live bot state and reuse the same validation as the
+# slash-command setters above.
+# ===================================================================
+
+# Slack member ids per channel, cached briefly so listing a user's
+# channels doesn't hammer conversations.members on every UI request.
+_channel_members_cache: dict[str, tuple[float, set]] = {}
+_CHANNEL_MEMBERS_TTL = 300.0
+
+# Serializes UI config writes (mutate channel_config + save_configuration).
+_config_write_lock = asyncio.Lock()
+
+
+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 = _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()
+    _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)
+
+
+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(channel_config.keys()):
+        if await is_user_in_channel(app, channel_id, user.id):
+            channels.append({'id': channel_id, 'name': await 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 process_mentions(app, reply_message)
+        if not ok:
+            errors['reply_message'] = f"Unknown user mention: {mention_error}."
+        else:
+            template_error = 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 = 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:
+            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'] = 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 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 team_cache]
+    unknown_excluded = [team for team in excluded if team not in 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 = parse_time(str(hours_value[0]))
+        end_time = 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 _config_write_lock:
+        channel_config.setdefault(channel_id, {})[config_name] = clean
+        await 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 _config_write_lock:
+        configs = 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 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 _config_write_lock:
+        configs = channel_config.get(channel_id, {})
+        if config_name not in configs:
+            return False, "That rule no longer exists."
+        del configs[config_name]
+        await 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(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 team_cache if t and t != TEAM_UNKNOWN), key=lambda v: v.upper()),
+        'template_variables': sorted(SUPPORTED_TEMPLATE_VARIABLES),
+        'opsgenie_configured': 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: get_user_by_email(app, email),
+        list_channels=lambda user: list_user_config_channels(app, user),
+        is_member=lambda channel_id, user_id: 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)
+
+
 async def main() -> None:
     load_env_file()
     slack_app_token = get_env_var("SLACK_APP_TOKEN")
@@ -3330,6 +3741,7 @@ async def main() -> None:
     handler = None
     heartbeat_task = None
     scheduler_task = None
+    web_runner = None
     try:
         app = AsyncApp(token=slack_bot_token)
         await load_configuration(app)
@@ -3347,6 +3759,7 @@ async def main() -> None:
             opsgenie_configured = True
             heartbeat_task = asyncio.create_task(send_heartbeat(opsgenie_token, opsgenie_heartbeat_name))
         scheduler_task = asyncio.create_task(run_scheduler(app, opsgenie_token))
+        web_runner = await maybe_start_web_ui(app)
         await handler.start_async()
     except asyncio.CancelledError:
         pass
@@ -3357,6 +3770,8 @@ async def main() -> None:
         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):
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 96c1e17..26ece39 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -25,8 +25,14 @@ 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
@@ -35,10 +41,37 @@ spec:
               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..a10ede4 100644
--- a/charts/hutbot/templates/networkpolicy.yaml
+++ b/charts/hutbot/templates/networkpolicy.yaml
@@ -13,6 +13,15 @@ spec:
       app: {{ .Release.Name }}
   policyTypes:
   - Egress
+  {{- if .Values.ui.enabled }}
+  - Ingress
+  {{- end }}
+  {{- if .Values.ui.enabled }}
+  ingress:
+  - ports:
+    - port: {{ .Values.ui.port }}
+      protocol: TCP
+  {{- 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..c849f42 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -22,6 +22,22 @@ 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"
+  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/test_bot.py b/test_bot.py
index c4de620..87b8975 100644
--- a/test_bot.py
+++ b/test_bot.py
@@ -15,6 +15,8 @@
     extract_message_text, _scheduled_replies_cache,
     set_forward_channel, clear_forward_channel,
     set_replies_enabled,
+    validate_config_payload, get_channel_members, is_user_in_channel,
+    list_user_config_channels, ui_create_config, ui_delete_config,
 )
 from slack_sdk.errors import SlackApiError
 import base64
@@ -2534,3 +2536,204 @@ async def test_need_help_yes_no_workflow_end_to_end():
             await bot._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
+
+
+# ---------------------------------------------------------------------------
+# Web-UI backend helpers: validate_config_payload / membership / ui create+delete
+# ---------------------------------------------------------------------------
+import bot
+
+
+def _seed_user_caches():
+    """Pre-seed module caches so update_user_cache short-circuits (no Slack calls)."""
+    bot.team_cache = {"Platform", "Support"}
+    bot.user_id_cache = {"someuser": bot.User(id="U1", name="someuser", real_name="X", team="Platform")}
+    bot.user_email_cache = {"x@example.com": bot.User(id="U1", name="someuser", real_name="X", team="Platform")}
+    bot.id_user_cache = {"U1": bot.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
+
+
+@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_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
+
+
+@pytest.mark.asyncio
+async def test_is_user_in_channel_true_false():
+    bot._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():
+    bot._channel_members_cache = {}
+    bot.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 = bot.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):
+    bot.channel_config = {}
+    monkeypatch.setattr(bot, "save_configuration", AsyncMock())
+    app = _ui_app()
+
+    # bad name (space not allowed by the name pattern)
+    ok, msg = await bot.ui_create_config(app, "C1", "bad name")
+    assert ok is False and msg
+
+    # good name succeeds and seeds from DEFAULT_CONFIG
+    ok, msg = await bot.ui_create_config(app, "C1", "my-rule")
+    assert ok is True
+    assert bot.channel_config["C1"]["my-rule"]["reply_message"] == bot.DEFAULT_CONFIG["reply_message"]
+    bot.save_configuration.assert_awaited()
+
+    # duplicate is rejected
+    ok, msg = await bot.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):
+    bot.channel_config = {"C1": {"default": {}, "my-rule": {}}}
+    monkeypatch.setattr(bot, "save_configuration", AsyncMock())
+    app = _ui_app()
+
+    ok, msg = await bot.ui_delete_config(app, "C1", "default")
+    assert ok is False and msg
+    assert "default" in bot.channel_config["C1"]
+
+    ok, msg = await bot.ui_delete_config(app, "C1", "my-rule")
+    assert ok is True
+    assert "my-rule" not in bot.channel_config["C1"]
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; }
+}

From b0cdfcb66dc7daeb523fa601350351615f0ad567 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 25 Jun 2026 08:12:33 +0200
Subject: [PATCH 07/42] Complete refactor

---
 .github/workflows/docker-publish.yml |   26 +-
 Dockerfile                           |    2 +-
 README.md                            |   33 +-
 bot.py                               | 3788 --------------------------
 hutbot/__init__.py                   |    8 +
 hutbot/__main__.py                   |   76 +
 hutbot/actions.py                    |  172 ++
 hutbot/buttons.py                    |  281 ++
 hutbot/buttonutil.py                 |   28 +
 hutbot/commands/__init__.py          |    9 +
 hutbot/commands/dispatch.py          |  158 ++
 hutbot/commands/info.py              |  206 ++
 hutbot/commands/patterns.py          |   59 +
 hutbot/commands/setters.py           |  599 ++++
 hutbot/constants.py                  |  149 +
 hutbot/datetimefmt.py                |  247 ++
 hutbot/messaging.py                  |  243 ++
 hutbot/models.py                     |   21 +
 hutbot/opsgenie.py                   |  424 +++
 hutbot/persistence.py                |  118 +
 hutbot/routing.py                    |  255 ++
 hutbot/scheduling.py                 |  157 ++
 hutbot/slackcache.py                 |  259 ++
 hutbot/state.py                      |   68 +
 hutbot/targets.py                    |   52 +
 hutbot/templating.py                 |  236 ++
 hutbot/textutil.py                   |   95 +
 hutbot/webui_backend.py              |  416 +++
 pyproject.toml                       |    5 +
 requirements-dev.txt                 |    3 +
 test_bot.py                          | 2739 -------------------
 tests/__init__.py                    |    0
 tests/_common.py                     |   76 +
 tests/conftest.py                    |   12 +
 tests/test_actions.py                |  150 +
 tests/test_buttons.py                |  336 +++
 tests/test_commands_info.py          |  224 ++
 tests/test_commands_setters.py       |  284 ++
 tests/test_datetimefmt.py            |   28 +
 tests/test_opsgenie.py               |  790 ++++++
 tests/test_persistence.py            |   68 +
 tests/test_routing.py                |  349 +++
 tests/test_scheduling.py             |  304 +++
 tests/test_templating.py             |  125 +
 tests/test_textutil.py               |   63 +
 tests/test_webui_backend.py          |  176 ++
 46 files changed, 7386 insertions(+), 6531 deletions(-)
 delete mode 100644 bot.py
 create mode 100644 hutbot/__init__.py
 create mode 100644 hutbot/__main__.py
 create mode 100644 hutbot/actions.py
 create mode 100644 hutbot/buttons.py
 create mode 100644 hutbot/buttonutil.py
 create mode 100644 hutbot/commands/__init__.py
 create mode 100644 hutbot/commands/dispatch.py
 create mode 100644 hutbot/commands/info.py
 create mode 100644 hutbot/commands/patterns.py
 create mode 100644 hutbot/commands/setters.py
 create mode 100644 hutbot/constants.py
 create mode 100644 hutbot/datetimefmt.py
 create mode 100644 hutbot/messaging.py
 create mode 100644 hutbot/models.py
 create mode 100644 hutbot/opsgenie.py
 create mode 100644 hutbot/persistence.py
 create mode 100644 hutbot/routing.py
 create mode 100644 hutbot/scheduling.py
 create mode 100644 hutbot/slackcache.py
 create mode 100644 hutbot/state.py
 create mode 100644 hutbot/targets.py
 create mode 100644 hutbot/templating.py
 create mode 100644 hutbot/textutil.py
 create mode 100644 hutbot/webui_backend.py
 create mode 100644 pyproject.toml
 create mode 100644 requirements-dev.txt
 delete mode 100644 test_bot.py
 create mode 100644 tests/__init__.py
 create mode 100644 tests/_common.py
 create mode 100644 tests/conftest.py
 create mode 100644 tests/test_actions.py
 create mode 100644 tests/test_buttons.py
 create mode 100644 tests/test_commands_info.py
 create mode 100644 tests/test_commands_setters.py
 create mode 100644 tests/test_datetimefmt.py
 create mode 100644 tests/test_opsgenie.py
 create mode 100644 tests/test_persistence.py
 create mode 100644 tests/test_routing.py
 create mode 100644 tests/test_scheduling.py
 create mode 100644 tests/test_templating.py
 create mode 100644 tests/test_textutil.py
 create mode 100644 tests/test_webui_backend.py

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/Dockerfile b/Dockerfile
index daf2947..3f9bfd5 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -10,4 +10,4 @@ COPY . .
 
 EXPOSE 8080
 
-ENTRYPOINT ["python", "bot.py"]
+ENTRYPOINT ["python", "-m", "hutbot"]
diff --git a/README.md b/README.md
index f034f35..0053dc9 100644
--- a/README.md
+++ b/README.md
@@ -126,7 +126,7 @@ export HUTBOT_UI_ENABLED=1
 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 bot.py
+python -m hutbot
 ```
 
 Then test with a manual header:
@@ -258,7 +258,7 @@ is the operator's responsibility — Hutbot only consumes the resulting header.
 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)
@@ -355,3 +355,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 079cb6b..0000000
--- a/bot.py
+++ /dev/null
@@ -1,3788 +0,0 @@
-import os
-import re
-import sys
-import copy
-import time
-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,
-)
-import outlook
-
-try:
-    from croniter import croniter
-except ImportError:  # pragma: no cover - dependency optional at runtime
-    croniter = None
-
-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"}
-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' ])
-
-channel_config = {}
-scheduled_messages = {}
-_scheduled_replies_cache: dict[tuple, dict] = {}
-
-# Pending interactive-button messages awaiting a press, keyed by (channel_id, message_ts).
-# Value: {'task': asyncio.Task, 'channel_id', 'message_ts', 'config_name', 'target', 'run_at'}.
-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
-
-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>.+)')
-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)
-
-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
-            # 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:
-    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 CLEAR_OPSGENIE_MESSAGE_PATTERN.match(command_text):
-        await clear_opsgenie_message(app, channel, config_name, user, thread_ts)
-    elif (match := SET_OPSGENIE_MESSAGE_PATTERN.match(command_text)):
-        await set_opsgenie_message(app, channel, config_name, strip_quotes(match.group("message")), 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 (match := SET_TRIGGER_PATTERN.match(command_text)):
-        await set_trigger(app, channel, config_name, match.group("trigger"), user, thread_ts)
-    elif (match := SET_CRON_PATTERN.match(command_text)):
-        await set_schedule_cron(app, channel, config_name, match.group("cron"), user, thread_ts)
-    elif (match := SET_SCHEDULE_TIMEZONE_PATTERN.match(command_text)):
-        await set_schedule_timezone(app, channel, config_name, match.group("tz"), user, thread_ts)
-    elif (match := SET_CONDITION_PATTERN.match(command_text)):
-        await set_condition(app, channel, config_name, match.group("condition"), user, thread_ts)
-    elif (match := SET_OUTLOOK_SUBJECT_PATTERN.match(command_text)):
-        await set_outlook_pattern(app, channel, config_name, "outlook_subject_pattern", match.group("pattern"), user, thread_ts)
-    elif (match := SET_OUTLOOK_BODY_PATTERN.match(command_text)):
-        await set_outlook_pattern(app, channel, config_name, "outlook_body_pattern", match.group("pattern"), user, thread_ts)
-    elif ENABLE_CONDITION_NEGATE_PATTERN.match(command_text):
-        await set_condition_negate(app, channel, config_name, True, user, thread_ts)
-    elif DISABLE_CONDITION_NEGATE_PATTERN.match(command_text):
-        await set_condition_negate(app, channel, config_name, False, user, thread_ts)
-    elif (match := SET_ACTION_PATTERN.match(command_text)):
-        await set_action(app, channel, config_name, match.group("action"), user, thread_ts)
-    elif (match := SET_TARGET_PATTERN.match(command_text)):
-        await set_action_target(app, channel, config_name, match.group("target"), user, thread_ts)
-    elif (match := ADD_BUTTON_PATTERN.match(command_text)):
-        await add_button(app, channel, config_name, match.group("label"), match.group("spec"), user, thread_ts)
-    elif CLEAR_BUTTONS_PATTERN.match(command_text):
-        await clear_buttons(app, channel, config_name, user, thread_ts)
-    elif CLEAR_DEFAULT_BUTTON_PATTERN.match(command_text):
-        await clear_default_button(app, channel, config_name, user, thread_ts)
-    elif (match := SET_DEFAULT_BUTTON_PATTERN.match(command_text)):
-        await set_default_button(app, channel, config_name, match.group("label"), user, thread_ts)
-    elif (match := SET_BUTTON_TIMEOUT_TARGET_PATTERN.match(command_text)):
-        await set_button_timeout_target(app, channel, config_name, match.group("target"), user, thread_ts)
-    elif (match := SET_BUTTON_TIMEOUT_PATTERN.match(command_text)):
-        await set_button_timeout(app, channel, config_name, match.group("minutes"), user, thread_ts)
-    elif RUN_PATTERN.match(command_text):
-        await run_config_now(app, opsgenie_token, 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_opsgenie_message(app: AsyncApp, channel: Channel, config_name: str, message: str, user: User, thread_ts: str = "") -> None:
-    message = message.strip()
-    validation_error = validate_template_expressions(message)
-    if validation_error:
-        await send_message(app, channel, user, "Invalid *OpsGenie message*: " + validation_error, thread_ts)
-        return
-    _ensure_config(channel, config_name)['opsgenie_message'] = message
-    await save_configuration()
-    await 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: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    _ensure_config(channel, config_name)['opsgenie_message'] = ''
-    await save_configuration()
-    await 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: 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)
-
-# ----- Setters for trigger / condition / action / button fields -----
-
-def _ensure_config(channel: 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_trigger(app: AsyncApp, channel: Channel, config_name: str, value: str, user: 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 send_message(app, channel, user, f"Invalid *trigger*. Must be one of {supported}.", thread_ts)
-        return
-    _ensure_config(channel, config_name)['trigger'] = value
-    await save_configuration()
-    await send_message(app, channel, user, f"*Trigger* set to `{value}` in configuration `{config_name}`.", thread_ts)
-
-async def set_schedule_cron(app: AsyncApp, channel: Channel, config_name: str, cron_expr: str, user: User, thread_ts: str = "") -> None:
-    cron_expr = strip_quotes(cron_expr).strip()
-    if not cron_expr:
-        await 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 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 save_configuration()
-    note = "" if croniter is not None else " (not validated — `croniter` not installed)"
-    await 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: Channel, config_name: str, tz_name: str, user: User, thread_ts: str = "") -> None:
-    tz_name = strip_quotes(tz_name).strip()
-    if tz_name:
-        try:
-            ZoneInfo(tz_name)
-        except ZoneInfoNotFoundError:
-            await 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 save_configuration()
-    await 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: Channel, config_name: str, value: str, user: 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 send_message(app, channel, user, "Invalid *condition*. Must be `none` or `outlook`.", thread_ts)
-        return
-    _ensure_config(channel, config_name)['condition'] = value
-    await save_configuration()
-    label = value or 'none'
-    await send_message(app, channel, user, f"*Condition* set to `{label}` in configuration `{config_name}`.", thread_ts)
-
-async def set_outlook_pattern(app: AsyncApp, channel: Channel, config_name: str, field: str, pattern_str: str, user: User, thread_ts: str = "") -> None:
-    pattern_str = strip_quotes(pattern_str)
-    try:
-        re.compile(pattern_str)
-    except re.error as e:
-        await send_message(app, channel, user, f"Invalid pattern: `{e}`", thread_ts)
-        return
-    _ensure_config(channel, config_name)[field] = pattern_str
-    await save_configuration()
-    which = "subject" if field == "outlook_subject_pattern" else "body"
-    await 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: Channel, config_name: str, enabled: bool, user: User, thread_ts: str = "") -> None:
-    _ensure_config(channel, config_name)['condition_negate'] = enabled
-    await save_configuration()
-    await 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: Channel, config_name: str, value: str, user: 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 send_message(app, channel, user, f"Invalid *action*. Must be one of {supported}.", thread_ts)
-        return
-    _ensure_config(channel, config_name)['action'] = value
-    await save_configuration()
-    await send_message(app, channel, user, f"*Action* set to `{value}` in configuration `{config_name}`.", thread_ts)
-
-async def set_action_target(app: AsyncApp, channel: Channel, config_name: str, target: str, user: User, thread_ts: str = "") -> None:
-    target = strip_quotes(target).strip()
-    if not target:
-        await send_message(app, channel, user, "Invalid *target*. Must be non-empty.", thread_ts)
-        return
-    _ensure_config(channel, config_name)['action_target'] = target
-    await save_configuration()
-    await send_message(app, channel, user, f"*Action target* set to `{target}` in configuration `{config_name}`.", thread_ts)
-
-async def add_button(app: AsyncApp, channel: Channel, config_name: str, label: str, spec: str, user: User, thread_ts: str = "") -> None:
-    label = strip_quotes(label).strip()
-    if not label:
-        await 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 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 send_message(app, channel, user, "Invalid *button*. `delay` needs a number of minutes.", thread_ts)
-            return
-        if minutes <= 0 or minutes > 1440:
-            await 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 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 send_message(app, channel, user, f"Added button `{label}` ({descriptor}) in configuration `{config_name}`{warning}.", thread_ts)
-
-async def clear_buttons(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    _ensure_config(channel, config_name)['buttons'] = []
-    await save_configuration()
-    await send_message(app, channel, user, f"Cleared *buttons* in configuration `{config_name}`.", thread_ts)
-
-async def set_default_button(app: AsyncApp, channel: Channel, config_name: str, label: str, user: User, thread_ts: str = "") -> None:
-    label = strip_quotes(label).strip()
-    if not label:
-        await 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 save_configuration()
-    warning = "" if _find_button_index(config, label) is not None else f" :warning: (no button labelled `{label}` yet)"
-    await 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: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    _ensure_config(channel, config_name)['default_button'] = ''
-    await save_configuration()
-    await send_message(app, channel, user, f"Cleared *default button* in configuration `{config_name}`.", thread_ts)
-
-async def set_button_timeout(app: AsyncApp, channel: Channel, config_name: str, minutes_str: str, user: User, thread_ts: str = "") -> None:
-    try:
-        minutes = int(strip_quotes(minutes_str).strip())
-    except ValueError:
-        await 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 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 save_configuration()
-    label = f"`{minutes}` minutes" if minutes else "disabled"
-    await 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: Channel, config_name: str, target: str, user: User, thread_ts: str = "") -> None:
-    target = strip_quotes(target).strip()
-    if not target:
-        await 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 save_configuration()
-    warning = "" if target in channel.configs else f" :warning: (configuration `{target}` does not exist yet)"
-    await 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: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    config = channel.configs.get(config_name)
-    if not config:
-        await send_message(app, channel, user, f"Configuration `{config_name}` not found.", thread_ts)
-        return
-    await send_message(app, channel, user, f"Running configuration `{config_name}` now…", thread_ts)
-    await run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel.id, 'user': user})
-
-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)
-        trigger = config.get('trigger', TRIGGER_MESSAGE)
-        action = config.get('action', ACTION_REPLY)
-
-        rows = [
-            ("Trigger",            trigger),
-            ("OpsGenie",           ('enabled' if opsgenie_enabled else 'disabled') + ('' if 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>'))
-        buttons = config.get('buttons') or []
-        if 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 buttons]))
-            button_timeout_minutes = (config.get('button_timeout') or 0) // 60
-            if button_timeout_minutes:
-                kind, target = _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 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"
-        "> :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)
-
-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)
-        # 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 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:
-        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 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 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)
-
-# ---------------------------------------------------------------------------
-# Trigger / condition / action engine
-#
-# A "rule" is a named channel config. Its `trigger` decides how it starts
-# (message | schedule | manual), its `condition` optionally gates it, and its
-# `action` decides what it does. Buttons and button-timeouts reference other
-# named configs (trigger == manual) in the same channel as their targets.
-# ---------------------------------------------------------------------------
-
-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 get_user_by_id(app, ident[1:])
-    if re.match(r'^[UW][A-Z0-9]+$', target):
-        return await get_user_by_id(app, target)
-    if target.startswith('@'):
-        return await get_user_by_name(app, normalize_id(target[1:]))
-    if '@' in target:
-        return await get_user_by_email(app, target)
-    return await 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 get_usergroup_by_id(app, match.group(1))
-    if re.match(r'^S[A-Z0-9]+$', target):
-        return await get_usergroup_by_id(app, target)
-    handle = target[1:] if target.startswith('@') else target
-    return await get_usergroup_by_handle(app, handle)
-
-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 []
-
-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
-
-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},
-    ]
-
-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=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 get_message_permalink(app, channel, ts) if ts else ""
-    template_variables = find_template_variables(template)
-    variables = 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)),
-    )
-    return 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) -> 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 (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}.")
-    await post_opsgenie_alert(app, opsgenie_token, channel, config, user, alert_text, context.get('ts', ''), context.get('permalink', ''))
-
-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 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 _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 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 _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 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 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 _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 = parse_channel_ref(target)
-    if not channel_id:
-        log_error(f"Action post_channel: invalid channel target '{target}'.")
-        return None
-    return await _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 = 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 register_escalation(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config, context)
-    # 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)
-    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
-
-# ----- Button-press timeout tracking + persistence (mirrors scheduled replies) -----
-
-async def load_button_cache() -> None:
-    global _button_states_cache
-    try:
-        async with aiofiles.open(BUTTON_CACHE_FILE, 'r') as f:
-            entries = json.loads(await f.read())
-            _button_states_cache = {
-                (e['posted_channel_id'], e['message_ts']): e for e in entries
-            }
-            log(f"Loaded {len(_button_states_cache)} pending button states from cache.")
-    except FileNotFoundError:
-        _button_states_cache = {}
-    except Exception as e:
-        log_error("Failed to load button states cache:", e)
-        _button_states_cache = {}
-
-async def flush_button_cache() -> None:
-    try:
-        async with aiofiles.open(BUTTON_CACHE_FILE, 'w') as f:
-            await f.write(json.dumps(list(_button_states_cache.values()), indent=2))
-    except Exception as e:
-        log_error("Failed to flush button states cache:", e)
-
-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) -> 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,
-        '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
-    pending_buttons[key] = {'task': task, **entry}
-    _button_states_cache[key] = entry
-    await 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 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: 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 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 _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 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.
-        src_config = channel.configs.get(entry.get('config_name'))
-        idx = _find_button_index(src_config, entry.get('escalation_target', ''))
-        if idx is None:
-            log_warning(f"Default button '{entry.get('escalation_target')}' not found in #{channel.name}.")
-            return
-        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, src_config['buttons'][idx], run_context)
-    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 run_action(app, opsgenie_token, channel, target_config, target, context=run_context)
-        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 = 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:
-        pending_buttons.pop(key, None)
-        _button_states_cache.pop(key, None)
-        await flush_button_cache()
-
-async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None:
-    key = (posted_channel_id, message_ts)
-    entry = pending_buttons.pop(key, None)
-    _button_states_cache.pop(key, None)
-    if entry:
-        if entry.get('task'):
-            entry['task'].cancel()
-        await 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 = 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))
-    pending_buttons[key] = {'task': task, **record}
-    _button_states_cache[key] = record
-    await flush_button_cache()
-    return True
-
-async def restore_pending_buttons(app: AsyncApp, opsgenie_token: str) -> None:
-    entries = list(_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 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
-        pending_buttons[key] = {'task': task, **entry}
-        restored += 1
-    for key in invalid_keys:
-        _button_states_cache.pop(key, None)
-    if invalid_keys:
-        await flush_button_cache()
-    log(f"Restored {restored} pending button escalations.")
-
-# ----- Scheduler (cron triggers) -----
-
-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:
-    global _scheduler_last_check
-    if croniter is None:
-        log_warning("croniter is not installed; scheduled triggers are disabled.")
-        return
-    _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:
-    global _scheduler_last_check
-    now = datetime.datetime.now(datetime.timezone.utc)
-    last = _scheduler_last_check or now
-    _scheduler_last_check = now
-    for channel_id, configs in list(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 get_channel_by_id(app, channel_id)
-            if not await 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 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 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 get_user_by_id(app, presser_id) if presser_id else None
-    presser_name = presser.name if presser else '?'
-
-    channel = await get_channel_by_id(app, def_channel_id)
-    src_config = channel.configs.get(src_config_name)
-    buttons = (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])
-    entry = pending_buttons.get((posted_channel_id, message_ts))
-    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.
-    run_context = await _escalation_context(app, entry, posted_channel_id, message_ts, presser)
-    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)
-
-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 handle_button_press(app, opsgenie_token, body, action)
-
-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)
-
-# ===================================================================
-# Web UI backend — channel membership, validation, and config writes.
-# The aiohttp server itself lives in webui.py; these helpers are the
-# bridge to the live bot state and reuse the same validation as the
-# slash-command setters above.
-# ===================================================================
-
-# Slack member ids per channel, cached briefly so listing a user's
-# channels doesn't hammer conversations.members on every UI request.
-_channel_members_cache: dict[str, tuple[float, set]] = {}
-_CHANNEL_MEMBERS_TTL = 300.0
-
-# Serializes UI config writes (mutate channel_config + save_configuration).
-_config_write_lock = asyncio.Lock()
-
-
-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 = _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()
-    _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)
-
-
-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(channel_config.keys()):
-        if await is_user_in_channel(app, channel_id, user.id):
-            channels.append({'id': channel_id, 'name': await 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 process_mentions(app, reply_message)
-        if not ok:
-            errors['reply_message'] = f"Unknown user mention: {mention_error}."
-        else:
-            template_error = 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 = 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:
-            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'] = 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 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 team_cache]
-    unknown_excluded = [team for team in excluded if team not in 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 = parse_time(str(hours_value[0]))
-        end_time = 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 _config_write_lock:
-        channel_config.setdefault(channel_id, {})[config_name] = clean
-        await 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 _config_write_lock:
-        configs = 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 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 _config_write_lock:
-        configs = channel_config.get(channel_id, {})
-        if config_name not in configs:
-            return False, "That rule no longer exists."
-        del configs[config_name]
-        await 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(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 team_cache if t and t != TEAM_UNKNOWN), key=lambda v: v.upper()),
-        'template_variables': sorted(SUPPORTED_TEMPLATE_VARIABLES),
-        'opsgenie_configured': 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: get_user_by_email(app, email),
-        list_channels=lambda user: list_user_config_channels(app, user),
-        is_member=lambda channel_id, user_id: 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)
-
-
-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 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)
-        await load_button_cache()
-        await restore_pending_buttons(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))
-        scheduler_task = asyncio.create_task(run_scheduler(app, opsgenie_token))
-        web_runner = await 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/__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..831792d
--- /dev/null
+++ b/hutbot/actions.py
@@ -0,0 +1,172 @@
+"""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) -> 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}.")
+    await opsgenie.post_opsgenie_alert(app, opsgenie_token, channel, config, user, alert_text, context.get('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)
+    # 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)
+    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..51436ab
--- /dev/null
+++ b/hutbot/buttons.py
@@ -0,0 +1,281 @@
+"""Interactive buttons + timeout escalation (mirrors scheduled-reply persistence)."""
+
+import json
+import asyncio
+import datetime
+
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log, log_error, log_warning
+
+from . import state
+from . import 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) -> 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,
+        '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.
+        src_config = channel.configs.get(entry.get('config_name'))
+        idx = _find_button_index(src_config, entry.get('escalation_target', ''))
+        if idx is None:
+            log_warning(f"Default button '{entry.get('escalation_target')}' not found in #{channel.name}.")
+            return
+        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, src_config['buttons'][idx], run_context)
+    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)
+        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:
+        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 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)
+    src_config = channel.configs.get(src_config_name)
+    buttons = (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])
+    entry = state.pending_buttons.get((posted_channel_id, message_ts))
+    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.
+    run_context = await _escalation_context(app, entry, posted_channel_id, message_ts, presser)
+    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)
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..9dc91fb
--- /dev/null
+++ b/hutbot/slackcache.py
@@ -0,0 +1,259 @@
+"""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_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..7f6064a
--- /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(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/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/test_bot.py b/test_bot.py
deleted file mode 100644
index 87b8975..0000000
--- a/test_bot.py
+++ /dev/null
@@ -1,2739 +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,
-    validate_config_payload, get_channel_members, is_user_in_channel,
-    list_user_config_channels, ui_create_config, ui_delete_config,
-)
-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"}
-    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('bot.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",
-    )
-
-@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")
-
-    scheduled_messages.clear()
-    scheduled_messages[key] = ScheduledReply(task=AsyncMock(), user_id=user.id)
-
-    with patch('bot.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 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"}
-    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('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.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 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"}
-    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('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.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_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('bot.get_opsgenie_template_variables', new=AsyncMock()) as mock_get_opsgenie_template_variables, \
-         patch('bot.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_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"}
-    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(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": ""}
-    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")
-
-    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"}
-    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('bot.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('bot.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_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
-
-
-# ===========================================================================
-# Broader triggers / conditions / actions / buttons
-# ===========================================================================
-
-import asyncio
-import bot
-import outlook
-
-
-def _mk_channel(configs=None):
-    return Channel(id="C12345", name="general", configs=configs if configs is not None else {"default": DEFAULT_CONFIG.copy()})
-
-
-# ----- 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('bot.save_configuration'), patch('bot.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]
-
-
-@pytest.mark.asyncio
-async def test_set_action_normalizes_dashes():
-    app = AsyncMock()
-    channel = _mk_channel()
-    user = User("U1", "test", "Test User", "Testers")
-    with patch('bot.save_configuration'), patch('bot.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_schedule_cron_valid_and_invalid():
-    app = AsyncMock()
-    channel = _mk_channel()
-    user = User("U1", "test", "Test User", "Testers")
-    with patch('bot.save_configuration'), patch('bot.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]
-
-
-@pytest.mark.asyncio
-async def test_set_condition_aliases():
-    app = AsyncMock()
-    channel = _mk_channel()
-    user = User("U1", "test", "Test User", "Testers")
-    with patch('bot.save_configuration'), patch('bot.send_message'):
-        await process_command(app, "set condition outlook", channel, user)
-        assert channel.configs["default"]["condition"] == bot.CONDITION_OUTLOOK
-        await process_command(app, "set condition none", channel, user)
-        assert channel.configs["default"]["condition"] == ""
-
-
-@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('bot.save_configuration'), patch('bot.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('bot.save_configuration'), patch('bot.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('bot.save_configuration'), patch('bot.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"
-
-
-# ----- 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('bot.is_work_day', return_value=True), \
-         patch('bot.flush_replies_cache'), \
-         patch('bot.schedule_reply') as mock_schedule:
-        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
-
-
-# ----- Conditions -----
-
-@pytest.mark.asyncio
-async def test_evaluate_condition_none_is_true():
-    app = AsyncMock()
-    config = DEFAULT_CONFIG.copy()
-    assert await bot.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"] = bot.CONDITION_OUTLOOK
-    config["outlook_subject_pattern"] = "standup"
-    config["condition_negate"] = True
-    with patch('bot.outlook.calendar_condition_met', new=AsyncMock(return_value=False)) as met:
-        result = await bot.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
-
-
-# ----- 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 = bot.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"] = bot.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('bot.register_escalation', new=AsyncMock()) as reg:
-        posted = await bot.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"
-
-
-@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"] = bot.ACTION_DM_USER
-    config["action_target"] = "<@U777>"
-    channel = _mk_channel({"src": config})
-    with patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U777", "alice", "Alice", "Team"))):
-        posted = await bot.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"] = bot.ACTION_GROUP_DM
-    config["action_target"] = "@oncall"
-    channel = _mk_channel({"src": config})
-    with patch('bot.get_usergroup_by_handle', new=AsyncMock(return_value=Usergroup("S1", "oncall", "On Call"))), \
-         patch('bot.get_usergroup_members', new=AsyncMock(return_value=["U1", "U2", "U3"])):
-        posted = await bot.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"
-
-
-# ----- 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('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
-         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.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('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
-         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
-         patch('bot._post_message', new=AsyncMock()) as post, \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.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})
-    bot.pending_buttons.clear()
-    bot.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('bot.cancel_pending_button', new=AsyncMock()), \
-         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
-         patch('bot.cancel_pending_button', new=AsyncMock()) as cancel, \
-         patch('bot.reschedule_escalation', new=AsyncMock()) as resched:
-        await bot.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"
-    bot.pending_buttons.clear()
-    with patch('bot.flush_button_cache', new=AsyncMock()):
-        await bot.register_escalation(app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
-        entry = bot.pending_buttons.get(("C12345", "10.1"))
-        assert entry is not None
-        assert entry["escalation_kind"] == "config" and entry["escalation_target"] == "escalate"
-        await bot.cancel_pending_button("C12345", "10.1")
-        assert ("C12345", "10.1") not in bot.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")
-    bot.pending_buttons.clear()
-    bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.flush_button_cache', new=AsyncMock()), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot._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")
-    bot.pending_buttons.clear()
-    bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
-         patch('bot.flush_button_cache', new=AsyncMock()), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot._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"
-
-
-# ----- 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})
-    bot._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
-    with patch.dict('bot.channel_config', {"C12345": {"sched": sched}}, clear=True), \
-         patch('bot._cron_due', return_value=True), \
-         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.evaluate_condition', new=AsyncMock(return_value=True)), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.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})
-    bot._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
-    with patch.dict('bot.channel_config', {"C12345": {"sched": sched}}, clear=True), \
-         patch('bot._cron_due', return_value=True), \
-         patch('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.evaluate_condition', new=AsyncMock(return_value=False)), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.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"
-    bot._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
-    with patch.dict('bot.channel_config', {"C12345": {"default": msg}}, clear=True), \
-         patch('bot._cron_due', return_value=True), \
-         patch('bot.run_action', new=AsyncMock()) as run:
-        await bot.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"] = bot.ACTION_DM_USER
-    cfg["action_target"] = "<@U1>"
-    cfg["reply_message"] = "hi"
-    channel = _mk_channel({"src": cfg})
-    user = User("U2", "x", "X", "T")
-    with patch('bot.get_message_permalink', new=AsyncMock(return_value='')), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.run_action', new=AsyncMock(return_value={"channel": "C", "ts": "1", "text": "hi"})) as run:
-        await bot.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('bot.get_message_permalink', new=AsyncMock(return_value='')), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.send_message', new=AsyncMock()) as send, \
-         patch('bot.run_action', new=AsyncMock(return_value={"channel": "C", "ts": "1", "text": "hi"})) as run:
-        await bot.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
-
-
-# ----- 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 bot.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 bot.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
-
-
-# ----- 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('bot.opsgenie_configured', True), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
-        await bot.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('bot.opsgenie_configured', True), \
-         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
-        await bot.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('bot.opsgenie_configured', True), \
-         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
-        await bot.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('bot.opsgenie_configured', True), \
-         patch('bot.post_opsgenie_alert', new=AsyncMock()) as alert:
-        await bot.run_action(app, "tok", channel, cfg, "src", context={"channel_id": "C12345"})
-    alert.assert_not_awaited()
-
-
-@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"}]
-    bot.pending_buttons.clear()
-    with patch('bot.flush_button_cache', new=AsyncMock()):
-        await bot.register_escalation(app, "tok", "C12345", "1.1", "C12345", "src", cfg, {"text": "t", "ts": "1.1", "permalink": "p"})
-    entry = bot.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('bot.save_configuration'), patch('bot.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 bot._escalation_kind(cfg) == (bot.ESCALATION_BUTTON, "Yes")
-    # Unknown default-button label falls back to the config target.
-    cfg["default_button"] = "Nope"
-    assert bot._escalation_kind(cfg) == (bot.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")
-    bot.pending_buttons.clear()
-    bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=channel)), \
-         patch('bot.flush_button_cache', new=AsyncMock()), \
-         patch('bot._post_message', new=AsyncMock()) as post:
-        await bot._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_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('bot.save_configuration', new=AsyncMock()), patch('bot.send_message', new=AsyncMock()), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), patch('bot.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).
-        bot.pending_buttons.clear()
-        await bot.schedule_reply(app, "tok", ch, cfg, "default", u, "orig", "M1", wait_time_override=0)
-        entry = bot.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('bot.get_channel_by_id', new=AsyncMock(return_value=Channel("C1", "support", ch.configs))), \
-             patch('bot.get_user_by_id', new=AsyncMock(return_value=u)), \
-             patch('bot._post_message', new=AsyncMock()) as post:
-            await bot._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
-
-
-# ---------------------------------------------------------------------------
-# Web-UI backend helpers: validate_config_payload / membership / ui create+delete
-# ---------------------------------------------------------------------------
-import bot
-
-
-def _seed_user_caches():
-    """Pre-seed module caches so update_user_cache short-circuits (no Slack calls)."""
-    bot.team_cache = {"Platform", "Support"}
-    bot.user_id_cache = {"someuser": bot.User(id="U1", name="someuser", real_name="X", team="Platform")}
-    bot.user_email_cache = {"x@example.com": bot.User(id="U1", name="someuser", real_name="X", team="Platform")}
-    bot.id_user_cache = {"U1": bot.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
-
-
-@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_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
-
-
-@pytest.mark.asyncio
-async def test_is_user_in_channel_true_false():
-    bot._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():
-    bot._channel_members_cache = {}
-    bot.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 = bot.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):
-    bot.channel_config = {}
-    monkeypatch.setattr(bot, "save_configuration", AsyncMock())
-    app = _ui_app()
-
-    # bad name (space not allowed by the name pattern)
-    ok, msg = await bot.ui_create_config(app, "C1", "bad name")
-    assert ok is False and msg
-
-    # good name succeeds and seeds from DEFAULT_CONFIG
-    ok, msg = await bot.ui_create_config(app, "C1", "my-rule")
-    assert ok is True
-    assert bot.channel_config["C1"]["my-rule"]["reply_message"] == bot.DEFAULT_CONFIG["reply_message"]
-    bot.save_configuration.assert_awaited()
-
-    # duplicate is rejected
-    ok, msg = await bot.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):
-    bot.channel_config = {"C1": {"default": {}, "my-rule": {}}}
-    monkeypatch.setattr(bot, "save_configuration", AsyncMock())
-    app = _ui_app()
-
-    ok, msg = await bot.ui_delete_config(app, "C1", "default")
-    assert ok is False and msg
-    assert "default" in bot.channel_config["C1"]
-
-    ok, msg = await bot.ui_delete_config(app, "C1", "my-rule")
-    assert ok is True
-    assert "my-rule" not in bot.channel_config["C1"]
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..77de82d
--- /dev/null
+++ b/tests/test_buttons.py
@@ -0,0 +1,336 @@
+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")
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..663d7a6
--- /dev/null
+++ b/tests/test_opsgenie.py
@@ -0,0 +1,790 @@
+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()
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..64c750a
--- /dev/null
+++ b/tests/test_webui_backend.py
@@ -0,0 +1,176 @@
+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"]

From 6cf19de679e856da92c0d1da237b72ef241c71a3 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 25 Jun 2026 15:51:08 +0200
Subject: [PATCH 08/42] feat(ui): add allowedIngress UI config, strict email
 auth, button fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Document UI security considerations in README and explain `ui.allowedIngress`.
- Extend Helm chart values and NetworkPolicy to configure allowed ingress sources for the UI.
- Set default `allowedIngress` to an empty list (back‑compat insecure) with example.
- Introduce `get_user_by_email_strict` for exact‑email lookups and use it in the web UI backend.
- Update OpsGenie alert handling to use the posted message timestamp when the original ts is missing.
- Snapshot button definitions at posting time, store them, and strip interactive buttons after a press.
- Resolve button actions against the snapshot to prevent edited configs from affecting old messages.
- Preserve the original author in the context for config‑running buttons.
- Fix escalation task cleanup logic to avoid removing a rescheduled timer.
- Add comprehensive tests covering the new UI auth, allowedIngress, button snapshotting, alert aliasing, and escalation behavior.
---
 README.md                                  | 12 ++++
 charts/hutbot/templates/networkpolicy.yaml |  4 ++
 charts/hutbot/values.yaml                  |  9 +++
 hutbot/actions.py                          | 13 ++--
 hutbot/buttons.py                          | 65 ++++++++++++++---
 hutbot/slackcache.py                       | 16 +++++
 hutbot/webui_backend.py                    |  2 +-
 tests/test_buttons.py                      | 82 ++++++++++++++++++++++
 tests/test_opsgenie.py                     | 18 +++++
 tests/test_webui_backend.py                | 16 +++++
 10 files changed, 221 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index 0053dc9..d83d117 100644
--- a/README.md
+++ b/README.md
@@ -178,6 +178,18 @@ readiness/liveness probes, and opens the NetworkPolicy ingress for that port; th
 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**
diff --git a/charts/hutbot/templates/networkpolicy.yaml b/charts/hutbot/templates/networkpolicy.yaml
index a10ede4..e3ad542 100644
--- a/charts/hutbot/templates/networkpolicy.yaml
+++ b/charts/hutbot/templates/networkpolicy.yaml
@@ -21,6 +21,10 @@ spec:
   - ports:
     - port: {{ .Values.ui.port }}
       protocol: TCP
+    {{- with .Values.ui.allowedIngress }}
+    from:
+      {{- toYaml . | nindent 6 }}
+    {{- end }}
   {{- end }}
   egress:
 {{- if $rules }}
diff --git a/charts/hutbot/values.yaml b/charts/hutbot/values.yaml
index c849f42..e47f550 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -29,6 +29,15 @@ ui:
   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:
diff --git a/hutbot/actions.py b/hutbot/actions.py
index 831792d..41a17b4 100644
--- a/hutbot/actions.py
+++ b/hutbot/actions.py
@@ -54,7 +54,7 @@ async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channe
     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) -> None:
+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
@@ -69,7 +69,12 @@ async def maybe_post_opsgenie_alert(app: AsyncApp, opsgenie_token: str, channel:
     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}.")
-    await opsgenie.post_opsgenie_alert(app, opsgenie_token, channel, config, user, alert_text, context.get('ts', ''), context.get('permalink', ''))
+    # 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:
@@ -152,9 +157,9 @@ async def run_action(app: AsyncApp, opsgenie_token: str, channel: Channel, confi
     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)
+        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)
+    await maybe_post_opsgenie_alert(app, opsgenie_token, channel, config, config_name, context, posted.get('ts', ''))
     return {**posted, 'text': text}
 
 
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index 51436ab..e441061 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -5,6 +5,7 @@
 import datetime
 
 from slack_bolt.async_app import AsyncApp
+from slack_sdk.errors import SlackApiError
 
 from employee_list import log, log_error, log_warning
 
@@ -61,7 +62,7 @@ def _escalation_kind(config: dict) -> tuple[str, str]:
     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) -> 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
@@ -81,6 +82,11 @@ async def register_escalation(app: AsyncApp, opsgenie_token: str, posted_channel
         '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,
@@ -145,20 +151,26 @@ async def _run_escalation(app: AsyncApp, opsgenie_token: str, entry: dict) -> No
     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.
+        # 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'))
-        idx = _find_button_index(src_config, entry.get('escalation_target', ''))
+        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, src_config['buttons'][idx], run_context)
+        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}.")
 
@@ -175,9 +187,16 @@ async def _escalation_task(app: AsyncApp, opsgenie_token: str, key: tuple, timeo
     except Exception as e:
         log_error(f"Escalation task failed for message {key[1]}:", e)
     finally:
-        state.pending_buttons.pop(key, None)
-        state._button_states_cache.pop(key, None)
-        await persistence.flush_button_cache()
+        # 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:
@@ -235,6 +254,23 @@ async def restore_pending_buttons(app: AsyncApp, opsgenie_token: str) -> None:
     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 {}
@@ -257,13 +293,17 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
     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)
-    buttons = (src_config or {}).get('buttons') or []
+    # 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])
-    entry = state.pending_buttons.get((posted_channel_id, message_ts))
     log(f"Button '{buttons[index].get('label')}' ({btn_action}) pressed by @{presser_name} in #{channel.name}.")
 
     if btn_action == BUTTON_ACTION_DELAY:
@@ -275,7 +315,10 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
             await reschedule_escalation(app, opsgenie_token, posted_channel_id, message_ts, minutes)
         return
 
-    # Every other button stops the pending escalation, then runs its action.
-    run_context = await _escalation_context(app, entry, posted_channel_id, message_ts, presser)
+    # 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/slackcache.py b/hutbot/slackcache.py
index 9dc91fb..b99a047 100644
--- a/hutbot/slackcache.py
+++ b/hutbot/slackcache.py
@@ -206,6 +206,22 @@ async def get_user_by_email(app: AsyncApp, email: str) -> User:
     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)
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 7f6064a..84900d1 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -404,7 +404,7 @@ async def maybe_start_web_ui(app: AsyncApp):
         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(app, 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,
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 77de82d..258ac57 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -334,3 +334,85 @@ async def test_escalation_task_auto_presses_default_button():
         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_opsgenie.py b/tests/test_opsgenie.py
index 663d7a6..d1143cb 100644
--- a/tests/test_opsgenie.py
+++ b/tests/test_opsgenie.py
@@ -788,3 +788,21 @@ async def test_run_action_no_opsgenie_when_disabled():
          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_webui_backend.py b/tests/test_webui_backend.py
index 64c750a..596be4d 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -174,3 +174,19 @@ async def test_ui_delete_config_refuses_default(monkeypatch):
     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"

From 2cfc45f51b1bb9e74b42db2ad733d3e53bda4985 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 09:07:54 +0200
Subject: [PATCH 09/42] chore(ignore): add .env-dev to gitignore

Exclude the development environment file from version control.
---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index f38c313..4fdee46 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@ employees.json
 .codex
 scheduled_replies.json
 button_states.json
+.env-dev

From 01d4e0fd9f1ecf130467a9d8c863db3f09b6df8b Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 09:28:32 +0200
Subject: [PATCH 10/42] feat(helmfile): add dev environment for independent
 instance

Define a second 'dev' environment in helmfile to allow running an
independent Hutbot instance alongside production in the same namespace.
The dev release uses its own name, PVC, and secrets, ensuring complete
isolation. Documentation updated to explain deployment steps, including
environment variable configuration and image override support.
---
 README.md            | 48 ++++++++++++++++++++++++++++++++++++++++++++
 helmfile.yaml.gotmpl | 20 ++++++++++++++----
 2 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index d83d117..3b9a1f9 100644
--- a/README.md
+++ b/README.md
@@ -335,6 +335,54 @@ helmfile sync
 > **Note:** Helmfile uses Go templating to inject these variables and will error if any required environment variables are missing.
 > Ensure you run `source .env` in the same shell as you execute `helmfile sync`.
 
+### Deploying a Dev Instance
+
+The Helmfile defines two environments so a second, independent instance can run alongside production
+in the same namespace:
+
+| Environment | Release name  | Purpose                                          |
+| ----------- | ------------- | ------------------------------------------------ |
+| `default`   | `hutbot`      | Production instance                              |
+| `dev`       | `hutbot-dev`  | Dev instance (separate Slack app, own PVC/Secret) |
+
+All chart resources are named after the Helm release, so the dev release gets its own Deployment,
+Secret (`hutbot-dev-secret`), PersistentVolumeClaim (`hutbot-dev-pvc`) and NetworkPolicy. The two
+instances share nothing.
+
+Register a second Slack app for the dev bot and put its credentials in a `.env-dev` file (also ignored
+by git). It uses the exact same variable names as `.env`:
+
+```bash
+export SLACK_BOT_TOKEN='<dev bot token>'
+export SLACK_APP_TOKEN='<dev app-level token>'
+# ... same variables as .env
+```
+
+Then deploy with the `dev` environment selected:
+
+```bash
+source .env-dev
+helmfile -e dev sync
+```
+
+Production is unaffected and keeps deploying as before (`source .env && helmfile sync`), which is
+equivalent to `helmfile -e default sync`.
+
+> **Note:** Point the dev instance at its own Opsgenie heartbeat (or leave `OPSGENIE_HEARTBEAT_NAME`
+> empty in `.env-dev`), otherwise the dev pod will ping the production heartbeat.
+
+Both environments default to the `ghcr.io/mittwald/hutbot:latest` image. To run the dev instance on a
+different build, override the image via environment variables:
+
+```bash
+export IMAGE_TAG=my-feature-branch
+export IMAGE_REPOSITORY=ghcr.io/mittwald/hutbot   # optional
+helmfile -e dev sync
+```
+
+The target namespace defaults to `mw-internal` for both environments and can be overridden with
+`NAMESPACE`.
+
 ### Persisting the Configuration File
 
 Hutbot stores its channel configuration in a JSON file (`bot.json`) on a mounted volume. You can configure the persistence options in the Helm chart like this:
diff --git a/helmfile.yaml.gotmpl b/helmfile.yaml.gotmpl
index fdf0a44..fdb099b 100644
--- a/helmfile.yaml.gotmpl
+++ b/helmfile.yaml.gotmpl
@@ -1,13 +1,25 @@
+environments:
+  default:
+    values:
+      - releaseName: hutbot
+        namespace: mw-internal
+        imageTag: latest
+  dev:
+    values:
+      - releaseName: hutbot-dev
+        namespace: mw-internal
+        imageTag: latest
+---
 repositories: []
 
 releases:
-  - name: hutbot
-    namespace: mw-internal
+  - name: {{ .Values.releaseName }}
+    namespace: {{ env "NAMESPACE" | default .Values.namespace }}
     chart: ./charts/hutbot
     values:
       - image:
-          repository: ghcr.io/mittwald/hutbot
-          tag: "latest"
+          repository: {{ env "IMAGE_REPOSITORY" | default "ghcr.io/mittwald/hutbot" | quote }}
+          tag: {{ env "IMAGE_TAG" | default .Values.imageTag | quote }}
         replicaCount: 1
       - slack:
           appToken: {{ requiredEnv "SLACK_APP_TOKEN" | quote }}

From d10f1092983dd237c7d0677a64afeafd9fece861 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 09:35:26 +0200
Subject: [PATCH 11/42] fix(helm): enforce pinned image tags and update chart
 version

- Update Helm chart version to 0.2.0 and appVersion to v1.0.9
- Modify deployment template to reject empty or floating image tags
- Set default image tag to empty string in values.yaml
- Pin specific release tags (v1.0.9) in helmfile environments
- Update GitHub Actions workflow to publish immutable release tags
- Document the new tagging strategy and deployment constraints in README
---
 .github/workflows/docker-publish.yml    | 18 ++++++++++++---
 README.md                               | 29 ++++++++++++++++++++-----
 charts/hutbot/Chart.yaml                |  4 ++--
 charts/hutbot/templates/deployment.yaml |  2 +-
 charts/hutbot/values.yaml               |  6 +++--
 helmfile.yaml.gotmpl                    |  6 +++--
 6 files changed, 49 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml
index 921e11e..576d26a 100644
--- a/.github/workflows/docker-publish.yml
+++ b/.github/workflows/docker-publish.yml
@@ -53,11 +53,23 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      # Tag pushes (v*.*.*) publish immutable release tags only, so deployments can
+      # pin an exact version. Pushes to main additionally move the `main`/`latest`
+      # floating tags, which are for convenience only and must not be deployed.
+      - name: Compute image tags
+        id: tags
+        run: |
+          image=ghcr.io/mittwald/hutbot
+          if [ "$GITHUB_REF_TYPE" = "tag" ]; then
+            tags="$image:$GITHUB_REF_NAME,$image:${GITHUB_REF_NAME#v}"
+          else
+            tags="$image:$GITHUB_REF_NAME,$image:latest"
+          fi
+          echo "tags=$tags" >> "$GITHUB_OUTPUT"
+
       - name: Build and push Docker image
         uses: docker/build-push-action@v4
         with:
           context: .
           push: true
-          tags: |
-            ghcr.io/mittwald/hutbot:latest
-            ghcr.io/mittwald/hutbot:${{ github.ref_name }}
+          tags: ${{ steps.tags.outputs.tags }}
diff --git a/README.md b/README.md
index 3b9a1f9..c931a9e 100644
--- a/README.md
+++ b/README.md
@@ -284,13 +284,29 @@ python -m hutbot
 
 ## Docker and Kubernetes Deployment
 
-A GitHub Actions workflow automatically builds and publishes the Docker image to GitHub Container Registry on pushes to `main` and tags `v*.*.*`. You can pull the image with:
+A GitHub Actions workflow automatically builds and publishes the Docker image to GitHub Container
+Registry on pushes to `main` and on tags matching `v*.*.*`. Cutting a release is just pushing a tag:
 
 ```bash
-docker pull ghcr.io/mittwald/hutbot:latest
-docker pull ghcr.io/mittwald/hutbot:<version>
+git tag v1.1.0
+git push origin v1.1.0
 ```
 
+The published tags are:
+
+| Trigger              | Image tags                     | Deployable |
+| -------------------- | ------------------------------ | ---------- |
+| Tag push `v1.1.0`    | `v1.1.0`, `1.1.0`              | yes        |
+| Push to `main`       | `main`, `latest`               | no         |
+
+```bash
+docker pull ghcr.io/mittwald/hutbot:v1.1.0
+```
+
+> **Note:** `latest` and `main` are floating convenience tags. Deployments must pin an exact release
+> tag — the Helm chart refuses to render if `image.tag` is empty, so a version has to be chosen
+> explicitly.
+
 This repository includes a Helm chart under `charts/hutbot` and a Helmfile configuration at `helmfile.yaml.gotmpl`.
 
 Create a `.env` file in the project root (this file is ignored by git) with the following content:
@@ -371,11 +387,12 @@ equivalent to `helmfile -e default sync`.
 > **Note:** Point the dev instance at its own Opsgenie heartbeat (or leave `OPSGENIE_HEARTBEAT_NAME`
 > empty in `.env-dev`), otherwise the dev pod will ping the production heartbeat.
 
-Both environments default to the `ghcr.io/mittwald/hutbot:latest` image. To run the dev instance on a
-different build, override the image via environment variables:
+Each environment pins a specific image tag in the `environments` block of `helmfile.yaml.gotmpl`
+(`imageTag`) — no floating `latest`. Bump that value to roll out a new release, or override it per
+invocation to test a build in dev before promoting it to production:
 
 ```bash
-export IMAGE_TAG=my-feature-branch
+export IMAGE_TAG=v1.1.0
 export IMAGE_REPOSITORY=ghcr.io/mittwald/hutbot   # optional
 helmfile -e dev sync
 ```
diff --git a/charts/hutbot/Chart.yaml b/charts/hutbot/Chart.yaml
index df2a8ff..e7f4834 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.3
-appVersion: "latest"
\ No newline at end of file
+version: 0.2.0
+appVersion: "v1.0.9"
\ No newline at end of file
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 26ece39..c5734ab 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -20,7 +20,7 @@ spec:
       {{- end }}
       containers:
         - name: {{ .Release.Name }}
-          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+          image: "{{ .Values.image.repository }}:{{ required "image.tag must be set to a specific image tag (e.g. v1.0.9); floating tags like 'latest' are not allowed" .Values.image.tag }}"
           imagePullPolicy: {{ .Values.image.pullPolicy }}
           envFrom:
             - secretRef:
diff --git a/charts/hutbot/values.yaml b/charts/hutbot/values.yaml
index e47f550..768e9fa 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -4,8 +4,10 @@ replicaCount: 1
 
 image:
   repository: hutbot
-  tag: "latest"
-  pullPolicy: Always
+  # Must be set to a specific, immutable tag (e.g. v1.0.9). Rendering fails if empty.
+  # Floating tags (latest, main) are intentionally not used for deployments.
+  tag: ""
+  pullPolicy: IfNotPresent
 
 slack:
   appToken: ""
diff --git a/helmfile.yaml.gotmpl b/helmfile.yaml.gotmpl
index fdb099b..2c7e5f8 100644
--- a/helmfile.yaml.gotmpl
+++ b/helmfile.yaml.gotmpl
@@ -1,14 +1,16 @@
+# Image tags are pinned to specific releases on purpose: no floating `latest`.
+# Bump `imageTag` here (or override with IMAGE_TAG) to roll out a new version.
 environments:
   default:
     values:
       - releaseName: hutbot
         namespace: mw-internal
-        imageTag: latest
+        imageTag: v1.0.9
   dev:
     values:
       - releaseName: hutbot-dev
         namespace: mw-internal
-        imageTag: latest
+        imageTag: v1.0.9
 ---
 repositories: []
 

From 6f883477d11965f5d5aacb171310a40728d81a64 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 10:29:26 +0200
Subject: [PATCH 12/42] feat(deploy): add deployment scripts for dev and prod
 environments

- Add deploy-dev.sh to deploy the hutbot dev instance using .env-dev
- Add deploy-prod.sh to deploy the production instance with confirmation prompts
- Both scripts enforce pinned image tags and require helmfile
- Support custom helmfile arguments via extra positional parameters
---
 deploy-dev.sh  | 73 +++++++++++++++++++++++++++++++++++++++
 deploy-prod.sh | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 165 insertions(+)
 create mode 100755 deploy-dev.sh
 create mode 100755 deploy-prod.sh

diff --git a/deploy-dev.sh b/deploy-dev.sh
new file mode 100755
index 0000000..138df20
--- /dev/null
+++ b/deploy-dev.sh
@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Deploy the hutbot dev instance (release "hutbot-dev") with an explicit image tag.
+# Loads .env-dev from the repository root and runs helmfile in the "dev" environment.
+set -euo pipefail
+
+readonly HELM_ENV="dev"
+readonly ENV_FILE=".env-dev"
+
+root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+usage() {
+  cat <<EOF
+Usage: ${0##*/} <image-tag> [helmfile-args...]
+
+Deploys the "${HELM_ENV}" environment using ${ENV_FILE}.
+Extra arguments replace the default helmfile command ("sync").
+
+Examples:
+  ${0##*/} v1.1.0
+  ${0##*/} v1.1.0 diff
+EOF
+}
+
+case "${1:-}" in
+  -h|--help)
+    usage
+    exit 0
+    ;;
+  "")
+    echo "error: image tag is required" >&2
+    usage >&2
+    exit 1
+    ;;
+esac
+
+image_tag="$1"
+shift
+
+if [[ "$image_tag" == "latest" ]]; then
+  echo "error: image tags must be pinned to a release, 'latest' is not allowed" >&2
+  exit 1
+fi
+
+helmfile_args=("$@")
+if [[ ${#helmfile_args[@]} -eq 0 ]]; then
+  helmfile_args=(sync)
+fi
+
+if ! command -v helmfile >/dev/null 2>&1; then
+  echo "error: helmfile not found in PATH" >&2
+  exit 1
+fi
+
+env_path="${root_dir}/${ENV_FILE}"
+if [[ ! -f "$env_path" ]]; then
+  echo "error: ${env_path} not found" >&2
+  exit 1
+fi
+
+set -a
+# shellcheck source=/dev/null
+source "$env_path"
+set +a
+
+export IMAGE_TAG="$image_tag"
+
+echo "==> environment: ${HELM_ENV}"
+echo "==> env file:    ${ENV_FILE}"
+echo "==> image tag:   ${IMAGE_TAG}"
+echo "==> namespace:   ${NAMESPACE:-mw-internal}"
+
+cd "$root_dir"
+exec helmfile -e "$HELM_ENV" "${helmfile_args[@]}"
diff --git a/deploy-prod.sh b/deploy-prod.sh
new file mode 100755
index 0000000..291cf5a
--- /dev/null
+++ b/deploy-prod.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# Deploy the hutbot production instance (release "hutbot") with an explicit image tag.
+# Loads .env from the repository root and runs helmfile in the "default" environment.
+set -euo pipefail
+
+readonly HELM_ENV="default"
+readonly ENV_FILE=".env"
+
+root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+usage() {
+  cat <<EOF
+Usage: ${0##*/} [-y] <image-tag> [helmfile-args...]
+
+Deploys the "${HELM_ENV}" (production) environment using ${ENV_FILE}.
+Extra arguments replace the default helmfile command ("sync").
+
+Options:
+  -y, --yes   Skip the confirmation prompt.
+
+Examples:
+  ${0##*/} v1.1.0
+  ${0##*/} v1.1.0 diff
+  ${0##*/} -y v1.1.0
+EOF
+}
+
+assume_yes=0
+if [[ "${1:-}" == "-y" || "${1:-}" == "--yes" ]]; then
+  assume_yes=1
+  shift
+fi
+
+case "${1:-}" in
+  -h|--help)
+    usage
+    exit 0
+    ;;
+  "")
+    echo "error: image tag is required" >&2
+    usage >&2
+    exit 1
+    ;;
+esac
+
+image_tag="$1"
+shift
+
+if [[ "$image_tag" == "latest" ]]; then
+  echo "error: image tags must be pinned to a release, 'latest' is not allowed" >&2
+  exit 1
+fi
+
+helmfile_args=("$@")
+if [[ ${#helmfile_args[@]} -eq 0 ]]; then
+  helmfile_args=(sync)
+fi
+
+if ! command -v helmfile >/dev/null 2>&1; then
+  echo "error: helmfile not found in PATH" >&2
+  exit 1
+fi
+
+env_path="${root_dir}/${ENV_FILE}"
+if [[ ! -f "$env_path" ]]; then
+  echo "error: ${env_path} not found" >&2
+  exit 1
+fi
+
+set -a
+# shellcheck source=/dev/null
+source "$env_path"
+set +a
+
+export IMAGE_TAG="$image_tag"
+
+echo "==> environment: ${HELM_ENV} (production)"
+echo "==> env file:    ${ENV_FILE}"
+echo "==> image tag:   ${IMAGE_TAG}"
+echo "==> namespace:   ${NAMESPACE:-mw-internal}"
+echo "==> command:     helmfile -e ${HELM_ENV} ${helmfile_args[*]}"
+
+if [[ "$assume_yes" -ne 1 && "${helmfile_args[0]}" != "diff" ]]; then
+  read -r -p "Deploy to PRODUCTION? [y/N] " answer
+  if [[ "$answer" != "y" && "$answer" != "Y" ]]; then
+    echo "aborted"
+    exit 1
+  fi
+fi
+
+cd "$root_dir"
+exec helmfile -e "$HELM_ENV" "${helmfile_args[@]}"

From 515513564e725a3ce9ca84b01554227f5ed09e48 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 11:49:40 +0200
Subject: [PATCH 13/42] feat(helm): support configurable slash commands per
 instance

Allow different deployments (e.g., dev vs production) to listen on
distinct Slack slash commands by introducing the HUTBOT_SLASH_COMMAND
environment variable. This resolves conflicts where multiple instances
cannot share the same command registration.

Changes include:
- Add `slashCommand` field to Helm values and environment definitions
- Update routing, help messages, and error texts to use the configured
command dynamically
- Normalize command input to ensure consistent formatting
- Bump chart version to 0.3.0
- Add tests for command normalization and routing configuration
---
 README.md                               |  24 +++++
 charts/hutbot/Chart.yaml                |   2 +-
 charts/hutbot/templates/deployment.yaml |   6 +-
 charts/hutbot/values.yaml               |   3 +
 helmfile.yaml.gotmpl                    |   5 ++
 hutbot/__main__.py                      |   2 +
 hutbot/commands/dispatch.py             |   2 +-
 hutbot/commands/setters.py              |   2 +-
 hutbot/constants.py                     |  14 +++
 hutbot/messaging.py                     | 115 ++++++++++++------------
 hutbot/opsgenie.py                      |   3 +-
 hutbot/routing.py                       |   2 +-
 hutbot/state.py                         |   8 +-
 tests/_common.py                        |   4 +-
 tests/test_commands_info.py             |  17 ++++
 tests/test_routing.py                   |  19 ++++
 16 files changed, 163 insertions(+), 65 deletions(-)

diff --git a/README.md b/README.md
index c931a9e..86a9cc5 100644
--- a/README.md
+++ b/README.md
@@ -319,6 +319,8 @@ export OPSGENIE_HEARTBEAT_NAME='<your Opsgenie heartbeat name>'
 export EMPLOYEE_LIST_USERNAME='<your employee list username>'
 export EMPLOYEE_LIST_PASSWORD='<your employee list password>'
 export EMPLOYEE_LIST_MAPPINGS='<optional comma-separated mappings, e.g.: user1=alias1,user2=alias2>'
+# Slash command this instance listens on; must match the Slack app. Default: /hutbot
+export HUTBOT_SLASH_COMMAND='/hutbot'
 # To define netpol egress rules, you can set a space-separated list of <port>:<cidr[,cidr...]> entries:
 export NETWORKPOLICY_RULES='443:192.168.0.15/32 80:10.0.0.0/24,10.0.1.0/24'
 # To define host aliases for the pod (/etc/hosts entries), you can set a comma-separated list of <hostname>=<ip> entries:
@@ -387,6 +389,28 @@ equivalent to `helmfile -e default sync`.
 > **Note:** Point the dev instance at its own Opsgenie heartbeat (or leave `OPSGENIE_HEARTBEAT_NAME`
 > empty in `.env-dev`), otherwise the dev pod will ping the production heartbeat.
 
+#### Slash command per instance
+
+A Slack app cannot register a slash command that another app already owns, so the dev Slack app has
+to use its own — e.g. `/hutbot_dev`. The bot listens on the command in `HUTBOT_SLASH_COMMAND`
+(default `/hutbot`) and uses it in all help and error texts, so `/hutbot_dev help` prints
+`/hutbot_dev …` examples. If the running instance does not know about the command, Slack Bolt logs:
+
+```
+Unhandled request ({'type': None, 'command': '/hutbot_dev'})
+```
+
+The Helmfile sets this per environment (`slashCommand` in the `environments` block: `/hutbot` for
+`default`, `/hutbot_dev` for `dev`), and it can be overridden per invocation:
+
+```bash
+export HUTBOT_SLASH_COMMAND=/hutbot_test
+helmfile -e dev sync
+```
+
+The command name must match exactly what is configured in the Slack app (the leading `/` is added
+automatically if omitted).
+
 Each environment pins a specific image tag in the `environments` block of `helmfile.yaml.gotmpl`
 (`imageTag`) — no floating `latest`. Bump that value to roll out a new release, or override it per
 invocation to test a build in dev before promoting it to production:
diff --git a/charts/hutbot/Chart.yaml b/charts/hutbot/Chart.yaml
index e7f4834..843d35d 100644
--- a/charts/hutbot/Chart.yaml
+++ b/charts/hutbot/Chart.yaml
@@ -2,5 +2,5 @@ apiVersion: v2
 name: hutbot
 description: A Helm chart for deploying the Hutbot Slack bot
 type: application
-version: 0.2.0
+version: 0.3.0
 appVersion: "v1.0.9"
\ No newline at end of file
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index c5734ab..2c866dd 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -30,8 +30,12 @@ spec:
             - name: http
               containerPort: {{ .Values.ui.port }}
           {{- end }}
-          {{- if or .Values.persistence.enabled .Values.ui.enabled }}
+          {{- if or .Values.persistence.enabled .Values.ui.enabled .Values.slack.slashCommand }}
           env:
+            {{- if .Values.slack.slashCommand }}
+            - name: HUTBOT_SLASH_COMMAND
+              value: {{ .Values.slack.slashCommand | quote }}
+            {{- end }}
             {{- if .Values.persistence.enabled }}
             - name: HUTBOT_CONFIG_FILE
               value: {{ printf "%s/%s" .Values.persistence.mountPath "bot.json" }}
diff --git a/charts/hutbot/values.yaml b/charts/hutbot/values.yaml
index 768e9fa..1fcf3cc 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -12,6 +12,9 @@ image:
 slack:
   appToken: ""
   botToken: ""
+  # Slash command this instance listens on. Must match the command configured in
+  # the Slack app backing these tokens. Empty = the bot's default (/hutbot).
+  slashCommand: ""
 
 opsgenie:
   token: ""
diff --git a/helmfile.yaml.gotmpl b/helmfile.yaml.gotmpl
index 2c7e5f8..689c2af 100644
--- a/helmfile.yaml.gotmpl
+++ b/helmfile.yaml.gotmpl
@@ -6,11 +6,15 @@ environments:
       - releaseName: hutbot
         namespace: mw-internal
         imageTag: v1.0.9
+        slashCommand: /hutbot
   dev:
     values:
       - releaseName: hutbot-dev
         namespace: mw-internal
         imageTag: v1.0.9
+        # The dev instance runs behind its own Slack app, which registers its own
+        # slash command. Must match the command configured there.
+        slashCommand: /hutbot_dev
 ---
 repositories: []
 
@@ -26,6 +30,7 @@ releases:
       - slack:
           appToken: {{ requiredEnv "SLACK_APP_TOKEN" | quote }}
           botToken: {{ requiredEnv "SLACK_BOT_TOKEN" | quote }}
+          slashCommand: {{ env "HUTBOT_SLASH_COMMAND" | default .Values.slashCommand | quote }}
       - opsgenie:
           token: {{ env "OPSGENIE_TOKEN" | quote }}
           heartbeatName: {{ env "OPSGENIE_HEARTBEAT_NAME" | quote }}
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
index be3e9cd..799c683 100644
--- a/hutbot/__main__.py
+++ b/hutbot/__main__.py
@@ -8,6 +8,7 @@
 from employee_list import get_env_var, load_env_file, log_error
 
 from . import state
+from .constants import normalize_slash_command
 from . import persistence
 from . import slackcache
 from . import scheduling
@@ -23,6 +24,7 @@ async def main() -> None:
     slack_bot_token = get_env_var("SLACK_BOT_TOKEN")
     opsgenie_token = get_env_var("OPSGENIE_TOKEN")
     opsgenie_heartbeat_name = get_env_var("OPSGENIE_HEARTBEAT_NAME")
+    state.slash_command = normalize_slash_command(get_env_var("HUTBOT_SLASH_COMMAND"))
     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)
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index fbd2ac6..8e26f1b 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -155,4 +155,4 @@ async def process_command(app: AsyncApp, text: str, channel, user, thread_ts: st
         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)
+    await messaging.send_message(app, channel, user, f"Huh? :thinking_face: Maybe type `{state.slash_command} help` for a list of commands.", thread_ts)
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index d8aa43c..1994c2b 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -191,7 +191,7 @@ async def set_datetime_format(app: AsyncApp, channel, config_name: str, values:
         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)
+        await messaging.send_message(app, channel, user, f"Invalid *date/time format*. Use `{state.slash_command} [config] set datetime-format <date> <time> [<timezone> <locale>]`.", thread_ts)
         return
 
     date_format = tokens[0]
diff --git a/hutbot/constants.py b/hutbot/constants.py
index a95206f..fbb4aaa 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -8,6 +8,11 @@
 import re
 
 DEFAULT_CONFIG_NAME = 'default'
+# Slash command the bot registers with Slack. A second instance (e.g. the dev
+# deployment) runs behind its own Slack app and therefore its own command, so
+# this is configurable via HUTBOT_SLASH_COMMAND. The live value is kept in
+# ``state.slash_command`` because the environment is only loaded at startup.
+DEFAULT_SLASH_COMMAND = '/hutbot'
 DEFAULT_DATE_FORMAT = "%a, %d %b %Y"
 DEFAULT_TIME_FORMAT = "%H:%M"
 DEFAULT_OPSGENIE_PRIORITY = "P4"
@@ -99,6 +104,15 @@
                                 'channel_purpose',
                                 'channel_topic'])
 
+
+def normalize_slash_command(value: str) -> str:
+    """Return a usable Slack slash command, defaulting when unset."""
+    value = (value or "").strip()
+    if not value:
+        return DEFAULT_SLASH_COMMAND
+    return value if value.startswith("/") else f"/{value}"
+
+
 MENTION_PATTERN = re.compile(r'(?<![|<])@([a-z0-9-_.]+)(?!>)')
 ID_PATTERN = re.compile(r'<([#@!][a-zA-Z0-9^]+)([|]([^>]*))?>')
 TIME_HOUR_PATTERN = re.compile(r"^[0-9]{1,2}$")
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index b8a4811..fb797a6 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -9,6 +9,7 @@
 from employee_list import log_error, log_warning
 
 from . import slackcache
+from . import state
 from .constants import ID_PATTERN, MENTION_PATTERN, SUPPORTED_TEMPLATE_VARIABLES
 from .models import Channel, User
 from .textutil import log_debug
@@ -148,20 +149,21 @@ async def process_mentions(app: AsyncApp, message: str) -> tuple[bool, str, str]
 
 
 async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
+    command = state.slash_command
     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"
+        f"> 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 `{command} 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"
+        f"> OpsGenie templates can now include current and next on-call start/end dates, times, and datetimes. Use `{command} [config] set datetime-format \"<date>\" \"<time>\" [<timezone> <locale>]` to set the defaults.\n>\n"
         "> :pencil: *Customize reply messages with `{{placeholders}}`*\n>\n"
         "> That means 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"
+        f"> Use `{command} [config] on-call [schedule name]` to get the current OpsGenie on-call user as a Slack mention.\n>\n"
         "> :test_tube: *Preview your configured reply*\n"
-        "> Use `/hutbot [config] test` or mention me with `@Hutbot [config] test <message>` to test reply templates and variables.\n>\n"
+        f"> Use `{command} [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"
@@ -173,66 +175,67 @@ async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_
 
 async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
     supported_template_variables = ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
+    command = state.slash_command
     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."),
+        (f"{command} show config", "Show all configurations."),
+        (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
+        (f"{command} [config] disable opsgenie", "Disable OpsGenie alerts."),
+        (f"{command} [config] set opsgenie-schedule <name>", "Set the OpsGenie schedule name."),
+        (f"{command} [config] set opsgenie-priority <P1-P5>", "Set the OpsGenie alert priority."),
+        (f"{command} [config] set opsgenie-message <text>", "Template for the alert text (default: the message)."),
+        (f"{command} [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Set date/time formats."),
+        (f"{command} [config] set wait-time <minutes>", "Set reminder delay."),
+        (f"{command} list teams", "List available teams."),
+        (f"{command} list opsgenie-schedules", "List OpsGenie schedules."),
+        (f"{command} [config] on-call [schedule]", "Show current on-call user."),
+        (f"{command} team of <@user>", "Show a user's team."),
+        (f"{command} [config] add excluded-team <team>", "Add an ignored team."),
+        (f"{command} [config] clear excluded-teams", "Clear ignored teams."),
+        (f"{command} [config] add included-team <team>", "Add an allowed team."),
+        (f"{command} [config] clear included-teams", "Clear allowed teams."),
+        (f"{command} [config] enable bots", "Respond to bot messages."),
+        (f"{command} [config] disable bots", "Ignore bot messages."),
+        (f"{command} [config] enable only-work-days", "Respond only on work days."),
+        (f"{command} [config] disable only-work-days", "Respond on all days."),
+        (f"{command} [config] enable", "Enable sending replies for this config."),
+        (f"{command} [config] disable", "Disable sending replies for this config."),
+        (f"{command} [config] set work-hours <start> <end>", "Set active hours; 0:00 0:00 means all day."),
+        (f"{command} [config] set pattern \"<regex>\" [0|1]", "Set message pattern; 1 means case sensitive."),
+        (f"{command} [config] set message \"<reply message>\"", "Set reminder message."),
+        (f"{command} [config] set forward-channel <#channel>", "Forward replies to another channel."),
+        (f"{command} [config] clear forward-channel", "Remove the forward channel."),
+        (f"{command} [config] set trigger <message|schedule|manual>", "Set how the rule starts."),
+        (f"{command} [config] set cron <expr>", "Set the cron schedule, e.g. 0 9 * * 1-5."),
+        (f"{command} [config] set schedule-timezone <tz>", "Set the cron timezone (IANA name)."),
+        (f"{command} [config] set condition <none|outlook>", "Gate a schedule on a condition."),
+        (f"{command} [config] set outlook-subject <regex>", "Match Outlook event subject (stub)."),
+        (f"{command} [config] set outlook-body <regex>", "Match Outlook event body (stub)."),
+        (f"{command} [config] enable negate", "Invert the condition (e.g. no matching event)."),
+        (f"{command} [config] disable negate", "Stop inverting the condition."),
+        (f"{command} [config] set action <reply|dm-user|group-dm|post-channel>", "Set what the rule does."),
+        (f"{command} [config] set target <@user|@group|#channel>", "Set the action recipient."),
+        (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
+        (f"{command} [config] add button \"<label>\" ack [text]", "Button acknowledges/dismisses (stops escalation)."),
+        (f"{command} [config] add button \"<label>\" message <text>", "Button posts a fixed message."),
+        (f"{command} [config] add button \"<label>\" delay <minutes>", "Button delays the escalation."),
+        (f"{command} [config] clear buttons", "Remove all buttons."),
+        (f"{command} [config] set button-timeout <minutes>", "Escalate if no button is pressed in time."),
+        (f"{command} [config] set button-timeout-target <config>", "Config to run on button timeout."),
+        (f"{command} [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
+        (f"{command} [config] run", "Run this configuration's action now."),
+        (f"{command} [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."),
+        (f"{command} delete config <name>", "Delete a configuration."),
+        (f"{command} news", "Show what's new."),
+        (f"{command} 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"
+        f"> Either use the command `{command}` or just `@Hutbot` me.\n"
+        f"```{command} show config\n"
         "@Hutbot show config```\n"
         f"Displays all configurations for `#{channel.name}`.\n\n"
         "*Commands:*\n"
diff --git a/hutbot/opsgenie.py b/hutbot/opsgenie.py
index 09e70e7..96c1473 100644
--- a/hutbot/opsgenie.py
+++ b/hutbot/opsgenie.py
@@ -13,6 +13,7 @@
 from . import datetimefmt
 from . import slackcache
 from . import messaging
+from . import state
 from .constants import (
     DEFAULT_CONFIG,
     DEFAULT_OPSGENIE_PRIORITY,
@@ -344,7 +345,7 @@ async def send_current_on_call(app: AsyncApp, opsgenie_token: str, channel, conf
     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)
+        await messaging.send_message(app, channel, user, f"No OpsGenie schedule configured. Use `{state.slash_command} [config] set opsgenie-schedule <name>` or `{state.slash_command} [config] on-call <schedule name>`.", thread_ts)
         return
     if not opsgenie_token:
         await messaging.send_message(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
diff --git a/hutbot/routing.py b/hutbot/routing.py
index 842e6d8..719ecfb 100644
--- a/hutbot/routing.py
+++ b/hutbot/routing.py
@@ -244,7 +244,7 @@ async def handle_message_events(body, logger):
     async def handle_reaction_added_events(body, logger):
         await handle_reaction_added(app, body.get('event', {}) if body else {})
 
-    @app.command("/hutbot")
+    @app.command(state.slash_command)
     async def handle_command(ack, body, logger):
         await ack()
         await handle_command_event(app, body, opsgenie_token)
diff --git a/hutbot/state.py b/hutbot/state.py
index 0a263cb..e0e79b2 100644
--- a/hutbot/state.py
+++ b/hutbot/state.py
@@ -12,6 +12,11 @@
 import asyncio
 import datetime
 
+from .constants import DEFAULT_SLASH_COMMAND
+
+# Slash command this instance listens on; set from HUTBOT_SLASH_COMMAND at startup.
+slash_command = DEFAULT_SLASH_COMMAND
+
 # Live configuration: {channel_id: {config_name: config_dict}}.
 channel_config: dict = {}
 
@@ -50,7 +55,7 @@
 
 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
+    global _scheduler_last_check, bot_user_id, opsgenie_configured, slash_command
     channel_config.clear()
     scheduled_messages.clear()
     _scheduled_replies_cache.clear()
@@ -66,3 +71,4 @@ def reset() -> None:
     _scheduler_last_check = None
     bot_user_id = None
     opsgenie_configured = False
+    slash_command = DEFAULT_SLASH_COMMAND
diff --git a/tests/_common.py b/tests/_common.py
index 289586a..fb7ae19 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -15,7 +15,7 @@
 from employee_list import get_env_var
 
 from hutbot.models import Channel, User, Usergroup, ScheduledReply
-from hutbot.constants import DEFAULT_CONFIG
+from hutbot.constants import DEFAULT_CONFIG, normalize_slash_command
 from hutbot.textutil import extract_message_text
 from hutbot.datetimefmt import parse_time, is_work_day, is_work_time
 from hutbot.persistence import migrate_and_apply_defaults, load_replies_cache, flush_replies_cache
@@ -24,7 +24,7 @@
 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,
+    handle_reaction_added, handle_message_deletion, register_app_handlers,
 )
 from hutbot.webui_backend import (
     validate_config_payload, list_user_config_channels, ui_create_config, ui_delete_config,
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 1d2f2b0..b7f1cd6 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -112,6 +112,23 @@ async def test_process_command_help_uses_compact_command_reference():
 
 
 
+@pytest.mark.asyncio
+async def test_process_command_help_uses_configured_slash_command():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="team-asylum", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.state.slash_command', '/hutbot_dev'), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "Either use the command `/hutbot_dev` or just `@Hutbot` me." in sent_message
+    assert "/hutbot_dev [config] set wait-time <minutes>" in sent_message
+    assert "/hutbot " not in sent_message
+
+
+
 @pytest.mark.asyncio
 async def test_set_forward_channel_with_mention():
     app = AsyncMock()
diff --git a/tests/test_routing.py b/tests/test_routing.py
index 8764db0..a4b2bff 100644
--- a/tests/test_routing.py
+++ b/tests/test_routing.py
@@ -347,3 +347,22 @@ async def test_handle_channel_message_skips_non_message_trigger():
         hutbot.state.scheduled_messages.clear()
         await handle_channel_message(app, "token", channel, user, "hello", "1.1")
         assert mock_schedule.call_count == 1  # only the message-trigger config
+
+
+
+# ----- Slash command registration -----
+
+def test_normalize_slash_command():
+    assert normalize_slash_command("") == "/hutbot"
+    assert normalize_slash_command("   ") == "/hutbot"
+    assert normalize_slash_command(None) == "/hutbot"
+    assert normalize_slash_command("/hutbot_dev") == "/hutbot_dev"
+    assert normalize_slash_command("hutbot_dev") == "/hutbot_dev"
+    assert normalize_slash_command(" hutbot_dev ") == "/hutbot_dev"
+
+
+def test_register_app_handlers_uses_configured_slash_command():
+    app = MagicMock()
+    with patch('hutbot.state.slash_command', '/hutbot_dev'):
+        register_app_handlers(app)
+    assert app.command.call_args.args[0] == "/hutbot_dev"

From 747bd10cbcba0fc50482bfc6e8fd61f05ce63408 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 12:03:26 +0200
Subject: [PATCH 14/42] feat(instances): support per-instance bot naming for
 dev/prod separation

Introduce `HUTBOT_BOT_NAME` environment variable to allow different
deployments (e.g. dev vs prod) to identify themselves distinctly in
user-facing text.

Key changes:
- Add `botName` Helm value and `HUTBOT_BOT_NAME` env var support.
- Update help, news, and forwarding messages to use the configured name.
- Use Slack handle from `auth.test` for `@mention` examples to ensure
they work regardless of the display name.
- Derive OpsGenie alias from a slugified version of the name to prevent
deduplication conflicts between instances.
- Pass bot name to Web UI via `/api/meta` for client-side branding.
---
 README.md                               | 25 ++++++++++++++++
 charts/hutbot/templates/deployment.yaml |  6 +++-
 charts/hutbot/values.yaml               |  3 ++
 helmfile.yaml.gotmpl                    |  3 ++
 hutbot/__main__.py                      |  9 ++++--
 hutbot/actions.py                       |  4 +--
 hutbot/commands/setters.py              |  2 +-
 hutbot/constants.py                     | 15 ++++++++++
 hutbot/messaging.py                     | 22 ++++++++------
 hutbot/opsgenie.py                      | 10 +++++--
 hutbot/state.py                         | 11 +++++--
 hutbot/webui_backend.py                 |  4 +++
 tests/_common.py                        |  4 +--
 tests/test_commands_info.py             | 20 +++++++++++++
 tests/test_opsgenie.py                  | 39 +++++++++++++++++++++++++
 tests/test_webui_backend.py             | 10 +++++++
 webui.py                                |  6 ++--
 webui_static/app.js                     | 17 +++++++++--
 18 files changed, 184 insertions(+), 26 deletions(-)

diff --git a/README.md b/README.md
index 86a9cc5..08dda24 100644
--- a/README.md
+++ b/README.md
@@ -321,6 +321,8 @@ export EMPLOYEE_LIST_PASSWORD='<your employee list password>'
 export EMPLOYEE_LIST_MAPPINGS='<optional comma-separated mappings, e.g.: user1=alias1,user2=alias2>'
 # Slash command this instance listens on; must match the Slack app. Default: /hutbot
 export HUTBOT_SLASH_COMMAND='/hutbot'
+# Name the bot uses for itself in help/news messages. Default: Hutbot
+export HUTBOT_BOT_NAME='Hutbot'
 # To define netpol egress rules, you can set a space-separated list of <port>:<cidr[,cidr...]> entries:
 export NETWORKPOLICY_RULES='443:192.168.0.15/32 80:10.0.0.0/24,10.0.1.0/24'
 # To define host aliases for the pod (/etc/hosts entries), you can set a comma-separated list of <hostname>=<ip> entries:
@@ -389,6 +391,29 @@ equivalent to `helmfile -e default sync`.
 > **Note:** Point the dev instance at its own Opsgenie heartbeat (or leave `OPSGENIE_HEARTBEAT_NAME`
 > empty in `.env-dev`), otherwise the dev pod will ping the production heartbeat.
 
+#### Telling the instances apart
+
+`HUTBOT_BOT_NAME` (default `Hutbot`) is the name the bot uses for itself in user-facing text, so the
+dev instance introduces itself as *Hutbot (DEV)* in its help and news messages. The Helmfile sets it
+per environment (`botName`), and it can be overridden with the environment variable.
+
+The `@mention` examples in the help text are not affected by this: they have to be a working Slack
+handle, so they are taken from the bot's own `auth.test` response at startup (`@hutbot` vs.
+`@hutbot_dev`) rather than from `HUTBOT_BOT_NAME`.
+
+The name is used everywhere the instance identifies itself:
+
+| Surface           | With `HUTBOT_BOT_NAME='Hutbot (DEV)'`                       |
+| ----------------- | ----------------------------------------------------------- |
+| Help / news       | *Hi! I am **Hutbot (DEV)*** …                                 |
+| Forwarding notice | "… will now be forwarded here by Hutbot (DEV)"               |
+| Web UI            | Page title, wordmark and messages (served via `/api/meta`)   |
+| OpsGenie alert    | Tag `Hutbot (DEV)`, detail `bot: hutbot-dev`                  |
+
+The OpsGenie **alias** — the field OpsGenie deduplicates on — uses a slug of the name
+(`Hutbot` → `hutbot`, `Hutbot (DEV)` → `hutbot-dev`) instead of the display name. The production
+alias is therefore unchanged, and dev alerts can no longer deduplicate against production ones.
+
 #### Slash command per instance
 
 A Slack app cannot register a slash command that another app already owns, so the dev Slack app has
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 2c866dd..1e2f316 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -30,12 +30,16 @@ spec:
             - name: http
               containerPort: {{ .Values.ui.port }}
           {{- end }}
-          {{- if or .Values.persistence.enabled .Values.ui.enabled .Values.slack.slashCommand }}
+          {{- if or .Values.persistence.enabled .Values.ui.enabled .Values.slack.slashCommand .Values.slack.botName }}
           env:
             {{- if .Values.slack.slashCommand }}
             - name: HUTBOT_SLASH_COMMAND
               value: {{ .Values.slack.slashCommand | quote }}
             {{- end }}
+            {{- if .Values.slack.botName }}
+            - name: HUTBOT_BOT_NAME
+              value: {{ .Values.slack.botName | quote }}
+            {{- end }}
             {{- if .Values.persistence.enabled }}
             - name: HUTBOT_CONFIG_FILE
               value: {{ printf "%s/%s" .Values.persistence.mountPath "bot.json" }}
diff --git a/charts/hutbot/values.yaml b/charts/hutbot/values.yaml
index 1fcf3cc..795fea5 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -15,6 +15,9 @@ slack:
   # Slash command this instance listens on. Must match the command configured in
   # the Slack app backing these tokens. Empty = the bot's default (/hutbot).
   slashCommand: ""
+  # Name the bot calls itself in user-facing text, e.g. "Hutbot (DEV)".
+  # Empty = the bot's default ("Hutbot").
+  botName: ""
 
 opsgenie:
   token: ""
diff --git a/helmfile.yaml.gotmpl b/helmfile.yaml.gotmpl
index 689c2af..82e0e5e 100644
--- a/helmfile.yaml.gotmpl
+++ b/helmfile.yaml.gotmpl
@@ -7,6 +7,7 @@ environments:
         namespace: mw-internal
         imageTag: v1.0.9
         slashCommand: /hutbot
+        botName: Hutbot
   dev:
     values:
       - releaseName: hutbot-dev
@@ -15,6 +16,7 @@ environments:
         # The dev instance runs behind its own Slack app, which registers its own
         # slash command. Must match the command configured there.
         slashCommand: /hutbot_dev
+        botName: Hutbot (DEV)
 ---
 repositories: []
 
@@ -31,6 +33,7 @@ releases:
           appToken: {{ requiredEnv "SLACK_APP_TOKEN" | quote }}
           botToken: {{ requiredEnv "SLACK_BOT_TOKEN" | quote }}
           slashCommand: {{ env "HUTBOT_SLASH_COMMAND" | default .Values.slashCommand | quote }}
+          botName: {{ env "HUTBOT_BOT_NAME" | default .Values.botName | quote }}
       - opsgenie:
           token: {{ env "OPSGENIE_TOKEN" | quote }}
           heartbeatName: {{ env "OPSGENIE_HEARTBEAT_NAME" | quote }}
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
index 799c683..4e0dda3 100644
--- a/hutbot/__main__.py
+++ b/hutbot/__main__.py
@@ -8,7 +8,7 @@
 from employee_list import get_env_var, load_env_file, log_error
 
 from . import state
-from .constants import normalize_slash_command
+from .constants import DEFAULT_BOT_NAME, normalize_slash_command
 from . import persistence
 from . import slackcache
 from . import scheduling
@@ -25,6 +25,7 @@ async def main() -> None:
     opsgenie_token = get_env_var("OPSGENIE_TOKEN")
     opsgenie_heartbeat_name = get_env_var("OPSGENIE_HEARTBEAT_NAME")
     state.slash_command = normalize_slash_command(get_env_var("HUTBOT_SLASH_COMMAND"))
+    state.bot_name = get_env_var("HUTBOT_BOT_NAME").strip() or DEFAULT_BOT_NAME
     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)
@@ -36,7 +37,11 @@ async def main() -> None:
     try:
         app = AsyncApp(token=slack_bot_token)
         await persistence.load_configuration(app)
-        state.bot_user_id = (await app.client.auth_test())["user_id"]
+        auth = await app.client.auth_test()
+        state.bot_user_id = auth["user_id"]
+        # The Slack handle differs per app (hutbot vs. hutbot_dev), so the help
+        # text's `@mention` examples have to come from the workspace, not a constant.
+        state.bot_user_name = auth.get("user") or DEFAULT_BOT_NAME
         await slackcache.update_user_cache(app)
         await persistence.load_replies_cache()
         await scheduling.restore_scheduled_replies(app, opsgenie_token)
diff --git a/hutbot/actions.py b/hutbot/actions.py
index 41a17b4..b0192e4 100644
--- a/hutbot/actions.py
+++ b/hutbot/actions.py
@@ -36,7 +36,7 @@ async def _render_template(app: AsyncApp, opsgenie_token: str, channel: Channel,
     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)
+        user = User(id=state.bot_user_id or '', name=state.bot_user_name, real_name=state.bot_name, team=TEAM_UNKNOWN)
     text = context.get('text', '')
     ts = context.get('ts', '')
     permalink = context.get('permalink')
@@ -65,7 +65,7 @@ async def maybe_post_opsgenie_alert(app: AsyncApp, opsgenie_token: str, channel:
     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)
+    user = context.get('user') or User(id='', name=state.bot_user_name, real_name=state.bot_name, team=TEAM_UNKNOWN)
     template = config.get('opsgenie_message') or ''
     alert_text = await _render_template(app, opsgenie_token, channel, config, config_name, context, template) if template else context.get('text', '')
     log(f"Sending OpsGenie alert for config '{config_name}' in #{channel.name}.")
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index 1994c2b..ad1a1ff 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -108,7 +108,7 @@ async def set_forward_channel(app: AsyncApp, channel, config_name: str, channel_
     try:
         confirmation = (
             f"Reply messages from #{channel.name} (config `{config_name}`) "
-            f"will now be forwarded here by Hutbot :palm_up_hand::tophat:"
+            f"will now be forwarded here by {state.bot_name} :palm_up_hand::tophat:"
         )
         await app.client.chat_postMessage(channel=channel_id, text=confirmation, mrkdwn=True)
     except SlackApiError as e:
diff --git a/hutbot/constants.py b/hutbot/constants.py
index fbb4aaa..9d12d0a 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -13,6 +13,10 @@
 # this is configurable via HUTBOT_SLASH_COMMAND. The live value is kept in
 # ``state.slash_command`` because the environment is only loaded at startup.
 DEFAULT_SLASH_COMMAND = '/hutbot'
+# Name the bot calls itself in user-facing text. A second instance (e.g. the dev
+# deployment) sets HUTBOT_BOT_NAME to something like "Hutbot (DEV)" so users can
+# tell the two apart. The live value is in ``state.bot_name``.
+DEFAULT_BOT_NAME = 'Hutbot'
 DEFAULT_DATE_FORMAT = "%a, %d %b %Y"
 DEFAULT_TIME_FORMAT = "%H:%M"
 DEFAULT_OPSGENIE_PRIORITY = "P4"
@@ -105,6 +109,17 @@
                                 'channel_topic'])
 
 
+def bot_slug(name: str) -> str:
+    """Machine-safe form of the bot name, e.g. "Hutbot (DEV)" -> "hutbot-dev".
+
+    Used where a stable identifier is needed instead of a display name (the
+    OpsGenie alert alias, which is the dedup key). "Hutbot" maps to "hutbot",
+    so the production alias is unchanged.
+    """
+    slug = re.sub(r'[^a-z0-9]+', '-', (name or "").lower()).strip('-')
+    return slug or DEFAULT_BOT_NAME.lower()
+
+
 def normalize_slash_command(value: str) -> str:
     """Return a usable Slack slash command, defaulting when unset."""
     value = (value or "").strip()
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index fb797a6..7704595 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -150,25 +150,27 @@ async def process_mentions(app: AsyncApp, message: str) -> tuple[bool, str, str]
 
 async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
     command = state.slash_command
+    name = state.bot_name
+    mention = f"@{state.bot_user_name}"
     update_text = (
-        "Hi! :wave: I am *Hutbot* :palm_up_hand::tophat: Here's what's :new::\n\n"
+        f"Hi! :wave: I am *{name}* :palm_up_hand::tophat: Here's what's :new::\n\n"
         "> :robot_face: *Triggers, actions & buttons*\n>\n"
         f"> Rules can now run on a `schedule` (cron), DM a user or group, post to a channel, and carry interactive buttons (with an auto-press default + timeout escalation). See `{command} help`.\n>\n"
         "> :calendar: *OpsGenie date/time template variables and defaults*\n>\n"
         f"> OpsGenie templates can now include current and next on-call start/end dates, times, and datetimes. Use `{command} [config] set datetime-format \"<date>\" \"<time>\" [<timezone> <locale>]` to set the defaults.\n>\n"
         "> :pencil: *Customize reply messages with `{{placeholders}}`*\n>\n"
-        "> That means 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"
+        "> That means " + name + " can include details like the `{{user}}`, `{{team}}`, `{{channel}}` or `{{wait_minutes}}`, or even mention the person who is currently on-call `{{opsgenie_current_user}}` in the reply message :exploding_head:.\n>\n"
         "> :sparkles: Just configure an Opsgenie schedule and you are good to go.\n>\n"
         "> :list-item: *List available Opsgenie schedules*\n>\n"
         "> :telephone_receiver: *Print the current on-call user*\n"
         f"> Use `{command} [config] on-call [schedule name]` to get the current OpsGenie on-call user as a Slack mention.\n>\n"
         "> :test_tube: *Preview your configured reply*\n"
-        f"> Use `{command} [config] test` or mention me with `@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"
+        f"> Use `{command} [config] test` or mention me with `{mention} [config] test <message>` to test reply templates and variables.\n>\n"
+        f"> :bug: *{name} now ONLY cancels replying, when the _expected_ team(s) have already replied* :lightbulb:\n>\n"
         "> Issue was:\n>\n"
         "> 1. Team *A* sends a message intended for Team *B*\n"
         "> 2. Someone else from Team *A* adds additional information\n"
-        "> 3. Hutbot cancels the reply and does NOT remind Team *B* anymore :fail:\n"
+        f"> 3. {name} cancels the reply and does NOT remind Team *B* anymore :fail:\n"
     )
     await send_message(app, channel, user, update_text, thread_ts)
 
@@ -176,6 +178,8 @@ async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_
 async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
     supported_template_variables = ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
     command = state.slash_command
+    name = state.bot_name
+    mention = f"@{state.bot_user_name}"
     command_rows = [
         (f"{command} show config", "Show all configurations."),
         (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
@@ -224,7 +228,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         (f"{command} [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
         (f"{command} [config] run", "Run this configuration's action now."),
         (f"{command} [config] test", "Preview configured reply."),
-        ("@Hutbot [config] test <message>", "Preview reply with <message> as {{message}}."),
+        (f"{mention} [config] test <message>", "Preview reply with <message> as {{message}}."),
         (f"{command} delete config <name>", "Delete a configuration."),
         (f"{command} news", "Show what's new."),
         (f"{command} help", "Show this help."),
@@ -232,11 +236,11 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
     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"
+        f"Hi! :wave: I am *{name}* :palm_up_hand::tophat: Here's what I can do:\n\n"
         "*Show All Configurations:*\n"
-        f"> Either use the command `{command}` or just `@Hutbot` me.\n"
+        f"> Either use the command `{command}` or just `{mention}` me.\n"
         f"```{command} show config\n"
-        "@Hutbot show config```\n"
+        f"{mention} show config```\n"
         f"Displays all configurations for `#{channel.name}`.\n\n"
         "*Commands:*\n"
         f"```\n{command_usage}\n```\n\n"
diff --git a/hutbot/opsgenie.py b/hutbot/opsgenie.py
index 96c1473..a4ec4dd 100644
--- a/hutbot/opsgenie.py
+++ b/hutbot/opsgenie.py
@@ -17,6 +17,7 @@
 from .constants import (
     DEFAULT_CONFIG,
     DEFAULT_OPSGENIE_PRIORITY,
+    bot_slug,
     OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
     OPSGENIE_PRIORITIES,
     UNKNOWN_EMAIL_ONCALL_PLACEHOLDER,
@@ -384,17 +385,20 @@ async def post_opsgenie_alert(app: AsyncApp, opsgenie_token: str, channel, confi
         'Content-Type': 'application/json',
         'Authorization': f'GenieKey {opsgenie_token}'
     }
+    # The alias is OpsGenie's dedup key, so it uses the slug rather than the
+    # display name — that also keeps a dev instance from deduping against prod.
+    slug = bot_slug(state.bot_name)
     async with aiohttp.ClientSession() as session:
         try:
             data = {
                 "message": f"#{channel.name}: {text}",
-                "alias": f"hutbot: {user_name} in #{channel.name} {ts}",
+                "alias": f"{slug}: {user_name} in #{channel.name} {ts}",
                 "description": f"{user_name} in #{channel.name}: {text}",
-                "tags": ["Hutbot"],
+                "tags": [state.bot_name],
                 "details": {
                     "channel": f"#{channel.name}",
                     "sender": user_name,
-                    "bot": "hutbot",
+                    "bot": slug,
                     "permalink": permalink,
                 },
                 "priority": priority,
diff --git a/hutbot/state.py b/hutbot/state.py
index e0e79b2..dae2c26 100644
--- a/hutbot/state.py
+++ b/hutbot/state.py
@@ -12,11 +12,14 @@
 import asyncio
 import datetime
 
-from .constants import DEFAULT_SLASH_COMMAND
+from .constants import DEFAULT_BOT_NAME, DEFAULT_SLASH_COMMAND
 
 # Slash command this instance listens on; set from HUTBOT_SLASH_COMMAND at startup.
 slash_command = DEFAULT_SLASH_COMMAND
 
+# Name the bot uses for itself in user-facing text; set from HUTBOT_BOT_NAME at startup.
+bot_name = DEFAULT_BOT_NAME
+
 # Live configuration: {channel_id: {config_name: config_dict}}.
 channel_config: dict = {}
 
@@ -42,6 +45,8 @@
 
 # Resolved on startup from auth.test.
 bot_user_id = None
+# The bot's Slack handle from auth.test; used for the `@mention` examples in the help text.
+bot_user_name = DEFAULT_BOT_NAME
 
 # True once an OpsGenie token + heartbeat name are configured.
 opsgenie_configured = False
@@ -55,7 +60,7 @@
 
 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, slash_command
+    global _scheduler_last_check, bot_user_id, bot_user_name, opsgenie_configured, slash_command, bot_name
     channel_config.clear()
     scheduled_messages.clear()
     _scheduled_replies_cache.clear()
@@ -70,5 +75,7 @@ def reset() -> None:
     _channel_members_cache.clear()
     _scheduler_last_check = None
     bot_user_id = None
+    bot_user_name = DEFAULT_BOT_NAME
     opsgenie_configured = False
     slash_command = DEFAULT_SLASH_COMMAND
+    bot_name = DEFAULT_BOT_NAME
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 84900d1..befa234 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -385,6 +385,9 @@ def ui_meta() -> dict:
         'opsgenie_configured': state.opsgenie_configured,
         'default_config': copy.deepcopy(DEFAULT_CONFIG),
         'default_config_name': DEFAULT_CONFIG_NAME,
+        # Lets the UI brand itself per instance (e.g. "Hutbot (DEV)").
+        'bot_name': state.bot_name,
+        'slash_command': state.slash_command,
     }
 
 
@@ -412,5 +415,6 @@ async def maybe_start_web_ui(app: AsyncApp):
         create_config=lambda channel_id, name: ui_create_config(app, channel_id, name),
         delete_config=lambda channel_id, name: ui_delete_config(app, channel_id, name),
         meta=ui_meta,
+        bot_name=state.bot_name,
     )
     return await start_web_ui(ctx, host, port)
diff --git a/tests/_common.py b/tests/_common.py
index fb7ae19..7f37370 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -15,7 +15,7 @@
 from employee_list import get_env_var
 
 from hutbot.models import Channel, User, Usergroup, ScheduledReply
-from hutbot.constants import DEFAULT_CONFIG, normalize_slash_command
+from hutbot.constants import DEFAULT_CONFIG, bot_slug, normalize_slash_command
 from hutbot.textutil import extract_message_text
 from hutbot.datetimefmt import parse_time, is_work_day, is_work_time
 from hutbot.persistence import migrate_and_apply_defaults, load_replies_cache, flush_replies_cache
@@ -27,7 +27,7 @@
     handle_reaction_added, handle_message_deletion, register_app_handlers,
 )
 from hutbot.webui_backend import (
-    validate_config_payload, list_user_config_channels, ui_create_config, ui_delete_config,
+    validate_config_payload, list_user_config_channels, ui_create_config, ui_delete_config, ui_meta,
 )
 from hutbot.commands.dispatch import process_command
 from hutbot.commands.setters import (
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index b7f1cd6..3b99f78 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -129,6 +129,26 @@ async def test_process_command_help_uses_configured_slash_command():
 
 
 
+@pytest.mark.asyncio
+async def test_process_command_help_uses_configured_bot_name():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="team-asylum", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.state.bot_name', 'Hutbot (DEV)'), \
+         patch('hutbot.state.bot_user_name', 'hutbot_dev'), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "I am *Hutbot (DEV)*" in sent_message
+    assert "or just `@hutbot_dev` me." in sent_message
+    assert "@hutbot_dev show config```" in sent_message
+    assert "@hutbot_dev [config] test <message>" in sent_message
+    assert "@Hutbot" not in sent_message
+
+
+
 @pytest.mark.asyncio
 async def test_set_forward_channel_with_mention():
     app = AsyncMock()
diff --git a/tests/test_opsgenie.py b/tests/test_opsgenie.py
index d1143cb..514e41e 100644
--- a/tests/test_opsgenie.py
+++ b/tests/test_opsgenie.py
@@ -806,3 +806,42 @@ async def test_scheduled_opsgenie_alert_uses_posted_ts_for_unique_alias():
         await hutbot.actions.run_action(app, "tok", channel, cfg, "sched", context=ctx)
     alert.assert_awaited_once()
     assert alert.await_args.args[6] == "111.222"  # ts arg for the alias = posted ts, not empty
+
+
+# ----- Per-instance naming -----
+
+def test_bot_slug():
+    assert bot_slug("Hutbot") == "hutbot"
+    assert bot_slug("Hutbot (DEV)") == "hutbot-dev"
+    assert bot_slug("") == "hutbot"
+    assert bot_slug(None) == "hutbot"
+
+
+@pytest.mark.asyncio
+async def test_post_opsgenie_alert_uses_bot_name_for_tag_and_alias():
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={})
+    user = User("U1", "test", "Test User", "Testers")
+
+    class _Response:
+        status = 202
+        async def __aenter__(self): return self
+        async def __aexit__(self, *args): return False
+
+    posted = {}
+
+    class _Session:
+        async def __aenter__(self): return self
+        async def __aexit__(self, *args): return False
+        def post(self, url, headers=None, data=None):
+            posted['data'] = json.loads(data)
+            return _Response()
+
+    with patch('hutbot.state.bot_name', 'Hutbot (DEV)'), \
+         patch('hutbot.opsgenie.aiohttp.ClientSession', return_value=_Session()), \
+         patch('hutbot.messaging.clean_slack_text', new=AsyncMock(return_value="hello")):
+        await hutbot.opsgenie.post_opsgenie_alert(app, "token", channel, None, user, "hello", "1.1", "https://slack.test/m")
+
+    assert posted['data']["tags"] == ["Hutbot (DEV)"]
+    assert posted['data']["alias"] == "hutbot-dev: Test User in #general 1.1"
+    assert posted['data']["details"]["bot"] == "hutbot-dev"
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
index 596be4d..0027e7e 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -190,3 +190,13 @@ async def test_get_user_by_email_strict_rejects_username_fallback():
         assert (await hutbot.slackcache.get_user_by_email_strict(app, "alice@external.example")).id is None
         # contrast: the lenient resolver still falls back to the username (the flagged behavior)
         assert (await hutbot.slackcache.get_user_by_email(app, "alice@external.example")).id == "U1"
+
+
+# ----- Per-instance naming -----
+
+def test_ui_meta_exposes_bot_name_and_slash_command():
+    with patch('hutbot.state.bot_name', 'Hutbot (DEV)'), \
+         patch('hutbot.state.slash_command', '/hutbot_dev'):
+        meta = ui_meta()
+    assert meta['bot_name'] == 'Hutbot (DEV)'
+    assert meta['slash_command'] == '/hutbot_dev'
diff --git a/webui.py b/webui.py
index c9b230e..0d24e9a 100644
--- a/webui.py
+++ b/webui.py
@@ -55,6 +55,8 @@ class WebUIContext:
     create_config: Callable[[str, str], Awaitable[tuple]]
     delete_config: Callable[[str, str], Awaitable[tuple]]
     meta: Callable[[], dict]
+    # Name of the instance behind this UI, for user-facing text (e.g. "Hutbot (DEV)").
+    bot_name: str = "Hutbot"
 
 
 def _ctx(request) -> WebUIContext:
@@ -83,7 +85,7 @@ 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.")
+        return None, _forbidden(f"Sign in with your Slack-linked account to manage {_ctx(request).bot_name}.")
     channel_id = request.match_info["cid"]
     if not await _ctx(request).is_member(channel_id, user.id):
         return None, _forbidden("You're not a member of that channel.")
@@ -104,7 +106,7 @@ async def handle_index(request):
 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 _forbidden(f"Sign in with your Slack-linked account to manage {_ctx(request).bot_name}.")
     return web.json_response({
         "email": email,
         "slack_user_id": user.id,
diff --git a/webui_static/app.js b/webui_static/app.js
index df05d17..957efbb 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -25,6 +25,18 @@ function h(tag, attrs, ...kids) {
 }
 const $ = (sel, root = document) => root.querySelector(sel);
 
+// ---------- branding ----------
+// Instances (prod / dev) run under different names; /api/meta carries the live one.
+let botName = "Hutbot";
+
+function applyBranding(name) {
+  if (!name) return;
+  botName = name;
+  document.title = `${name} · Watch Desk`;
+  const brand = $(".brand-name");
+  if (brand) brand.textContent = name.toLowerCase();
+}
+
 // ---------- state ----------
 const state = {
   meta: null,
@@ -66,12 +78,13 @@ function toast(message, isError = false) {
 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.");
+  if (!me.ok) return fatal(`Couldn't reach ${botName}. Try reloading in a moment.`);
 
   const [meta, channels] = await Promise.all([api("GET", "/api/meta"), api("GET", "/api/channels")]);
   if (!meta.ok || !channels.ok) return fatal("Couldn't load your configuration. Try reloading in a moment.");
 
   state.meta = meta.data;
+  applyBranding(state.meta.bot_name);
   state.channels = channels.data.channels || [];
   document.getElementById("app").setAttribute("aria-busy", "false");
   renderIdentity(me.data);
@@ -119,7 +132,7 @@ function renderChannels() {
 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."));
+    `You can manage a channel here once ${botName} has a configuration in it and you're a member.`));
 }
 
 async function selectChannel(channelId) {

From a98ce67361a3892741b0af370cae7465949e84db Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 7 Aug 2026 13:42:07 +0200
Subject: [PATCH 15/42] feat(assets): add hutbot icon assets

- Add hutbot.png
- Add hutbot.xcf
- Add hutbot_large.png
- Add hutbot_large_bg.png
- Add hutbot_medium.png
---
 assets/hutbot.png          | Bin 0 -> 29861 bytes
 assets/hutbot.xcf          | Bin 0 -> 620160 bytes
 assets/hutbot_large.png    | Bin 0 -> 227334 bytes
 assets/hutbot_large_bg.png | Bin 0 -> 186414 bytes
 assets/hutbot_medium.png   | Bin 0 -> 50065 bytes
 5 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 assets/hutbot.png
 create mode 100644 assets/hutbot.xcf
 create mode 100644 assets/hutbot_large.png
 create mode 100644 assets/hutbot_large_bg.png
 create mode 100644 assets/hutbot_medium.png

diff --git a/assets/hutbot.png b/assets/hutbot.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea408b8fc7c00400df894d83f282c252ef0eade3
GIT binary patch
literal 29861
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
Y16W@Xu5{X6b^rhX07*qoM6N<$f<K2cX8-^I

literal 0
HcmV?d00001

diff --git a/assets/hutbot.xcf b/assets/hutbot.xcf
new file mode 100644
index 0000000000000000000000000000000000000000..cea929e5b5e21602a3257abf984f5c85515d7d73
GIT binary patch
literal 620160
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%0D>7LY7Q48C(jX3ehGuP|y~yL-r(
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%0D$M*K0lO(N0XP}jiRBP!U^)RIC<
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%0AEoT_i`G~;23$WEY
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%0DUL>ep}5dm{FljBp`DS9!jRh8x^CS(`oXBCx~
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
Id%gJo06USD<NyEw

literal 0
HcmV?d00001

diff --git a/assets/hutbot_large.png b/assets/hutbot_large.png
new file mode 100644
index 0000000000000000000000000000000000000000..3e20f8fccba9eb4bc6c967ea2b26588de4215274
GIT binary patch
literal 227334
zcmeFXcT|&4w?CRflU}4qFA6BqdkqLul-{NH-g}WGfD}O~Hc)|}C|#P;OF|PwX;P&H
z6r>Ys=*f-vec$t*b$@H!b=JDS|4y==HS^5u`OKcZ_w1S3^E@=v*P<e4B?kZiR65!k
z#sC0_kOcwANC?S(#OMhj8FIDMansSc0U#s15Ga8}03advhZ6W7c@Pi`027K62@gFX
z|A*$!!wMw6NFNdMZ2#n+5%Pln(ERC890&qX5z-vOBSFYtCZwf=$1~|~Uu}f^pC8%9
zUz?EogZ!^lOGnR;TS7!!Ohi(S&|XYJN<myqL0pPkOkP1+PC;6pKn=|QFOL2o)rD+4
zA)q|)R983DQCH^<2=aIH^l=3MB64Cfm9;xn*}Lsc-W!)vhtUT18s=`yldf5o89pF?
zW9~85zW80#<9o)t208KyVp0fG8MVkjlR^V|+&pRW$M~mjQ=c6n-wpAO$Nz%1G#@rZ
zlad`sjFeZf<geDfywlaK8)in?!ker@Bo-g|^4{m1tJj7D@6UGjOf(A)uHD}n94`BP
zljKO_CyS)+>xlS>s1X@C3`5dABlCxY4|{Z*xOey_7}L>m%r;CBZj-u2zaMsXIlX!O
zT*mFT311#>TJbCW<6EDdpYJibf3R`wkKScY3_9tPnDC_Li@kkQEsl)X?3rQWW5Ev!
z*O`nzabf1Ug3jq1F9$tG^;W~lrFtv4&S;?F-b(@kE$<B3SD=A8>2%yx6jEMkdodew
zj~P&SN}E+-*n8@4&?k1@o|%04Ft&yUKhHkSfJQK-%9Wby%})@88G~Sq`@Y^ihj}Kl
zipW;!!@v{3yOOd+s(=8pM@)jzt)0!$Q_-h~x*w5TTU|kuTURa-bVqINX=)i_si&*p
z?C&e$=;H6>DiYxv@JC?)B}hboqqDbb2)C1~yQiNrFQysE%kAl+%xfX7C#Dym?&{&G
z9Tnti5~XkI9OdmS@4^dFAy<k}AOQHfhB$IZ`1<$-D?}*sUf?Pa@_&j&dATo0LcEoE
zEeUp{?jPjJEhQo)A|`x0!ZS>QSB0EgDagf5!B|7{9|*#mGOtHSNPvQ<Xn1(INVuek
ze~`PVxV*f)sF;MPgoH4GLO3|mFT^oI*e{sx55!*#4cB1jAkTmhPk%q|KbVeA{-Ght
zyu5^Z?tk&;8=$B6Z+O4pf22T=hiHUjfT*~Ln5eI>=zq2d4!Iph0QrZZ|6_|_)5ri<
zQDfI&|Ii?3*V|#Pej$AS3E|@W@Ad(qK|UA5ad8%P^>OtjkOmWa75{Ht{+V(AZt+J1
z?w-B@7p(}w{%@2ao^JmotpCQ_pPGx|{3j!X=Kse1Z`A)9`voz9N>5Kg!{0gd4|_Tq
z%DjL2S8(xn_H<FW$U4ioh`TwtNeDZMIm-!4NlG~hJIYHq3%iOtNy<98$hgT%Oa2Fx
zj$d$yqo1?uA1DI2h$jI@T3lRC)=}0;SXSK8QCP}NN=#Tz+*MN8QBp=i!qrh+QdUap
zKOhW(JPB6m=<}ak{ef~JK)Fauh`G2qI}!k7TnXIBhzmP9%g71KxHvjFyE;nC$~a0~
zK)E<8X!-~FIug|B>Fen3DjMMDeo^s9;0kJnI?B8fB4YnlV(8--;znqo%&Y6^7aH+j
z6{eoPt|lRlf21icD<LN*FCi-}BSz>*T;{)s%w2<m36}T=^TKyt)cjG40%0%&!8-o2
zQv$$6Ibkdc>OroKA^t(8{{BA7y#MyP|E|^}OeYt|5JwHi5LW`|zx}Z3zx=R}n1q7Z
zU-tjN>G`{Ox<&qfQU94d+)4y`g37f$g9-gdUKIVEQ6{c|f8YMT`gmSUC2sDENul8A
z{C5b!j$y7Y7km=1{#H4AIQqG}61>Mh=K8O4&;NrdNJ+RzIm=1P2#d>!$rJSFNYJ0W
zn53}0lZ2C)yqL6%oWx(T{u@2m-z_BEG00WToghbotO(|Lu|jbRUMTANf9ECK!}X6A
z2m%up7ZVnjx)7MOf|%St0u%keKSXC&f`Lm*NeeqW5e!{Q&Ph^OPEy=S*wu~jE+r`@
zA^nfF|Nl8ec?EHq|2{+|(LZkSUrJRH{eP+bFTsEKQG#gxmJ$3j!QG4g+u#2qGXlT=
zH-G<_+yBijxVitglmC%?|5sf9E3W^M1pY_F|7%_UE3W^M1pY_F|7%_Uzln?dzfO#<
zeuRx)IN>~akKCw`aF!%-x~ruD!2kK@w-!Amlw1nXz84GtP%!*?fPhyyEQCVR5FNeS
zq$}jqq>41sTMat^05?EKL(Mc|YNPdDrOWDbj=FK2zQzns(H*ALZr)Uv@TapbG;g`p
zYLq~Uz;lXY*wH;P?#?PI$RymJ(ptg?MN7$2!*!D^&Yp6xYUat1#I<VctFO&$%XvOZ
zU}yse>a)1oB=5VYEd1_&6%jW6A)4>!H@d*_Id4p>O!cHwsxX$gCLOj@PgWd#YvijZ
z-YsHgPHHM!-x2{(t^4W*tAjl?t-Gl$!{&aP-QT%Y^h5K!b8A~Fbn-m-`>6No6)L-o
zu9I-w%nIft-2cZ(mD-bcwac3HQtP<}R)s3El5kzNCjj}Y?Y67eE4j*`IndFw$G;nK
zp<8&$w1Rt|UpZ?d$Ihs*A}inCkDV=RcOp+JWy{=_O(5SmWhWG@D-Km$D*19@r-fcs
z2;AOCdg@ZxM*`b1P*oTaG?=wYzB*1{g&aGfKfP3~p9nC#^>{vGG*0idUL)gD`75@N
zWunnjUqErQ+A{Pu9{y5hRD}hk()@G<P|)hMfl0bL?d%(?e5wdxuN7Ld)TW+${N=E=
z{ayx3q|VRn6mMMrou0f?RUhc?*E{6kr1I9n#)2_UXc%j->R@BR`W!^RRf!5mRV>+D
z#R|gr^00v-NpR7*&)-M_P%oy3{)o35gy#dFZvF0O=)@iS?vY((Yk9ZO9~QBf7bVhs
z<?hH=?(`7p1UdQ1O|{vQEC%DC7P+J{w+(PoUhn8Nr=)#J(iG|s2JQjB;V(Da4_T7J
zEWqa6r1+BAz^(ZPeEhI2<_cEz3d2*By?Q>TI1YH^ZiJ&ex_dsDPc6nw0j~NZtS{vW
z6<dC~{XvHcUhyW{rJN&GqS8Yehqf7|BD#KWVV6LP-*jaCW!}_&r{Gm}Ex$Ez`JHRh
zau@Cm4PWcbrC$3oU`-ls>>a3(_gtp*+K(J9ru$qCO|3&nm4`pZKJ{E$Nx=0l?DL*Z
z={Rn!NPSYxyRi~27u?eijPOd6?jW-0c=Xl-M)KMiTTFePG)Q%J=RnoY1c;|R@(u(r
zS^HFrx-Y^6Z!H>?fH*ije?L;yOZCRfu$KE@KVu#JArIVO(g-54vT@$zc5x-<<97r&
zoC{{euW&NR!`@GHvDbSwA!p0Go|P7><*5egD^$XjN!@=d&}X|-PJ%5tA|N4M-h6jp
zrr{Yc==v32v<acIHOJn>i>16%TtmWiH_o1OrWPbluD%DZO-wpAM148)yGJ<*s4}2`
z)DA;{TjT(#!gZ6(R5O@C2#XxCDgGYES8^9R`_Dgu8lWI!tYs|8%<$sam!^pP#^B)I
z?B&Cg&eg}BNr2WI7>M(?P=KNTkVZDue0?VL>9oF-T9QK2TfEwh{JTFWk6`0@8Dh^N
z{uP%KAJWToCxsFN6^+3}V<#-O?e<v%+B8yWI7L|xd&Z7WPluw+Hh9AAT8h*H5mG^;
z67H%o+Y|4&-a7WpYj2Z&8U@^}n{=}G*%m0Iz-@hc|10?Hv~IXU;mQ*)n>#AD4|7{z
z-QJN_4Jn#Uc;u^x;+bDs`5u^K#3D!S`#I-cPshCR<GQc$76B_HA<WgmBpFEYr<hu?
zZ@n&B>eSwVpf#8T1|bZ~v5-EJ(yy3uf3v1OP;jz9O3Z4yImn3LTpb#kMZp~Z>N6r_
z5O}nrA|suQm#3DGWbe=)C;KG3%5RT;PAu5TF78jg;zh)2V~hwy1XxY^E^S8govq!*
z$+HbvS9tDxeF<l3Yo?AJt;;rM>*CaU;LMzl5!3x8;BK|UkB<5ck!D0aI`QW{vl~Dj
zi&LwZn;hrTv8gU%JhDJW_+qIFEFzFP+6cz<W!a|Z4OVyKM^D=d>>pEOKiZ?N%zZJ9
z2okkYUEYxf`;KvVYu!?Y@$x_`YpI1J3Pq$#-dtOYie>u50DZ4T<&1E6)4nlf&2mVA
zeT!t;|KZ3!ZI1fQt|bgF;rVcA_4WH<Zrnoc@Xaoo)Gf_WYIY}O@d5lHFv9SQf#Jq7
z-fSHpbu-rChk|g`@)sUGc~Bq62b}yv7Lpm|DcH<OR<)9sH<%>9VuBJk^z*L{9|_{S
z5>C_{C$7MT#3w(J>W@*fmohsH)X;bnWti<bTV5`%6F~5?NjcatWRPZ4b<P$pyd3-P
z8go7(4P<{Nk=z#yihO)4zTW|TsdqAQ<~mEyj!*n@Oen?dy^WY@IioXl5jOLFX~jV$
z!;#~F(x(A>#dnw+B8h3U8H_7RHIxy<0ooc!Uxs_#aa~63_RHK=e1ND;r~(<TUqo!_
z6TACeDip!7EXAJt?`})jt8V)ncNR#<r8(r&%;n6g7$`S6+OhA^-&Th?(BCB4_oJTC
zW3wZ@dPPnr^ux3+m1;lS0Q*KjdxJ|hI<-!}vntoGS7hI6om3hB6b_m36KUym6h@7P
zjupRjXh65LijtnZY=Ko+f2w@(Cirrpihd5(T5~Pt07>1@?12Pga0&;fdGc4+@UzY=
zTa>t_uZND+-At!JvG_r}Tl6yQWD{nMke%nE>QVxE)A)I{`D1!dxwO0wuEj@gi<F78
zgmrs8rc_0?rrQ$fVO_mnBb0t7ysxW!Ga`Q5E!dF#^QBeGlDo12+P4o~;z<+S9(Vci
zwR*>+#n!LFU!%8Lxx$lPp^XolGeKegYBQ4>xWZ3}->>$uWplWwfzM=eMYT_~m@kd=
zAIJRoskV+73dMSkQi&Oom~OG}qgg3OIcUDz!r*m9uEPmj-(Z8_1@Z5aVKR@}Qn|!u
z$tSl|pX#^2S%D%%P>*EPm^LR?7g?>@u5tbrj+5pXA_Ld54OnfHP$HxDh@WY7tC!4|
z|3Es|N%Hd^oJjYKFrB{{BiA;r4J~s((q@pNGb@%ewS*z}t&2IYsg7?#g~f;Ev|pIu
zp3WmuRcNLTd&Nt!xrr(a8R71_#j?K*(%bEoU(WLji#-K7V7@4R$2AI5|53hK0p9*h
z4?1_1%fJe*^&x1ZkfuUrma0m0d2rR<3$~ii$2%%#r3m!${^sQf=QLd2_m?!)?o1t%
zqgMZ6AA0*it^iyHkLV}&;F{>^WZ$2Di)5AFi-HG6suXdBcBg=^wCcQ!pNkCJO0A*p
zP9t9Z$QRm<5YJ*8!mYqoim6gS&uMOWc*#Vs%pGhL!M^dIFAe~_c?;&;!rXrKB3nP1
ze1JFFM@;;k`5P10&hS6Mcy|EqW2Qn;cAN^o18gvY$}B$AEjOt}rb^^H-@Q~4R}|_}
zZL6KXjgaaH<8ptVIm5y7O;sdqfc+xml?5uVE09T*4^jEifRc>e{(T<9<U=0ml0E$~
z(apA!JvM#NRpPqU#7o17^5-AV$H3>qp&QKP<HUKka)YtI2Z<PlsBl-loa<}he7i*T
z!Zcf+T)Im)|7V-f7>8emM)Xj|Ea*5>$PY^I`=M+_vW8S?3sXfD^I2w&NqwDzN5Vg6
z%L<-(PxP%(*DN)&61!}kDG#{i7f$z+4b<yV-j0}L*j)(Wu^W83Msw<k%M_#Bhg+He
zIL^_Ck4k$ghb^zKK>WA)u{l606Tm$xz$nJeBOcdIHs8J+FPVwYdDP9>zy+~l`D2DD
zKbAAsAsqXWyZl=V*~KIED9$lh6<I)48kQz|uwY&33IEhe%NBN`d`o|puzg9Dag(Z9
zRcU>r8uQ`x%=Hx#`Y|WsdlUuFYUP67DfFCkejn{^U#-^#3*?X8%S%1^k$kq8iM$8n
z;`7CqU#sFerbz-G1mVE1kg4Ot*8yQ?XT{mZeXejxlvd?jWs!0Q>?FC(<`Z=so=CFx
zVo8SM*TMM6oMrDh#v-O{r{hDwep{@1P5>GIQ2Oxz|2oktUKQ8r(PEN(o$ge2fV=s#
z33(153W^~vwPb#L#`DgS+v9m2Mw>(~)ORF1@@Mm=jABRp`&}sJ)Qnw?&x+=3Xf|~2
zasYBC)2~6&l?5C+oW1HN^;WLLw?*Znn|L_Z-&SCdn|X#=D}$&Qsk0>8d-H<37<pj)
z;IA1E$kvXe`)qtS(9);6+fH&DEk6aRV}vKwiv>~!&!O&zqd1dPTL<EH6dLKPNutzx
zKa<w)!Fe7fqzVM>)DGBN6i@Ik^xOvcjDds2zEOaz&wr-%_vXTR;4;zIK8dCb7T|YY
z-x|<7_i&+$ozs9gWSmyMrjN>pgeWLvaMhhsS@C2Dow*JPQ7ubwBNi>R4(_#ckqjPu
z2W5Z2GGi%DuDj<`KedW}Vd-_TW>2smpz$JhSI!PM{p?>vK-~o>uka?3&cUOEC?x??
zGM_h=U;UU!#b~(Klqz9G#xim-%qs^<iTcJ6uKcX)WSO~uVWOIk3_-7Gw-(sx#J=10
z3NTS?omug{8%hQ&Du88-;BwHfa`)}|A+~x99q&vr`=^=jNuuT<#lU&mvp}-5(7r>B
z=$P1qKO(D4j$zuz?=(W8Og-%kmPvfnkACDFy*Zh=Itx+BnR|!I)Bn1!+EPy1S^{SA
z0!fLltCq{uzIM&@QL!x45p?0s8m3?o2gp+lKW9jm*BmdPl8bm$;)Y^f41Lx)1`}MO
zr(jKCm3g2wYm$8zmxe-Xx`3K+U)xObp_v*o!k1R$?N=ypE^0BaPY2)P?0D?C&IC%&
z(^u9J7|AgncSo<Wzna~;v~OU4@@&GLC;qSwQ{pPuEj>!xt9(0lgLwAb2~`q%>z>6c
zGD?!o{olisNmpg!BVUEodZqJ(gSsfsdRmju+cZXl$xGTp-bHECMSCbaO!n~XtCB?Q
z<}R{)v#RD5^yW1D3`lm{7`q~+573ov@Bi{7&W2VnJdVI^dvTkLi@>6nmRxu!phIkJ
z(E2E99`O(mI`M%+P|AL?2n<E3xI0WSkvdd&zgWThB}Ybmf=L_=VpllA6e1=}mReYb
zOfN%nx_Z8_g>d#e-<VvNUJQTDu8aMe;Ay42(6(liH84mq-rH{WwHQv968@Dxfz5TM
zA>%G{sD&qM_>?gbHu3N+<X%>1HL{cXylHFb)eOw!XrlJyJ;I89xMsy(y%D+dOX@|n
z{X6lYnI7#Wn#W2za!3Ri7dW5Z!av`&0{i`O#=k$?I<(~PQ~{o09&0xkY$Nxo1M>#w
zm2+;AE}~R|3h*|0hyJk<#n;dpd95YECU2WJ-U~HpK%%{3eAAHq$FkModktk>;2`;*
z*n<k;C$=L{S)d@qQU7c<I_|2kAy}2oi^6i`l32_@aQgBq`b6jO=Q_tA6Fz9PG`j-%
znZYT`>U>R4EWYDn6IMxf)-vL@6++n}$vL>?B=G??tS?XYBgqKoVz0PoLs(s*Tdq_J
zbbvASxaV2D_3t;-%inUNIHcA+*5B~j3vr5F(@V~|qTRE);u8CDV$U%)w|wW@^cT+0
z>EXRP<zI6tr1jx1-|wwU0>Fii8vFrb?Xf>1fCrcHBsXAs-=W$&Wx)g4@<e@~L6TtD
z(pyNU<SfmGg7L0}{L`R-<G<FYPlTT+`tdR8+p<t0D^?4u6e5_jz^NGuFriknuZOKD
zEwbYHj5t(F-U(kKDJ$dYRm8K-@V;t^d1`Dvk}eYhis+i2Q}ze6GT_yi#`LA~gGZ@{
zKp)2-8>-<pO!=HC45fTA5~NW2s*G49kj!L$kpH^GQS-8Mi1rNI53Po9*dfK)s~%ep
z)h7P(Q}L)hKz?S#AarH0axE|zwl+0199{Ykr=+-%)v&p*ZAsuw`*i1a1|_zwKuVHF
zw_r^<Cq>`gIco%~BV(!_H`TN}zqGPh$VlqtML3Vy#$C!68tc?)O@{t_r7sR-Zx8f;
z<j7^4Z9gVrBsNO*IpXrX;NA9?WtEZ>D@F4LI^1eHlOIPaRNC2^Xwv+kWF6ako9;pR
zlzqV9-m#A+oe(qrO8U7g!(qLTE-6k=Lxo;ep=J|LHu7k_N{n#O!#=OI5C)v(v?C5F
zaXr_rZ;{}%+VUO*OMc4B;@-NuO5Fq=r5{=2C!(ocu-+yGka|du>-ZdiCx@p(Gi@~4
zq|$Ww&lRE6@r5J@B#gE3sX-iw@rhM4ybw5A|5&>}vc%J0`yR~oIsPEqUM2yi?gqS4
zn|?F0qx$O;vxU$nF}|M=2dC*%rziBN<6mlv5TUswzZWPVF@&n%3{1hfE_w6M?n`(c
z|1ut*8FP03xyeg+rZf>3ISqZ?C9A_)Dt)8IjXq#v6Og@cG`#eF%;O_Y^<g1haMNYg
zHfjNi?ZkYEC4_74-kJ`n&a3SN)`k2=#Cf$($8p{qtO#Rpw-iRU#tvsP+w;ONpyeeq
zgdxT!-Z}iz$7k(TT&^*=$P~m6@1jJk66kYLE}WtL;$XEgF}X!|hPl25iR@A8t6uR(
zXl=!RoL+3W-(p>8f3tY!<>8m$rB4CaD3$9~Nk6>aVlMIL2Lr5@tmv<E<V$t*D6_qu
zpk!g`7oDfPuH3}0ET8-Egn0ioX4njWD58ffb`T3{7(Ol<8%ADnG^aThe@B1G1hR}M
z;3d^pvqv-A_QfibavR}-4t4kJpYFCDJ1$qc`tQBTj|p)Q;E9C!)KV)@r2Ywq++Bnj
z%)`n-G&HyRI9k)rONe%pomDn;1MIUL>MB=zArnm59;7~>``+gEWqlaD{v*moUsdLl
zs4yB(qv$YxxqPVve&36mhL%0p-`GTUh>?Yw5nHGTcr{k^z|U(nHjUNY<iKE^`Aj@N
z^~{&%Xz;CD50TV>(TmfGe3Zd%dp4S6BgRlRd*o#5<GS*#m|t6&ft#rN-ylmwx?AoS
zht!8>n7DR<>uIxmN5K*95V3%5mu(D>L$mB|TGoquD#)+LMd+8?cXK@q-YD19LF%le
zrGJ(U@>M~U_`R?DkW+dOm9`_KDKa7%io5Y^o1qEt&JNYbMm7(|enzPKo>wby89#@r
zk4>QZ&E+HaBPD7?&ql~_pN3%{l?S@I<i`*QU6H<Zc#Duy2xj^4Bl23i_}01B-P1#A
z9?@;Z#3?SveIsAk)W=vbdir8^+ZU|hlT%JjWCEWt1T1RIn*gx1M|(t}s)X%{mR?1!
za@qA0B=KzGhPyy`YD<JjYlSXr+J`CX=+#(-U5nY9mRiHqsCTB9vl+{)4T8guBeAhD
zyHS}X*ZkxhJR%-?z2Vf}XDM0XA7%#*r3HY=NNwG=+HKykzYFT=0t`{QX}-EHey-~a
zBn#bw=n^#)^q9!wS@V@G4p+(XUIHjZcL4p0NT`G89lOKR63;K}Zx1)Z7l&r-IBb@x
z#__R(r56ii+s}DCxpQ>-<6ifUxyJVxDb5IVW)Oc5axgO6i7w(na7VoR7-xTgb7u~u
zrVcr$m%CQ+vw=Uqi1p@gC&|XI-*sP^*nfn6BN`e?-I(@*hBBT#9&ylY0LV?V*n((F
zR-S3a^T}DF%FLD&O!gn!cx#abS*{nb+@ZL^7{Nx~{QSrGdzM*S_)Q`K!NRwYjyP0C
z?U{5V-gA@-?pgshgkTd-4AS)U@PnUDbhd2YVdg?kK04w_F|}@x_|qwzzUOf>+tFd#
zg%NEC`BYvx6PQ>K-`U|fY(J-o=%|yweiUv|=Mcqa;z!qW4a91ObHANXBEro~(U%00
z_ED47YWuZjf<uJ9OL<^lqL;Dd6Pv5|yoJX*_bx1$8^ia0XohWSj;wLD&ZhfySyJ_k
ziZLU?IO?NV8}MT#-F>HdS2!b_{A%}{_QXIz#q4?HGZp$BBgS(JY9)0+72yF9y9ZQZ
zlyBmspW|b%uhD2z0)|C*y(_2pX+JN15sO8Z72=E}fxe6O%h=~ec%M&rR%JL=LDusn
zdujsVOa=A@D!e#hCW(*NN79Tw<-AZD(>C4*8yUWhW|(?f#MuW#E<AhKqZAMk-L)*~
zaZM{oK3CNcYma5$yRZDJz10h`eg~wXquZuR<+JrLJiwrJ-|Jv6bEzj-D?h8vL-o`B
z#@VB>1Ge%owAisC@vp-aY4mq~rG)(lC@`D`&<t-N@wi;>2cj)bF}#9ei?!gkD>u9k
zT41=t)!{$4$1Ka`Q`sRJ8i-SiI67KdD=&t>9SEO9eSGHT1)L<s^JDCb)TerpTBl!?
z!T8_x&7)a<<Jo3w4{;vzEZ=lbM>2O?&v%C94Btnt@U{Lq<Y2uwugoA`Kn&tB7Hk!r
zt@E&rl08Wx{1+h!GLvSsb1b)h3dw;Lw&{+tbXS{3c+q=(xCqC5UMaZ^5yubHT=AoN
z;!VHmo2e1OF=?A)Y)obK>NjBw+h~c-!*AQlL~X#Ix`x0GFFLe_%jos6-po=4`bX7Q
zR4AM17`v^>1{Y2MiH8eg2It*l5Yfso$h7YOy8dg@papZfU#b%$P^*GfEV(9FwSt4q
zzZf=dhVS=)^i97&V#6(t(JMEKW$#pF9(K>id6rt)7d^voVh$j<(|Y_rgInh~-mBf%
z<77#E=o>VMO_Sebus->H1mrYh5R1r+zY&>c=g*5Ruc=Vp;$K^w=Y5w3N_&^^l$T>Y
z?o^~`Gmpr3i1Nfc0KKjg(`u@!rzF>UGv40b*0g@Yptc#Ozdf7Y@e0|Kj|LpP&}EJr
z&(IBukmOUdecvWjy|pDC95Y3)Mb8w+==Mq4l}0ssI%S(L_2_Q(_vjn-kcVamNr4tP
zqWUG#fa8^yzT@>wDU$=5UVJgsQ@`1-`!7h(VjeGwzJ|g=pCH*OaV7TNvT0|PnN?3U
z_cGbc-GVm6NkpBdF0s&Ls7Ul76`kw<MB*JcvO%c9D`$<QXU8eiiw}dzd-$M5(_nWK
zGNo^F+bD$`dDuXC=Os-CIc|>(UXS5qV|3<9#`BUVZ8(m#z9<SHC6FwZ3|RGcpwb$w
zOVqoDbqhY-u&}SRQ#mz?U85Nn!c_?#aTpt@L71!Q9cy)|XE>_+-!lw9WSQmx)($$t
zt2y)xk)V%&25#mR4M(Abs<1>S(w#d-$XojeGb6mm-BVbKmI16L>gaP%ca(|STZ%P+
z3CL*=%njm9U>UxQ`@*p$()e{r`zEaH99;~c#;I3e(C2H;kt$!bz<p4;B`rzixZ{zj
zkuAC7GhomCi*3FANH4zau*U**8cD0XQMQeeiMW*qt9gab4t5+gdf7^Q+C(j<uvK_F
zgAe0=RzJjZGpdAmJaY3HNkCCSC{@#o))&N8*pO1&#wlg|A{8<U$M$Ff2900q;hC?G
zThPlExlNo!J4<&><B|w(6RowIEtzA2(?>Psp?Vb?8P?N)aPC4hXE=AV8JVRuJoZ74
z>aqNT;64P)algaK){PUIK7+Ya(&l9@yko@nV!EvT>4`v@6UQ{@Gn4J~iv5R4gYywM
za$*=tg)<!>56Mv2SjCu}2Tvhiy~9R(!J-oU4<Dkl@-8A{!t*f5X|(S=?7QQ(S;|?&
zS>vNCiRa8exsPaG_y*&ohbW_W*{Fc}$`#ARA=GLnl*v)085&ugEn$Ff#s*3pPs&@S
z@-TU@{WL$7^V#`kq$Sb0y!C>uq*6xX?Z}iZpeeO!W&jb2yvmZNN_C{h;<8Y=MVXa%
za%ij)kHJ9P%!1K23!O7@6wyL}#xrqHu|p6GhbCjb@|z!>fR+yu(E8Fo^fq%dKA5c@
zpOKElK?8T@Nu)?`6c!^%VDjtiM47zM(c3X!#Dk=%btH)d!4XuYXV!E@?HX@*jxe!d
ztJ>R;l?bn&d(dZ^Jr^Ns5U#Qbk{6d##I<H*+-5Ql6C8x-b?>c^#PO`R%g-+#Wn<qH
zMGeH(thLw)PA%bnq@8?dFNIFV!TO140XBKJ0tDcrbSRdQ;?@SL=CZP+W&;FFOV$F`
z=x}Ud4usq!kB$Q+sF&00r3tFPQ?rS6OyKn~EElP=$}O-&#CDTZ4Vg{Gi&@#SWnVv9
zGC5i?Y`h&Bov_(YVcP7Csu$BFQZQWKzH&=Uh_llC$Tm1e$m_7e9=1DPH+7B<Jl!`i
zr{Rq85=wR0e|DJutprx9Z`iLClBO!KG_5E5-4Lm!UNT!U42gkrU8YzQ@x4#<Mj8F$
z>FvfBtbamf^piF?JheQmweJuHO+hPr9dpfb9#)`zorA3AfOXvV`jZoVJ@LaTrzxr<
zR>bkQ+8dqSNMzWV^A5Z~yJ~9R*x|2s1o|JjB|0S1f`p0k^Ji6}aUrK?1!(oi^GbgZ
z-l<w-jw-<xPDZVDEh(OsLW3A3Lsmv{x$N$PF=ES{cqMS7U+sx2Kri&E-8nnuvn3U(
ze6nI979R5q^sQ#*<ody?=E%g-7EtY7R`^ZYs>B44W^j1R&AYAjW&7z4?l4%)@ey7*
z`eYHD$EYY)N&@52EctRMyAM-8l+{<&!rnb6g1$brnD!Y~aQX2|?Y%1gW~Oh=MD@^X
zGu?qq^3y^os@vB>=gS%{ZlNl576+Zp6<Oacx1Wr$r!*fd8GL||ofT;({&FMQ@K<AJ
z2Ocux^@@Nes|m4Nc;IjWRDtKqIo9s$v#k~SRnSVgN-MM~8e4`Q+e}4zmE(AC?dTc1
zI{=62$I?N!fC2Gizv<sJz(0sMmQf510L#}AysO`a0c69@B*Es<x37Q!u_@dZ0HKWL
zMMw^?j=Jijbm{c+<lOy~>1prm8|4)03%ByGv}@f)U3t^P>CbtRy4%0L`x}Nl`Ya3W
zd%U@;1__-*Tsf*Qcq%<kG4L$QWKo56puq8Rh4RSp$t^&SA+}{1W8>%8_*kTFGE4LX
zUtV^;%!fa=9`y#{!Bgj_s|TwG)aGk6*Uy|$h-mi8n0bVM(fWZuAqo%~7giziDk|2m
z(Ji*HuQKpzc0UuIG5KHL0^ImkS2ExHI(4=OgYWf6;9n>1+FO6v<Y1aY5nV9?7B|Fg
z(BI7CE=M@UU_&pj7ghbFV-W%7sn3j3qsSLYsuq=sInEePAljjzcd?uE`6Qv2ECH#E
z<(7Px-Ql_51<E*{6YAk`ZVpu<Q{r39v1hDrWUGXH!$bFMP<n#pPP1rCE_mpv4yWKw
zAT2UjfpcQR{hUlCFFa%5XAJ$}#UYB~2rY2L#a4>}!`ei)1xRj3T*ZnL$1g4K9&Wy{
zipT@P>H_A@Drs>2GEvGWFBdspW6ulkBVx+hk&&Y>j@_wMw*syb=XuqqiK?8Kx16k?
z<Ip&^?i5U(ZO(@rI(?q+hBfe{yOV3z&E4&_0<obF#!TQez#Om@*hbCrS|Wf7CHo!p
zc*5xb^XifVlrg#PQ6|u(cx;UV?u{CtHK(akfdMFhu8|ZaM3%r(?n;N0o8)=K^LnN`
zC78P5uWQ7;S>~7DNBgh?v<JfO`&Ulck05?!N)DxfsCwiLqmN6sd<P+bZ*w28tW+?!
zmc=iK;WhU2n->=}^gotOx5LTKj_*t>=?^a&ia`Bi(VS=x1QgXi+z~GYqNyT172#YC
zYcH9CM|rY^knNY^o7?N<<Kc-({t`cSuqWRuRgS^kWe|I!Q*$F9kVgikKB$|OM+snI
zK%4S=S^NRjB5~rcG{uaMS6e8qE+Kbb+x>b!)Q)j574s5MrAw3UB72KkyZJMar}%y>
zGvYqHw59vFNmWgC>_usS8yT|kQW>(TIp)i5f#sD=L{xhz!?BudpKKYH>jwGKJlgog
z_OWW={=`$V0sOaRn&q=WOW}ZqGw2Jw%9C?D_CG%Di3UC#fVbEM*=e<N9r|M`=F=J4
z5n9p`TmBSs8oy}Lg2zc0biaa&*xB?$Yyy7gNWPqx;r^Bbq;<F%{(5cgxEXr-)1I0M
z_Vrev-))D>w6omS1!P%duY0NvoQF8!VboKsL*!M4;a3IKzfR$~NwfG(7IUw9nR3<e
z9Bj$1-wXSh$ZrCF3)rB{q9LDYJ0o&!X^)~xwoYcevhk#}E&a~^X2lHja{a<^0m8X;
z%2o2|E-nTum1XtPzM2O6%InZO%Q2WYMj)SfQ<+NSG$(GPEubexD9aO0*j10cC00pQ
z!B2p2MTl9)DXvP!GjZfM;P$djE=r@xk?Y7{jZ_S6KO*-cqZX?C_$N?x+7|YB=^(wO
z>3G<SVUDa_@aoI^fm9S(g68S8<LT``9sBm2iL-b_?|O6}uI1J#`>7+fB{7YY6BtkL
zok_nUJua!IDc-ZO2TSt3!9JDHgy~)RaUS2!GHc_OcL`{>M~KgCcqvf*!p<+quPEET
zR`e>*63l>+$mzScr*l~Uk<ZY4@SEfG@x=*EzFYHS?SHS@fq0X4{J<xCOe`#K4>1LI
zqj{pmWWzy$%X!ZwXJVNh8-bL7z3mN{3=sqFvm{QA_{ML(U=x5})j)3!G@R}$7Or!3
zew9_XWMsOfEYjo9O>Dm2Lslk>`gsXOnlUg>t}|M+wTfB9v^F1I2??W034YHpt})Co
z#++CoV?Vpv2WJ74!^f_fXR*<u#`f5<ZxAuK&}B$oE|ctqT^54T`EQGlcZUk5xUcMo
zKCd+@h2%xP!}P>L4fO3PRp$26P>-BTU-lwmVtY<MUc?ea*#?lB+lZM?p}u3Z7Tbt!
zJNnJ}*86!H2NeU`-x(RSMWmoW!1jhDFlO=Fi~f6H{c^MdX{mICbs+b{xHz;DjG@^b
z@~#3lsLSjIta^6HY++f+^>$JTnA!v21S-UTiZlJBjGGfY9cv?Aj|BK$W3TOzeR=Yr
zDv!y-Hrhcr;Tet69S#tY5=bys_44vH&J`w6#5pJy^`i+MrbwH)dz5Ill<sU6!&;eo
z*r3u}-T&L1!Rx;AGmg(VdN&oC)=boOs(`aYw_A6N<<aq-%IBvtW!32ypOIh_YL)Q#
zSM4zTi>;zT7#d6c`#hZpuXuQLcw+@C&N6a9etLpCybf?9KIU7<pMfoO?T7~pCQ^4!
z%6q&fUAq)}b>6Q$FQ%Tb3$_)thdP^;r_y>E3d9=1*GcEsc;I(Yg9}#bAG-WK4$jzK
z<*lroO63@wg64Ie@Gg{5CFkh>*4(~)F2n%_)0TN>uuc9J*R7v4tuOZDt!rksOak1g
zns1M5BRNE;FMUOKj;$5wMeHdj%=ayyme_-ec|5331V7em?{SIjCZ~!YM2;_pI~WS&
zkJL?{-nfWM#{A&LGh{_bSGDzYwkaMV79X*zof??VV>s$MUaBO^Z~NE$Py*mi*Fc3~
z@at8BT(U|*9BZ=uE-$=*z0aHuY3pTaSRm&d>7vl)@(NKA(Sb)i+)n}|YUdMzQ6j)x
z^)?-|BezguPAfeamb%D%$X}ECaR3IuHl)8x)%)E4Wf1_?r8Ig#^hx?1*#v7{B-mSF
zhOaN{S~7>ZIgrG1TQ51P=U2adifp%N>A{j@b3+TK#-X0$yu*Ee<;RiRZ|KC?$1Jrl
zx@N%sYbEGe{@IK%PwnrqgOW*xkRa-ip33Em4R03J8K$Tg9}35d6Gv<LpEI^2PFK$O
z+L4WVLg~E%)Ts>84^B~t0?xRHk}SWEk~&o5dwx(`>BQN2<r`6LZ~7IiyQ6QloW!0j
z$twHBCzx7QPWfgK3;F=^1lG9RX;X+!j8nRPOuL`tmYvotR7-CHJnYtDKllWEe%Glc
z){g}*NR!gt0<>rgKU@I%P?d|^=(2sdi&d|p1#vKS(VnS2TEaw!?rDu}jv>ki2K*gl
zdQb0y6E%am9Np~t98z4sr+p1VW0;t{bpaiYgV4#3GkN}>=X^yk?)GEL-{2yX{7-DN
zluTt{T{pCRelD6L=WMZX(jn4W_9hx%M9;GugfkE#Pr0|zd0wt#`2oKVR|5vuuuAT6
zE3|{Lsu|k5xyKb5dQfqC5LvqHopMYz>~#e#jiQ26^-4b?&WS6FqYyK}oQ-@bc|1A>
z#{5!wQJV%NY18Yd4hvJgBc1^tp1<M9<Pb(}YOR`O={rXx!dLN?<85BMWgLHYH?LUR
zH5&Bc>{$Jxf6L(2#2HA+izx1oy+|O|IoFKyQrF@45y(`3L!d*K^k37w@)q|CemvHW
z=PXX-BM!#`Mbm9y_O*B(u9VZOaQCQvQdFxzky_fIJBmbi6!3`<i$T3oC*`HVYWbjs
zfB?__<EY5i;r_jFPz98|ega({CaPWyeNbi9{<v7_t%fdr^&K<pPx2I!1kkO7Fhddf
z6`w<^?H=*BxIGX1n4&kN_5~%)@yUwFxDYZk$qtq$?<0w<fclrq=$W%*8ycH#UF*3)
zb~8sX^r2-8SMxNcXY&AZX_*G{{-wMB>zZ(_AMUqF=hho<B{lv`QjBYJn=nU!Umwk2
zH5va7@K`B6+URiX;f=+^yNcf`VcHA+__6uSyl)G=h~TF<xdfY$Uk{2h(!iu|xx&-3
z&sI-5+|C1EI?x<NKS7EWgjpDTiovOG*qw22RdBMgyT4{6O5$#K(8u=;I7WX;OJ^O}
zuF%av^5GIIinS+GS&HOC)Gfz~?s$EzeCs#zj5;g(*rv32Q%(<V3vTlRaTSf~NTRtM
zHGMMb?>ec(bZyrw+frw-;)5cUp54^O9LM3GI@=lzHdd0aqY$rK8Y@`>ephQ&B&87@
zsXyzym}V9<X9>Sng8JK{xaJ3+4sLLw5Iu1GM(xYVu9A6(MG2&v)5X0{+(F;;bU7<g
zef4lA*25EDr#V!*85Tdyj4ni<$#<>Sw>H^Y1IEih+c#pH-d~S#dn1flcZpnEfnwxX
z9m^jKwg&o3KCVnET8pN5@_9l~vF>-@RYo=N=1oTNM2ZLf#P_XH*Rth3G9B&{Rn9H=
z9m<p)z4>sj@Ksx2#rf7RX{j-IIB65Ih*;{b(8j&{<A0;cQJMJa<5=ge$Sr=A&+*~k
zOk(e&6_lQN$q6q*l=s~~3&<1UCO=Z?7Xd#zKxVr0?W<rmA2bZD)wLT_c8_~74|bQh
z%2U_0oDKkiTGz*YgEZbbP+Bs(Tlx<;lrcJxD5&1O1#uy=495>XnO>W_T+MuRn1GdT
zCyB79@rV=deHqvCS)ZFXIgVtKoXj1y1}f{nRyW34eL3zDQ;v&Le5rrc6m+6*7eTzO
zsj1s2NGer@1xJM^_c5v5*<}`{F!p!ymx0aW208jwyCeQwOl(j%A#`<d&HmeHBnb^V
z<M-R&;!k!(w6@88+DF6Wz__PsBM*sTALk)FKP77)(;d-pB--pJu`ivUHghNd?tQn}
zHJr6m{=KOMLj{~NfBG!@bMG}{pS2*MIw+g&Z71bqx$GC9pg91PUx?*=2rRw_SD_sw
zMm=uG!^Vx+2+fG?T3CNDFx0qVXZo5FU?Rb%$4JdRE+~^F=s#f08n3bDax=amh8G!0
zI+<%dFL_PW{V30KaM@5YGX`myah}?-^C{mv<><K(FtnG{^3P{3)<+MN*#UO<fb-l(
z=xZmCP*~FGhUP$5^)9jcv-xKmTXUT`Uss*&OgyT}TAGkFM~zQ;;>NbH-zrs3Hl56H
z38>xEsaCn@;|+!v^|F&TDjM)uPBn9n#BCxb2a{0I%IH~RBfx4cQ2;n|)vOe<K;xxA
zvAZMx62+nTiTBiS$`vrG174gM_!yq{M%m9WR5`vVv>aeT1K$RGXT3$t>R|rTIec{o
zt9KX#{$4IZq_mxDWL`4quo<ZTaWsALeF@{C?|Sh$I~aHIB~eU?ZbNz-KAMU0cbVT=
z@)u|l3jgfa6gp50Nx`Wol&qy>0b!!PeB@}zC3fYQrZt`r!JXZ_=9h=p92&E~RClVp
zS&=sfJ!)&cj|I~D2L>J!0g0SS3rUIPO-SMNN9y8=Eo5S~3niR=>Z9PO-G}wHmImme
z{je9Dk>8dzM-VZtHA(|l*|iJR+KgvQ=4s6+SZx7VZYqiI)K?wbfqsKZb1e(iE$=Sh
zd{Fvy>&ISZMpTUkxQJWSMvkmEiZ~y3`-#Jat))6~Vcz4B0Z`)f_m`<Pa6OmLAE)gH
zxGzA-9ikjLN66)fanWTQ{I#IMc4)(WYFy64v%Oy!1o)C!GgX}^nhJVe`MnNyuO87B
zyf+-(y=RZRyn~eoQ4|MplW&t7>PBE{sZ~FGMFipXPUOOxw4Ly>_XB>Le*~y7opoAr
z^EkT63Z_es>oaMW^3kzwT;tI9Pi1^sKnJixZSXwGf>)@q-jwrLQh0H{%Th(`u;W|Z
zk0TddK#ZQ_qba5!n<e(Al~4H&nvVf{bDc*&{_bs~2%*6@ikNh*Nz&n;vt99Nm%7re
z@<==PuWWY*WDKd?U(UgNL>K)SfehKJWC3#=z@Kl!zSWW#XPs@1y&m06Z~Tt@IU$NX
z_}O_VgE-qYs5)N+E7_3JQi}=|m#X@o;GV&o0|Bfxaiy^>cAu#V-K-D?T8js-RwM*s
zS7;8dm>!1@dj8xE>8CRNtx_jU{w;s7nMdO$z=yU&y+QfGKIH?R?D#ri8-=9O;0}rh
z8T$#r0T#dPLKq^Sw>&vdh#;NDg-GqLd$de^*=WCT(adD)$6j~0L%D#O*YuK{*MDL8
za})&TwUO?n6^^DF>F4)w3nMx6%%5|?>L2jH*BQ<W`Sbok4D7YoG1#HulZQyO9i(Qh
z8)Gtof08ANJUxp)9Du~&-Di~X03N^g2L0h`#YNCHL+XeJPG%-}9R~qlGv9$%k%x|8
z<x#<tjq`r_%GER@|KO7Mb)4{Vw)jZ}0TlTs>2Cx1rP}dC{f^~i%PA?Zt!|Uq1_ED^
zYq0B6d?Pvg9`Um2M$kCV%7+?(C+G>CfKLon7Z)z_)61Ip!|KDuJ7*Te?s;unZ^Am{
zU&LyOz#@<gYw(e`Dke11&xlT=c2BJ+PoCq!+nCgIINU<W;n23Cl<V~1E4uM~Y*5tx
zY?W&o`^%o&bi$HhUZms01Ep~XL|n8p(Wm&IREA_^Bo_S<PsJW+>=u```9H@`J_a(G
znd}?{Ycb5{L`3E@X}=Me6etVNy~AJz$ug&ckIjNU*V)5s1r75-vApttg3h(K5gcW6
zMa>No3ed>e>01|}86>9+bM2n0APoKCeygiM`mctb-lR<qxjbh8qDPLg>*|pK^EpRU
z4kHko30)N5*M^Hc<Ci2Ua0M-Lnr?Ekm7$ZKL(2VBB7ZFn;vlJ9ILhw+BEidak5svp
zHfYN@lr*!8;+jm!U=-a#z3gN_yDK*;4aFW)B(e#PQ^LMw!~H-GPhLGLq2e*wQlvEL
ziFq`-k-DNlKNWSqj)M$7@t%yjo=l5~mghFDK7|{tZrs6rhl8hA7&!ZgzGJQo6+LZZ
zQy{{ercg>D^ZqWRkB0G%73X^{bR=nAbMd)hnrXe)DBVADD&du<O-b9eVqp*|<+mX5
z_``?294kT+SPA+_g;=T&gKDXcZJUXgxEJhlqg&27eNUN>c7Gg}(m>l9k5{r5`z0+K
z<8|P~4FG1kuk_V7jJn9~5!Z7p)@PtWH+VGUKo9g46`n^D?N9npi@MwqO0F!*whi4!
z)N|HcBWC^L<effzFP;z+-q9ibqU=hWmgvnvj&tWocCHJ*!-3X;e%=nX_G>3Z8@j74
ziYdphr^VVWklDpNZu~W};{(UW$$T8HC}KZ%P-IZcIq8$VrI?MQogVs-B@7t`>$`rX
zj{DlKG`moeoVaF0wp0IQSF!nZ7LC8kF{*T$*>L9lS({d`kf8Y{+RluYw~MSqW1mB5
zi(7Q0CK=!?x;Ahfe~tjQea7@%E<ovkw09NO3|5ny2GVs;kmGw-PbNZkt4Van--vd5
zuK<Q(?%!qp^NpB_R`kgxvT%e4$Jj73IG!qB>jsa0ihSDd(qj`}kOQ}9hQ5@0M6yyK
z?(tESzu=O)>P$2%!_zRc=ftMaesVm}vaNc0_HzBipsHC3#Lf<H3cq1Um-6M3M+)Ep
z`7Xyhj(iR{eaV4n?ZiRRxt_&VcoL$Xtd08n!>41!PcfAfQ6yB!&Bi;<Uu*UU9LKK=
z(LEYp7)02uXKg*3xUdElt>z+->fBd_CfTGo(j+SV&7I!UpOl6J;>0FK!S!i{6JvH-
zg*2C6P1Y&6^E+SV_guhLA6yMKSd4ZKrGDYhb5y_3oZ8T=Hq-iGj2!0MZpT5@$wzy)
z%TfqXvx=zXe!f~{gmY%zxf}U4UyKtlT1#3;bQYrsoVC8ed4pJIc_zo-Bs+UR%{L(-
zB;#dA?5FWo0Y$03M_W74zYc_$2+ttcp%{<cf`WOdhld5YPa0N_drjeK&qVSH2b-m0
zHJ7Ci8VZ)jf&*&2<pVU`K#+cjc#NZ)$I4tB$YbZpZ~xda6VnMHbel$PYhsplZ>t-S
zsM7lU^4*A;jxvsS8V8DHrjtGV_MFxUD9-VkilQQZn^wntd{ggr&YdsDK@mzFW@DKA
z2?nx}oOgA*HNG<=-%bnL8T#f@aqi|L2;|E{Yq=DXQM<4J{GsdAu<f6apS4fOGW5Ae
zLU=IKR>U$Q?U?{OyXO-ii{zzv*N~#rfYG-MN21>#^)zP-eq<43Bd@n-!RT3{=d$@(
z`4&IK5F`xVKW1+5nwMbgr6-GC${p-OijAg}>F*!EgqoJbyb1rnFjT0_n`{ZeMm^*|
zAABh5o)NqN4dA^0BEkT{);8t#X=2dkBKRorQoku?d$E6&+GG4fJ41VhWGa^rxCI<7
zevczeELcISd%ePcazn0V7#+RG7rz>{t4)^$$U~LYmI|+0U;a&2XntKTOI-UWly28b
z7CoA>n(v$08^wTXRmq)P0g+W2^+8p80$yx87E%hD!7UDkc%`REK`TxptQlJS{UsiA
zhp#C54w(RJ$%7TtF<e_)k<>n(U>l$6!S<~er<kD3$AFxuH}#sb?dpdQ6=xLEXwFA<
zAIclCHX!@1vjU$s9;y2#CMhxtyy%I2tl!dv2~;3?tiE|7Un0tpfh4&!tW2~5T2u!l
z(CV00DI8+1I$WPC=y|bP7=0tddumN$8E$(?{ri^%?s~`xJBP)SaD+Z;^86dgUR?;3
z$P`%Y@R%&)8OfDQ{j!oYw__66n9;edjGI-l!Q+Vn9?Yma-DjeKGA1(4XME#-7wK<#
z(9_D*3<j|-wJ8#S(Ti(g&B8?758_;!KA3$HQMgkhrut~r&7J6`%j4zMHV4}B7m#b0
z%9hLAdDjKBcC}JY*#SG|^XFodTyo!>fzjB5OEivsp4mh@@ph{9_f;%jnCQnD_p`lg
z+s)UAxOo-H9r!SgXW=9F?TCG;S(;zeDqj}nE|Y2kfWN*cWpss^QUDL^CX`0nCpIYq
z=ApW+u!G3!g|S+XLWMQ-tTJ-73@3D?2I6ZDJ=XjWCP9ylr3-pttY@J)+em$XfJz6#
z^1@DLt^n!|G)nz%dMR|T{kTe*Wy$EDX+GbXu7WznARXwE58Tv0#wk)9g@lfmzGOk&
zqFY#^NVEjLraIfDckACbeFOj15l#jb%I}D({aK)uCGpJbb0M|!&M)G<=;B_!gxIuD
zdj6{Yd<kx9)t#$21h1(S#@Itu<B`pijfWzon3R#ABBzdZfW{Y=+C)#PI5)!m-7PV0
z0OxBy&&zl(d>=49R14n1vG!DCncM|<W3&Upqo&C$A!~ckZ`tPOK`VDNqnUZVkT~e)
zoxyjUubec^e7_dhWC#k~DkVq`ZCN4iFene+OP9uw?dMG+ZR$opjiY#eEPR=WE=OIc
zcDW0%n2uj@$5Z1M@CV>iDLcBd6k^fMrk1MRFxSs<3-=j2+^ioMGS2_vR<5PJXQ>m+
zZ5qO$Z21;UNq>p;__7*rJ>1Ul)72=y3^wJyR?5;F<78FjoD>N+Ods8z`8<}=W@TpO
z|7}nv0b<!W7qJnw-|Lc)Z~4VFK;VYJ>`U>If)JT>lKsHs53TF$;2|wF+(XI^?w<&E
zVB#BS-G@t1h`sA~QO|pDnUibtKw|(|L9AO9?Yt&g$#(zRf;_LPz+zl;=W9>6aUsSz
zbf1g+K~r7-6Ulkcbk=GB^?edgz;$M=4GQ|l4X+Y`szgSy2N`_r8n4(a=>l|GOCFrp
zP)g@TA#b>tR*D<!8Gz0%H*kT%RxLlwpYM^szu0z9c;fqE2lm^`?y_Bbq>sYrd|caa
zk^Q_;F1udU*kD<0S&7FPRHZT7Txxsbd3$ndumMYIlUY}KYjVg3>;ZPX_J-RqLy$<6
zNK}>aD)>F1*ODevJj2tWjOezw5n>pACw5x(8BrMbUE}w$&HbP2*rw79b&m9h!~Y+e
z&VnHdu8Y<)!_eK`9TL(#ba#WK5`u(uH&RNMba!`$bc2+Dq;z);Fqikc_x^@`&RIL2
zy^b$&%S~$&rpIca@n<$A3)0<|uPU*ad|YCkmD^Tu8()+&@ar(tkz}F>M1Lg3$7EqW
zpyb^%Q?0wu@$id2M10J0N0ar89Ze63r{r#W(HP1#MM_YQM@S2z2FL&;odKFf0S&ZD
zKj8>>Fk<ob??>(E{5GEFZvwc<)H3rPO~r4gB}np1gn2%}iv*XO*|-8a&vpv|vI+RT
z@o?%Ny&SDBUk_eQ`f}#rzm4f2-KWq~fM8+&QP@890q2e|;}j#t%1v+FlL`G+$0*ZE
zbtY}QRi}^j*G!qI8v8gLtXIBz-{kf@(f$<mx^QN~xno?BHFC#W*E(4dOi4J<Rj%m>
zd@{?<bSt1X_aiSS1}7ldptOR$@R+faf>hs=5dSEZPoZN03BNx9*(*KjUXglsIu8+=
z`Ifc%18Yn)FQY0QijEjsP5s($Q;+qH;h&n3R_rC&IP@&tykcz0Sxmzek0n`9#!hz1
ze4&}&BnV#8$`3`s1EIKaL3ddq2?|F6?7wn~VBAN-;@ws>wYF{)IJF=ql(!@HN_#q=
z<P7;#aGI(KC|6AD6q9Z8a%M?wQey^tuenc26e@0UR{|@!m409Z6*ufCVnAp?(nXYw
zK_UesilIAVt^fuj&TuSY_$OSQ=X56ofx6kx){1h#ryvhVmnP_cB*@z2>repH<8V;0
zyKY@W^P$$TMtuN%WD;X=S9c3p%2RTM)GC8t{|~MH<)49YXOWxI@Qwq*mNQI|qoBec
zxxAAo2zWfGq4=Dr>P*VifsvCQkr;K^jYGwh<rxdvW?=vjx^7EAJV0udlByz1UA_;;
z2`NzdO7WtKl?3aDE|>nOg$_v_cPZM;yS%q`HLUjh?UL%N<sYdzwSPsIn!OQf#ERW>
zD%r%0j9S}~%%K;ZD`MWgS63fQz~KuGdx+l!eMG(I`@Z*e&v@TleUHv9KtV2!0xrPq
z8t|EK!hgSl9jFoR%%A`5p>D9u;4ZcP6aMDbhY*5R8&~S*Qh|6subKzAk04UQqcC^!
zB&EMUeAZ6<_0`8>8hd5}t#GLyOvP%D20xPywAuZ>5Ccj1-AJ1%C5Cr*NZVy~c(2f#
zqj*C}I(p2xN!c`Ej%e|}#(+F@8aCczPPutZy;6WKnoW3vn6r5m|LY08a?x~2Fel|#
zBFmA&t~brnM;*`aBjI!$HX<%dKjlodJ|s5hhb12=vZkWZU?VfpiFhOo(M|oTe4pW#
z-O`2_Qp>YY_-;{26u2mr7Ppo?_ra|gWK-W2D-0+pc#pV6gF9&!ns$ZikYuEYsSRX8
z-oQCFN;F+vsX^|fx?tX&W;vpjn08;dOSE2Eq6|x2#VlK6%&7Hw^=#<ycFtQXkh_|c
zb#Q%naPW6}+Bh_SBwv~VvTu+0!?|k#uf2VmlT&y85RVwe9K`*97GNK-ndR>G*~l>K
z<SuRf4<Ho8k^l!7C$K(fv_+CvAdZXRoR9J<2MpYNHWOXfQ&~3cnf_=f<H6M7v@zd1
zFZQiw0s4LNaoz=OzEF@USVJ0*`c4y&*jwH8c)z@aApj>gdnflE2)F-lCfW2qNzJH(
z?bN`m-EYs@F8k&dgfeq_KGaY;=!-BHbQ#D7G<<)Mb&GDH*)~F2Se^YfhvY++g~_t)
z<!b*yKk`Em8l4?^!kcO&Bn9=guj+^{<2T|#f+LT#2{-tI*}t8&sV6>-(Wp)*=4%UA
zcPSw1qtguyeU)FuhvyIH2H}yGaux&lIP1njr_eyVobo9q*AQu1))4o&=D6y@hq63R
zEByev13%64<fworjlW&6+2NL)O0jM)_quNX#|I0a>xZE7=<5TS+<{&bGj}2{uQ+%C
zD=FrLJ>x7yRiMB4*!iDt$hA4ZfSBGML1|Qsdz9)3ND*Ey3KIxV(*RO%8|&N2ajf8_
zgS;5#3`yPtQVGI`O1TCuCXP+Yfz|razD{^T^;|$!>)D;bJ*q(0s;5&##X^}l1wxHe
z*mczbXYV;Y3=ZNuA}E0TEQd;N=>OlDMe7ZCHico{7&o?}3{5VNo%mh{5ALS;5`~2`
z1dJ>CM>n3go~%_JAFqz}bXVOJx(00OW<~2qB4MCbOMh9q9<s5jHACt%L(r~MOkS$X
zi$b>w<)TVkczMXun#m2bg>aIH^t8M`KRcH`7R5(yR1R87;yuQzZlbcNWdQIN&(_`&
zkQM{LY_ovn%lVb7D_KN#0U|VgVkd_rB;OwqI@nQB?#*GBQ8V10&)hX*_hhU07M;%q
z250_WFNbH-V%}}ghsxG2Z>Q!}<Lp7(hRCl?!E6^ZBmc}FCST&8gMxcw`uD%8_L`NP
z{1Z;Ekl!130^A+d!I4QnXQAK;fAvS<ab$c5ltePq=+$MdH3zDXzm%7*@&4N4EW!&E
z5d=u$Odk5v7+z8e&9rC#WbN(LrE;YAT{{f?nJ|08`2kx~nFgXQjF|h%KzA-X(f-O4
zy@1&J%&9(&gxrNQ$U)XNdHI$7ZFJSMcz6Dq)uV>TwmsgOGKR{S4e{*A@6ig|7N+Mr
zcOZ8>EkCNdYW6mi2_Wn8Ru|;QAdp0|;AA3tht=5rel_l61XvnbXL5#bn*U{`v7Jgu
zQb+d?!OoaRKlP@6!VGP+N!^e_zTGjw?494bO{*|k=t8?tn8A{DwYO|0s!AUfdTt46
zd!Nw*H&xl_f{fmm7IeHk`CYi`Cr?Al!dXjh8gRHHnGi>j9MH1@>G_9F(CY0^Qv)_}
zjkXu2v+97a#>TMg4ExLIRJ~PkQ4aTW)67#buZIywc6RkDz2DibBI8@J0B_s0nNRfo
zdvs2}ip)4-D1-fA%kF<ZK)+Bv_kGEG>asfbYMxha$q~77{4Ftrln-uH0=<p`&9Hlu
z`#|3IK1bL?*jG4L<rL%}B>&K_Wb(510^WlZbGoXL)aL^K?vVGc1U;N68we>~Xz!GI
z=bKZ8%FuaBDJV&h*bpkWgAmDsu<<ChGCe-cSC^R%e@Om7(J1=gs^iJh@7I3VSpdpv
zR*jx;kJ$(Dh2`az^5mY5)#USahl=wrj$@8%2T!C+<=MJS6xzRKzOP8v#Z3$pR>~Di
z`g$K#^EWW0R7dyY{P8i$u?&Rw^wCnje^B2)((2*EUC2i5R+%WVXXq$`aP}I#+%dq%
zWdauHgTPq3qr^7)AorK~l*oNUckUJ;l^KNWQ*`<wW@)8f4z*wJZBV9hje3jOf+XSL
zB_(=Me*Mf1*YG4!?<7ZA|EB(|8Z=JHeI}NB{whQ42zyw*dy370E#Fe+5bE`K|I>K9
z8eP)u(4kfskXG8#XnG1qc@@BJODK@<No7a_z-H}yXkeM_W^bCrUjzqJMGsdoVGv+B
zf&2v#U@N1^qDFdM1)Hh=vczF;zUlhAr31E5uJ5%ibWy_6$x^n^71#*+bjG!SO!u9X
z*c1~kSNW-BwE$fcvy6uZAE?_z0l|@s3r5Y8bk3Ho&Gu`yLIK>eKzyIQe@8+E{Kfxk
z`_+WK$OW9A8$3F9;VkVBKAmjoZXKd~Y&<;d?PchE-{6bhNWM9(pI=?A3b1DtX^+oY
zV<MQHfN;NWobBXN!A?xTN$<l(Lkg-@PhD?n8?s8WWtpd~)HzY=^Nh+QwKe4f__)WL
zl02vAS);azRQ!b=msW7A>1?b|g*7x6=l+|@D0fE(D7D$B_?v<AD^%azNbcM**o%sA
z>mMn~Nw0;lqsAk#t{^mf%MZ2mZu6Hdoa@&;a&PxdBg3qXk^`>#CeQXMU$&pRn*5$F
z|Ans}4`XT&$i(fSm-Q9!2H%H>V+O)F&&b)tvD82DeG4}jiT&Cn{?y}gp_hViKvA+D
zfZQ48sbUC^F#Fvqu#RHYh+ENi-K$6t;3`o>RRdK-mX1~6RpY7?1NDMH*t@v~d@5yk
z7v8fjBppg*L;)^@n{spZaUQI>O73OYD3a)R_z^fmNx$U_V$nBO%qws{>2L$GD%O_p
zS5RLWgX`aWygCJix(eOpY<~K0`f6$b#e9XrCQp1Vh3_X9lzKYX25WTcp7<Q9duWYb
z_L{FYI@gbcTZH`@G;aljIL0Cts(D-pE@~|rLFy1}UFHUKz*&<v$EG5St*p`;I*N<r
zF(~`VcDP}OjZ-$1X7-UeN-h0Vg(Ww#xidxEz7)1+MY4uXUZzXM)9!zWaH7a>%>65P
z0T{<<kc))_K$Ga~)@ZLNP+wiVlpR^@aCHe0=jG1jTkFNkT!cD(Iy^RHXpSD&)Y6r+
zMohw@6-lz7YQxYK`2g=*k?U_WZz`$t`d)W6KsPx<d?ndhyiDvJY|y?9dg1Ki=H}mA
z5hYnqE91++DW;@%ec>z^Xg%mF*f}lzifH)aZDQ(PC+O7a{TTq<JL{yr4Bl*Z2bkeS
zq%p7P_a8#eau+Zl@FQ>$AO<NNnOv4c|8Buea6byWgj1+@Ifap@wNX&Q6*(_0xGUv7
zL_!_qZ=XA*uH4<bn|`WNcR<3r8oVC-XLu)a^9*t`d{x`)xmT{hk~&c4%BBKc(B0IJ
zzYWv>y+y26u-A=8@rTp!)Vn!Te@)*j3m=oDOKLO6a~9w8;+u_b_6kZ9$G1m`cD<S`
zR%uv<eieyr0P-jO1AN3crd;P<V<(h642}@ueAGU)KDNUn!o}Y^rQ{*1EuCepR;YKH
zfnn^u^7mIru|KRLN+cmPySH5wE$K1_)vh0_l{U<8IjJ}+=xU5w{@VGac@wv7qAT@P
zA7qiqwUS51T|Ez_XxjACGa4-x7%X}}F_!;~IU$(;WvzE{(5O8S6I{q$JpL3n<He+_
zHo3SVApjNCCKUg{0=taP$O!Pg#eqHdSzd1SBX%5LyM5P<ZOT%<aCvV=IdevPu@8Qj
zo_&?N*cW-==gm5CL7i|G+!?@I58{r?WK}~0m_XX$cVxfaJT^XYk0b?`hs$Bx$o*?)
zEjpqNic2FNV9}W-eV@Wi_@W`#94m`=!w9EIQhL)BTz8y%o^(I=9gcI}danv|*F>^g
zhQ)@BS{jKIi6E~w*`OS2zSYVU_qu-n2o#gF5C7!#fa_Zjzw}k^ut;{1$nY)2?8doU
zg5C8{MaM?3diuPo1>9bZjw_yjSUc(VdAW=}cVLA{(03m<wqy-1twkZW6y@klfd<oO
zW!}h}S+t4;5-uT&cUde*9j6!-3n<h?7WlXV)*%WO-^)_7nOP{(l^{0+e^+PAe<H>3
zbUx0vpQ=Y~+9A}<dY3J~HfM3jwYr+>HTSe{i@SbCcFPK~$J2?1Q>l+DFA#IwgseR`
z70Z#i-Ah!DR^PGk#T!k5TodZ)5aR2pi<y2?RRXI)ry`*Xq*jB%z{{4%2Fkf<*r=P=
ziyZ&kMndB4(IZqX`(b?CMfTrYx<)jFSqp?_fiYTNPt+_M16Y^eRva7g!=&W$;R95u
zDU8I#fC1bxEXLAu$eSe9@6c3fE17Uy7SJ9;RzAnA?~Ra0VMj63=NeMzQ><nRF1zK{
zlJoE4!hiiDu9j1_tMg;ht!jEnRFdKtBf{Z^D-dOXFK~9ClG2f3Ukv>!eIAuadY`-B
zlSheKSs2x$hm*UY_rE4TN7G9QY#c_kJ!zDIDfYS>5-a}K|K-X3{>-5R>VW@($o{Mg
z57mYDvEKLmAiE(@uA`4%iiefFaz=!r&4s@~4C-_pIDnKdN$Kd6>2+6~>8U{X`7d0x
zJ{vxKSN8h-4LgEMW82O34Bh*Fua*>)A@a_Uk*Wx}^GBtSvW9#AF`PT<2(duZP0zfK
zL)wNzF}8E5YK_B=t>akRJm`g!Ba<+uOqIhG1G1809n)X>rwf}!GnhIAp9Y0!3J4`3
zUgyH^*=>H>dJ{Ry>i$*OfxE};-03L??Bw}m@9v~Bg8C0$kT~)-E<}8Jgm3=-7=9NL
z&^k@kvLOK4G4sMeL32*;@!}@&7oJ9M`ADlF*%|~TKxn}-8ziaEM>s2{kXf4_-Mhxu
z!p^m*42LVL23|O1AtNgOYpoaT$Bw=+Fjxv?MZ(Trc<)NfKL@sl7$w9Px(Yp<hwu3?
ztskFZdBogU_XQ{b+3t!Odv3*HHJvfBQJAJCS+Jdw>6{Y>abKvr^+wzB^1Y+`Yr*mA
zkx$3_Zn%}DFZfdimAV?W_O2-!NElS1(wb+Xw?pc>WrRJPQfyiSxVBrk_tL}sR3E@n
z-|=T|j+NYgWkxh*w@zp_FI38fB!-4{reV4T`1v_npdKpZ!dD(bt6h7((zLGt?tprV
ziX|!k<elX;wZj*^>V(3$zAMaAxTK!f#M{B%G3MxM!PfR(>`2<bB9O_?9nQ@Eq#fU1
z1fKPNzR(3Jfa^edYM(2@-%dWkjVPDD_|SqlKrg`44SG2J@%d&MHoe~QI+9|1Z{E{%
zC#JLJw?7rqPdzvshet^gRV;0gBp;%=jse~YhzbNh#tj77gGXDa0&)KYTQWh!2I^Gc
zn?H@X)3It$tzy$MCrEx3@US}Tpw!tv>CzReY%(n=hprP(&AgwN!`ff(URYST{bN_P
z@g#bdd3I-R;ivj1$KlT-Ym5TS24AxF+d&6L-aqhnbkKrA&Np624wDE$<ZN}XSrGVO
z>e7LWd6Qrhc|fdA3oZuVekJw8>xX=2bf9|6%mT^vcovFuEJoMA_2Y1^yZcgQ4fqHb
z%8BK;_%%3)$orrqh(fXzr{!)?=6z>k4+Y2awAOQu!n{uaJWRA2$$>O*^>`!VxaaB4
zac*}t_V8$Q?jqdrOpVa{=4dce{Q5z2-Sd8SSM4O_!m{t~mhL$|v&EXYel(cMhbAiw
z&4FE^4Oc#d(0uUKHyn#bfXQ_<f{at8*q+b;tLtI-ZK+3E6`5N3mYc*v8mUh#n5O%m
z<D3rWZF??YfW7LNB+w*bDd!pm(pZB#h)Xq(P?*~b=hsG?vhY=FReHG_fvopW)|b}O
znM$Xy+edz~9{#TvPdbv!_A;WqYxl@_BSQM?(NH?9uXZ@vxdWACd_mje!Uj{4LyQb!
zFTbr^uIP=Md;ECSdMd6SI;^ds#+h`f>!GqpyL&pl0$uklvoU{b5LttHJ9_Y8Pm;e$
ztnzd&IXGcYN$2#oZW+oAEXL)V3BAEsK`Q`hERODAjr;t#D5TE>t5E2M0$u{Hc6|r%
zNeH5+quF$<=bvT(xtr&#xwjUoh2<f~S-7z6C4G@LfVZLER^k^R8m;3`e>!ma`65#B
za14FOs<Feo`MKdl#@1#JaHtW#UgCHig2}p;Y5mFU=9KHaySTg>Wb7EP$uxauy3F|U
zJjePtPjiFq)SakP@VLbp0T&VS^N%oq1%=H3i^+`JzE`U^fgm&U?E{HBD6ydRff%hU
z>pTFfpszIHN0nnKfZTk6Ki^oqsO7P~_w2)@-xndqaJHtiv)GzSrCK#+3Jlk%V1pyq
zw;3IC8N5ByO29m?1Zo_uZEOvE&XK%yKQ*R(6O({9MM^$ncRJIxKnp>^MhI!&tij&$
zXt?Ezu{RO>nd=zc43?+M81<L;SIhZVV?13CLg9&Orjs82b{??x^Nlv2*Uc$%gEUX3
zZGq}%VY&x$s4zy!%USFSkV-pRwCZQr8oL=fbL@Lgl46a8zBc_nRA%GS1NtBw0ni*W
z)0ZI5K6xk0RrSKcbwC6l9|4C6Fo|VARUf#9HNs$h7oMkbS2D#&bf+FFMOlPtg34J*
z+n!cL!xP5F07nOmZ@tl&B#C}Z5D-BK1Jhp*RcA)o^}blgzf?=1I<UVEcZV&G`mL?1
z=B!bRY+QS+0{)r=Sk?60ZoJ@#dcIW5t=>~~KCE4bi(l=GJ`aXtvUhi;UJ$xR`yaAw
zX^pL>CJrQmQOX@ejLa-70t*QBDyUC18xIm)RJlQ1SDlEs<}@MCj3}F$5r4Hd<nM>J
zTOxy~E$9WPo0xM}3a7KKvu#<=92nFULgv+mO&)>+9JBU1l4}*v-Sjyk+?|;kC94Oy
z)JYxl-h=0Z+?s~j3Ky74nc$wpa`REWJCT{fU*jSWwOtD8i)RY>eEe`V<-dv5<r9(e
z`nM(I2?1!G0ChCSINBE=Y<t?_REaIx&aEYZFaFog9xxA0|NAP!^F2Q#De5I!k-&b0
zt>V4h3aN#0>&};38!7tR$5`C1>e5z~5WeC4`ZnD#7HcMV7U!}kWopnIv&{;Ktm12o
zoJt^={hw=@&E36;1U#J}X6_%LwSFcZ`j^Lbb0^<Bu}-qUk3eZ25ezxNCxkc%J29TZ
z;s}<d)rtm^8q*Mb(5ls^wfUB%AlEF+3zPJaw>=JMo@hu5dhhA2_1Tl-YhTObrOuz{
zsl>;rkPX;Ntm)+S{=Ty5TZzg@DZ19fHNK|>9pHHPYxOhfTM0{}QGBIdq;?V6eoyz&
zDlQ#rFoitFV=jJ<9Z|dHfSpzwsf(u7j6fCrl8P*!fb~(@cv7gWW)W-8Hf>Svd$~Lz
zv0a&m<<;K%Y#(DYAuB7TrnIQ@&oX!uyBmgicnj^O9Qz7+*a@vh;^cA!@GEh_{=qdK
z#Zu4ZcS0TkV%p?Z2n#6?;TyAy@VPy4b)+y>1qdoP)oC0iWt4_`2ndst`H}%w>{l-`
zVkep8Gt;0aAIIv3*Tq5B`C3;)#~+9IHV+9QEY$Bk_y;7oxp&5fY+qL<F<fDCrOCNM
zlSXdm9<crm=&!=6C&Cj5mA>{3N)%dlB`|^!<4#k@IH4vBEm`8@iyj@M^MT_VnN78{
zP`-o6nRA95<rw7<4nS_De(x2rg_l791aJ{-M4$j|lM8&9!NUcy*2ny)ao5eRazAz<
zxVy)>RBHWJcaP=}D7M7y+Rwh-3~cRso%jHI<aiNHN!q3i2=MSAc=|KAd)4L>oBew8
zFZ$6A8n!NvBi3g6pqjQVE8sLn^%K5#o#+7=5rp+IIYp|0Pm3alQwMI(QUdLJ;v_<O
z@F`v%%gE=UQLB)~lUk;@ilz2T02pQ4B4%#WZ;y|caIyRI<EninkA{neU7)w9$j_0#
z;GaT6^;s)Cm3~bmH-PV0QtvLikj-7d^G8DZjNb0@c~1SE@{zhVt(Qz1ZbYqV;3`zt
zaOF8B>>K^Ul@mO667t@)LFrQ2W^eIb>0U{+FRp?SNOv9ZK|zxPNMAwm5IXLlsoqO&
zvu<vUPShE@j_4bsr=8h1Ps@$~XXo<6k;3kTd-On9-U~;}H5|r?KPG~#sL<B^OpiO3
zxX@xx^_f&OYqCYq3_eypJ;)(%3a(U`5I%zZtVSDdANWZsgpGkwFtj^Y8V>j7;QXq;
z$3b66u)HXJa->uiXxE}?PJMy4eiB)LB_Ae4V`c|(C|$eN5teNx)r!CID)e3Y^?Keh
zvQZ3NH-X81fbDVw2!CMcy7r8u3^=~rjTQIwy=*EW?5H`R_Z2jUB1?E`BsHT#t~34q
zqAZ{<u&JSwswp9)Xr@iP<M;-^m>eVYU+vU)S5zA_N`W_k|CLg<PRTQo_xXjDKZZJC
z_PUiXW3(`o30957rQbEVyk<m9_Ktc+7jHQOkq2Lra6>Z@=vU77IiIkPZ4=^dYI%9W
z9s=eqZK*`@4eyl<iC3!OQ|Itr`TWure#k}eU?Qn6h_F-Zr{-|-ekppsR-Ua4Cip4}
zr#KTf@j09|js;|fqZk`7sr@ePXP~`qC&DJj(BaN*gK$k(dk<2HTJ~R9YScK?+C#Fu
zzKNIL>>WsC2TV5hG7|>4y#TZ`R^Z=girDb3P(DJ{WfX~mZS|bA<8#|Fk%&ctwvm7B
zp$UGO;C+uoXJpIiwOgMhuo9){i>^)r_~e1s$eix&kJKm%&%@VLMf@CxfqpbnL%;TW
z0e#n+eH^3Qc)kwT067Vn2QidYa)Rp4s(sZNot0A*WmddF{&>qHz^S%};wzb_<B~m`
zlh2D?*X!c>YvRR=c+%W?&&y3y3uR8gVc+AKU987p$<+Phk8x44czjCWN2Lkrfo2LF
z1Vl-+PzVNUs_NR$NlR684E3m(vegepo8B2y874XHS!`bcE>7NJEvtG7nJU@ocoUPE
zCCVK?l)&M~OCq`cOXWK85Q_SKY2)17=FdOdBmPJtl>CCHGDWtD?tI4@d*<Xoa&gyW
zjv_|$kM&bOFPFwr1JNuBG7;~;?eIo?XYxV|`*YKN>#Dxl{+|tUxyv7;h*4O?CgxwL
ze8Rs--|7@Q;glrKUHp<$y-#)BA1#3P&>lWl5t^*9b^Dea4=D@9yih)`bUo(q&1HWK
z+ge7u-f~}gHN2a3<EZM6DFM@<g7cB_R3UGgt~@1&?Fba6MB%N0cVniC9Oc%*)qb;z
zjg9#-?TC11_t-=FF<`@#q5oQ?Cp<{1d{4Iw%f?;!qa$FVI}L*Op6LW@J4QhM`h&p1
z;Lvpc!yGa{E!;HA9wJ}wIkWbG=v!~{fAVqkl;dx&2Al5M`1|@V;9*aWW6C3^tJSdk
z>QidK-lZ69elU3Y)WuWK?t5_WNU@H!ZtOHYm?pa7omRtL(RY@gmA+0c?pN8Q>6~1>
zXl@E7%&LJB{|53@SChSZ(!V(CqJnXFH(t)h3=lk<CGHlTwE0zAcB+ntve(4pF2~lJ
z<Ff{kji}?W5y&yl?E}V_Fj+F(3Cib3pUboAFv3kko=BN5()QHKP@|6*N#)=dkNfJl
zIez=o_Mmt!S)^=E5+n{26P`)_R6PDzDFW8rgh#nV<;u*4{B~bPHZ?hbVHfXK&1o58
z@Vv0POR-)_eaxlBHJglBBK`3R;Q_{g0nxh|S2Gw~VgW`*+(Slkk&%qlMc~7J_yBEq
z$I906rY3kW0>#5u;txLEC2e6S))1*)J~J|1@`k-ieIQEW&$tn<iUUjz_qGCJ0HsOE
zD<Bl%3m#mT{UMnbsEM9RAO$sIb$Xyx!)n*AqnQ+o@%?3McX!W*{N^gc=H1hh?@LL~
zP0#Q99uJb&GjUi`gABX)<-_H!nz--PjWwm|r0FW7FZ1;ttz-u7_+oTpBx$N7sbC~8
z=})<_F>W7AG^!YrUSr^<dwo$_R7G0E<gvKr{EbKzmUs{^)x6}n;PwRH&xUK%vA%bK
z&Rp|()d#UT(5rL!oip6mawST$A1ZA%LT(3R9)oZp@?T8VPE=$Vu{l0~BeFc;ZO@<Z
z@V|$i0=vnPHQ?_!+JKX%r|s%%>mHEuF10~y`I;<T(#=!V7UP`?cdd#=5%1I{uf(Dc
zc-S)V61QnOG@6^>iJX<p^+zkS1WPsNudf#^$WRY8Rm&}@{q8M~{1~2AUDN|E$eq)$
z_=z$eTwBODTg}&X7tj;5K|Ha>FR2$<Q4he8tH7M8nKlJ6N6nwf=C-xNzY>pL1-c+V
z#)Ef6<2;g;5nIXBqkjZrpi7{VvG_kz%2I6dp7ZYy*tlim*#Y7-BEDN%LN>vn#7L1$
zp2PZL8O~a`o96|z(E$thpkXbjQx73+u3a>&ebm!kJnw%uL#osNGT_0~Ci~ib&%@N`
zf+yhcaN%mQM6JgE%p!Fojk|{dZyG71ltjK>l80K8XQL(mqxF1<94a%jHlA;-Dm~}?
zs0%&!cL^kFNub)oHKuUlSFrCDA)Zy^JcvRnbPJ=GNaVO<uDUg4WWD~{+G;21Xn&pz
zD0S;qcOxo=@WpawxVzyV#r*rvcbC0_w1Qi4QRrW(*LCJ{w@H|i1NkYCkILc8n(M+E
zmsZK|an)rE<S~c;HQ|5x3_RfEGKu2oEl-c3*NJsw{oz{1j$JAFF1$EdJt;MQ!d)P;
zwmkET)WiH}R>wwq^PKCY{=@TV|3<J$m&=``Jlx@VDJXDg7+EyNt7gPkK=*Gr2f9tK
z;p>uGo*zPxX0qxx=?GzU<v<osB{H>M^WgU#^7%YK%a!|_EL=Kz@F)^KP(OED`DtAk
z5I)#LO*PFm;7>IJy9}^X4QtyYj%)uVv5*5ukMs=ZwB#fNDpDVnS4NA;8n6jI$nD+=
zj7WP9{nI;eQGPx5Xv&@Tq5QuAY4hJbhY7*fJFb^KUUz(Q{Eqw1IK<lW9na{WZ~XfR
z_wh^=Xc8CBPr$8#BVc1I*4|H_1ozCm*WaIF2PGLx?x{PfOxsz1e)mZlOAkSQncoF~
zh!FnA!b9{&tkgxYy^}ZfvW|4->J7%B{=HuxO^94k#svE31IDNIv#!6zZE$=aDUUF*
za~epjD8}o9M~j=PYi)i;g@@pT7;^}D^h6b+X|b8VP`(2~LdMsyH|xg*IVTM-MRL!+
zc}$i5e-@xga^EP{0Y|*~x{*(&G45SQA=ti6@Mv))qHiaaZ@(^3HS~fRLrctWEBVEr
zu-d&tt_QcI<eq<(iB<V$48A+r;QJ>AGqZTgzv0ym72X%;<ed3k>~n~)DU~=P^)Zz6
zyriH~X;P=Z!Tp~K7o&D;WM;-w2O0p{153=ral|a#@}dN-k{Syh?LG*FR+hd8!4O;K
z<lC>Vjv{uq6B9@aKeY^#s4vk_eCVex5TdFsm$tO5WK3iEfwzO2qB~w6xPQb-h);h;
zlDGRk0&Tz$d*1usL#AE>yUck-^}nu?W9+$<JMVnj>+%qXO@%}|inI@ywrBS15h~}5
z1aoVk<evx|e@$Dvd!`vm!vsbwWDZZ0goRIecY86~%~_}^?!<LbgU}>ZN27}SPnG>C
z8H$enI-hP-@V%s^l;A1vBJBI%+25|5fAu)(M3O}Pclh!$yNtw7x)IVocS|T61-?b|
zIR!-h=3Hh8sj2HY#T1?2-uNNAmS<ua@?&WJXonYW<>^lI#nF{0<Je`!DI~9$z{1#$
zE|XB=#0##9&CXin(=pD2H<En1LW2YCbxHB*@^r+}?)&3~$HyxU6STvx-;0#;?SdBf
zFTI!Cw46FGYV;67#!Y?9Xa3@MI^|UYBDDKJMWRUrHdy&8o2@btq)3QLvFx+h{g^;1
zi#*7-azGkk;NJ2);LDB#OPGHX=pd0&{DcQ0`V`iE=~VGip_w7n75Qf&;9R2f<M!XU
z%Dw?xottB!o>I7H``sTkuzRZu7}Fd~@NYu4!Se>Ux6^-BIpxu<TEIQ#0p_|lmOl)0
z!*{FiU$ojrz{7#vMi1=32s4L0;B$*|&a@;4or=W3H(qx~sF*0G0oHP{v->d4?DrGh
zOBBW{=GZUJl_F<NJ99=!3X3P|IciXc;DoC8OVZ*xGK!Y_WmHz+6bzNxWa-(*VWMLJ
zohF#H75N8|MWwkuwBlxKLM%|~x7-J$n<IXbyN#DojZMG!?`+F@1c2~tb(;zdgxqAJ
zKPuehI5XnmUFCVo|Nc_r`{_b<+0@Tz{zA93#+^903w$t;s#Jg39+oeBDdU4%!!api
zB&n~VZR7)WLCwa9wK!AhgB0kJlhXQ$xdQl<8O1S2<~nyuQVGxf_rp5cG0p!<*ib?O
zjDt)ix)3j5K<bNwoee3NH~5Ot5Vq!t`!nfI{hf608{Y~T$V*p7ZrUunN-vey0XZ2w
z;t886d;{5-Jf6k&P1`pv^z+Ukq9Ef@^xuxbq4KayDr@}3(pErjL`6!~%GGA@HQaZe
zlRrGTN^dOppNWE9Y&5mSiY--}Vix;{b;rt#UGm+I@Ne(|T9(3{Un<1AC^vjBc9MPW
zbNmlG9M_?HT~N$`SBswKu)<4R7Vly~_=GR*#^>ESQf`+YvC@cG_%2D)><3i@1EZ?N
zon88H_u=tUx(ET9z{sF(bu$Z!T+73WuS7@LAbOk7HD6h~EsU@kJ(1^8_g6vdTEpMo
z-?5jqzzbO*ox*Pj$yd4{gNYBNwRfi%7TbN9;qxSE-%xB+SSOa9rxhAyQC)HgRM03&
zd>iHebgSRTR_Sq}1xbo(=Gyje_APyepeXj!WtGNt1xE8zgc*GuL7ZVni)4wfok58t
z`ql4sI^*8+O(OzjK!XZ<9RGXY7d)2~tw2+8L9eajKcPNq6k`5qs=H9?9huwqB6r?5
z^AvQaA5xht?dQz*b3o>mHEUu4qbn-je`auECz?{Z`hXQFPAS0<ng~X4j9DzagQli^
zkOn6Q@>`y{7$(eN2D}0}4XrRL=!pQHsE2^YEv{uFp)2ROERoG3|0<(uwNQiuo$1FL
zf0<Uivi#OpU?tYo$)E|>UWg8Wo;MuVn3yhMTGBpENCup2I6QB)m_u5Y5Pe>@IbcgS
zZ@7Tk>rUSS<GNQP^eLzN_N-;S9kydlVOq?=vdt<uCwnbPx9s}($>*-#u3Dz3C4Hg!
z8j(~JOA-<R{Aso&N&|qCSk4Gkr+)+OtgnHy6xD_8!<eFUm`%nuKh8wYqV`QB`^R!c
zOcId|SAWrrFrzz!CX*Y-0VxfHT?8E2A2tJ7I|D%p+;wlWyX3xP=#-$8VxQ#@UT_6|
zp~6d}ia^(INGw)o)SoILILRL&K?rU4^zGAJrA;cNA%=PfHcd3e-Pn2Mw48Dh2=}tm
zZu-B{h;!}LzNpZbE7AIt=Q73VU`I%%6%*z@qD%TZ-Jkr6b$@fjDLbM3q9$;Bi=Q2n
z+hKQeM}*=;4h?t*s}S}#l!G_gI!Xs>Vp(dgOFf{F;FyE1!BMm88_L!3_wMc8r3@KT
zDd~t1tWvg_#_(d|fpxHxoY<_Cg|!_IK4nUx=)!a^#aaCrclE2V&Ur9RD?QK#Axu<q
z!X`!*?xx4vNXYu_o047J{49gGHM!3qp__7_5T<N{CGk==fGA7fj1l-PZ|1Cq?KnQu
z%5HYRHagVAuQ#_Imng-&pHerxJRfgM^qxM)pOV{9O{R#N=x@(2dr<zAh<3~h08O4v
z+vfN0SVpn?XNF<3TR4%`LDw@BFwC^t1laT={3j-JyKT_42U@lLz7m!(22+FV+pG3f
z-4^UHJSGSP96t4{cOi~UMwU}+l--X>&G?#MRirxy{avWVGg@^_te`7xkV+283)W@e
zSvbfnWxY84n;UcT$DsxeuQKdhm!R||!tgkkCrb>VYs#qI_|4GRh*DSd<orA;g@&nL
zxR}?R2xAi`n64bj;Rx&qN<&t}YZ#FuzGVEhcjlLJv&J)S`8}2JFEzj1>|TMzNXWve
z;Zw^Vn5@#rhY<W$+%x5>ybb{`?2(X}PZb_<NC@LVmv|(MHjVd)srO8PvOYB85mX*V
z8-o2i%eblB&hR}}CM&E-b>qNaEv1*r_LyoR-FS#%7?fyFra1^6uSVulU`LxfGvnS7
z^-rJ1;vkY_cVlxHTFR_YtHvt%VHN5lMNi`_=GzX^{NzjAAR(sB_V0O^We=2Ha9zg0
zH%+>^U3#4rFNlV^w6@E0WQuos|63bY>v20@8-^_!or}Ca?OML3?M<c_uMB68EG5pP
z2o8gUkv8k0lVVn`PQs*8;zex<55a^N>`;W|JbUiZNSz+lDc+Hy&k;b8K_TK_S`U8`
zHF;JQgF@`aIuNKr&3;2@O068_PafjFEcW#2z*B=A0h0FeiUL?|$2kx?ZO$@XtIi~n
zq0mgSe9M1mfMzJ+D3Wq@l36OgrWW?YnTbrgHOk@4r_yUOTdl20950r<B)6#i`um?l
zdy>8?c`-V6_EFyrC>sBeK|juMA=kFQTU?^l55FxFXH`78=RhwIOvw8{DMjcblHaux
zQWGdax_y|K|D2eSnA+2DGS^=bef>CPY!XO{>USs+TZQbf@<=%!-zOho_zIB$mDa;5
zr0e3}D*&_ee1Xc`Oo74t0Nfx+FLeAi1ZH60{fpo-l!(Pl1*sj-&dmWx&(qIM1A>u)
zGhld&eypzu$=6iLFJ|cg+cx#47Tk>=;GHiRG($!Px#JiTgq-xH44;sCC3pq|uN#N)
zz^nvT?>5%F2fjTW(*+s&F+>r{qvFy8uxUf1kNFklqHm#|zq4x|{wH6E&c>qaYA$0n
zA11E}&(;ENP#re{p3m1hU^l~4)2Vuz+mZNq5fGAcLN+K~&DtZC?c9guz&i(jCPPo&
zk+$~V%u-|PJ?(dHIiDn3t{d}d*IYAXa>ut@Xrq(S`*7j12(cuS(}R!%t(E7r-w>zv
z688IQaxl$r0R#XO;|>|t$IzV<V$hir5wUb4E*AVOeeB`|l5@RmaL9|#l!|DtSQlaR
z_T9Xj>3vs+Xx6)^w8-{frOCoU81FeaaB7}`QOv)wpO;!u*G$YSW8~o6JA&8HBFB;p
zaL~tt?CPqC(0zpd<$i4CDoE_k)8k0$rM3uKrw*MC^L$dtnm#-AU{sqnk-ztuU2GZ<
zUnnT-Ig2Q<Tk3r6k}jN2BqW)LeSh1MNv#K(w;cp+6Gti8q*Wowsf}4sVFkNzDTe%!
zEEKjDucIPQCXN%;cHcvgN5yO7^{CK`vBmABJo+g`zG~_t9;2DL@IjKe&5%e5I~xZX
z`#duElCHYp-pEVbH34GG3!D-rm-Vx^>+VJ_h51%K#2U3)pFd$LgoMMK*ZkK1OEWP2
zUv5nwp_hG+&zHmd9XbBj>miPBQF_?$f7rSDv8H;aYL06#`d+4fl2p(VtAFlzk*<vW
z4xa~dZhtT8&w_w@u4BxM>+{a62zZfi{2m}Zpo?k(aG6S`8yb*hC`S;?if&J536hR?
zF8}U(^lI91SP6bDOj3y%3XS}z7uY4=&JxrrLt@Q{J!E4e$9^Th@#2Cwu6NK?t)#0d
z?5+*S8vTkpqnGc8erbU3pmf9PKJofp;ITGmYRK=zlQO^bINsf<fP@O4JMUJrG`o4F
z0^nrNJxhSP-Sd_7!S=EQh!w;F58pL0VY>X~>=k)SZhgh{<?`Pl9bG=0AMElZ&<^L-
zH5pu40IFBHU7I(p{8o0`SR|IbQnM>sJb|)>HY*yq10^+b2?Jc-(+RnSK8Zn^;xrph
zU-1JOpbc!<<*6Mq6W1#F=Yur+Z6&K8?cSD45>!B?&iagz^*EDb=8JtkPw7?#KTiEn
z>hF$&o<<M1E8X<r)N6{VX@1i#gP!0-InLL}Hu*3f?z~}30nhxfzPrPlD?7|}zx|T)
zu9pjO@BO|<ehRVn=h^X!8=C8H7HNRV5y1?M4Ua#z6BTfJ9n=zCEO1Xmri|m{&>dW%
zD(?b>NWz=n08Z}0#BJW^HiO6Fr02ao>|Tow|B5v2Enk7>Oy4n%9<|G34i(Ahf4AR)
zqiiOrpuK&|&!fh0Wqb_q7A;OxB&|p?bJNmN`J@^i(ryiOcv<%lLb#5*zvix05}0Al
z=ez6j@=J30d@^?|SGsLq2W8}}$z-MpZRG4{uWFp1FkpXq!@|!oNw`D9%~n4S3pJNN
zj}q~ThdJHB#JnT}o;2fzdE!NIlSHL~)h;ha#7vq!=jRzg1X3c(MdT?O8gQD_pB6gf
zZ28y~oYoceM;U-EAK!Opwz`<8TESKB$ZSXj)%KqFHGMN6FTc1+Pk>1X11*01_2JfY
zrYd}dr4DPW(C8!m!JYk$A0T>#YE$uVm$;@Zb1}3^5MZ1EK~#DhH6OfoX&P+w44LKt
z(>}OF|5v1XPcLmeSi{o%&nG+AN*>DOFtdG6Pvr;$9-){VuWQ%QyK~pSN|Z@ac!Cln
zQ^3aW|9I?D*Lpp8)YVQN$m&4?g$&M-@{jX`P6oPvr7h*ziC<NlmMr8IhBwt%ww%F(
z4L&3cYpqQV{RTYT%Wolj)?&5qeY7!);2aDjYRktBOQuh+V?#|tp2M50)<50nPK-x1
z9@1ID?&9x}mr{s$GUTdGg3e3v{QmTaf=Ke|Z2l)Y_H8da`fPV&ifD!87)i<X+@VUQ
zam_4#fNi25HOg-rAtkxr8xuQk1`<FD_HUBE1s9Vw70}HMm@jg{1e*>3Kja8gbN}1>
zy_bRt^b%2c6JZcVN~^@!k|QaG2%x-xQfSruXw>E|%zs}z7w(<-SQDKsIzYOiO;T1p
z;*Qw0f$cQFv42oSmKB*MI{bh$;yoT}u21O{6-TM|{p(il0l&`(rtNt^=fP)=+d_;O
zE|r2Jz^}?cR@=f##Z39nRz)&haK%!aA28Lw@tW?*Yjcv@gJ$skNp5)YQJADa>vLy0
zx;}+lJ~x8tf&UAV+LFhHcl7HW>=wFOcoS)ykOMpGLWK4Gmn#f8sMSp4v<ygR!nZS}
zBn8Qc=ntE<DK?50Gjp6zD;Bc~ox63nR@XmP2c160Sv#=%kp-{yu+S;35=QglS(b>a
zB=W+k&L4YBiYAs2lqBe=t707ea4l86{GbldpKa;IvCY2Ie7{`uafUSwjxXZ}?rUQ;
z;)zG?H3wG9!Z$S!H~eiDAbu5BzZ9FFSEgb}S!@LEi+s3_WZQi`ODUq0+R?!S;pBRY
z960lfd_kQ?9TK}UZ{k<?A7&hsv$s=0?Rt4yU<le*vnpS7is{D{w%Rt71VCbGH$sfK
zzx)12aeuEiAH=QEdeI`0goo;ohp!^=wfuL7Bu(`oBF<{DJnXJROgEmPZ{P<4s$&{G
zv1V2QtYKt4M)ioHzOUn_poe+<;B>$05encZVt|k^VsA4_E)Jt_;R9w3S2e%ltC=AH
z;^z6<n&J%n42tiSV)reQK-q=g?4l`*`lD{@@pWXSFdxv#z|zX`v>V2fhu*Af`vEsU
zicF*c*^>|DicGpEqx%2FY2$eVHa!{E{Sf)W9&oMJ?Qu@H?&W#;<62bg=lh(Uu!#3R
z4`Yx(MAWJy<?_{Gg#9BDH{V;DW2^qEEUqBFxURp3ytB`Xu4*_~Qg8IsB=+Iqv?-cv
zX#&8V)$ePG1zH+leI!#yW6qPzmYY%A9u#2;1?XJAi{K*Ks&yHQ=F-hrPvYjALy#FO
z2|l{Bu9wKjacSmeb1n_5yFfqkZ>f)6_!w1XP&(*k*$Fpj_WTh+Nr%i}H00e`ivnor
zjPY2&Tn8dw0j}{H)i9!9A{PW_B-I!&B=V~Z@fahvix@fvh4Xgb<AhLP1L9nYA-)9s
zj5%9m-Og_Q`<Pet!ovpbu2W<;-$J~)&TFLXSXtm3m^8a7iptOYUDNjd76|UT8=hm(
zl{?GiH;4`@<AIo@ndAZ!e7NP6;<TMvPu{XqF9g?mFl3E(A62>y%qgs)_sv3F=wDv5
zb5+;F<~XeVlBuTXClNj5E)W+W{5wLjzfxKlIc*k9Lr&v@Cy7}7_4N3T&uv$3P`uS;
ze7?Jvf4JA5T-^iwqv-NWP9UY(sIwi|)khR|tM@w9QZnB87%!*B;eWT@KW^Fz`*h!+
z=JBZIvX|&gwA#Vv5v^i$NAO5I_(x_8BV;P#ca5@}P!GQN7ZT4(FlP&SYx{2i#k0<i
z*X_<}lmqk3L9snRp4lg46DY}oVbD*b1-DA2t^W`d3%L;eTdkAmXl?BTy_MCpkYoB%
z#6g>}-iDlSJgZ&q5BKsf)gmrG{DWH^3K|N-U<G^B3J;VBvj`;z2XEUhFls^_6<Squ
zuU=1TTb1lqeS17<8TKt_?wb*h-(%f3vj~DS27lXbz`x(Qf=qW5@BU?xYG}(asd91t
z`^fS*+)~03z^L^4D$?V{8#Wn8jyApiC!n$@FvPWHR}f7FvIU10pD10S(`P=u=SLE$
zxGwR@(Gh`fBZ4T8Oaz}Z7W$}&puG3Qh?<K^#Z6~QU4km#E*-Z#alQCCurTXBv-&F0
z$>r0H%lY%tB)x9L2TH}pv|x$UAvjK)sNi49(mqzIQ4$e_t`{x`OyAct{HsXk^LGPT
zf$ha+6Q}~~V4jVrf9MQV52?o)qOlg61aH{D`s%Ie^V^Rqse)b4JI*lNSW44Z=($Me
zLtBNYSTeoCn#+*AZ_^pFN_onUz8DMFezBicHwu2<JfhzX{{_b2$rI?(vMfl%b{-He
z8`5jKU9@ZJv1Q)qi9lT_JPrh{b6g8*kcDc~%81XC<i>b>VV>V?CP8M_%aMuHq(=Z7
z>I1Hz0lFyJZ9a$o&WYw0E6J2QAE)7f5!>(2AV<stdE*<GmPI1CZ%-O>J`d?at?m3`
zN9y?O!kV^?PwQw0W-@;Zz{aE6mEf#-T?9l<doHYef?RE5IG=9;<S}{`8D{`Wb<BV)
z{LsoL5H{>!Z)ZyF#JwZH%`Gha65g<UO@sVQg5L???dkb2HnyEB7P<mX@(XymukI81
z6~UR6Z6f(8maVyXA1M?WX&q3@+tS5tB?IVuNSwez#zK}q1PL0`><~|Q(Ko7-Au_kW
zJVW2WrQ;<CNwv?t1y9x_9OTZ*uyDD76A1#)ke4>MLW!={FFB^l-G12!U}K?f`v;%<
z8D=M5|LSABa<AKmr~+Wo0~B_Bt3iZE;+I3lt)3=o{SQgI*MAP!<^Q$o(B@NDNa=Gw
z`#3G?*$&%V(0To2XhT{{9cMA+6Wu}|mcSjR@MT&B@HUgKbt3QeyQ_g!>J{X&Gh<fZ
z1GKoyfPcsTjw*op*A8{zEyotq;b&aWMlC(&cz9C+;up#cXJSnecI|kpv3WhD;!2)x
zg^kXTyy%k<Kn2!6$=<u(b%MBA@BxCB1HDLGAayn+*-Rp~MaWNj=NpFN!`ss~M9KY4
zYl2$#u7W*tj97)Lv%vWgm1RurqbOQ8-2wck(_#W+X2hptkMl`Wv-_sThG}Albr_=5
z^ww9sbZ`})gzCwc#5*%(p4LD7CMa&{zp)C&-*F9Mnb5CyN{o*l|LM6AJ$Q|mjFD_u
zdUID9>_IjC&G(>(y*mT0bnz)YFH2XgRp&=7bb(*U@>l^<V-2D+sh%O4?FD?QOXFpV
z)+Q7407Kxki4r*CuZvU`@DJzUFk}+l2$qXXv`%gjP0-bAz{H;_m!-bnAtD8`FrzXu
zO-oX9-I$rWrgaw#Zw1(*;~kOYa0bG{z<;3lH*0+oxDYt=i&8JFSwpKQ5tZKmFoQ14
zKd=s190klus6%<2@LXI7hDj;b{p2xKbG6SKuBE%3iI-mA6(0p2E*tp;;+@LEZ&7wD
zpZ~jgZOd&`=y|Xk^!Lw7ljqkL4x@!IPihVXF5n09i*$sIS)grb&lPqgSFlv+;93+v
z>HJ0!9LaZ%AGP~PaA7eun>b?eX!&LaCl-0YJ+9mcTyqp)`KRhI3I=fLKABS!YPF42
z#Gd}JZJ0QCpF>_piPOU$c~`IkBS`1rG(!4oPY6A>E{GcaL+}><<$kp|!Owig;kL*)
z7m>y@lP3IUiymeAf#unc<SIX?h{FO5(0w@*(8gV)(h<*Oo1}`jtq<rpm3+!!)m=-{
z)^NtXpawJyEPO?SDVpnJ#?=N&)Q1PkGj`a);U3=4>INt|5(4_&`IdiWdSG2PCW%3A
zDiG(e*60YC04x(IVCT4x=NSl!V5Cx3XFyu!)-t5iET7EX3++6?b_UZ1*FoIE8#8Ig
zzeDJ8JpYEytyD<qbv*qZ+YHR-mfYmm^{e7`O5T68o%}RJT!>7=Ep3Hm)D6V136UPt
z`Viq&f=9sdFf0HFN0Ae1pJu{OZx1hAQ84q{ud(ymynymq14!P5zFDZt-*y$kQLGjH
z{jbXXvGfMiMRmM94s#ItzBuPOo^r$V$2=u?od5<Ss>u$I@_k~Dslm!!bPo7}N{DdU
z)BT1rP`(7+pfl+OoQpqm(1?>-R_JG)IJKd!!Z=nG2`MfnO8GPF@b(HvN=d6D29Kr%
z3kjNmPmx^8R{lFvK}C7UXOVF-)bg?^Xuv!yRC0AI4F8$Wlf0!e!BV>nXh$d)R6w>O
zO&u!9nao+E;}p}mOr(!ScCHmk-9YtSzQeY!Xz*u+9=Z=M%+EFn%1PYn!v_oHM03ey
zi9*(PFD67OCm$({2~XGagLKH352mD!=rf`y25Rc1M|0JA*>K?~w>bT>w+|WbQn!2(
z_r`@bf&bXyKVF)iKKMlRK%p$YF*Z~PzsDBxa6su&S>iwF%G*82L^}Qt0Kq^$zX1fm
z6TlG~s0I4;D+IC63Q2YzfJFck0tkDkT)8}OWv(-LF&vsOsA51?RFAI!p2H{~>o{oY
zkO!)}C2{|P8BFd4P~@G;3W^JHm?ebdK7H-ATkT_T)XLy6E_kp7K7jLw5?@UQJ>_u-
z3mCrvYb0Q-`St~R{{}*OivZkS*I&Q%tN$c?=RCi9wcy9k_xi0}qBjzzmq5ZL?|X8O
z`K;Oe^^3F(rTA;ja(88S)pvKF{Kf$wbb+xxl?b3k&Ql>~u6V9N*p`Ur7JC&Wtt7$@
zmX``!^FZb)hC#hcVAZr&c-{V9B7w;h_`r>8P^O^BW?^fFK30{ubE=WzI7o&-*y^G9
z16299`6n=sYlT9A)W)G_Vu$&A(;Qnj<jRlA9vZ~%yYDK9(#RCDpkyOER?=TPV5?@z
zEmw1SK3sk%IoGLwT!|ENq7f-eNvNuNB_HNwnDY9_A;k#aj|{F7>r8`naP$75fxl4K
zKxh;MF0y;S|Lo5f6LW%`M&i#RY(5vKSN{Nbc%_(2_b{^aMw6=p$>31KS_o5PHMHiT
z`)8xL6Ae@a>L%(!lu%V#RPs!k?TyP3$`jyT02-Q{c7)O0LRWIN(<Lkbxe<`&m7&tW
zW;ixCuS(7j0{tIRwpZZ1lY~NS7{LOf<eVgN1S%>JW(6-oB;EM0bR9Ht?XPmUET~e5
z>hCbf0gj>^bj0xN&>ZLh3Fy0m_tOOE?F!)by7v03zx-|b<A=MmbD=Nn5`ON<UcY|1
z;I$+aL2T23I21?%K?Zfj-+}V3@KY_Qqe+c6`CjkzHyjv+n!{a}k9ME_smM7SsLa&%
zkJ_d3l_FJ(^ynaml{$bNQ!fsN<#CkBSk-=4BEn{~soxudLH+w(!Zc0TOcR#<j1WWJ
z1I8&La)64%{E{oYS@-S^{ZD}rLv(Z@+geu@q_zUEr$8(WXuVS}d?B%cg{!oZyixGm
zyJfPhCU?SUm{aegK7U-vje$Gdh79VDAvAJeL0&qRI30!dwV?*+)LWfN5c&`z?W}|a
zkdk;;)e#=3RQA@|)(*Ynp#>fl!^eIfz}`6Wl!;y^-hAow<kf$vdif4?KkIr9K0xp5
zD?x42?{xh*_V;1r9X+u@Eq<{!7uuQt+r{l6c@N3Se(6968$$uY_!CH}i?J+3z--8p
zCVvDG(AlQx+MQ8N;iGF}l8#TVexHK?03ZNKL_t*WsEswzO>Q2mwL2a08zASF4AMh^
zYJ#aCmjMAF1SRlH%8N}EosGj`VLy&l(2+I3x~Ci^fZE3bu6zMVu~rB^cN6e_)&c#R
z<F)~~y^dcIh);F<(Tl6}lNWRTnK|hv7r{1*hi`f4hvw|Ip}7`_-lV^z!Zlp%i1oIv
z(EyCHnQ}~X(-dpxURV79%JkoZ!yXH)<zP2#-7J4|YGH$H8|k6|&}>ph3S7f?%9Pt6
zKdGF8l#;{zig}*Fem}i=NLms&5aKkUxDdCj0GqxfXUk1s!s*GWkpRit8GpV-Gr$B6
z_FOY50th@9%WG>S+?u$g_mx6ijDuoe=Mt2cz}Gik*ts)TCN+d15Ies@TMmFWH#R2s
zJ}9VwSpGo>Y>%_tPFv;xk=Dl<z40n&QGkLW_4eEs>ORJ~N<Fp1%Ne~KP3tP7cRTFD
zYt+3L3ep6I8~L&-UJ4vP8#bq}Up}SpaL5aXpxwbwBPia7Q>}`9_w}Jy=+*_D!V@%R
z>)CxZJG|~LNt9^;^4_p~1=v>r&H+%;p^%ltMnl|uRpd>8-E?sTK!y>NRuDb`*A{f`
z;-jD6AaK<C6VWvb?$S6afDBP{G-M>8@)a1C^%NGSkTz4$0|TGxB1P9Z>fOx0?<#bs
z8LWudfCIGKk&QmX`oL;>4H{7W!JB}?oZ;IB;PyJW{`%kfwQw%<@=o-t`z3v2H|IA5
zd<PU*VN*V_Y4Nir<h*z$H!94pUGGW-X7i{}9rl7N(pujL)WX1Zdbdfei{>Tr$FlZy
z>pmDO&2E|SO*1c*FxIDjm14r$`Q`iMTmAO63)6wQ>=kV~bHEfQ(`1$Az%kmKQ$-G#
z8bQw_Y}I-Ik{2wJkh^GKOAaJN4*;@4?dz66gR`8uAfl1&0AD5epS?&=9G%Zlet(NG
zo?>ZKs1^ru{sR~Jp*K|o9Y}*MWsoW_pfx4Zrf`s{)GCtU)lJ$Ofv8OF&9guUFNsi#
zN&$dFSp(484WLv{hG<7TDUDH4o|JvHO98FvB@*bV5MF2Ad_i&NpR1f-A*NKh`QsFL
z2nF=Tx|fkwx!-ziKz$_e@F`g}0sUKC3A{kkg$i8}NGl1DqphoW<mgp2-FX1c-1UMF
zC;fRb?fe5td0fK`bbuZeKa$pkRd&Vm!2Zy~uT%4OXlP<~#X|0^rU(FMfc5|_!=ODN
z02pTOetfxx2zc;diAZ}+Ktbv&7qDpsuki&Ka{~YzA^```!_Wlivx@(118{pCy)H>l
z_DZkslYC=Y^4FG>KSms52mzUFA5X!j>m`q|tlDMFxxB0drK=uJ|8y;RsG$M9vtIuu
z)&f`i^ddr)IbWvvVF!K00H_om?QUDV0l;X)LbQL!>fkKJPO{mnZl<X^`_*tE1wypw
zV$p2*0gf;zF_c2JzvXDrz!0fcza`Nv#(-&xh|zKZa!Lrq*iNQkC_zHyIkRG2<Vu1N
zf+5JF^|41Xl%Wp?ibR-7s$s{+pt9TVtOd%{7rJ=idLX+pAPg3*jSa%o{g*m(A(4u9
zw{-+nG=!bU#_X>PEMl6;Ec%#ABcgua(ycN21H7I0!^}tQo))2^<4i;fiK_gXB7AO|
zUiz5i%ln$&O&sE}b<)88U+sOzWq3~*Y+ve{02&L?^-X|-`e9K?m!y0J1O)|vCPxA=
z<Q`GgM@nr1Om3oe;%A?#`#e0tvDBp=+V6c2*LKbC_tG1H0<ABkYKEvO7W{w!l$0oD
zfG+`Fjzk3>y<58R3kP7tdcnUQ)tjib$BGWs0R0^vu?fCDK!|S2Hq-;8_x8HI+V$W6
z>aT|HJ)&0@#ZT;){8K5*r&V-vH5{1D%2nCqXiDPfDSIMarFOYID|c_qw%>go!f%n?
zl@ALyE5Ffcub<}O1VC1Yt{V}pKZv<X{MzI_GzQEto}sSt=G7r>sU)`|5tJI&%eC;6
zrw58;uo^#rJ(gCh&ww4mY_6?{F<2AfKQDNQkVXHxVj!4Pdk&1v6mWX7MP!@YtCLt)
zq%~)I49wPmz?%>?C4x%tx~Q11GA{h~RV{(Wwyx@YFC6T@XW(E{v^a6njOe^Lmlc8{
z6eFhE2#|e^+iPHM#aaV_N*yf3#Za2EZdG6ng>w~31Hkq*srzg~sBZ;sM9aWnGBk;h
zol9y+fnzgJfJNmFDgDT_dExbC_rjl~^!618=&{LvNc1CG!`Q>rUytt|#Tl9Z&UMt)
zos3O@Eh{)9=N+I|MkWaWM^HfkdURb|u7Zj}v$QB(5s<)%bh#PsQP&tAR2KT7oK<5G
z6*?aPM*y@D0M(ltMo2{A5{R=Z7cy(_cSVDP)N`%?=&%VGTmy%|!LFF&NDt6i0%BnJ
zjW)rZfA9c3II%#FT4^6y_1<2$SG%s}7fuEF^{n#ECFL)R=u51ilolXcxCXJ>u9^fI
zot!5nna<zbB1TdZ->E`6>N9nAynKB6FC$RVt-C0^=>O48>{euoF%WsyKx5$7sNU)!
zuLp`AIrhO8qcav3KHQP7AOs;WVl*k>e!s_Nn!tfE&og3-NGU;8F-;SuY4YNw;J^?u
zAA!KYb`x-Va*E9~`Ocgif{zF;Zw$Vp&r7oB!c_^ZinO0`KF^5UV0rChN;TWsAxq0J
zkW{DhYT4VXB~%Q-sY(R23A~^xju?pBCI{y$6!W*<g^(b1XCKIX2TFrx2eYFU+$Z5_
zSMbaC89EWDpf_X<Mh*BWQ-9Y0`12kEBQimlpuxQe*d9v=Z0HriS2<=>AvJ(6)DR(6
zY?Z>tm^VKPKK<Q1Pmd<h(oOq=nzi@xA3}_&8UJ*vFvZ#pX*G8`v^?k<2eWK~D#whx
z?92=Z0-iu&<7)t}rbuNK)1l|)mr>9g6)#Lu*D{TC(bP7B7j!54e6QEFUI0WZ5ac=p
z02O&s$qk9}PYZ|>h%c3Creej}-Esdv2PVKbG&avL<!P>g+7t(E`(G9m4Za^80f!jk
z<NSh~*8zQdGX$C4HUPI*z5eRA|L5>zhgUQB%USiSN${E~CMH7K?~&7Ng~7e*#c)w@
zWXR&vdJEma+SFA$>tFOHEI5)|iza{TWKmFbjQ%qDXM_I>`=7y3)`3vSPIMzTp|Scd
ze$IRFP$9ypBB#YBOSTVY2;5+3CbJG!mliSO&e=)T>4#t+%4xDGJ;sQW(=E<UPB3i(
zril=v;{c-W`)@0g676eIz{T0nAo7}ESd346?I1aWRDFW&)+2CEq*}uU5lmC8tp5go
zx10hCE(&H0MC^x?w6sPt7rEdpMp9Vw2iw~xKX40&AaaDLSdIY%kr|l*Qj<KA*zL0x
z1t)pa!*v&5X73Cmu;;>WSlQun$3X~Gng?;xV&6m%VrW0df|?3xk-(G@ND!xB84w{>
zf~O};1_HmLf-kDxc^!E5zUteLN?dct<mx>EMl+yQ6F{9Y167=&t>#IGC_1P9b!G@<
z^lMqlVkAJ`S@$-9_yo)wFg0aH4+RWPiKRA{wSY>s)U|ebWaX0{nS&2jAKlVO*C7n+
z=wQ9(&#QZLFhr=17AVQ1BpHnE@f!ZLsD?{~X~x8b1gJC?c|9oVtKoo-+3gapLqTXr
z6C5%DXg~&fvfto;*~|UPTcwX1Y*T-?B{)h99M%c94Z!UM0Qk@T?r+e3k<-1>XJ*Au
z?lV4<l<s)BKVbi&N~ub4$~u{=?c-YdS~F%rmox|TZ2vw`hmFCnBZF9-WCnNKt6vqH
z^pr}RE`fuY<=Brbg{^(G%AeVb00n~P_V{h306S1Z06~$K<OXCmcb-feoSvTAL?0L@
z+ifMV6$E0l*<!Pa22HCP@s0^;Ntlz#u0*pXCMNT4VJ4fxVCxLqYqkj9l42;?H2Z-)
zl*kXOvKzPOS%92D;?s8_Rys<e(yhNi<}^rzW!@v_3=WJbL<9;zR^%l0agc_F;duT7
z2P&FBureUsq$t+-RFffpOa@kXVj;U?pfq|p^{#0iOw_2RMRkB0GK~7(WB)ICMgp@n
zY3vPVFO3XL2oMBPY&KT(Lu4#d0>coSKp-Z0fkeJ2dHYi-fBbxYLVv{J{4(%viBTkO
zg2cc|!}xg22Dr<p>TXcN<?zfV0HYH?Egmc?d8Y_Fv*C!~c#05T1nCy6Y;w{<lJtTt
z09eTT!(3M+kPOOZ@omNp**zB7n&6T#O<ii_;Ez;@gSbAizAErmM8D!NI#krocDTS8
zEdH1?2!bGjKmyi`EXk;+G$lni2gR8pDblz-c!r))Z=?b|!{T5SjnoGP>9s^a=z9|Q
zKOYj%kb~O>;PwIl+)<)AoO~p!zA=k_^(yH{7NwZgidbN>DAAmtnvG?x!C<yzlWF;|
zS|2J<${=nwtd)yX%x-!!k(F6bfu6-9YzrFDht#mMi^~*e_sErS$kBG^%OdvkB>Uu1
z#9_wP7Ze!S9#2+5oSYm8^A;dT+p#OK*=!JkWe1#|o?)}uKtwRbh&yL@5L`OAEQ`zk
z7-_f1es_tK7EDv{i9Va<YzT;fkyAoi>{ObjI5b6)Q?vXfLZDz71!@J^eh;lV3R9pi
zrq^$i6jKbCV&~o`)C#n_$!jJE6!R`Y#GMQ|0LsW|K~AZyLCWfZ+<!srbxKH(B*uxz
zof?FIB*_b}eb2-ZL_kgnIaxDA(}XZhU?ya-#!O(6&A@C5h+={iFepn3U{Q^PoGe=G
zp;Lx)2*{g4M+|&=ga|fK5n=$-48jZ|MPU0`fpJ2VUyn@R5;=)Ez4{u5m+oz%Jk5#=
z(Y(v^epXy%qD7c<4nZx5&!v&Ig3&-NrR!*C*EIp?L;!^V!U#F#d<B(DRtPj8#8ZUn
zE=W(n5&<mk+L0keZ39LY1!en;mRt?W0tBC?+4k$E2x4mhH55BR|GL-GgQ<Un`^UOk
z92;7V!T=;3HUZWAiLJRqHr+p~AV@}F^CuBa$ROdknT5i+BJ5el#O5RLe>d?Q>@!r4
z)!rkP!iRXk;O5h11`I|4HErm+;GhG7;UFtKa10!pkMi}~2H^HGGKehkDomdg(3i8~
zvq^B0b==JxnoJO7bKa|1W83AD6R>Ld&5B$GBCr;J03Hv5Ba%J9*zYYbfH2G$o!Ltv
z|MfDi;tek%NG?~5)8tHZKXll%?>RO1y6rR}Mt1lcI6FJVG)*`;+2ZcqyEdJg*Kl<Z
z+%F5R_Iu2iS7!B_6LL;23$((y%zJyH@`S6aD<k}Ew%E@*3nzDIKE`NF{gNx-_fwu5
zA%Fsz!B7a8!i1a?=4G+whYc%_!6b4<>@t0PT8!isn9P8vJCK<S(Ye}R0cs6Rm^R2c
z<MRB%o1Y0W1W3-<UtU3{jeoEGybuiCK+ah5+=0IeNm`lv=Fv}%gk;YX$gWTzXcA;y
zEV)j~ipe$pWlaH7fFx<MN+PniLFYcmUf`gXvWRSp)+so?;?r1CM?;h#Sr8Jcxe_^?
zOeEl-ff+9W@>L>vHH4F&+J^8pLbwm$on=|x-7l99a^5~>-k*n%o=$POoMKwymNG{b
zQqg9TNe6s^ek{GI2^i;A|KJ1`C0r@w0-BR)Wg~$mkeN>p<<u;*2_*hpdwz$>>1<`B
zIYV;-Bta=dD5Hu@d)5Putb|pXL@Vkf$C!Pq;(tTBZ6V~snEv9^K6I&8#s&U24GbxP
z77gK2!!)a~1^D1lp`ZsAz}IpDZW_?9!#cE5k-FkM*rklbKI$2dy#lruS-giP;Fbh<
zd$sGo{d>R8R}#;1#^*%!3j(|<&`^SSu3_u+3oZw%WSHKISx&R#ZGArK=)%K?zqZX?
zXb**UKxenfRiLur&2Y#~aUz?;o@c^~3Y2VWvz@-N!A&yP^yAEg&1S;(WP{VwGn{NU
z*lcY2OerI9a3Y;z-tFzNsoCD<oWRW3?RHq^#U{*@jF9M`%xQ{9X*SuO@0zDLK_%nr
z;sRL&C)<<Cm|zgnyx8w8QooOw>bj+P4-fz$MixPu7jJ3;lmzMsfn=MwLu`9$6+>>y
z%0)!5$PCFDfe0}KEX$0XLkrN+jAfajnd|!?=WGoJ6O3vgo+Q}C{T5Al%|^G^I0N8F
zSeE2!g5r5#=0TFpK#1MJv2sjUY$d}zhrw1!W^LS2OWlx4G*|zF!tF?lAue?t;0TXo
zgSaIVguU5=0J0Px3<^vW2YN+G?hxfqFY|J>+wo-}oJZ0pfj5sg)9Hgv3=cLF?gdWw
zQo6i<IbXc1xOg1G{%YFjygdz><1qbq%Kn?008qby9~d+ovJx%<JvRYAd;S5t^t4U9
zBY)0{zX%3HJT2x(k^wbjk8rb!POtsf>#}Lqw1M~FZ8z-yQ!^*i+<6(0f@o2qy>dv}
z=?3~zUF}Sc#2Vee2{`sEu2BDhLZBEe(r%Umu5$r!gB)<=1RPrj)SKTn0Jj&AC@S$Q
zBKk#Dd{$M@3NSflkJH#F)4J=YF2c9Df*thm#RjwziFyc5yQu_#Bm|0nfa`&mdy(-O
zfz9{(b+2hG{@`-IUe0%RdV-U)Q^Xh$V!$*_VE5w>aq0+-ZvK-q@{+KhXIx!ec%jfC
zJZMP^a>@>C+cZ@qZ8>L1ZgBiEF9!K%fr?@?`Bd%2e$I2t9U#IKqay)Qch(jc8~^}0
zE#5Q%fx;k7R4=6HzSfN6X*5R4#zP41WiZcs5S!I;i~*8?loFCiYrsmg2Ds;esSKD1
z(`M6I2iqhb{2&r{8&qQCWpTGf0$1B(^-Kve89VtTDuR>&NN|W=-I3Cpi{J=}Hhuue
z<d4NzDEQ7=oXjcak_0%<!w7E~QaBE-j3|W=S)mLH%26RvA!iw)3yVb392hAw@AHC-
z6mdQWdPq#~Do)-ZY~KvwmA9GXe%hz|dD%SzE-yg)U6}G5qNWg8LZB`-`&bjuE!u}g
znv)KRcSN}GOk4#qQ80NW*c;@2NAHr<=C483BcOO~SX6KZMXf53>k9Q@iVhtq@;|^u
z$J&ju!tv0e@;SBxN{DD7q6NgVA{-pq=Rd!c;XV2V^xeVW__LA&j^RMHUt6E3bYrV^
zQxkC80Q@<>zWvw!3jLn)7DS&EkuT(oAIXAAv_)Mv+-kMPqmt9Q%DhLndv$>}brXf+
z8LHt<v!8PYiA^rz>~eOkdy%GP&9#LuE`g=>-~ep5TPv{9SovVW*_|_NPfro2h|PA3
z7>%vI%nOz@V|TSfS{B!>vqR&8l)ONOP_<Jb1cUC2YoHJ|)8sq_@_)~b+pR!O8OyxK
z6en!ATf`|sl35UEFT&Fl?R%oJ(3fSgbwjZ|UNYDx{FD+v<`EFxFF@*JYHOD47RSjO
zuxXl%(}k93#*Vm%7duj}=uGuy@aLb4)w36D@pXu1O9^ZVj~!cI30bm{9Rc?t5Z~z+
zZ-zz?t&nnwcM$a^z@&;C*&6^cQzf5>q&AtwMbZjef)(}vS55eX%vul!-zU2UL#QS3
z_8bxwTWOR^EMQX6psFE5rvy1&D8Cc}3kA-^G>1qRQ;3h^L=Q#v9j56`Xn2ch`*vV?
zm$KZake>?gFH+d=!jxtXl0#%ArXfv73kS}OF@`3<p7Jn*a0%6=r85PW%66aU?(<d}
z08;^=+3T})<eFzd7PJp^ZzXt5X{0s?+%)~apHRCpjyGpx1+=6Xb|;Mzpqy31LZGE+
zS4j0h;y3s~9Srd6yvl1i0T}svdfii`>j{701YS4kAK?QWoA{q45xi{x{+wU`_sid)
zg~FLYKf7f4^pf#n&dO5vfJb`lBgQ4_Mac+yxw~z1Zz+6$;=Ny@Yx`AKX(meKS&R`O
z2G1zTKEZnIFpRY?Dp(|gq1aB0&1N#A95>Cm^THYK-o1-EckUoglTYIrbDD8+d4YME
z!OTd@g57>!R~DKDn#}Ki3b8VF*d6$C&OWsUY^SN?IRLw>oizagNMiS2)&-FXn>ayO
zF-4Q*T|9kSXANe?X4)X71)FICRB`e2X`QB*dB!Y)v(r<gd9k8f_!EJVRKQ}I{F+D5
zp%vox#HwNhyCfB<P!WH=Gtxd)TVJRkFEi4-*zXWR%~&7>B$?3=DctrLPEJh737{#|
zV^TPH-hwM7G}p$cpvt}VFd&wAEN&d6elsyrqbMQg#Zwuzo%hbC5Nb_KEfh><WTiA9
zIYtu@^M7y~WKqi}tg8rWWLA4bp@v{to56*f4h2!l#6lVbIx*8(2>Ou_DaC;O6zOsk
zH%~Y5<N*=gW0g0N()UGo-xrN<rLepk;_@_ZaTO*_Ko$zdAgA8hSjQ&7o&#Q>=?ao&
zXcUmUGzGH)7Am=m9pz0Fk`+0rkuI|-Gr$7P36l1Zyz_*>EuJ^rukADRxt9g>45*;2
z`OpO+1KAoBUCgtj7#x{7f<VHI92RI8tUqXwI2~;U^q`OrHVn_(tXz)=blRkW{l7*E
z=&)<Jp$Vuxm>z2aZX19<=hu7|f~dYIM4wU6M^&)}hyq7s67)`fdZQ#|)bpx$3e-#d
z8s!y4;qXIIq;qJig{*$~mxGE+s$Vmt3DJmW+mkKszH}FN@7~3BdjeI(ex3m)h$ybE
zu0XpTL^4uJ*zNb&&wIoW5n_ajU~veWJt)Vb#WUt5Rqp{QO-e4hXhKdF;FD8AN(q4j
z_Bms-+1T`63a5wfq_hAK?60m2_Rkr2?%ZknXLn@Vr(HeQB};{bNrBzv&UETtyhQ|=
zTkyzc+B7Z&Y^P4%aFiy;Vt;d0Q-}yQh-T=ciYz`^ixc}`aQouE0$Wc(M0GXP8V6jL
z$p9AL?*|y1uZ|RurwJCfG)Wl=i>(Q|lt_`})2b&KmMJ_7a#5Ld2nD%zy`bdkuVc$Y
z2-djxdPFswl+cNv;wy}z+ZIK2bu3oLqT=L5dus;Q7;+2ou}RvBF%bt+1+r?;ESpSn
znpp2HK|i_={K**Tiy_DblRVi>)BWxC<n4+1Ey(=6<^1ydm+9hdrTM|M%}=IN-o<T5
zfw}InNk`S8A}r8l2i4h3aLf%5kv$NoLjd~Kw!ds5Ui{0dUj-@)L>2^1-h{6Len|1Y
z<LR&E0z9LzYFRltKS&lpW`L5rM<_h}KtPz4DQh6bI`;2i>OWrCk9<?_{-CSo;8^|F
zYkz4S-2%HQUiAp3e_bfh@IbCh2_mA~2H?;6wcS$O0WW63$5rv7n}!?9J*U=bm+2OL
zxJutKQ@@4lcJ(y0p(x2~R2AxVnra787m~szM-wl!X8ggJriksy3C_+=ae8_Ro+1z!
z93lcw-Nww|%sK6Gd6AIZ5ziuc#hL*mv+xZi&t8x<17xy4b~w3M)|TWyRUnJ$qVux&
znnJ87sZCGp$cUj1<_VC*h;$}j<7&P$?`JO>wzmu+ASWX+h2T>&TNVH@W7*GE;9}F^
zt5~8S0Z7%GKiJ`&b7jjH$6Bq$S}kP|3Q48eF{!0U#=K7^`3tcs03;<W>c0auB}kg*
zdi+$rLecS)r50-EeI{-$rT%)r8x>}*iH`6HW~;KHQsu;5CYiKNKyIJ}_3t4DJPSab
z5Sc`3QenR<wu}aU-%xXw)4IMf&O*_A^~i8pTL^VZuJXNX+yoGeKVS|@lu4tK#LTiy
zf$lQvM`J)vi|+S(xd;)DL%=&Rp1l*p*_#~XyOQVc&gWO(TP`o(4cp~>a~A%8_TH?=
zvMo6e`y$rf=VaD!r@B3`)y?K;k}Y;q6e$iOC>x$0{Ac{=Hv=|cLys0<0kUlP&9to-
zPcRGuwnfmU-GpV5qC|<^Y?|!8L*1G)E2nezUMs>65wX_VCr@T&-FsVN^X35xw{BJC
z8TQ$GN5mK3Fr|UL`n5bnqBMi}0-z0$1Uvv~@H_yn2tbWu4jHIg!z9k1^SbKkpOb~`
zkZJ98Z&=Uk!u$IA#eYFw4CKuQ7M0n4xm1xNJ&H(_cvhmUxO$qY`h^{1vKw#!^fCwF
zh7if+oxOIGzV;amOMd_5(4ak-|E?yWK5iR;&-jB!Ua8>iT=a9L=p89aq6AR#UF*`V
zE1=oMcFQLTaZi19M>i-L30Jj7uZFR^bgBUHFrM1M*5G)mh3H@yaIjuuT-mgqh7rSR
zjn%;c?%utJGz`eaNP4Fyr#0R*m)Tw1jG#6<SuU{=*aq^#n$7x^+1T(_Po$CnnUk64
z02tUUZ<*^cl2Tm$X0pXOTjJk535w);1apDqDHdB<jKg4X|D17gcJ3~9ep&i1-)_QM
zz4L7xHMqHm`7GGIJ=70WeGhmT?FQld^iq5hPbQ-)b9VA1YW%NF@M4laW^?$<Gc+@X
z!-R1d%o#pslssEOrWU#+-Z-LL0a;^JjQE#IO&_$zs%<w_3T9D58)_JhG>UuC`aa21
z-w0yoo2w!;jH{e<7#YTiQ#C3Q&Cq0j7Kw&{Kr-ALpy9*hm4;xjxD{_lp=zR^*42fe
z{d?}7gH^kPJOyzW>$p#YC<%d-i6_V?D0i9l-PJ06<=|l4u2$(d2_6Zh_n5}-upImu
zWb@%PZ5|U(r<7!yMw)mSin$ynAsRNoa1M+Gh%~?iA#VP7mAKQ2o|GktJ{kbX1d*-r
z3Ik%_!|GWyM>j+Su9o~=RduOJ2{rad(Ev=|07!G(Q!a|MRivyQp1t(_*%JY*yMlnL
zrGI)Q1K|4o|1OBSa};*jfrOpt;LC<VwcvMli@QH_+W_1?02EFKBIQAr@@^I!%tbM0
zLJ>7qdl>fMa?7lJ_3!?kBEf{Z_*QL`eJFFavvQ3afQCJ58juFF?@i-?`}gnT&9~mh
z!JWg(s^3l%w$qH$lM_P<iXaz*_wCvhOw$&5955u4zYWAKN><bhzFX{iLZ7PX@MHQf
z*^F>X&d8-*3Z^&!03ZNKL_t)TLtGJuvl-c^=ph;BKr)~#*ls7}NsxvCfKBx4)rgT3
zl#GBjP(q$&TwI)6{BA@9JGqadh{ohDYJLX(cg2gfBy#6EhESOK6rZYXidT_pc{{K%
z+c$Yz69WMSr2!?+Mu^7<&`=#8EmQ}UutzXbCMj&fuMoMfN_^Equr-Z{V%|<DZlFXy
z-A6FcFmOXLaxtl2jSz14c`0r*Ls~Nnc(AmgATCA$u35T5K(gCDhfjqnN|~E<z9vMX
zo<F4R77KsB8UaIU$VNmov*$Q)Nc$Z&Cyyr{+<Zd9Pe3X-QB^bwV5V@f90)*~COMe%
zv`$QShmpUqS`YuqdbR%RLmD1Yq3_8oe<G0gndc9Y<cY54W2|T+3KkhM>3Ggq70_h2
zd}eF#5iSXa%7kH;cwLoZB*)4FAc4phDqBFeAY@>t0r)rz0D6Vb{#8Fjm0@b$40gb+
z0f5dRI2lkCqzpnTkaPj087T==sSznVg8dGkUw3f-kHZ1bR}TDpez!B)FEoWjx<dk7
z$Oa?Cdyyu*`!lx<!0khzhm_L0tm$paW#oY{5<|8EP6_PZ^PCb$+)+!4L9EX3HyhOi
z8j}@C?It8<HxrTC2#AKCyF0;gbMGT292_3t{{8#7cmF=_+__^~b8jFv+il&M=aMnI
zZLSt^O*?lDvzqCUI{^;EfRqMgHNzYsMOuwW@WPP=<R12U&Y0#>A^&im%hLoY8LQRG
z{OzS+T&+NftKU8W7>9%*-7%ONPF!?ip@hkb%i0VWVRuth3o{DBUL@)TT%Y{LUBru(
zO$POSjVm`GDp-vprp?9*l%oQy1B3;ca-GZ>goMbww>3b?1(O(BU=Daz%p}{-Sref3
zbGRHIS!QomnqNP(V4gA<z%V4_c>=rH5fLGmjB&6gjfpVJ2Aj<V#&N)EwE`1EOLj*{
zRQp~j#q{0~Kp8x04X&|iAN3fPlEK7Sj|0ZR4S`DWAR~)v2CR`0w<f0Ek>A%~(dvq7
zCABs(o*lzbAJ}lObvh-K>aVX5vofv<16rD05l|%l%*+D|D{GNaa$e6Hy*qGucO2xa
z>($}U930$vJf{4<$i<)M&H0~C)BHUh%NY&nkjp@-34{^ED-f@cRx6}&Y{*-PEQq1r
zAQdnEVGfi4NZDG*AQf-r<DA`vx~Z#+mt|{2uel<iW|dRdG0WVA%28060L&HztZppD
z1DH}SpbKWqoED;_%Nzi@Qrd8dI6#Y~{H5Pq_u=#vn}B6D(kq<+cMmgN=LK-v0DRUT
zfBQfF4F=LZBKo{S-c-;SP`!50m(~yzzafPwO9aXUH^8BNU1Yb$jj*8v;U_TrF8=Pp
z8gJgek9&9TU>FCxi8_Nn^#607G0#S@D{h}#o#7OgUoNnq6K-As<i%DbL)7JnrC3TK
z6f)&TDvNCNT)-YuBd}z{dAqG4LDQyy6~-q}!8jy;KU$OgIHjiH?wGrhGiC&wPp+8I
z1*$39vJ9ka5Gsa3O{>jrwv=<Rd$Kd{MFh#=cqRg+RCn=`eX5So9SJsg*f{%ILo)Kz
z5gtXbErKznj#%h3U!VwaUQk2;CvSX;LGFp6g<B2)+V_)Zo4&0G7nA~&Odw7*AgKYc
z>;(&TRbcVU!Q3wqy6o<P1w}Jv2%tl4hyu4V-axD&6q-GMfh}HYk!=%Srn+=7noVhc
zNxd`;CQmihW1u?iShoa5H|rs4ESu2ni|u+*fRcrjb<{ye6uv7(-YGeMWk~ra64R4$
zIQ(Et>pxSTAFGtltBjwAu10VMcm+ys>)eH3kv4O#YV0M3oRD8P429}c3#{2G_EJEt
zfZ$U3|9X4yz2$IGFFWs$#jafd%}|{{m_clO5^Xlevr;;zwA#|JD%!bVUPd+-WWZ|+
z_O8bX?HCDO?g#d+5v~LY_D}$Jse)Im0<LcYZX1Bl`u_iie~6KWdk}rMNV!uKDN8}l
zVZyTPa6>AVhQVFHV3EM^{lDlU!cv{2CDrNFPS0^1v0AT@lF9s52M0L3dk=T--ocOt
z%z4K7<^pGDXAnKL=PqJXy7W+^HVa~b2a*)KX>oJIifGUxYEiJF)hK74XAI-eT=t4!
znrEz5D<k>k3{DAoGGiX{!kg!*@*K-FThR`ORyJLFG3T1vOjV+ritYKs=GO~mN=D9t
zDhi~=4%c0{7qmJts``H43LJ<qRV!U1<5ihA;2!u!Mr5D{2MINweqywhfC%z-s_BU;
zf}$B11|uR8S7~PBYfvMDn|3o8Rfcd#X%oDZYStsAU@DuimGF38LtNCI6Jtdz4oA1u
z1v$rKc9%s)&VnJb5Q5tv1$myJCA(jO2i>Uc{?*ZiNKZ7R#U!bT8XtukebLkjP_T4q
zdhR2@ofk&-!@<<cUA3{<YOJ+ZP}$Bmajt>Zcw|cC4v35_#M4yPbIR*sEN`wy{1AhG
zj1qnZ#7{_QMOc4{Fs^_BpaI|!ioxWHBy9z!enkluzbZPXrm=@ifNVkRJNA|gR$V%E
z7Xa8hC4Z8KcJWCa4+D-0=?p@k6bT*$JcH7?@_H5?6eVBfOr%R5pI)g5xT+zz65zNQ
zF;K7G71WFM$^w542at9-1-A{rXZWEjWg3PxiriD=F@UxrQb}Ej8JZGEq-z39^CVt?
zz_tr-$!xYWRLON!U|~0wML!-K;O-muarfRmtk-MgQn1-<@cj96s3?ku=*&6SBDmOY
z)qr|hBom?-k&irJCe{H#%CbU<YSyD}phGIaU{hgnCq7AL{kxsESg%*r`7beHJXqVF
zd@!$p*?k1!Y7=SJwBa5H&#;dhijoDegpF-wnAcQAZyYMw&2s^=)+P+@TOT`lPE@UZ
znHiFexnBw(C1do)q{fkoLY?RsMn4R;6|n-P2#T27VCeo$Hkh4fU`hZha_mijBOBD#
zJvG?Lc?07()b$7Xxk0W%uocWu*Cnb20yf@%mkcRbruv23A!#Hhiun&%UL7d8qkvP}
zNd@APzBqniuvEVzfB%7I5i`^~6mhpe+dpfF@$HxB!Uuz3>3T&KgFnyG;ZLkNFs*vy
z9gqdw1xeFVHx#KDGN6)Bm|fO4LWL;L^SF`n=8*H9v?^a1IMJZv9rM#3Ks12U+Wx%}
z8LF9=eQdI8Be<9D2NHY+cyYB~#dhz|S1<nQx{3H>m4CDaR%s+aErw9&45~K3393m!
zX$I0cAVsy*Doky+bLoxM9&Q(EzdX|GjTRbO8B^DU9PD{3i>RT!QNh>~4ScBsz>c@j
zZ3FNbe%#S93Ftt<cSSJ}4<IfUS(_MA6v_<N7Rwqt)tn3F+4So1cT#e1Wo^^_xW@Wm
zjeB?Qc}m`Z?L6UpyT!(Ti4*s7&M2Pn#$@rcIp-<?>{nm00~F`CLK>Nh#35Vm;LYIp
z_{A%Et~R?O2A_*3A2O5e)TJPG@M5^=4J$&Hg2bbR_LQ<TEzuyS`I^Fuy0FxUTVvXz
zde8&5nh+}0?NEFT&|q#<E(O@7kxqnTsO{Y0T6>U1pt_bHDo{>dgk9bj!8zT3;VS|5
zWV|}qA^iA*s8{SQ6>$Tof-GKqz2K{8&1;Woos${rsA%;cAZgKkoD8M0hST4xnkPTk
zTe8*wpkZK)Lo!Z;qZXou1c>t)lsqIZngL%^WHBV9q9lsiurSD3@9iEcE|2RW=SCWI
zOe&5`z17+pp|*7%nxr+VP&#zS_U(k`atV&(U%dulA;XnwXeb5Sd(R|<G$)bFNy<tr
z0hh-+REdh?umZEK0h9wi^F}S`a6*t`&mGbp5;fwVPKE+-L1z;1+U5IGzyNms&r|>+
zwgyPfQ_u*H0B;rP0>n~16FQO~q5lnC2lMOB-v3Izz*We?HGBUnKj0<5|JU08?~4|`
zO#}SQKK_&c{+l$Y@J4Vbf_nlC#7v0+W@pW^!PUj>X{Dk7jFfCrn6;qfVgxN_jH7AV
z6T1^1B@D@8U2_r4^9Gyk2Ag@ZiOLz|MyP9+s|8YnU#RyR_oZK;e@awm0a9u@120b6
zdCo`Z5BXj?SnTGPj|vwP5{fhJ)4*VeBN}#dpSJ1~=3Mpl+Qo9!JOnHo5EU<ukUFiZ
zYu$si7}6w$LUXZV81QgRt5CZ+S9zS);)n3h_XI)lX*l%o<ZyU!9zwP@BqMTiCv~F;
z))7IO)d^|73Mf+73aqHv3F1V~AZUdwkrkG;Kn%^&8Y7j)bMRYKRslk;$QE?8AYA)v
z+1{RwAgXR;<e!I!<hcnBQWtSf0;(-qcu#Oml(ch)yBnw_S30<?Et(mgdTE46Z4*|w
zNZQ)or+BwSCaT9NR#>4D2s>t>7OhozbkvM);x$Q9EdnZvA^<pp(rl^-Rzd-lNic5;
zh5}%4E8uYrN-J*wa*fpOm4M>YzctoDh_oGhZ2-b#XRkBvD`(+Pz5!6(+W-`qK{CM?
zFR@}NAi4n4DTrm?`>LeC1qblz^}rI`Sn}<$-yfN-Iasf)BzR>azzs-&w++B&^zpT?
zzKidC@HFKjhgsyls1BjiCw8Au*p1qza$L%uBxVc)AtjfJA$3hD2a=8Ag+Huzi<D~9
zOWhtkq=Lqpw*oPy)UGFONrLr+?xcj3AV+S<6MO60xERDqC~m-GldDKEqF05gv!NNJ
zAW0~tH-u5-*>vplG-0agt6c9M3<4!D_I=;t&UB*e?EkoVm&NA@vmi^^^Xvnk@KuU6
zWoX)d<BzdTtU-#TKp&(gC&sW+L!GLvvO+1DJ+2zzPkh}G>W5Hh3<GzH3t%;jP8w{k
zhzj4A+veX$hUA)ZwY5T^MD}^z%`hd97}1hMt5no9?Mp9;ibyzF(bhMmHbqm;9eQFC
z&mmEZiuUIX*GlmwEi&2^K=O0RQ;X|8H70aJph_QQRn2i?4=!e2P|sJP#c~<c$>+%R
zv#OCofR=$kCSNq(0a;V(t0j+v1X2NM0aF1NM~6bfS0Y7`f$_kJfX4VQTD*DmxNmRF
z>lz?P{s<1hY`-AODoD7Z?tMBF|MlyI_J*}&lLA6ofD>p2(K!*Hg1I#E;(oUNo)E?>
zi}ck&Kno_s>w_AvLI{BCQvt7djsD-<HUOW|$C`wc(^w=QmZFD6gbRcuZiXJctBP8v
ztC>sZayP6-48v%$D<MqNjO}*9G)<W2j52k^J>R+8K3#CJ+1g2%k`oIF*#mEke~^sb
z-(Qfs-q*fUg}bo_#NTXWz48zN#8!Yx!78l*Fmj$;JI)veyBwx@uJ_fP1*K3mu5rFw
zOR@`spKJYNzfNG=u>yw8YPahZt|Z0cBsz9W<CyZN_;V+<F%gQpm&Sx2H?goMW-n+B
z)<;z*xJx=n1WICs$)|7QDmwn{-?94oV>L9ZUt)6ko5|{0sE~JhZlSD>u=u{n9s3k>
zvBss88O&xV6rUGEvN|UM&AIO8i;Br26F2{VEl9*jo;hF*1S3nX-@z<`)i6}Vf*?>D
z{M<IQ3c~;*Yc|DKO)2*CZf4a_`3tvpKgJQXL}=-j@o%)o8@P#3JwFX$Ve0n};eJJp
zP>L>qiK%i7Y6_q4yb==<B_vj`2v8>I?D+>wK-SuDS_81M^VQKO3F9OI0L$G7_d}`q
z3_$`cUDU32^-a+U>c4-J|FyNV5i?n`q5chVnH78n9?!u;(WZLn*qE0=hRcdTx=H2M
z#Y$nZD(Er%R}S^BXnc0Ue)jkR)2@xd&d=O70H4vvAN{jGrt#e$ULos&h^|zXi%YLG
z$Yt8(e^J2GFyPLx!jMJ~2;1$1v$Jz-H(Ly8g`5kv+b!m~AZIbgw%hlzL&KqMkEvNi
zP`2CJ%n!`XOs2F%qA=-c$zQf#txWTdZET!0Ckb^C#c`7;Wrm1p(20zAsHL&RgGfh&
z>WmkV<B%+xH!)*ygo5IRT_+`J`+CtX=EGR`0r|#st;}{$W%kJ1;?uH!n3S55zzZrn
z;!%r{OB<OPl#<7}q9zQI2N#hSW>Tr1`_bIhJD8ZM601q~41G`(?UMUQk>^HKH1kK3
z(3Or%S2+>H{(V_sloTh)IcYBBkK!zSg4W{`cERFuz<}z5d})nEZqilBwo~^;ha*bZ
zi<_vCFqO3C0fe<Mx%^LroaELJCQ@mMmuNl~TnoD&OEe=QTa}0_XQW9j<Gf_H^#HN4
z9*7$`)X$X^j+CYo1yRA65=KX{DAX9k3{C|}E!0OQLYXG$Z2k;j0*xamjbL`vr^YlA
zI>&F5c#1A}16>n9uT|uwLk2&c{eSPlQ2*2$I?`MbH?Q?s6&qz-fJsRENxyU1-y`|!
z%!05K|L;W)bkRWUzP;;)ecB6cyrKyJb{GAfNI>@{0(Sh<+Xmn>`dAGK$~-E`T7Xf(
zB%(2}x!DHS_`ieI0qEcm^E6|#*?L@V#&$blv)N*rW-w-yoH5VY2M)j4E1Yf4wfJZh
zMGen*UKrbmJFFRVp4v`*fwF1czr{2q^(Jq{wC#M|)PxLiDB0v&i6bjskn?P)#*mPU
zaU0@2<=M?@hM}$$Y#MC@vU>j@GS7jE{Yyn9h$0SHDpbfs?z66_(qu)|z6+bXoJG2`
z7s&$hXjf)-26-SX1WH5Ilv5=o8p$i-beYr)oL~#?;-tfr7%50$Qk)rYKQou?yLkqK
z9dd6?1i8&Il@2ne4o+3$AyCl@{Zr?xPoAYGd9HE8X2B~y{koJ+6**7l6v>P%EtrOx
zFt~*=Iq5DE3oAWAfGk^=Qkn}OB@4@QVv3clZq1Z}k*A$UgxTXb>eDr7=%ke{uS^LI
zSN8^hs^u}cL!hnH+>_56-d31ng<!kf?15VXb1P8$zKS{H8P9{jDj;!|D<xo918D_H
z7Vt#u@=s-m*!nLlu8p(crCz<T%Is<Yv6R4W6%g`8r_S$K0)JZT09qDP?G+UTirE?z
zh9iKa02dH#8MM`<q;Day$0CUL277<PReO)CmK9f<|Fr&5_n`GR?2GpN$ZnI+`2^oK
z0H4uEe)AsjY8YhNu5u|u5urLQtNJvYF!0KzrEEocv$??8**VV7E-+0_-YbGq6k4|K
z_ioJt`y^8t>|{x6p{18_86>vw7itEUmbB-3aCE^!s>{o^#t{3YEdj&(jhKC+qee(e
ziCwXv7{;-gX1XyEF(Uzv3J5eM3#d_>N=<GU&5{+!MB&h(-mo|qpc1&K(;J7bzwMG6
z(ZBm#A-(EuNuiq`!kfJ`tvCS~RV!QDR=&v!0APFJm=v8OLCGU?z4NpCTA&14z52r=
zLFNg{gmJY(B1Vx?3#@_3EzmUV^i7Q!pPw48EDioP-d|f?Sn&>$r`BmN90u(auo5g{
z#Xd1r6B|wp(Z<NHEPRfJ%VmdwA|!4rrW#gc$V}YZi$?<Yz8L6O|5BOsEo7IY5Y~QA
z>bk_7inz%#7x!wdMoH{OJXQMc=ae;|Mn)tW+_1;4t3uwWse*-}c>)Rps{t79fY*1C
zhBXH2zccfM47Ev-41u8&MFfNlh7;_Hn*q6kzzZ#w{`$Hn(wAN<>2H6fta(QuwiOT}
zyF(^_pFupaIA>+bM6@OF<hy}OWB79Ae|@9!F|&SdglsIEfSauab`=8G$N(3AaN7WU
zMjxl?knX1;2{vO9VJSk)HW6gMqe-!;u}lRok6+^W_!t)#n<^z!1<G736vn;u>jg?&
zd;d5YwT6wj%&hLvJ!@Q>`Avk3<au6fw78QQD#4o!YKTH-ZCW6p658%&BRbD5sZMfn
z)q^4h6uq50f?|PY^ZnO6yZfJ+9#J@qsgeFjw8GV@;sG?=f@-u)L{?WC)LUbc(V75W
z_#8OYE?OH7^BXYZA2?UQ;Cga*J%twY;^%O0EV%_Wx|UtMp)pdVLWS%1#l$F?EkoYE
za4X=+oa=O+K#6O#a0K%V#7$c+tpU=IGLq*A1X)nUIOR_GOWbh)puVcGH{PuCee)jS
zK&27sinJmc6S*lG)C-;!j~e&uNsZ{qkKX)5^l!*U*<t%IlOk;ifPsQ=c>BjnK-5Bx
zeD_ZwRv~G95Sm$3$N-tCx>hQraT6E-3k1cv2<9Q6Lhke^=7guSHRbbNh^)ah0>fRT
z^*s#30ffx(C~Fk)1a=-!E(HYzN(oXXjFgd(K{A2L#<cd{0Ep8JxI@I0+O_&=R!M7w
zV=!PqvLTERAa9W{I~rngMh7tqm?oh#1FQ>O|Gp+*G1%`<DeB_^2%S{v>TCnOX%lco
zeZM&(5R7MB;T_->gSQR9XYlcN|L*@q`h1}I3(AxRj3aa<f~nY!aZDp*nsIh~hT|8<
zI6phXcA6~HJ{Ko}6*pChY2Rj>Mh1>8X>f%a6xgOCt*n02T!(=Us>~}G-{d4dL^1cP
zRMg)?$D-G;bM<n|(x&fty&75rYXY=m^OFKH&+c)rT}l^K%hcpo603relOiJlF766G
zjmI)D<Zc#2%V27s)t<|l?ZkDLS<}cOs+GipSz?eh10aIf?w#0TjR~OQ3IhO~EJC<s
zzd6=>8avU_CMNUtH~ZaGchSYQ4eIP~K=bUpg&7)20;U~nlEZGTY6yZs`H?uMgSi&O
zhpDlx>TjvS<+hV2Vrb_9*#-822L^F6ro8XJ0jVAb_Hj!kZN{Bi9YJavT&)dd@ijm=
z@Ffm=XN8tI_^BRTNv@!2lVKPZg~c*y7%ViirEm@mOB?a#xO&PeRqp^Is-6IWNhoJ8
za?T?N9*U(V0b*VqqBDS%^GQZvSc8W(2KG%|SA7`XXp4Aug-abp!Qlj0%xuTAEgk!@
zqD<Nr(c-I!aB=wbx&ZAxd;JnEZcvnK8f2ISDN#|PSyIZx)W!W?F4n!xE*4P#)oOq}
z>w#TEAAL>tzpIKp-L#pY-JQUmRN&hN;4}DmDi=5`iSF~j;{Xhq3+bfO#TF+g7dSmW
z!^PPKFOSb~dU}RwJGErAn3(+LfXF%zxU<ULc4;vk9N4*^hK{|tq6TqCFKyy#`d66$
z#H}@+BVgQW%Hp@*YQ0JwX<3@#iNm<ur5B2pHj=@MkpH(`&OVhE50>#MI#}^lh8Fe3
zHT*@qnDs7)v9_r4NQ1#!94Xbe-9T;j!W#&K6>8hbJ1U|D)pcK;T<G$;>U^U;BrVnY
zmaFHzB0_sZQK6FkM=f)`I{O*);sm=+H!oHK6196Hg{J{*l~RL|90j17^G?-UfNFJZ
zAw9-gXMl_E$lZ@XP3@4}0HBf`yK~i|le_f{H6BLD3wzE96L&cbfTA=L9i*0w+1dOS
zcnTrZrt}Wu>bYJ)9hY$Zi<vKMmSY{EhN?uWpnY$}{S4Ih@@g)MS_(9WNms~W6NX{L
zFsy)KL`fOUYQ~1-D+Q>>0W(mN#RzMx^d_im-D$4?l%Yu8?t4QQ;j`*Tn?6mfyb3M7
zS#GYI<Vk=L1MDe)N}38G<uY&~ChfKqyP3e(74=uD0j}r{b_s-g>iMOD|8Zm#JKO%c
z3ZSd_0k;jnXYlbOKR(bAA0B|lH@6oT_m7WWj!&K*;pNE%j*riAbbOBOxlQ|0iifjE
zgQe?!nrhIC!I<2p4{eh#sWyp9A8%C&VCVvc`popsB`<7pse=%@=0agC_N9M*lOGcE
z@+v82Ues>xRG(vcu?NY?CowcAnjDW-zrjaVKsD}(&&{z5j`g=&@Opuh+5o8EWQ!k5
zcN3(h^6iHSf9h%p%>I6*H1e3$K6}nmY)bE`2v*lioqWkz@Z@m5MjW)?(8>4a2)kRc
zn}5wofYiY%ZqrQcGDWr*>^KM-&U5}An$-lOCA2Dpy%3^PfKcNa7+;|*2emjiq_ZSO
zV_UH|LefQ2BYgb5i34-JuWAwVaEO+QLt@%Yeq<4E-5S>_=L-O%KwQ6ipEd&`3Ue#;
z5L&Z>R)piFw(o+>`jR4*ki>t5Ow=+Th>N@Wl@`fOjA2+|SdEZjgr*B4%(+s5gR39_
zG6Q7*4GM?{JIM?wQ$0tFh>{x@pk_-(pa6C*+D};i$<Yrg)^IqIX5`oj>NdsE<dZT;
zQwGum$K>eJ9{*}jfVko+BJfF<|Cg)<=;J)Y4VwV$7zNy>0e)s5fB!fCUoION-ak6O
zceHu*m0^AQvoDTMfBb`wp5A-!gGcG?e1>ZBB4j2j9PDE^>k+@9r<#v$MZ3TVXF=2>
zRV=c=y5b+d!r-Py1)|Kg(3R$PR-N)V;C`yoK<V7{D!kp9eW*y?#lxdy!)ljPsxmim
zq=T6%{M~5|+~$@R(n!FR1=Q_<b+HBrJ6wl(<L0O>InM6=?%=1~>}auUrqIduVvkvO
z!^tK@aoHb(kjBwqahZ{e>E|o+yvuB$?l^IT7zrwq-V_D?c^FQZG?<w@ZW#4*H4aBK
za@G_je~l_LafL&`>@Ib4PC#hkD=|-69WlQFYDP)b^hj$Aaph2m1Jo6A>J|wd`HuQ=
zE%N3u)EmCl6K=;Y5EyULB#@{m{)_kFssImz3X5Rw7;);nnDAdFZ;-T3{4Vz-KZ|PP
zW_*A^cR*4h`<8*>4S;`_JdEJM{Qwd*GaZC8p_mPDVNhW}3<0qBGNY6UtR^ib6%b{=
zJ{eUuNw~@(=Mz4}aww=ERkX#f#Zo4yL=Hfd`lJfp5Yjn;GA*vqUOlYW?e7~aPdjHa
z0<Mtj(eg)jO!}@%4%p>`-Yi=9$|m5NaG=`;;Ir`fJO9J)(q=5fix+2irb!;WI6eQd
z4<0}J#TO@MfAi(Z#WzmQwr^}_<x<#uv^@h{+)d1G{9-q!2rrRfW^)Y=(oRPnd--<8
z!S9eAtn4Xx&E>Z_48rYSZ3h`{URD9PXOwHFA$QhxO0788gfpTV?2?#$KPvS$pp@!r
zlb|@p001BWNkl<ZK(*PzMyL;U8RQzlF#W18pnqw`I6(+R6d&%n2-0zJ;-;Wgqi%A%
zp{3Q;=dIPht`!Jkq&W;O=_|I6cX-=8?7awZ>V#P~8JCb;I#I9>-9ah7vt|$a3BP*t
zDKLeB!4Fm8-5C_M;z!PrpxQL5580mX>x}}}X|Ad5yR|_jfcu(*2qi`{cSdCQoM;(0
z!RSww#b1v=*8l`#pMq~t3W`ca4u(Y4-7t3JiThPbD@Ju)VeyJ}-=$*BvUtdkGJD=c
zl(tC!qjtJzLovW)jW$J2gI2dg#Ck|%Ay*_{)j)HF=qZgg7C6*7)*D&jOi+{pPyx7D
zJ_MBr2g;B<xfHMfFuw>3NJ`ci)h2mYy!&Yw1ZhP&#7Uo(NLscQ1x(=|!hntnq!S<=
zuLk783%eY>1oiJ<3FxIp;D(LE70tw6D`2{sVXy!#x((6}CxG@+0QT_#prG3Z;4k^(
zfBA>sO79(=AJQZb9v+|k<fF$=fA-;%XJ319a{l#A#*a){-=1a}at2vkD}j^|86n~+
zJ8jBqQalCK!bkveZ~~|=RNc-NsIGw3w5o&f8yFz<w3SF|^Zh$fc>beJhcP`X>U>?b
z=P^Z6GhG$osM*GSn`aP}F4)DJ88>2CH02$6folVzC{w9y?y6F9+gdmoOsm;j!0B3@
z45>2yr9$E4f%odBJu&%K<ikUL5}8yCd8*8SYD|-7R2G0w@KsFi8gF<5P?P9_6sMN1
zMrx))EL2}V2zo?-=7{{IZbPG$@K(PwcSs~f*VK7iM`5wZE^*T?IyVA(w4okum#eNA
zpzgI1JOuB#QsgPf-1h(V6s5&li9GNpQUeWQw(qhi8RI-oTrzlhAq~{!b4r9Y)q>cj
zRa<`uv{NIfBMrn1O;m5);Xv6>*l_Y)$R(A%u__r#*6<lI)6<Zo0KuM5BQTg9u$ci>
zSwdUI6g!R<vggD~5nKC|*`$RsgHox+T?WS&cY}<R_|vrk4$4P|owZ@0WKcu_Yjk8u
zp?pplP6?x2m*m%axW&F-UxC9D=}t|5bz<Q4%7W_}1Yn=*FX2Y9j9vA=MF9SCKK}MM
z{|~x%d^keJdw=lo$>*Lue*V>G&!2zo<>~p?U!Gn3)X~}IOQ+}C&u8TWQBHHVJaj?=
ztI29a6k{5oAmr)?ipA6#Mklrh4$IZfmNKR^?CfNNL(rYF+QYEYRtMqG*2|;_ZN)$p
zCT_4ZDJ=+y71|BtffStD-rwFoLlM6F)M8^R*g#Fmpq0JYrc){P3Jqp?O9zmaRp3O&
zXiP#`kh(^`UgRa$bxJVznO)8n<8wITb^HYm!WfL47&g8!;YYE7iiO>{g)YPY9#oSQ
zp~a14S|l#1yE($#{iN6$Kq~a>)2opC%~K`AnNoxri7P&<H#;cKAQ$n5iR)fP!@HmZ
za1Bl81-jC>B*E~vDO@8RFdERdr0*i8t?n0XQobOR=Eml#35TYd=o*TeHxUh=R7XPf
zH3~Wvi!t~cVKTZKiKEE`rp5&@7=W6EFFdg_(1uurNcj7^$A6w31sLpLrx8daG#LW0
z7|`PbxetaE3%sIIKvG<KIs<uQYJgPCSjfqK>I7Kxli;2O@#);)YO|Tz$x{ukG6)t^
zObyKw0-qC&r>a9)9_;-^nD+nXy2fG8wnM)!%@2LdpWFBLZySKWM33M8)A#8gfA{fl
z^ziKNd(WPHVROFu(TlT-pFTZ0{l?>`M_)fWIsf79T;43;)to_djp4P<e>M1xD+@Fi
zV01V%9O<;B0TOptkT^u$v!Aq2SlbZ<RMOP)bd2I*LsRMY++NhfYrkll-nyxeD#M&A
zJRfE}&C0YV?>Vp#yHAH&W7@2SJwEAC)ZD5<pjx}EU`qRd5(YS0R{+&2*EQwQ6tL__
zB!e93lX-Q&1385$q;|f4t;Z+`j9&CynnwyGSTbYNm<N;Hr&@0SszDK4S}3JTxXeh-
zVDzwP=9ED0BS7dHJ9g+h2$X^3Xz(r?Oq_z8r``G>QU%@SS-a^!_!J1a8pM?cZ6(_p
z9X3LtP)**mHI6QtQ>_gESBFaXw(-wi>Yl!RQRa0a+L1iF`Mh=kgyubv0>x>-n1M14
z_E&>9+~dHdfsSG*+nSDC<p3>h%OKtivs63jnh+`35diUqXz(UraFiyl8LCxAg<M6D
zjbK|cAVX~cWWE5;8_-YyPL7sXE2!>|p$qxnr<o6sx`v6X>nKSEqtxryJ`*dz=gO-y
zFqa0O>y?Rpx;y*RF5-TDk*%92bo%G(OZSZsf=~4*(rp~@Uy8?n_TT*u-FxF+`oI6t
zpB%irnBKYA%s+DU;^ogjef;d_pFcbLne(&Fmvg~eS!g{M<vAAu4{($l1DW-x%o&Li
zMoz#0<Y{a7uf*<1Rx5s$n)MTZWtX};nN31^We305YV|Rw-D%F<cGSYibTMuzwTM^q
zNY}+$Ou;n)j<hKPv=~v!yzZ&nwPw38QnJvaNb0LO^jeEQb%Z?T&YiBfIZDx{Zg7d8
z4YX}v-P(`lBFK?L&=r5)iw`<7qi(DdlV)yY<)+$DAn%|WF&p{Xfl+GK0=i5CC_Cpv
zfMS0BW)h`<j^3O!uLt!)M5N9aaCFFJf@WRZ82k|@+}1scVHm*PbVVLOL?WBq(~eW(
zw*OUebO$bDWIt~louLJZbT^lUY7@Y2P9&vZ_S8crMM~z45GjjUGsZMjX<;u=;ovoN
z=S2}gQqOe=QzQ4Qh)e-E39@lz!o||FksY}ac#%(90bM0+S-#|duLTf>$_&-)HLq^~
zMt3`0L>+lI<4%~R0FDH(#AH38lrto`aNm6fVf5m!m2^orm#x1h1i)1lL-lZ(RWT#i
z&tiZHixO>=(m5TFXxK^Ytkw6uQEjfqJ-O+XALz1#aCd3&dYpkP8Up&H2lloB_yK<W
zd;hM|7yjyZcr!m-A0M4Pc=+VxtB)Q(|HjG5`7ggbe)%(}r{{m=;$nJpo@6abNt8V8
zkBvoJ?bF2xMLy~Kgu!7FD*a`mZQn*a6TG6+M59eoapMh}*GsV()U5(`q;3^f)P<*2
zonos`t05F-#6oQki_)ZtT`v(j>nJd7L*eOq(xz{Sc6x9x*To?1$RSW}Q*33QLo2&F
z*yzFEX*Vuv61vC@P=n7?-Jj!9V^oi|`=1k}DI@C696NFC&8E2b=;wI;(kyV{%7qj;
z1$}{LuBva%Q-jaD{Xa>3r_>;K>9X;J>W;jYuwFeNLEem;sMhs_TLyN-PO0bsv+)!F
zxSqcwBswwG``5PGp_sOP0FKWRL<|kH97Qh8c!mhbGSwSAfsBvg>j;J?6{0m$mb_QG
z^u}li8%dSjjA}tB<WxN`Bo;0liUx8&0>4hU1$vOEa{;pP091jr0)|8IY7H7z_I$o(
z3r@zs2`G#*6_mMv)`~J`Ae$Ai<a3mK48get9ccn%1!aNITxFM$RnYAht}T4aKs)Un
zzn8^dZO&&^3~-K&%qa5)l(#h>p%kcc$_lzrqzlHd!#wWygmmq0p87Ynzkn0=hXUae
z2B7^eu_qbPYexcql1;#E1Mma-_y@nQbawRJ^^<4M-}&C7qpv)A^yIG|9i4vt^mOy}
zi;MZE&dx3#OjACvwS4l6rgK2sP5BC^GAFFDHc$74hxK0edWmwP6&mjs{GIJd)lfTY
zpO%D_E3G(oTsGb9y+QvzVVN$u6~R6vq%|nIl&EQ6Oi>FFI=Gpndn#zhHPGsLszod7
zxxKzF5RfRc(KLjS5Ti-@YB3`ZanX)c*EawQS2%9~VnRkp2&o;vF4mO9=O<TTa{cT}
zi}cuYgBlUhUNbp!y{%^|iIKWyu)lGVyFG>hQ|#M&?nfmrTH_|tYxmLi$Ye=<Aod%7
z=N8FSciN4tXS@lghuZGGBNu{p)>Ji8+SLz%(nx9HP2TW{@7QDOArb3aX(ElZ%^n90
zac+W8HH!)_B0C<bNe|&!7r`Xaj!Z}zfB+)%riKWSP3@3k>ybPGdGfAk1@PcXfWeap
zJMV_BVJx$tOa-H)4h@(9IYXYFVU(8uw(d%qyrC);)mqvf=_}EIU5DO~_AbcoN;S8j
z`4G%zP*k=covSy7-TTr+#OI*2wOqxkD!l3|ApRYuzFtT6dlkuVPeaiCW^ZrtsXuP5
zfPc^)fB*OYg!v`LKl#q@-hcM^@t2Q|U;fOC<I|se^6cmv$H(VCvAxJ&$XV}5k--K|
zpNKl5kCFALCD>``x0~#(deiqy&+h8%f7jMzRNc(fCmYpn$_a5@1daRhypKh%vs6D3
zcTRy;#A3JXaD1@aBlWH}2fGMGc<gJnYVAsP^L(j(@u*(%VJ&RIE4{8?YoilMXaU_W
zR0?p|Id->Qj4uc0fO=W6f~DEe_DukFjC&3TG$#a-Ht+T3rO@50Y7zHi%Gwp~o=h2>
zINq7S!}7RGK<r+NN$VU#)i;I0MZwBg(ON+JzA{Q>^>gS8avWP~vQDKX3Dn#OgVElI
zXWX4!0jF!t7HHlO=+YWBIwhsr@&(eP)CE*kyJl*3&F+^0=Y}W|(jo@f_v6$)M+9$j
zh0i;pqL|C0_|GitjlDUr-pxsGTHKw{odAObm?saia>qVj185~$R?UION88FRPlA<<
z_E}3YB%z$6Oiv-xbD*3<Q*o|=bwY%0efCMifA&5BBWV~8&46y8dI8NFFtT041t6>h
zG+uzyIgR7gq6+ua_Zt%TF8la=Y_gwT`IGxug`YYd;I;wyLD}>F&woVE^Rx8PpS*V`
zZ{&-|$0tAj@S~@{^wHzzzxv|k*-vh#^0|3i4)dgm!K7+oG2(_TRXFF6eDd986eL2E
zWudaQ{bs9|&pM@R@THzO(-rvY4Huy}J1jubCBi^Gg|OCAty6%u^ps{k6zOO?Z?F|B
zELqMql9y|Is_WG1jZ3stpMfZNyeoN&-FlB6^bLJL@||CPz|~Cs6yB*Bq)8Y<B}ZK`
zj5SDY0#q*DIO{qh$dz^9kJdP$71#baH8NzJ3-<S15sc=A(i9q~O&0A0l~cbGktLuM
zu7+X!RG-UH76ujuOv}!}Ly~&yVeZx}+T1H6m!OX9owzER67AY8?c^sC=MEEClNaaQ
zlpkW|J{>>?Rzo$UYaXo$pcWDZPy6#Vi39<%JE#KpUvMP`*j`Iq*QoAq*Q*1BEgD#h
z#V>1~J!F9a9>K#18jT2OQdIHYT0H%aEhc)azziS*G8ND~gX97_zkp89fbtTQCX?Rv
zSe}*|Ne$Ic^?n!w0YgC80CEE46KFXD>125&nV~d_()vVr^-{-!ZK6w_Ji6cV_tj0n
z<)3-2X?@>{V7U~16@G9vN}#t5z+a-r|MSn^r*D4i$(lBJ`{eo2kA3jr<6nLB<i*b)
zoov2#v6ZiEC%M1bOrvBa4&Aa?15k>3<Sv0IwVPrTmwxiE4rf}6Z9@u{3;(OH=N8?n
z8cwRQMksaVQ1{>}ZR=mtQCgFb7&{F9mWdiuXqf8Mtbm>KpSo+Be7~;R_QtWc(2j%{
zFuWD}mMTZp_O}nzahYBp+Y2n1{f)7%bsA>(EeI)KZyk&Jcc_Lhi(%Ed2D~U&a_J^X
zUVx};dRkCZr#{$y{ebqBI~dmMrk19=*A{ZLlxm_Q8;1RXE}A3iEQ9OX#G{jYRRB>V
zlvO}IjwQDhO27Ic=}`>o&f``{L*Y@WA%f<0Q4N|}cV=(L6Zg2(=cqwc#5JI)o^aAN
zs{QSm8xJB3ji@sV3eHSxK%$Le=TeZl-TJj9WOm6lunOWU0RNQ*$g@rGN&pYwVTClV
z+(D8S3`WiB5>Y^X4Uh^Tvp}~qhQkRwoCDKS==2;ko`CrfnFha&aF;8vx0+os5-%f!
zcO5q?iN_T$gbCntK#rl)Q)oH!z#>2-0W@a9_yW8-&WG!XX(1B61k^X>pYHDE^;KI7
zx(ws*?(}aQ^Q+g80Iv8)*WCQBe#+Yh;4kpwfBWO#r1w91bNHQaKfL$e`wzeR<jIq-
zKY#J!7mkk4{>IVq`B%?2`JEzspvt6~fMU*b((TSG{OKe=s?Kbs5&-KBOZRQ4sAHVt
zT2^npaI}TEEc{!$_tgqy2&X!S?l7T&E>VHHgXe`ru)`&;yw3W9v)G5n4CZ_MR)Dk>
zikj)>)3b&{Vt3D^J;c6>4pM7+v^4<LM5#|o>?Y?Z?u;FHUQyKo!M11UCB+46oBZ3f
z-Mi~`4MvwQfQ}2nB%NH&8y8vH5tB5xLk{jkKXLa&$FSek9riYQ!yoLpBX(#;u+<%{
zvgy9<h7qPe+Wi??6G|Oip|s0WXvQ*&_ubt^Lz}O{9@^udhj|HURJmdE{IAGaHAZSh
zK9Ha|XrggExSB^*f`q?uAppf!CM3R93ts`L4uTMij4pYC<ZSW6#GsTG9DpTB&xm#;
zVhzA{#*hcl1n4B-TtH<D**rr&{|Mv3BVe@x(H*FcP#SAvR*OIBt7l@;y%RX~BeAb6
zEnRT~&>1AZfNURwaAwGZFd!>cUR@~G?^C+-B(3hv)PL!(D88f}Q;_yX0`D{Q)k{P_
zS}gWI5s~jzKX}EGKyML%AF#)N`di=PKm7lm9UeVB{@lZlUi`%K=P&-oi|0qb^z6mS
z&z@h*U)pZVVV;#l1dN2iFXUWGP5lb(@B;3xMV2}^y@Rl{yAjeJte<v^?e1<sI~I&C
zvo-ZHsqb>KPlp0fgVx(Uq;s?*bTV6MAwt#Y!wUp@NO`G3Y{5pp0`bYdy4U&Z^h|DO
zZ%#xt&5$X42Y9F9Xvdg+s;|Xf`>DG@`gKJBbYw#9NP*pM-EWAD<!z>)dRro6d%bF?
zRMC;nY1F?X*4-U!bLflEn0mgUMcG!=NOY%|b{vJ;R5TJ_Q!;c&%wnC<I0Ck#?@v=|
z360h4sGVLFil*iIV7Y>#x<YDM0=ob!dC~M{gdzf$J1>eT+FYgeCGsl#{0jbua?eFD
zOJ=E@1nHW+)(ogSI$HRUKv?U_LSZWqbs3=f0VqnIQA&1#FPV0~_W{rdXL28j;^#(D
zlud@t49*0d326p&%qSPnF|R(vaQ8jX>JUWlfN&R}1g4?#iEf~rYYO~5wN@8HyRA5g
z1i%HL$0+$J^7I4==jLl61Yk9*uAeI%{3+5KPewj0S~A^KZol01U)cm)Dz|&q_q2#I
zy}^rr%=*8NDWJD2fFGd8-}x{937ri(eDL0T_qP}4Uw(OX`i&1heEe%qpCA9i@yoLx
z-CWFXK+>Qk5wsb-#3V8@qe!H|iL>~rX{l>>d)ax;ZXk?)6x8m9{%SIhURuvyhVNoc
zARWxw$byxnPi;DkCZrY1SeSN@U`-$Eq+>la9@8*kr-(XIt8O>!fhN7xaKQc4@e^WS
z&b26d<SR8#d_upzh%m0Mn0Mqj>bwfblj>5ZbXcqzNc;3!FQ8!|%nLFdX)j@r8X4Pd
zxx44VQsLlD4(qZ3h<$ya9u?6cZC(+5V;Sa39*$GZn0jQ1f?Ht(PwG~xbsa;r!!=kU
zKum0?javh&%95kdtq^*?MJQc}(Wy5|Ba`kBvuhLMhC=YwKu?0G5zgK$2z9<d<dZt1
z5(1^J0qpZKTgCws85GZ*uVhbH6hO#~xFpPbJlHBcDYRGvAbEylcT5@*FpQvajpUgC
zpj<zT7V@NF0f{>aPX)Xlz?p#=pt(SB3cdIUdGj8IJNL~P3M(k?fOv4#i`<waw@dib
zy+~t79Wx+j(EJQ#`xtqCh5;M*JU9T+`a<dOyWqob>-vr7Eld06==<d+;7Y09UNm5r
z3-mF#0#_Asy{-Yd<pBHuKK|Z+{!Kce=j)la@4k5c@~0j>dG<?Bo;?4X&z`;f+Ufc9
z`FSdbT8I-7u~MBjAqLTb2$Y&nyNFg8k*GP4kv3zMHvWX4w#locPDOpV%~g!t%eL8<
zE@bVBXkWb+VZ5D&zn@UiP>YrYu+$+C=`x6B@xHVg8MSbjj?AE)4xa*Ebie-!-BT^z
zw6h=~jjRNF4en8kg^szw|BX<n3o;$|x_{}=j*5urLeUWKfn#N|*jg^VmZ?@l-9ZL*
zF^{z8><|iCaxCiW^qvB;`#tQOBd*YBle#WmyAQzO9WDd<Mv&TSAvi0M;z*3jU8tkG
zcIX4b5s<p6U%T^)8Znl1K^pH>V#M4r|J{g)I}{^|KWwVz9&iXJOkoI>#vcd*p%V_7
z8q#1{1OioVu7LFzL=3REz*MYx@Hk+}1)2r9WRzUo?UI3E1g};Yh5<+kO38_fjI0rh
z>=wH-FmDT1ha<Qo$Ohn1z-dOApI~$LXE-=K#K3nz!+ikv{Ci8a`TX=~fQF|4TcDg^
zK6{Mm{2@v?!k`zHg-{s4`uVte;}7-l{&(d5TPLa?&sgtchW}jc1F*Llc<qMZN(|+i
zt-!4hz+cqIZ~o3dO@I9G>AmOAUVP=d-+lCpkDk8xmFGw2f9>RK`=e(U^IN&liqx3<
zB@0Rx3}6h@yxEISdttL$J<*}|XRvg=h>BgF8?^T{34@^K+ux*feUD6Nx@)5S3KqLT
zcT8)N2D4)a3hzRK78>|q>GykC?d)y4_tV>WE~fGz^zC>VP_ImIlHCwVYn4;clnLBH
z<%?ZCsCfV_8k>HV+jDl>M7~rOsNdwp)BTom#x~6KCM)}5PP_eT*9;K4P#Y{=>?&8G
zt_NuGTJ7(&It}h7qgHgFHWpORpN7=va$;s#$Qb+Q(JnNKWAENIQZ)g{?P%jXAuQJe
z%j43HL3IM`jD?m2F|AS2HOHYp&JrpEZm*@d)QU!vQPlvhS_qgRcKMbt*-VWLrZ<m$
zPNq6Q#Q#<(%MbuV1>6gu6my51GBD4k<A*y74l7#&P_PI5y{oh)-t7eDtzyg!Dg>Ph
zbOv|@l>7pl)9*o72e>o5gMsgZFnV*n-Z>HJiW0SSA=GBO;|NzrTBZ!>49E#|ev0Yr
zBh2RyLFEK06S62&R$Ics`>XNo-_twqekALA(+)>=K`+o7wjH$Cs$bggzt$K}`*4F#
z-VnUjTH&?<_zUp(Z-3`ot3UYO`)|Gf!G}No=*iPxdGz$?Z#_Le`^L%X{Ka|3fhaK}
z86&&EI{IRAAK?i2T&~fpAAeZUI<wd!YI{h#I}^LA(fhJDf*|d{p)HSIb!ntS*h%||
zTd?lt#&<-aJ*O@$(1D%Fu=`C+;@vH_{o5Vpd5<n!E`nN%_khj`uTuxmqF{D^j$M6x
z*VHIGmmuPdoAFO?jo7ah0#?_WxlWCAw!`1h{(I`VMip-F{!Y7}rJZiC3k%o&E1`zW
zwAVxX-q4uq`)*ym{kqnu+|IJur&$Zf@jW?cK}zhOSiv4npv^I__J~xE^%CvD!gd-x
zzoM>)sIF9k$3VM%vT_Tf>e5-8!bTd8WMO8&%aANZcO0nN1Gi0+*)F5n9k+?!<M5jO
zHQBq4SSBSi#u`dC1;D0&HW}EQL$@cO!?oQw#x-cX3(yE6Ai0`As6VR=1u!om!7vMG
zRe-EuDM&J7-U_xa*GTCdkd8>J45SIbJpe1H4hTcCFa*Qm-0{Rr59Nw01qjv2>{I^)
z;M`<?(^KH=yO5LjpchY&<ic}FMiCr7A-eaiarNNaa`=T)(d4NLA8+}-mlv?u@4tSL
z?)=B}x+VU{c&o1@EZ#N%e*qr<(f{-Zyghlk`n`YptuMZK@#3c+J$(EtAAa=oUpqQJ
z`{`-MJ1S}9;s!f4`~yhN;stDXZT|K^LaNDYDq45%s*2*K90p$|>;U2I|1?<Hx(BlE
z|NV|DpzmOpg{j|#`^{Li<M{NFpQY{RQbwm8+kOedF{s-^x1D{T1&`gr->nQP4Ba~x
zMvN>7T(HC6S@I#;du{su{uu1==WIVqyG(W2Q8Zw|6^NBiH%j~1A}-nN-PUADa_r2N
zgE`$B6jfAUCnb-4g&<v#;+o>v8bi?*_Y&VFV<*(8zK<5hBee-=$5E;+Z`b^Fj)}{d
zU2hG;%CRq`o$Rk>(z^|B%|~D?qO8Nwv7N6{J^Cwkzl-5jM;e57uAlxU-aB2otuT3V
z-4Z7AX}%*%A`FYf*LvYV2+sp3sOLI7X;8!v0#1rV3Zh~$*SP?j0zIFgXD?CCSD-iE
z0wo2n4=~()6M1|J;uBC(BvD9GNQMyvlUWU`SOZX|3BwwoT!5Lt17jq?eEuP}x&q}H
z>o+&x^#zFE25=upcL6%IW30Sj9>umQfPMd#z&cdvtf2{8Ku-XD0nAUJXYWCez6Cz}
z9)^4j!UWYp3f()?bpP9w-unG~=W|c6zLQCXKEbH0ubkpPrWsJ*x?bT5sF$XlSHFF|
zX#;WF0Q^gO{QJN02kGME<(;#Wv%m8A;iF&s=)*^U>*<phKYxBc{qUS|M=}P<w)0ys
z*gFT`xJk9i%dJ6s$G$6QA)Whuccbj4|9Y-<)9->(-B{I3x+v5=7od;htqn-;HrE3e
z-3x~gN<_H!Q0wwS;ab?a7UCeU?P&r?YBRu<w5FHrhB>0mW#9Fu3+rI?O~68qx8zya
zzc1*c38FBnHodf2wV0Eds@eQXk1$XTAoulzbh62Ar9eGbpi9|<biYUE)!xbWx;M#v
zz5p%Bd)=mep)lwTh`4JR8Qr8Ey8oz$y=hUk<2BSMOmk{u!KslUJ753)mo7%|u7rm#
zMdzs4Vu?G0C*Jw)`$P;Ub`oRRz%HEc$k%5PUENkDicX#xhCo5i@BglTKu0!|AY{q{
zP9AGb1W>BThj=oeh(L<3tq3URGqxwEpz{GK51_SRI6TDqjW@78B%?=<001BWNkl<Z
zJcO(m$d($IM%apglB)y&N(xm*&PD*_8PH8e5rEc&aeWSz$JkClIX%U}-KQAteF-@D
z0zeM{yaA%S09GJLw$6x?!Y@|#HbBJ5izFayL39r2F)%*{=0_-}??I0K6twveoSy?Z
zqeuei?hJnS&(rwen`!-}-`9I@o`XquK>nNR5pTK{Xvu&56mheLqPG#yD;EG)1`54$
zWpFKF@wNf@m+<(n|K302Z_gjyfAsj#k3D?&=$D^9e)4Y}AD{lUvy17ACF4MaNQHe(
z*iYK%3j7|K%%$SL^Y2s_n&!59)rDvK5`f=1MWLNPyDk=JM0&Z2KtCxjU!S_rm4$M@
zGlNkqVSUnFBA!;(d^5w*){yIBaBh<@mOcW#KR}%xTX=#K4Qc7`uT8O_+V7%w{m=Ub
zMl0;EL2iqtrQ;`v%MG>q=X==EV$T!kfn}gq|An3PMw?JO9|G!Pg|+G2Ldq9rGPL_?
zc$tE@a9ikL_htu8ZCVFI0<)<Qc_+K<Pyw^Aj)|C?DN_XWcu}e(S8j2>y)h4QS48WH
z*H7Wp#l5k+|8~aw`!0-t|4ChLwj_o117S0kQ-Df!)?5TA3GH}cbGKfz+=GQQm84!X
zg4itdO_zh}9gI&zm^T@6dJZ}pu|7Wl#u2n0F}!&n>Hb}mqXX!C3ZQ_QjiiVX;1$v^
zf=2?c6qJmCKW{b`fTRNmBcup2zl3suY|fFlFOWBnfqP#9-~AGJ{Vs;#0f^rK(jf>d
zTMKlCL83X#r$LE8m_Tv@OwXX(k1$`nhq8SLJ^ui7@c~%QpqK$YfXG?|Z=9s`?myz;
z3%@(u|H}Jiby%=;*t=X2X-`RhjfwtJQ1BuK__f^m=!#PRil$)ynyg!p-XZ{h5gz}=
zZ~q=0A8m$z{`}z^fBxO~zV`IVvtNJu<mlI49G(2!b~}Gw1*5nImuY|!P((ZJbhqo>
z{o-{Gw`PakLRU47y$$WI0mowgx$IU4dR5$~?ntoo%I9Bj2s*}nK=lDXb613`lis4(
z$^zL~NXpPN>~{iyutT!Dl)~3HI2~%RNb=j|O)PiygzypY;3XB1`sP-<tbkhlixB{|
zEKHWPHVp+yi$|b#VLsZLp>{8lN>p5|c2rs;=0$`_+_Rt&C@a#Dc&Y2h(g3MP60F`v
zYC(b`EgFDo%7a!E38<zw+K20qHxPYD5wVf({56;e!tC+PuCb2^HYBdhHYP_XP(>YN
z2RZO&!}a)mYGp+adZL7PK@rT;b5E24u3xwjHSm`jGNRoH%i8%GbUx7PjaA*DllE%Q
z*7DV_my8&AF=IMCM?PJH@7w_m47zuS^wvG-(Os1J0*NfPm}ErJ5z1?%)dA9K0FR0^
z3WiZpbOTIVh!${R&`21E3{9tiY#`+Y%JdL2JqFEBkq*BII`|<Bs|UdFCcuscEL1<z
z8tYPkd<L1Gp==(aT)dBY^IgdN5imaomot>2C}l*^dr*4g6nOiOkv{iLU4Qx8dhhdR
z=zSSp7n^@gSYNS|G;p)$cr7}@B9-t4|LBT8sIPh30Q?Jly!ZHYe0lWp!HZ|dKl$*{
zvw!p1lcRt8>}2zk^Ncruafk_#-9*Fo`*~61vFm=<8|<Jr{<$p2qps*GbdiAB2h8*u
zw(4Zp?~)g$eti+?CZ`>@O}gACFB%D@244plM%`4+og8tOeZTY#*ySwHj%iNZAf+V%
z?(WIEi&q<+zZKHzi{BOekX8m4Ac%vi3nL&iRL^eEBCW{Bom!$f$WX~35jSor%glpX
z>;=Sv!RPB`Bh_eC(NKkZAopGX+GP&ZYyw51rDbomAuhY?fM!xhT?}lTD_orW0ESY+
z<rqNc4#c{Etl#NLd-hyhR|<8v&+NPkoA!m+C3W25eAzx%a<;pMf`EHc9#<$n8jJep
zZq`H5i0qm@_l<DPq0oiEwemBlbAZHRf6<vn?RY9ft0i-5tSop(SRJ+KwDv`tnU7NC
z3lb4zE7+b~VDoZ7dV?_B8$bsutloJ87cbs~T%2K`gro_qYd}UQMx@mNhSdr*06YT2
zm@v?cxtwF(o&kBrct{vn0h*xmIYbIr))2iwo?k)_pCTVV0UbO5uigfRH$dsYJqTJ8
z04dNiL#K1-#SzNpDf0Fa%Jdjoo`P@;$T>>M$P**y0}$Uo=k)HMrQvhGjl<9XV}0<Y
zXF9&h2k#X%_~w$oMHA4qbb5p5(AOpV=@lRbZh{UhC$HNyz<&{s|KPv+-)XpecYOHx
z>AO##AN|~iAAI!dPanPbS2r)WKTXPaA!E`~jBo{ph#;5Q<W9^U;3EsjehKsMJEiIJ
zK7MB^@Bex!q1#uymrQG}1}NwX9Gbl>b{6)6Jq^jSVIkd_SVQ~X<%x4A-|Lz3Z3iq1
z=)QNC<1R?3!sM!p2B4t<3Z();S-O~cm{JsZb^@Pjr16>ex^@%0*1~O><&fD6e1rGH
z-qgI?vo{5$<pzWeF==Q2YjgEjfRT4)gwhC&!FQ;~W7!N)zoH>UVhdVj?Bp3x`)`#)
z(q$x|Iu0%r0n#SpK7O|=s1bP7EP1h<y1O`Bj+DNds>kjs-C}%!Zki{Ca`NOmuAw^Q
z|1aFF4wzd}3WP!1-^VVV9F;)Ly>Hi!#^2Yyzpr|vE9|-}#C7X#j|QZ0C*sbh!1FcK
z-2hGb8wfxkUk;x~1CX4onE>4iHm5UIFB$8L6^6q@@M^%pgST<|{1`ZS3E~M{2&5w*
z2}MVwaX?y)?iG*#8j(go`3@wnko6Svw1wyd9w+cHA)$cE1=4ng<a1zt0o{Cnyt)S(
z?}3K9NaG<WtpV~<qy<uD$b12r&QPWk=zIz)CrEMz$T@(?WY3u}&np$ZKQX=a-GLwc
z4%VOlZNC4dhvUJ${ILUwsNGhtA^BbR<cod&9*)3OH|E#bINXTkN3VF6+XmqK{P+)l
z<F|+hUVrq#M?dt@<L7_<;nU~;&eJEyzpyzkUnLpt%T(ABI-7RC6eI5>Zb@2th1_(R
zm%Y<)?$eW~?r8+t8NXN?^r7wxl2}(<7y8|0f*&mhale7d!lsrM9{;Ua_Pg^adaSa1
z{;pUr*z7wOuWHxUXyX$=dg5G1NR-G_&qmrKLGK+<bM3|V@+wfVf~`_OKE<m<GZ0d~
z0@e)D-0XxkBxl<Gs|Ac=Q#g##&9wCV=P=FzFhDWDhuXS3@BXb1yUDl4kv<sYFzyRD
ztBJLG<0vc<fW-{l?eH%(jXOU2S|b2?u}<HS%6BWTKwF|bx&%=dt%f52(yd>q`2mD&
zZ?Nx$YtfEoKr8ZLzh`D}N{$e4MG@lXn1gG;?K)r=crN&3yS#xeDp@=dIX;UvG9Ws;
zXzQJ<xYveRw0cN3h(_9M7%Lam20*caPdX{`*^KSU2IX`D?yZ3J2zu*HtR6f-K0X2T
z6f!9o16UcP1BR54hQW$I4=7lfH^DGqwO)aBjcI;??L2`cW2Lr2QYlEOU>vs4{1P&a
z&|!q61JG~?84dtm+gYrHl4n3BB%Q!|fg~Gf*#c#@XyYOfC1i|Hx~IeN&KC5A?+`!u
zU-{tO-=sIb`0aH6owL{5wl`z+Ye;^2Ll?hGKEr!B0(<H|-Ml?{&6UA*&vn}Xd><d*
zdiH|;o8SJ!)%)*1`|?K*AOGUxr!W5XXGdqhes(&288aQSFmlcnx;G7L0TW|f*%UD6
zypz(lKydcZ0d@j$2s<P|-9rJ;#e}<<%6Ctto)p!G`q0wn|56&B_I~=>`S4RGJ(nG}
zdV{GM%lFdj_tAyJTn5y%0uU`#k1kE;{WWfXp3QKCvPqy~N|)l3e5pY=<WmbtG0k$o
z_#VX4UdI^y$x(_Z=-f^DM&=SEh!=iWPjj32V|q^^S0u&AKw@%KyX7A+5mGb&b-(Yw
zxJ3*zwaghJLh>oPH!$iEfX3+G#~aa|Jc6aZeL<LW;_4+$h<3P4{WqR`R|%BlWH)JN
zgzkt~DKHdqXTH`9sCN7Ua0}jH1|&HP-UE>x35Wy7Yz+D8k)Wyf5^ipPz41_exzIAk
z>dU_biG$i-!=)qQ#+RjNR-Hkh6mOtiKIqqz_A7{N$4Xc*znri+y1?qri1Doh(E1Jz
z-+l*pu)%hIVf%fAvn69-#xNv^CI}Kh12PjRDQGm5BCP?<1EdU?${AE<3@l(4P`Uu~
z29y|*7?MUHt)M(YX@H2y8@0^d{Mt33YEFhFE2JbqM=0Ha@?B_pbHnR*zsuw2{!d<i
z?jNQHU;QJx``}DDDMW5sO7{>1ub~Pq9Jc5t^|lu-zhX6y?@JSK-M_zW0KQL;|M8#v
z8UKUd`u)TAK78`UM~{wv^~uxc|HhN2FMs*`Z2mF|AFwbat4HRtGhhWOiZmpolx%{m
zX?gt=-kjIe-Mbb(|9j#zm+sX2h=Dt5flG!iO9Y@Ly~S;~i{$M+y>=$XYG<n*gj}0|
zo{+YL`h)1SNE?i+mwFQ3<@c-$=fAFz5TD$!L+BHM;{RvwU794xvh%R-oO|6pA|tcj
zRsEXj8H_*xA~Aqy1RzkLL@gkb7WzxtaI2+^Ml(r!nM~q>6l5|=5CKRcB?y8*kOK@b
zgGbLy&vbQF*E1gx?tbq*TAXtq?wR%M9<3_M!YVT&G9xp?!_PV2`5pm+0ASYt?Xj?e
zk7hql5`i!^aDJ%nWvxGf=&s%y9Pg<5{%4rpvF+cj0mwz(b1l-2tRcu|ZVWi5jet)3
zHGoH(0{y<uX*qYR1|YA(GmD&<%06D<bXtTb<=2OsB7f=3)|xNn*SIAMt{Z^X1OlWn
z)~HBPYF_q~)Sm#7mqTKWf!?kS0wLK^nNU$OG4B9@ChlbuE6K%FsA&8V>(ozN)dygP
zFc<X!5rf1PzCeCs5OYC0%5NXZ2!UM5{$<28-G2-3E#|{2AIwmH5zsdXVQNq@YLXTu
zSb`!8=F@=lFD~GE!ifXijcXWAt^>CN(m7)c&p|POC4m#b<lvn)03kO!&S6GG5(04#
z*Bzr1Mw}etp+^WKh;)(%M(w9MT}8kJB!&`7aw29@#4Eoa^gSn#z>w4<VE|}AqGL(^
z)&=O+C%~Qm1OCo$<M@N`^2v>JkxP=lm#ymGlz8{DCg8PYgIA&fixbmpr3QW_O~AVb
z;HPl;*WdpM{f~e4$<a?9J^%ROqo=?2+2;@c(<e{PfAw&f?@^>df{>(G_L(UqozR?v
zV?qcsLYUwjqwhP!5E_V{Uby9HWp&HjUIaC@ko_u=uR#zP>+HT|Vw^ylbi9gA5G})j
zO1?W9xVxNqu`n*8vJx;^oROz8(T=1E#%WmhizLGGv!#;u$0BARmx+6^#Mu_gv^4-J
zjS!hEbR;(bTKIL^Pe}IlIu|84L^z~c*h%Wt4Sjx(1V>E+&=h1(Qi^@YwfK7*NPTVw
z9O?hIu686=pVYj@HUXtca89o+a*$U8#TchS0kVBEQ&M=lakg7W2UCd?thUaw!cPf+
z69yL(>e@PHi)lzLa#aFbb@wTQDyeM-YIBh9)2kqg>Ou1TA=-qT8-qj^ct-^t0Q9z$
zvOF*I0xF@ftOkrj!0eQ-VJJa1dLp5Q;6@D}g^lGd%ix1dhRyN3IkRBVU`chLHEyV`
z671c~)Ff~l`7^0PAR#Ks#*BC#asFrz@&e}^j=CebZUcY)CWc!HQvlN8fH((GOaM6$
zd*wn1it0d^5W$c{h{2(!4SL6*VL-wKFrI1tfXsjswIt@K>4n*>h*{lC1>h8c6cLk!
z7Lf<>07pjvHVCpwlN|4bZhf!cee}<HbLXG&%{za=H*TE@y4N+vd1Vcy7qjyg$;7Wo
z61?<8S5l(Cd|=QU^9kNH0AKOtPd~X&|J!#z-TvhB#~*+8@X2rd@Uw^i@sp?Le`h>|
z_Ylx?0C_32C?)u0U+}`}uD<Fbu_3`xv)`tYphpWE(T2UhII3!ttSt8KSnVxk!P;vJ
zdeP(OVowz^FR`+%F;26L*MiMPK&z&ub$w6Ed;zJbLfy+tGbGX?9~`o@)Gd;{Y?PBS
zGhf#%g-M?*F4gw<DeC7U0g@(29E--DkV$_DPIO9VNnnZath;)Z<mm+CaudKPP`-Yh
zP3@~IJ1zR2wK?!ia4Z_!=18w(&4A-F-Lp#y#S-9H6agsf03-FW?e}e!P-<CjLab@X
zEPUm^*_t93yT+xihVe*A>uYoF+lf>^WrdSbS@O#h+=>o&sR5u;_)}^^7Gt4uC<2fh
z0Baaxvc@41EELaf*ZX3mrg>1ZToh`sBWqNWc~T^s>{<PCiJi(EawjIdP$*DNXw1F@
z<P=x0t`FJ>a87A#?Y6{@<czjRZB&{lY>KudBmMos`FBcc2E-ca>kQfBz(`}n{4C%M
z=b)HCNwB?p6K=P|@U;QSd7M9dgz@<Wk^r7NL~^!r5fCRZ#ll6A<jVUPV7SESh_qt`
zAw@!nBT|TZHnY42Ng5F4tqF)xn{0t0qs}9MF(yGEj?^8W(e~bV{r2wfxb2;P&Nn~&
z9^bfm4(F1*aTeYijm+{w<o@*~gM?KA*Gi?`x&g}NW?(@}{7NqG8i23x@(=&#Kcav7
z$A7*3(Pt08@x%KMe&e%;kN=a0kI#PPa1q|)K!Z=D<e!#wM%4v7Ppc&h{gMm~%iQwD
zM|Fu!r57BwYc9c>>Ux#GK#n|JyXCFc61ckgXp`ZpU2ZZ~ds^WUT<Km}YFDO2S$)5{
z5)iSl94qSCJcml*kA<~QFm`>;N{=SXvqnHlL!e|mPQiX&E9%IKc7^ku?eslmvYsLV
zY}2~4fl-<DO4jQd*xoyZ>77mZom({r&XQXl*9O240GErlQ^Pjm+yG?GnxX-%;w`TZ
zXaW6K6d=R;upt+eR|>X@;(ENTc>yJY7+g)GKurT^y7py4(bXr;CL~I7s$Ob0K+SDM
zAxR5_z&1A4BnV<6)O;NMIF<Wg_mMUYd5<nqP=sg%L@|DcLiVYw1WF^2;gsamG>5XI
z9x4LR%Jymk5Egp@l0s^2Nx&imN<|=G-*36}N+s1$yPMhGlxl5VU!#D8J@)8Xc^{kG
z48PrAd-o=i00-)Tiy0y6YwnCFnn>XX2BQ~JI+>8J3sO?m>YRX}mclVQ#OU?);A+t<
zQ6LeBlJgrJQWVT7B9Z_uAi52rJ37#C^E2Py{iAO8-oNzMKlp#>=7)bpH*cN8xmUsd
zuZGKC{0MmsC|}+{GWasS;Z?{0Ei;kjbsYd-Ya8*d0r-k8|M-Uw>Hq!1KifQecK)?b
zzj*xX_a8p_&HE3Z{k!{pyobmgB?2eYR;N@VY{d$r;Bul{8$Cgd&pFz3wsM<JR&oV!
zRd?^p9(L(r{vs$W)jmOFEl+Obe$r^vm+5x3fytz%I*nsNYm`FAEdfD=>}W7PD(O!V
z5-HNV%*K~&qLT@G6059EqBa3Zi+_rfG53Rwl38gG3%j166MuHea}ao{`+Ns61R&Y9
z+0EPT-LpdPJp;XmKHibu=NO&|oQu5`a&JU*=YY;>li-;O3hi7*qN!;B8icx8TUY6O
zj@*?B`*V%qrG~MYCHvfvJ_y<+a9IOno8ESXUspTr8fvNfxI9lSlJm;+F9qq6M2)S2
zA!3QtGa%A}0GE;$Rekw&f{)e^q)0mX=b~?oKn&I#1ValF*(yQvbV6Q1NS(~1SX{1H
zK0uZkGHYf%oJkF}5DP03rjJ8|+*MLwT?^ExVv$v9q6jEa<D!{|1uD|qR^}REKaPDD
z2A4l^JQEz;0gNXQ0K=Ud@Vf!K_wIn*fWyOQ7|%zD5PHYDZZZjLm+bh<r>&TPd4|j*
z;<#5iUx-N2Ax5VOg`^EKh*a?!EUUzl788J3fSDc8?-FlsJ@><%Px|A#f6(9f+W*?!
z{`fn5_v;Vic9>;BeEyR3xy$#xR#fm?q5-cYDbUJjbFsOlE1B7ERQ%sH0AJzddw=>#
zcXobp?~5l-f93N>Pk-~_)6-u&?B_cj4W1dG7(gP*#CC*e6KGi|$+Gw_8Sh++<RV}G
zvL_U^Aulb&zbO7vBWcTtw}IbDmM7%AnrP65lF`1J{_{@0#0W1|4H=!tjCffY7G;uC
z6J&%&cW<8gWzt78>Y2<AQT6qb$2-YaHP+GFl(CN#Op~u)&nA&`HVJzGUerH;#R|LV
zr0)&J?>O1sK3Nk0W8@oD?`wf~EEt?%=$h%@F`Q#~$7N6NoK#|;5%@9(fL*)4H<;g%
zLHMTa&$lyM6F_D9cTDQxV15AlI9lxZ1xX!R9cq!!OnEeWacD=B)dH<mv<Ba_3{Yv%
zE?RL;Ql$n;1HG>}03vx;pLrrqi*D43xZMPaNda{Oq)kFh0*Sh>*26<5P;CMTF$iJ=
z;ta&VdRr8PC<qY<_B~=Ege2O^=4QYUf|Q!~K)E^;=0S=`j#XaQ!Z2nwlw0Ad2%xKr
zQx=$6Ja$=_NzRR`{u#;EKG`>cqO|~a?uim{h!f^%#6*G<PuSkP0lv0F2Zw2jm=YmG
zl`o0_y(dsolAw!9d_^1~^Bxi|Ovir#Od}{dxY#3&f;3NvG1Nt4tR|NbLSheey||-Z
z+~#QNj;}rUC+~fyyZ-+FKAe2?FXY<SzAv}mJByn>zGkI<Q)u9FNXeTO>o!W@b)$mi
zb(o4Tbs?a2jKJ%847_UqzJkj?`0swVd;0Y3&a<ay-~PdmKKsoFkDmSN#YK4EN!Rz>
zk)(hW1c<2`c;smpX+^%PoA-4z#3I6X_2MtdezY(nC%WSM=N)dVqi@#)tvOKZ61Z?7
zY%O$?9rvl~^GPaMuOS^~LLN0qc4!)#c7l=CAP5PZJ@1R3z8U8jjE@*}vNt`xloh~S
z4R+FOT6-<}j*=SX6c}G)fSu?Y#MvG{Yx1@DOM&veOXxk&u}=DVitjwZdqV)cgXe_K
z3wkH;PT+h-0CI7c(ggTS+OuKNTky+@jBa~<o5HNvmwkRV{bAevI=06pGne7I|1Z;M
zHJ^dY9`?-?pPN7`?!0B{FOoP~Ay4_p$&aI}5m0LR03vAFaV@>0B~ByiB;3A@#EMiY
z{vwJH7?v+q@FfW(>J*xy75_kxKuAGRf-u91zaR!e2-XZ3haf~<8Dx|oiXa+Mfkb%%
z!l^by%z8wL84i_3K=&@xGy+I93OF~(m-!Qwge$q|bLLP~<E$F%ONFG!)(8obtwjQ6
z_Y4Ol9FH@0yAj>y7}vk{0e06%oIiMs`RoD`^=0kgtgovO3MG}zf|4Rs&LajOOacUk
zlivJI%(ub(7?Lo+J^JI5<c>B0+s&zLwm(Y4$sgnR*6-1+kN*|j`Njj;-8!J_Qme3+
zSNP|@Uh#d)fZ!{hcR>=Q*P75@=gHS$L2@aUcpWZCSMeC>T?6n{UjETP`F;QSG~Idd
z;PZdy$M+xpM~@$!{@TU){1E~+lt>e;Lb6?*5&s&fyNwI2NETlaUt!bF0s&Y$0$yb>
zMQ#3jOSxL4^sSiN3$vYO2wD3Aw6S)r3thW1kY)4H+T)f9zCEGmM`c*G+2`jSexBGR
zL;fj%;%wK5l$!zL2GqTO07)!+dq>Hb^|FxSWw~9Kr+L^8-*);Pi(Va}b3o^T-e7v~
zZI7QPd{6LR|L+{5<Alx`G0y|eYhibsw7_$10@$Sj^*d)1ehcw8`+a9HGi5k`G1Zez
z>e>XTtgQ**VJyOVbdihVKvz=tN>NWWpl21~+cpciXywL0N|W%C5v%=Xl8tkCacq{O
zP}ByOa#}K)!k-a?WLiOM3i9FO5_I}cq$`559?-`i0&y0ESyu##2EdvC4b6)Ym}fx<
ziU>^hm=MLDR+T;yQ#B3}wsn+!oI5(0kq~i_Br4Hx(FZl4pLrmZ<|>CbQNy7yM9@H&
z)J7bXTn~%qO%6#C=EpPk^HYRF1l>;9T?hKj4#TDgeQ*!q`5x)n8RB6CqORJKhz3%L
z8fSq7!aB_-2P94qXOccLj|Hfgg7ZC`-w1b`K;5wC&E_F*kA8yf?)zzT{GG75{^#+=
zhkpRZKsmpWzW#HM=HVz3D&bh(peVoje&EYB1Xpsf=<=xk8chJ<HQfJRVKOW)KnmV9
z0AJ?vU;ozcyXWXn9zA{X^N$}t{|_EMeERnf`}hqPdCLjFtgLc1a?v+>%DL`l9jcb0
zdUC2Rd<_)1Aor~%@GC(mxqROxqFy8A!&;NN`uZj?hZn`a5|rB1Ia-tT8mVCQ(N87H
z*yz<w17HNJ1-mQz<?945R^U@o10I#;P2d=8?;ndrufqBQmu-6yjhrWyyk}EB<>GI*
z^$hezywjb&O7A+SxA&fO@^=b}dM8@^yE?&Zk*^IwXWzp)fW7Yh*@?;ba^V-SlTz^Y
zHnQ7LV0$hNfld8IuGUx}TQh*X1~8jHYNUTye2q<#h07*2pr`y_vjg(iwrck!F)$bZ
zdIZT!QOcz}aA~mH_MTj<aUqt<mz5|<sy=?<B%P;zfTN%ZS~Q`Eq6Cy+<TYChgvuRA
zLA3bKq?7HeD}y-_Ci^@D*xEo>2+@!%N#@w6v5GZjiP+WznrWc1ibe)BBcjX|DD0gq
z`^)2Ij)=}=zpSE2R8=!Xs=YS@g>1~2kqQ8yy&?f)+~ag|h-Wjl#}_!db{+oc7~S<F
zM8}veMx^}(!kiET12am%mWD8S1O^flQWx}zItF74hyzn6j=ebF1wV8bt{<LpxA`pk
z;ZM@$_&aoR>rdUCkN%3TzyFMnt_5*UD8-dc^jBH@-*zy64PHRKL*9}f@X8<LitqX&
zO5<V@eAfWH<>kNqXTL+AT*U3^JbvThqvyZ==+W74JhA3DlK=o907*naRDX8(w<yq2
z2Ty{i`@kgdUg5u(l9GMdoXBFe@}(6ukJdJ#ExBr4+?xsQisjIYj~%K>b+Y0hTzYP-
z^z|ie4$UrKr9H(TAaek+(_0gkBkKl0>S`cs@s)|6jdx}wnQf0BkYa$u87a*`3~&+}
zSRYlxuD)ejbc@M|ne13TozD_Iu8e)p+5mL9s9WLh9O<<034<r}oqpWep1$)i*gqF}
zo#?$6TNfB)Z=}9;Vb5y-8wyM2yTYkboN1{=0$k%Fn|J!naY1>SH=h9EX1DL!BCkzQ
zYQGP;D?+2{N-D<#R~|<@%rBUQpw~X}(aO?#*{aqinVRjD74+;9Sfr`hEXPQ)qLaTK
zW>f<cldcZR>OAV>Vpvj1v?<8+5mLUu4D+Q2=2_wHc?RYHZ3=>}5mHJy5=glNF;n96
zIxC|yt~AfYwhCz|5z=@wC)?O)O;4rxmlZ-AkL;)tD6RiuYo-_kmn?-e1juQ^>G^Yv
z#}}AyjYwlaw>?9*J%ZnDu-SD8=Rg`6GJC|4k;V=Zr$VSrNsv-Nit57XiO{oyX9q`K
zn0<tEdpP%4eD`Vco9|;d{zL3;d}lts^W!vJKbLNk*nC6e4UV9<Ev{EmE#AD(AbIKT
z{!&!%S8}=P%>SwfziR;A^76R5xp_XHesurI^MC(~C(r-GCr>VZUS>L?AWSMUF8cmt
z#V*8XA3N*)c>$v@k3?f!mvE7Ut8DyeRe;OMR+>|3;|548!yjo923vWStd_3DO>EIH
zRE-KPeny*iq-`*&(m~q&y;LWcmc_4AeFRCK@YN$+GI7uL`E1a>M}$YT!ftSPNubXL
zIx5AZWD>q?vO`+%b${>BdDdd?0y-CMvL`L{j<hl8fWh13@3pY68vu57qW6A9=40Le
zlOwRBTF}e%pNlquy?zgB?CHU>u&OtaeZwqo;eD$iWKq7XE2squ(9%wd)Polx017hI
zVlTP46wBQf1TZt3Ht@+{?j<rsmsUtQH>J@BG?lMiRW%86B1HjE-U}_VB$-@FwZI!n
z(8>#SGM3Eh1844ltp&u80n2kjoCs-F9>Hu4!93}8nt^GAH3RB7kP;A*dQ2uj39FO?
ztc{m}8Yf(S1><W-b5%bF*0+x-iL!_w3BcltxLmCGqnHO8Hz29&V<Lj54wNF&q^qgE
z?|`#}ecWT(&lpZRbjLmV;|(?^J9M|V=xC$drjURs0&}eP*MR<U*`Oy$VBM!cLg1JZ
zBw-`qn~9i&JEp#y630G_Pj98e_><IMd+bkk=iPQQK{_cmmp{F_`Bi<*!UFh;ojrbv
zhCeTJL|AO>-ZcPkarrO*_4oacKYe!V@%iBwKmGCjzyIjT=`S9}c$1=IPP%u_NPmJh
z08#V=&El3X1(t~swN|ej`w9_nNy1yWSIg!7{#6|zt+MUcS@+U#21Him!16U|LBDAy
z{ML4Nx$DmeKrHEbQsjGSLFiLbUqA|z75^ECQ`P57G&@?`<y!-wa6PNsGAH&SGx~L}
z?^xw~9cw}NO!hIu+pgX_p!bZ<i(T!pjtmtb^qsB%e4g^17JqNBKeHBXXWRfbR==JP
z>!i=62@uotQz__0LhdqrZ<Bd0{C1lbd1;7zwfJWuADC2^o?(1OwWMv5oQX0a%~?UB
zWwIYpc?`<Vy0!VI2F+?3flCcQdsL-Wc7#+HycO+a>5bn;C8H)iHs-nIu{krRAq|Sq
zvH^%@_G3(ZP8AW*27n+zfI#I?&HU2d4%0A`HUXnx9D&Iif-osja1Ov6#bkxqbHJL8
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
JsZ=r#{Xc~Q;>7>}

literal 0
HcmV?d00001

diff --git a/assets/hutbot_large_bg.png b/assets/hutbot_large_bg.png
new file mode 100644
index 0000000000000000000000000000000000000000..70e3cc2fc1f60c5797f24589bfd461d50e3b7c96
GIT binary patch
literal 186414
zcmeFXWl&s8*DyM`ySr<U!3TGjpuvJW!7cdU9-QF8JwPB3g1aTShXfDq?#vx>&SQ1I
zs#|Z>``us9OzqmeyH~GX-m4{AT}>VXl@t{K0AMI8$Y=rpu+Snb0QvdlM=D(neN9;D
zDOxKkvI3ByA5cgbcmNEv^b85}Z)I2*H~<{9Is*FOLd(xE&krdK!k>2>v`qGQITc!F
z{u}1G4;Kt900a8Yfj->OGCuTO34QD${~D_UT7Lc^|M?3*M}CI*$6H=eRh^ofgA2&P
z1A_Jka`Ost0fo4Dsk!)s_;`hQxS`|2<o}DJXH0(LwyaS4!tA7_)fJ_ssa@Qht?eAF
z008ftfFx0cUJ3Gk6D?VmYD_O|*CF-XgF;z~Hv}>2G&88xLK&~`5L8K%35n#p8&_8c
z&1bv&^>vYSC9xj>u3j#h9!a>6bbNz8Z<k*QZ?7re9s>&W&9Y|kka*jzOH)v|vJDCD
zjd8jFQc-4d*6+EP6j{9EYyEC+e2F&om$#qDY51JEx|nbWGtK6r1ft3W-XLxVtOH*R
zvz`i`hA9%!2mWqZKO@^N?1ddi&(6FMam~<U^QxQb|7dC7$F&|+xtq#qY4l3a*>#T9
zbFPC4YzC~YWpmHnVouiU!=;Z>SC=Otn87a5Vd|I4y27J;!WraDQl`-*i6ciVmkK?&
z>4vPnZF*&9Kc$Mw7_?0E^NASl&MWv;@0ZR5$5v0+o4nu`?HjfH!9QM3kx{U_!J|9D
z5zSMm{($3n8??qG&2J@tHjR&pu=*I+!GeUo1RKoP)O01LMiqqanbrb>i5YxKYgOyl
z*4o+H1Rig=zlT9ka$75+BMJflu*B@N^*r=cRfH^@9XZS_oz1N{yd7Ph6$TIy_jWO}
zcw^;3ZEj^_=Ojvd+}cS?ZD%P;tIMYfRCSTIvb9t2b+gj)RnxZcePbbLNh>afD&j2!
zMc`=VVMguk=-}io<Sk132d@yc{9MgROZ^AL<Bce-9@LJco!zXcc{zAFfb6o~c3#}H
zVyM(2ZkE<Unlf^Kqkw*i(%O1>xCn7_zJ2?a<1G(|vzrYkm!O~^Cy<+yo0}a9!S3$k
z<YDH`?&MDQjN&gGGFI*uZgwsncFs=J&p6G@ojpB7X=$PD)c>H*(M47DpXi<3|CRz&
z9-Q80E}UE(Ku$+T&VTRW?jh?1Me;X6|HmHg+CDB;oSIhd&Yo@-R<d4JP9Ajsj>6L7
zpZ#4t-5ma~V`;%@<zVFq1$Bpx%Jm;ZK6~6hdpwK4#?H~@PcNvj{{zy)&iY@%`VZQk
zTmG=~?}R|R{}b<jK>vgHKfq8ZRaGGwXA93~@)Tu6X`jazvUIkvvlRMMwBWbovNpHo
zW;X{~fY^C?c+J_(1i3BPt+>p21k5e@tp)jb{tcC)le>qRlZDkYDkyReJ18C=GeItX
z0RcgFOK2x{US10*3TrD%c5@ypK5LLUKQGA2^50OrbhCq6rJ2LOQ}v9>5{k-_j~i%d
zZDGa^;^Mc0Qp3;1Zf3y`V&}IsGq<oZ;}hUF<Nkxn(n3hi+0D@ms!lscGaD;T7blxP
z4bK7>l2lg|rRC-T{;Nja!OX)N+Ch|7#m>po`(F*(c8*qB9%j$d<PzWp33BlQ1^D>5
z1qHYS{{{5Q%FP{WiO)Fy#Lho0&uS5ZG6NN?*|VKO5&Wr#@**VdW@YB#?56GP>>x_}
z&#3#)W>u&=S(<s6$(VUqL6QD54r~7-4!;0$3jzNk{~4XCv!$K2&;J+nv-41kK;fY(
zSFm%3j_>oQ>MxJdvU2_F>#t7-yFac(P5s9ygv>1dV!_?a>u+U2asAa~VQc1OV+D;K
zf1B$+>h1myrohW>$!h`P;b-Rp0R^G@GlS|+5Xi$WXwGd86a@0|gSh$sNa3H@-JPvH
z-kP~tN!mc=2$dDoJpas4)XaYr#qyufZ*8rfwEz_uI~S0hi&q;cD8$Dn1O)vpFwXz`
zELvDu^8)#J`PePYd4cS_Aafpe5D(Put*oKnygWc|K3?AcB>I1WML{7h{{J6Yv=*@9
z0`d#8Tl4S=u=DZ>@UaVWLA7XQZpFtX2(sh_g8nk~|1B;4ZT5Ws$)X77bL9Vr-HLGj
zzbyMNfPb4RpxXbd4mt%vXEe@#PHBIe1(e?Zo4>z3>i^~t)YShS<bNdJ|BCCs;`$#+
z;C}@CU+em>xc)~H_#XlP*Sh}K#D)5=MX{9=G?#q~UGkDTGBiV%%P1}i`tAS#8s75*
z1IWrDhE^hZD5}aL?Vw^}@Y8i-aYh3G)Br^pNp0`NgZAC5jiEXQ+reKjPB=+PnI$dB
zz6Jq)9X>J8|BO%0?%|i3;ujT!IyE?wxGuuyy-P4i$Q*T+Iu)o-X_}ezUde+a@tG98
zkbB6(3U{r~=>DL7SJAb4+X;)yZ-%p-0+$2r4T{@T`H=5NQN6mrfY!&2Z}S7u`+FwJ
zMB`|AGdEU6rZ>qyHm}tveM}FUyk~lgMV<V_A@tjPwRu>-#BnY-MK&e{SVFY!-ON`g
zzoPNDkd9)V9--g8>@aNeevl-XkD#fHuYu`3{QkDJiP4x15>529crx^u%=v^ddn+$g
z>+{$$2~jNP^|^9y5(&BIjCkTaZ7v=KMzOkdTj&G~Z=?H9a_*ADjJz=xCrddE$3849
zawA=iQKpTy*_d2KE^+o-9|}+T;3a-^4YyN^2Pbm4k#NH=6V|W|;3&ngu!B?MmO8cP
z<UxPHHEI3<c*cXa0tug_B0At6z{fnf4f^E`f0y?)T|x5&;t)#TPjR{V4b%JR`@R#Q
zq}#lB!USEu;`#4%?hh(cuD~|B<RHdr4Kchk9658#l(7i?bR0=_5mpQ!S<th5rEjS=
z4!(NVhK8<sD5#hEk8ei4{E3)4^MK4286@~A)_2Xw!X=#KS_8nXPw&iAJn&*)LNNDE
zVHtLU%O5Vmb5=O}Tk6M-gCcOVt?Aewu0`*}#~ugM*E@XH!?`zwUHmvhnz?;J6pE?A
zNDZL-VfnC0LHx4n^;KLC+6lqi=-)#Uu0P!6o{rlXytlHdg0}c-!I%ONmYngF-KSXR
z;_G|i9{54pkiqUBn=C6Zw_#dM>Mp$f{3%SVip3mJg6m3HVp*rwq4a&co0<`@s9e@$
za7lx+(Sf^se|Th)fN;8zq!)nU*SU*?lOktgi9g8vA}c^}cZ>PZLwB4mU(mT>-_U14
zVuQeFh_Brjp&*)RxD||{9#<vxa^fho{hLiy`eKl+h&3D#s(*vkCp)50<%EfXa~3s3
z`JjU!n*>Q1{OPaauws<p^hhES6WEuL_)OnUl2q}}(+W)$@R{8^;fhkmGL6ZDZh$?+
zR%n=t8N<}QpiGj8ko1M14HSUbvcZTTR3q3BynG1D({`-UNQn$j8OJWr;v-H-!U=n%
z07$l#X^+xv#9QJ_pJRt7qhqB<0X=ITao%MLLmbCIRfJIFaQe4J=K$xaXeM2d&tuj^
z=fzN<P&%Z4f{N2M5l<eZ`9VD5ASthEI!+5|dwLBSH!XF1EF^;Un?P{IPkEHH5Iam;
z6}-CEGi`{0x)~fI+q5d^{9{C(^Krt<KA1NAM?oDsgT<h29r#g1Q)74Xlk=b_s0TbM
z`sCyZI`X~zaI%p0vR*}mGG2m4OUy6fyA>^w#RC<cwFq)#1Rz?QHM>Wl5JXfsp)PfK
z#7-d^!nNYog4oa|l^gV6TvI60W6A8L=XZxr_QyK&Aupqzq$fa#^&2Vc>+VJ!F!FQe
zJ$zILgQ0ClGb@p`lIGwp24!KjiV<aHB_{mLy$2_?h;%zll_UkPpdU;yEpc#&(d)SN
zSj<mHJ#uDq!`_9EkK5c6P{X&e3pFNueEEKMqahn|^LnU)?Nr;l3-309ZX)l?e1-An
zZl6;9tY7_n^<qQ7Q5Xmw%`2LKd!1iydbOGAAKGcvhtJ93cIfi_oL=Bf!6#}_!Hxyp
z4<U-sA!np?ooCI9yGpn-`rR^2n5b>N5d5{N2hkeAEusfoO5DAmoVJKVK~#)YGu;8%
zx$f0OmLdo(5DR&4PITqz_D!chVxrTQ$@8a=;B>WFpKX_UK|1>=jG~^lC++tbRDMSe
zit20TGYyo&MJnNjuD^%7{NN!JUz8xd$YN}qYB3$114m;%l2&Re#Eq(iw9|Z3@0I_F
zxinNbYbFfzdM-sx#4rx{9%X%Ea(s#qX%sbqHssl`NglzP6JSIN@I|goK4j)ij?@+0
z)m9>!6q1+Q(0GnZ?{~|A`~`4%I$UODG#hKIw>R3r@_+|B;?B#tYe4aO2}k_oE|UYT
zzIwxbU&4Cr7Ftt^k+<kQFFzv5Z^8B-C#`RzNis0H+O{r>io}hnsaz^NTf<`WR(;fV
zc(jlwU0Vd+h7-sS&UAYg13gCQ(G!*_-oudw`V%b@oZu(BvmvZbg-<S+Sl}4sJ3Nto
z;$s#)g0UZbhibH26kryv|H8c=UvTHf3hQWFNdXD#BxyKE5b4=pbJmmdU>~W#N%CDg
z3&ut!dRP-A%v=PG%$Vlk#%s-n($WA^?ll*+FwFk6BD|yl;7hd3sXWTpS2)(4KtysL
z{-vrM+^!6fC1v?`cX(iJCghf>)tX$nYEj*13-&^s4%YQ9HL~ylRJ!xN=99%T(hS&#
zI3Ms3FD!)>!*IG(MiF6;F?d1K($-&agC&c<vzLG$K(O1_j>lYzY&*!dTO27?o<Z^I
z7@u{5d{B5$S#}&O4%!Al<6s^c<h&#R+~1!lnikQ%$}4|mzE+%2#iKzQI+ZT&8=9De
zqReO^flZ)ji%vS{LOqYyO-hTOq0S6gxCUI$=GCD&P?KqBZzepPs}M>`Q0QyKpd(Fs
z>^aw^SL2Vtji+4xKs@2P2~_0w<_DZ-EkW}5?o2#hFtt75y@qVI_oc{2f)>mbEKFCE
zzuR_j09ENO%fTY<*s2n5Np{)-@vo>Q#cUakLUqzl4-tD(FO+rJ7t<e2spB2nxtQ1C
zyxxLxC)v-x5WSHg5A1t6;Vb+G?ynf?e)BXg4=MYhmXl5A)n&qzPZftdQBWxpeU@@?
zt<GqxjzpJ2E6d=TAf`ghiiv|S?Cm?^+EuO#AkHf{wTLLmK~e~uEFY|pZbu%T)<GME
zddk-2bkI{e=Bu#^HCUqA*J^k3z4txd8(&ozTdG`$VH7k{cw)pcXLyl*z`sB8nWyY}
zqC)5lb71BEE_0RbiP7%!n;wf^3d=I;t`82e|0$9m(0;m88NZ+(PYxbZ7%Q;Ii>P)_
zHwgJY@N(?Wa6DT@ls_X&wgVn`Fz;<!THa$`3^#PIW!IcbNB43+oPk9vF@YT$M)98{
zP!@g=*$uqj&6llm#@|^2TcVjyQRIK`hJ_7IqjQb1pOnOGR=)I-aHb;zo~ClE_GMTw
zV?>0=<ztr-$5&ISKP2P<MM&Utj@15gpwHKjm#3E^n~1)vRvTRWaPk5hz<J>azZl!h
zj?spMN^*WA^dC8=o1P2;p{)5iKFk<^7??KxPwW82@JwV}$ArLC45Z8aAsV$LazY%?
zl;+fe_l=5P+#PF4Y3ud9A&FuSgR(E+k&_qpNss(F7(Zr-98pm{=Dm&vd!?XFg4ZwU
zb`l0v*vBXI<KL4j^U)KAlQ@x}F}PwQnHG*_glD)P_gnb#as@2|Ja%C<)GEBK-x|Bq
zW(MG9v&HH2Di7c$!Ia3%cYwBRQ8T#w&Ka7)fSsikpCnGOf2jQLWShSt($Nm&Ycqgo
zJ5ad(t}my5SQ<tiD=@>3+FkM?=+&N*Cw2I$m{88<4*uz(b_0tb&BUYx0v5asO|$<(
zVVQDDgc=y<w?YbR=q*fU0xR)t%~M$vVhnsJK1}ySkxhE<(7Zj;E0~1xQ*qfH@ma(X
z=%jXj=Xy9%#47f(@-FA?1C~7p*T?VTJ-4QJCS^RsC8Vz<tI=cm@P1;lhmj}Nb+pl8
zItTyocIivBycQ<~c$MTVet%>NK|m)&g1hDc3%h=((Uq9kSH<tfh@6zT2Bm!YtbxkS
zvWwnt38$~d=zTZ8dn)B@(H;F9s(xHU){h{u+WyA*TM<0rqA7(U+Z<cvc57d|D~A#(
zn~T?ja(_ssf03QM7Vek4v??49oX~_23Q@HO9jr~5s=f;5XI7pnY|J3{DtYJDX+$#q
zX}{`Y5GxyeB!bpshnHJhdYor)e9d&|z)+E7S9cI8$<|-~C@Ks9Q{GX%&+a6@Ga-*6
zpB`QV49XKFDqNiHm6475HXsPyMw*k0w6x@&Q6q$6brH0i)VX!GsY+-MFOU6xp&lG9
z5#kA-hI}3+kIw7U67ViOVSMb#Yy{0SIymE4H2<lrJ2xQE`zD8K3ERa>m7@BAaU3e_
z&-dVp?+Hwv7RFNdtC_0JWzvx;krdw;zr%R;Y7qfj?z*)V(AR?kzt?ymS(Q0rqJc0u
zUeBkJ4U@++F<Y-tp_W_kQJKpPlcLYj+<on4o8#WByV#AXn7WMhyewmzLfU23?$dO%
zO<1ZJ_?({2;fpXeAmXu*mopTQ+`V&A_?MMYb)QR6tvKH6Wkzn~w!_(qIcSPT%xo7w
zFm0cFh!#<wvA}G9GFum5O45pHv@x0j)YhM}%A$~u0ZjERSW$sQnXu~NTH6F^x@CL0
zU9$I*$<_^BrHx-OR84`17J@qYWP~|>-Gy{mrZRU-Hey#W`8mXNxeFd*rW$23jNp}s
z@ygFsw2?f)o8`rQ-@(JrRQVXiJiX)+NqDg%h%j9i|B(pIe;wA#HdQFTpN+1h`9t*a
ztPqSKF1EVNG>&ikrju6@CMOC~GWu|}+G7Vcpu@{)tx89ymMHeJ(17!?@Jt86R)8#-
zaIthr{NNg^b<3>j@nYiF@uCr)m*j{oEh~Nf9j|%1{sSG3X3eT4o7Fpubs{O!?>?}(
z?cdU*WE(YE9A~UB<#=(_3Lo?@z->Mm&<t~Qp9xLXB@>;ABW<fQ|KmCFT^<|xUhbWS
zLh!FbPd$BJW=dJf??hw%HG6&P0cJql`X&xUn4DKtzCP`*mp=;B>Rwv!>ULDN*XEq3
z`PRDFMJXq{e=)W0UStgW;^<ZIgMakV>3Y}f-mLY}yR-dgM0<2UP?|0jPYc5`-JE~d
z8@&HbqS`wSVTwn$g4D0ol)Ne>=0Z*?o)=!l3q9wNQDh4Jk5Bt1-$T~>@F_cEKg8lv
z#y+Lgst&QeZ4iuLxRu`hK$!ttjgR4VbT&XFkPMxoVD{gv(rIkduW_E=|2cbS-RRSJ
zR;AP)!^lMyg%=V>drv5gOpd<}PrxE&W!m~CyLG9z>~ZP7wUz4VNL=JV%<-qu8}<~v
z21}QhtRGk#;OFX=J8dNuG{sBov1L@g{b+~#R<7-v(EzjE`HC}>`2#d3vi=HDOcyJS
zZt_>A;+fx+x|pvI1h?r|q?r_ciBpmOL7WrmdAU7s5>!Mj4J1X|V6C2;J)1qdJG{GU
zn%~d1YOHKP)TU<d$F<dx&50rnm;0Q^mHFeTT&vdjjpyZ=y=Sbh$%>f&V&L7{(Z+S&
z(aO@H*x_O%BX6~yWVd`A;bD~*?>w@s)g+ridQXUk=(wF|o-JI<w-9s9)7_=muyc3z
zZU?~DrE;l$2lXA?cyq?<Px113INQjDpQnGmoD@Uy*{Iu;h@K}GzNfqEzzZDG(k~3&
zeUeGXpo|I~SdePJOEYZOUw+uy+Y-pG(yg-Jok1fnPx?}jiNKRgAJRx;2?q<KjUT;Q
zCSi(?5-dmD_9{@vq*ixdpw<}T)b!|bz1E6#{PcA66nTFY$l2}7&+sE?Va7@kzK2?I
zJ;aq>g_L{b*C&-iGWbM9yw_U?7D}WEIUmrx>NqZ-ghNxQg*|fCg}f!(k(`{b0FkXT
zOqumk<p?>xtR-=38+63TO^J*lDiunaBtgu;-Spb`0+9NSz}DqoHSe<**$G(XzMvOa
zQNN4w6fGv+eZ5J9hHP#^h=5OHXN_xXO?ZW^JvO_iP0fouJA9@@6g#^9jnjl(%>Vjy
zS|IPsG1a0YT&xm4K6e#7jjngSGe2l#vp(_G5^G<S)Wj6dxP!^`Iscj;@3#~|eWZ##
zo*op_HM&!{p!!Ll6mm%N0U4oM`wBj;tXEolruD9JxlO<Q&i8yzAbWPSu#$p86&6FX
zn9mMQC8s>Hmb|SCW#+!JhPBiQHYzB>v^W#N0GX!Y6M!paB8+;9Rn-i&MQOg4wX;qC
zW7X#6`i4N>Q3s?A($K{C+sXWQT+;+{ct+}m6=I^8x)ZU-UPt2BG7+JmzcLTmPY)==
z%V_bT7JN@OTX)7l!YyPp@kNIoQ@~D1F&7Xqym)K%rf6QCkai!gWSZqy4|~o2er>G@
z#LNBMy7BdFxtTfpXk0L9z6^q{Pt(b4OXaH$;~q{KqmK_|eM0ICulJCZTO9C-vyEEY
ze~S9sUtgOG%es8hi>Y<FoVu^&|Gw|*`Psj-LOkGncWp^}fq%ElwLxP1++D;WAOB+9
zLw&_&P!lQ3hM4U2$T8LWy~VfS=akcgh~T`>Y1yV+=)0ui$c8^y5N34x7?UBZETTn)
z@f{OhKf~QV%sZ_;+xV*;-qo04rrkx}>!U&t)ecchVC&c0!>!Tz?9sy(1K)CDX=NUm
zH5N6`waUg?{u+bc+8_q?SP)l9OpBgBRe_0?fNo1YwS#(f<=r=v_Vp*Ng^m^RHs`F?
z_kKvOCu-$sCc3eeSFt+n{*Atn^y{}Pf%ZpUjEoJx#tD9o6sI%4+mvAbl+LYj<Rb#|
zga3J6>^A;qA4vA@RCzHYc7lq?g^%tU9QH(~4O+quQnry(<B=6Q`z4?4`jO<FnEC32
zoXo|stmL_w(dL}<-p`flnw7clFK!m|<!s+f#gut>7aBO^n7nD6w8t=to}q1wBDw+T
zvgu(*r{itPxx-V#!>OYfm|`*2<5%Z$?0emtU7xtNw(EXr)OGey*InDwIoz+3JzVB|
zjO+|p=;&<fLZ4AgFLZ|A7w!bUx6aNwLCAMj=#W7`Mxu*FDydH~sfbnSdk!COTp{4(
znDN*NNJ#0g6ahc}O~3coo#>D9_gBUbpJ?)b$I7iq#={}b7P1=b?tN*wRSh`*V!Wbl
zz@uP68(br+`f;r$XGJ@fY+JXm@vBmCp?3k1YoZb$CaD1XLugd#)!M>Of~sUqhJ+s7
zWzN@)gy7IUjsvmdpRHe(=Enp9iJO{Lwez0U%lqQCKNGO#^aRtWUnqXUBaQiuCDcDE
z&wb{0`h^$?`+1p1@@PW-n794(GGClh`iVRrqHS<P|JEb1tba|<i{#33`0FfS5G^HQ
z5lhkRvqY^XI>#W(#+|NI<MPg>^TRAz=dT?%BLRmH_^HMd59MtW-AgjvcFm>&ZCX}I
znY49gR1F-}3Pew77D^AtAzIhubUZd{W9+bMQ<~Wpuck}urcTHpRKN!J&1n&G#G;;c
z2HH-$3K3VLzt`Fut2b?I+RK*4@xJrtGu@#DOmK@r*X|-_^GGP68;EPe&6|HLCP4<m
zbpFIN32~Tv8}lGI_OM!hEDkz|Hq^+8;Y$4Jd=EDFmy7!aW<eatpH_9J%$}dUBdo%x
z{DzjQ4c9k6W>nDPDfV<7Q=fk;c9})+3;vsSo?WCXVYo^(@+i163eVdNSP>04o#k#j
zvpnCOZgu`?-CEfm`DqEoDj*zu+shs{_vMT8C^MYi5!wS1e|{vSkUjqeb_^SK;Rj|W
zy?n)YJLz9wKEq_pA3Sve@31`aDHEQweyUvFeW)T46_o-Eu8=n8M~)=mYmp7kN5D<I
zoRn||#smS3_g{1d9=>|B{ib#qK?ztgx9s?9J#DTwUw49_f$&vf4O!hR2{|T51sS7A
z&J=A@X@b;vCbbey2(8kT4`<7-*SCk;Z&kg^-_Ur;>=U-UYI}O*4ts%ic=afq@H_G~
z1i9N!F&eHxjlx(1T>gSh2==!$Ms)fu$*6rkG){jf{a|+io+%hRdtSzVcD4)N&?*!i
z^x}*SMubn=3Q<QN2%FuvKW{PqsL#HdqiM=0Q|+`-MW)*s(n<J{IZeaw@@rrYYD{vr
zTh8y3$r4F(1wIk|doAoiWI)`pkcNr#t1kPu*Gpe+)rF%b7THDSYA<F3XOFTb8t%va
z5Ql@KBog;!N`~+f+-b=>cyZhPaxStNlUi&7i~b~!k9|7{EIw2?f?`YuGANT;lbshA
zo}lk<6MHD=!?2cx791vE8I4*%1n@o|ouIb59k9`^wH;?(xHqr!_)VvF%^5-W_tZ`X
zss`UiO`SFY14}OGeCO6SFk^{F>3lt0GcI2PMXfm5UdxdXyZQbk-yt`dH0%|7WtHLl
zfo^MLfUQ)kBThxhjHP;9FbT~~H}*ymZ@d?+c&PcfQ^aNvT})*ed7#-}djT2v)2>k+
zKphw3>qF*{4bWX)B5MzV#}DF;&*R3guE>XBig6CP7Z5jYO=x56H|Lt_ePkuHbIVC3
zv^@h3iJDGoWt_s4>uKA&qRSbKs1kF}Fq2%`a^Ry`{7?$GtmDEZ#%GiTET%#f=r99k
zU%TGlLOt73-|y%;QN7mNv+91O`s&*6jjdxMZdpRjnyDE{BeDv`szMz^f?kbsn$62{
z1L{os>2YJ?SCg2N5T6-H#k^}6Na*lB&w+@z0OBH#ZzbQQcLxS-zo@5)(Oi>nK?Epb
z!0hX`w4qk2Zl;e3;_yl2$OnY)8CcSN;hs}5$BO@9M5M$aY*p;cXqQ%Sq8?_z{w*xo
z0jEEV)dLoZsh}N+u*JLN7ssOGJ+{~V%SLzVT$}cuyGFzI>g>qUTjCZUb8_@s3Q33r
zcPsM&Nsm81(r5)nJSqgseGIA8eB!sae&t^|MQm0=>?Gs|e`%L%PAq$T0hnv*5&Lnl
z(wVOAsjd`4{OH~cHV=y#lE`-<;IFl+bAr9D^2OMOH3h8pRm%wU5ICA?YVoOI6s4lT
z({~FjOc)MKs#7mj>_=c06$Qb+XM@k@BZ+I|FrEi~p73{~zE?8TIOR)!^SZtIIxp*r
z=2P9#t=!O&Ecq01P!F?N21y2XK(7S+x=0ijBaVpK^G5QyZ}ZTa%;@;^%P>6nG2XlF
z=+KP9P)y7yo{@2y+2W<6%-cztpFCehE{ZJH{ZKty+Isd_wJ)W~uJ))a;gQuTmZU!6
za<C}J*qlZBRfk(9xc!tQU7z*)L2@nFokU|N>v2p1&u9*dC$*D<ch1Xsr1Yj@&T&Ct
z^vcg$C_`ut?MK@gR@3a2^k?U*aHM5|pe^$WZ3r)_{6blUPT#jWU;xd;*Tx&>Cn^v4
zm!H*hpb2~6yWivAc>!1whvety4Njbyv^sLFRMKGbZE*Z>qIr1?7gx5`qJc+I0NyZN
z=prRLPZz~q5u{b3(O~s%PB)hQ6x$?vNTs|B&Awa85@rU~IlqoChV^?Ja`NxbE^!wi
zYo&Y1gvT}uRXKQgnSuei*@~LtB@}_#^%p<F?yaeAj3*^_bJ*X1Y4LhHuXEmPM!e-m
zcl3r5UYvty)G&=Gn_vT^zu;aD*KOk;9Qpp)6z*iR<A|tkX`$1B#soO(DS?EWC-|uh
zsUuGvm(|q0$04<`0IvO|V9e8_A+xKvQz_>6M!(B6p{1r#8<Ul<mE5v#3X)c3!qkds
zSrJRlQ~7t#;KIk>;N#W7-1ZhC-K=VSVy>q79yz6hMN&f0hr)wugz|#xrc&RTlJe-t
zz+f}#+w1=Rf!dm?NHB9#`w&<W&Qk~{Qb*FQ9A&Y<U(hmAWE>z?i|g@BYa=3_N#Npu
z2KTnqj`(R6k>J+-%VAJ#4jUqcVZ7q3peQp8Yka_`fb=tp6LDJDS^J7?L!;_NMv?Lb
zHw}$-digJeGhvLlGErS3W6H?$>B(0<uPN#IBbxOv`#?$ehzkjPguv)q`X4(tM0g0S
z3Jg+T-*kTM?oCFFfhpx+d*xJj8n|0+mPI{>0#i5gh`H-SDMP=RL5$ppA5VD+xW@mb
zA^TH43o*CA)VOn%?@?G#gZWm*wlfUmt9UVpv%W+8hL`=p=i@R&WxXKLmGUy2z$IaA
zHT`36<%yp0{k}j)%~eCS)ZVw)M(ki%b)Cr9D=%@Pot`{C2&W^wi<|tKU1*{~T$ph+
z)N4cT*MqE{su|7EU)@)|WX`_#E{yc`M9ifUQ8vh!ZN<&(7QP=ooC8CwO++Qj^TE3^
z{CPsH&46vOyt*ryh?BSV|L_aFAOCXq?d42s<c_#oGSehDm5jIu@>}N9q*ewiaP&M-
zs{=-Dzp>L-YpLy0hk*Xz2V&wFOnzn6zE!)Py-u|K%nc3~H2`r<TZpdlBqVCV_>~3W
zSE{<@DfN{CALg@x0Mf`1YV2}b1}B!;76XUA+2AnETtS<_;7!lXwo)wFMl!#IX$@1b
z)Wu?n?6-Edk6HY0IAt8h@F&`yd=#?NWg$$bQh3B3M?Ef?ncdMaW>$P#r~1h@^&L!;
zRD<<IpdRG3BZ%!Ql?uS3Axl&b=jB~>=WTk6FT+(rHLsx%N_9mDP)C0z*0)aEBpO7M
zh%capO+A<o<bz51O@Hai+-Nd3Vpg^(C&AZrCAVo?iP|S=-?_kx^<4rvpLMKJhy4<@
zMy?f!Jsv^*H@URQQK)4_F%_eFDq9-L^00FrETf67*va!+k}SFGOv<~)d`I@4@~T11
znQ>EN1p+$uFf{;<^0P#=Vf&uLmJi-}Ufx|-?Hf}2-(5TzeGbrbsL5q!130GIxu4i2
z6S0q)rV_&xuTLZAnQ~sS#L3D$#u0b~w*7{I*>yIG0`8Q{HgGG7EHZS163y}9WM+z5
zaNo+#r4q94865Y|21U{@q#J)y4G;A>6C{vOD~C<P%1Q80|BybK#gY%*nNb|_XX!p~
z8+vqjL88_xFlKZWt$&#VltAiN%RLsSptZbsi`Ep_?tgxNd1-j;(fT;JBHju4vgDi#
zVoIEd$t1SJ7AlC!1WKHNO>0u&;fMCdrC_F!ZvxfPA_JO<`6Dlz_=iRr^)<96BwttV
zCcTemK%V@^T>xBU)SR!4J87n}zJNV+r(^%Bv`Tx%qdVO4F-Zm2Y}goWRK8^GmYfxz
z-HR^hS^0kYFyw)Gdyq~qS5a)Q{MSzlPUreF8`wwJZp*r4+a8(%ZS-)e_kNg^3e82n
zMk^f4PixSfj~cJHKdGLc)@mVyU#Q4M3{xcPUJ=_$X$2<~iqgLKw?eV|iarU++^+jQ
zY+^7WgR;ccmO($A$sjza=v<l+Y}Zvnf{rUcfaem@xYuY-*M_8>E4UJ)Wumh;V}NHl
zxKcbHVKMix`&$aleurhF!o=hGoWWZ9thm2y?;({eZ+S~2O<a@?4F8y5BZFy4%VFB#
zVyg!1z<uW?Q7$k$dJJ9mu9dpok3%;u4#5wn8?Dam88Q0P^^X1KhfK2dFbb(62=7Tf
z-znLO>?puQ{phvfG|(Mj2|!V|r}*RsVMcoA6vkDOacA2M>565`X?@jRs*UYwe<D1Y
z>)R!%&4ATPC1&rDJ53aTp$29c+b%yTcfNmKXrYDQrDp^DlV(A&TSe@VrRyIXiLtNy
zcU|;i1*7?j*5W}R1FTm_uzB)Ng5K@546}uIc$MX^o@SlrYav#3F0JE`o2|!{rv}JL
zHJWf3VX(PeEKjQn8?ZqN&p>I!I`^sOqb4qv3?;h%Zkt~Y_oB@~mVz@isx>1fPE~&6
zp5~6M%q%|4lu&wXuB8&veH&AEsM}0$4BH22y1ZD&gTM<tM)NsfiSIaPhI8+^7t`+q
z<3DmDbKeQP{6b+mWuNLI&IMm;5d-|4-q6JBN>-M=;^6c&ZS84w{}v3nn1{6AuW{D2
z*U~H?O-B%hG2&-1hq#QNP=8pT$+#=lCSPb&;PQmfqDbP&>>+I_P=JMI*7`8EbKE{I
zO?o@1(pmB@N6R3Z;Cxr5DFq@S^<P9T?7|wA69yb;`KvvSHwQfD(I#~?f|d0r9undk
z;klLfIo2pHBZhfmPu*|I-u1EUP?s`9AnGfl`$Ha-?C+%-YihvY&pw9A_m4|?5W}0N
zmrrX&HZG{Hz$UE2WhwPgVr^B+?=JFuu44v{)t4@`tff)Z?-Dlv`wLXGK}K~933M;i
z3O|*QDZ*LS&lqIMSQkq1O`GD%z>-jxc7&u(Gf(3&f7kd-oueA~74E*v-DLIqI~Y!G
zl;>#AIq?XVeA;f_S$QOVdF+wZlerk6)Ub_zw{hm*TV4fdx04biDRt0GDIDaBm1<q&
zTyb)Gvidyr^8Ofdc9PJ!zShp~#~_=l5r?dbw>S_f;i!7u!0z}WZVxqHe+DV6OR+3X
z<SR+Y(!#aP%{SK}K<sk!jT9*rA`WSY;t=dia|l&kedjoj3FZXb(N<xAi9wI$^E{5g
zL0T}*`W`}yctA`}HM`%3Ks2s_OT;u2Y?*aU<={i>MWS}O_jd3?u}anR@n_ZSJGAR-
ztm96{rabJcPhFr6uB#b?H;!zL=$3d6&So#)*s}Md#QFHP;<tQDK|H;MbNj)Etsr3I
z4HS*w<+deX|6sWiV_*Im^9Jqp#`KR5b~e_Cu|AJ&bq_2i`<!GjuPIAKNFRMFdc|O~
z2bYhS!M<I)8`P=+Bng^<@R}y<HG!Y6l=(-!{2-JL;q>o#>j}P?nj$y63e$*A`NDMF
z)2={=OC1rsXQSI`GR0`+xbs=8pI$K_h9PDNg|?X3j_m^;r!VLRI^q^GG&A5u-O;=N
zyTPuWRp+U1fmK=^HD8gIseVs#=w?P_UTj2k?u(_O2W8&8&54$i>C*{x)#7v}s{Hv0
zjC?;HGuNj{C_p%rtzau<I}IX)DPbV1FMyXRMToP83lQB5a!!vgEU@y-FDn2yFoN9T
zm>KZ<q(%f&=D;2PaoJR4IAP*b<J-k(f9}ETfV)vl>dP;p1Og--$NM_UVj&l=KddUW
zglyxMA~`3RoIw+yiYkT~N{8#_r6uLhMI^*ULBAIb7xY`143$0=cM&RH-7p0?+0vza
z>d_;IlZu=AG>!}#zXS}ILmPO7{SF4};C|CaoO@51hI5kCE1z!Eg3+w>`99A@t9L`Q
zVEJZeaUo=vUNe)a4gN8&=_XE;=48L6qcRuE;fn*MDaJ=xT@>l)O^AcEtzm&iNLPM^
z(F=l=RbHV^wmeuI^0gpp6*#m)iEtol>_Bn>8aF`1X%ale9r?UGBWhH`0Nk7wr9{u{
zSgh_Z9Nm};T-v(3TzGbVthB=5ilA`Vp3ULbQVM^SjgW;C#(kL>+@Dx8>HQY}wW@gA
zX8&rQg~qYS9`rEBzTcoYB|AeUm8ySV$V=yC^%{vKsqxsK<H1hyr)}kG_i0@huhgRT
z)N@~R+*o?a@G{>RlM%!md({%=Up=kiks-L$)iD*=QSI7`X$QS3BbqZo+*o8bo_3`-
zI;bYXXy6XuyLdDFX`A_!I2r6OwAH9Ih}^8x7?cUFN^!mq0*ljZFeVRWyw4}E4!O5X
zvyk5fLGA9|lpvO`pCUHM@7{7_Y3-QA;Jze3)V$mI&V=Rj<iRFg6Z%q#z(7#fPrI%<
z#`2Ttqn0(S@6?F70qD1k)b^Qh6sl3gQ~j9D!f9+eH)8+9YInavi&R9p;ruAJ!fZkN
zi6PjvZXs>D7v)A4jF4U{h$2!8K0*dmY9?-Ij|OA}7|Dy%`LBQSxrt<?ARc&kc`5}-
zaeg-mnc-lA7aY&qOva@%wx1zR`KW~?;`_nESseh95jWAE72M8=!9zP0sXNw%$HqgG
zWJAWV%Rz%DSe0aQp;hZcn<;FMy5w0hDRL3NC7&MZU9MMjV<|2DG0>tzs)$S;S+pyN
ztcJPw3Q3;gD)1El?i?XEh!#uaSv)*40PJ8!HNCVU<AU?8H?GDrC^_YL<>f^os4~XQ
z($^gd^kV=4pu*1>K66P0pn@&E3@7KCF(7L~T^WKme9<{uqT-?rX-wIk!b!ROMSY*T
z{yYeKy06(+*GsgnVoW1tQ->MKfmYwT4?}+#HnA-)Ppo}@lDds0BYB@j4v;@YkjuI{
z4^!t5VT0z%UyYK4#~WP*CkS2vjg$mwP&(Po=*|N95n&--hn0iJz#rv8oKo)jSW5f_
z*rY;jMkBW?_FR))kG)T4CT4FZ_iNT(#fMWPlSv;9`ErSVmS9_ejGxsvCj&t{saPM8
zi9Qwfu8@pw1HB3UauTT*1xa3<haX1O7Abm+dyGG(O`yUN*E?B#pqM)C7gAj~x0y%u
zI6DK0GTr?8AdMneUfv^ksz%Pts7PcIrqmP1`+1@V77<-2g70bQUCRS^n4Vy5E?Yy1
z-^mxi7uGr~>cH^CUvL}LOj7kX`>yg&<Z|b6kig0P=P5jo;g>w8M!!xWfsw4q<ot#5
zIhs3P6+%_k_eS=)kAz#Sci$?rItpKHi3YIGhK!NTz{@2?-D9J!t)H^M5}+35(8(yo
zvX`oR^~xY?_M5)SWV5v;`|^(0@Q0&SXWCNx0p)}fj#vFk!H)tTiF4{hV=20Vv<Yey
z!>p(%4G*a|YqWDa2gI3*NDsscTFh;qK$l&JIZ;5Rdtl4cLYh^@qEWjy=UB9qc37dd
z22A}F7}<fWWb*(+QISuKg#cZTaBDZ{6s<usI0{~8clbJ?N0W%yHp<9UN^@k$4&H`H
z{`bx*a^JQh-*4>O@g{^55TCFAqKYfc^MsplxDhMVk`-v?)ZH({R_o|P@rumQ@vGhs
zbBYJruPw8c;b?mX+psg*{XVD0(6g@GqN>$4<~U$Xuwn|M+KKuwLS$G}tk(V18x#ZH
z%NE9N6C5EP&NI_e^eph6k`^M7fg@R%=wkapQ+?~k)#qQ}_mO@+H*t|K7Xsfu5^}wY
z8dyEi^;P=#r0+lGleJ|xGBx=LVY+u+In)%t9E7yJn##I|9FxU3tS-T9O%pa?sLrK4
z<~e?tm?&AnfW{+{!}TfQDSpcbPAlz!u#3M!tN4Z!lfxopH}2YUe#hk~452S!m{M%1
zHt+c=VVq0e-VWi%`PZ+1?k&EmUA%N`ZL_bm+9&esv^83K<$2P0`>oBnAUGeSAzxb>
zPg?*-;Rz3q3i6-@Vh1xf6#1{i&!zHV(=?DRuGP1dln`oqT?$B+gtMTV15&k-C0<r$
za0hi~c9UXMfAMR;SQNeTTM~7-&TmCp2LCR*{(9dPnXnKz@FXb($0hjju`7W=_nQ6)
zh4>8#h7Ge)@Y9YeY<*TeiJcUu%eqLrrYx_nLboRsISH|Wf;!5;tA&^_Pz+j<>TYBk
zl~6nJ4vFXsW@3s;|0G&k8slt5+Ir#?+`5G_P6|?9n8aSN+T9U3Xp0l^x-2B<d2Ue-
z>A=M{`Ml`j=~%Vzbz5oVkkvmMSodRIcl6G>N$>d4tu`>B5(j>AHAk`_Nte&6&k6y*
zIUg^mT#iBxSO6y1K#mT%2#TWX$_U4g{%rpFql;#MJoy6-m~n#M7A2(A8W|@5yYXE(
z%q}M@JbS&I+D;g&HkyNB1ID%C((>979_7)=iK1A0dcraByY8pYyoP$%b<<;k$KS<A
z=~bv6Xz5(?@7=?CvzRT|h07&SrA>im#X+p6@tEq0=M=&fHpq4kWWXr+r1w*r1`0vM
zX1Id~Udw!p6<BSFQ(LJ(Io%mMNj6I=ah`h_#)o@IN_Sjs?C_(z$LRCo%tqyyUJ5MP
z+0dWH&R<{<IqT`}`P0eiZB@2oW1D<Hf<4;GjgYP5345-FmIkPxl65bqQi;rfCj}cv
zRj0s3O~+!%CXU@Lfe{c+8q?LBo~S5fmi1zS{q!4b3}b?}PI5DiRBEr8h=|Mv`l86#
zPd1=#Cs{tWXW_Dh`H#D*xlSjuZa%|ih(n&(!r<GpQ>wFFq-MXtd#w6S`2{q?I^ZoD
zRld0FhY8sCp1&xq;3DX{<Pa)$*uT%vTiS9ZfoM&U(dB|cNXLzp*r5O}C2U_!79f`u
zazOz?l7w9egtPdGQ%@x#e?xJ?3c2OmWcqptri!UpG#5R)?QfFaT|dK_3-arA7VgCz
zktVQ1@AtSK2E6U(1%eHaNDXciu(M%P=d16uar=@9`0-O<YxO*qfoPZWn%BD5Ivj5o
ziAcYsNCj+hl3y{P7{0!-OM8a`4VeO;Q1~>P|5ccrm=p~_TW1Y0z%7k~7*x#2Dp2_?
z12vU4C}CEzSY1WI!b$Vp-MMyMln1N1LbPOYXw+NEeBx@`hXN1|46D1fJ+}L0W9QvB
zFu|S|=g;xBd)wnqtYZiV6*zHRd}v8n%s<&HJ@?yp^4pCpaXdGPTV#D{JSJ@1O%kpT
zm_Hz38j8hnqrq<7o*`4hkf1`$<z8X!%9^729~C~yG?)N@p_%j#G($;j6j&tq0yyaX
zR`O83R>rlHv)}sSzrM4<Pn~tf)`OMZ0}@~Y7oQybmZo<D#jXT|uc5Z{Ls`^l)R%(4
zws+Jy>+&$LuDN#Z`f_%AZ!e{Fv1OCc>E!`RY#2IupCo>1;?9VCyl9#dy*UBv9^2yw
znBWv<Tx)u252KFHH)*mR3v2*b*Z1^Rv<NZ;H0EA<u&SA%q39Nhxqu-QGmYqJW8t%G
zDTZ+M@0!3#J{_1=xM22-Kr?LLER(PH75il1d#}2CsB}#80zYA`guh)`z*;#u%H_q1
zvJR5gONjCxaqR@!#o@jv!{Wmw>F2Tt4KB(pza@64^NZS@W6wY+s_+ii@~l)Fg^M4i
ze(UZ%`Vj+HO8Y0#7g~&B0xlUy%gcv)+fojy(egLf!!CJPxtNs*%`#>xuuVNf8{H!$
ze4|YyrmjhetJCV);$sQVS1x_=cZ6HAW(Qu?_S|`X{<^GFwRC3R)Um`qcWn^B-#&fE
zL-h8r(8|gsNG?p*wlbTrGDFK1b5BN#@?CPVjybHPu$=f9b~HVf&Nsqr?LInlYgw@R
z-O|*@mAD}fC032p)Z_z1Aug|q_eKQ=E4$4}rVTQ{OXA_zUiezntZ|M-ygV(d>dmN^
z2K)kUo>jG-Q;{pJtyov5NP#zz?T}@$Kq~fNJ;Sb{&*8FMs*Y3yoIQy_J!Wv8SGSpO
ze9m9@IlV3_*QDnyaHK_A!)+u=5hj)28c2<aCW&)U2*qQj*E3BujG{smK?sgelVnEO
zBRbTH`n}=~uTmtsZ=YB{!ekMucR_2QP-H7>P+wB6AS+Z)0_11wqrAaaIsP80HURG*
zebEKo((ptn1!)Z0TV0kKEg#K0U+Fq~>6!!>8-r)=LT9cG4*Q%{y{bw4T|Ct}FP3#&
zSZU1(e@rdhRH&oMN-FpA6^ifYSLS2WfUtBJ?Buv*Xqlf*R0}mlv@HTNy4f;7I-aN+
zS=7;Ev8*$8zoJlGoj$&&tR2sgdeW|@Ov7Olx@-=_kFo8dMZmRtVZazGS-O~ptZZZ!
z_f?L#k5pr3dA4eAtGY=pJ2&8IqT{~i@yPiqq4TWwZ5w!eDK~5@_9h6ldWQrNAr+51
zK=1*%eqQ0=muqaDa56+RD>>B)4?AFegPvoH$S0F#<&IrD^95sy-@Lj!8m5Lj*_`9*
z=<;!n<qi%P?R<m{7%mg_0k-gdd<NeXdU4B80j?orZXubVq|`e?l;;AAFUGs>l7zTW
z*}Gu75G;1^EWC9?+!sylw`uIPKdWl5vTKj#YQ@={#CFb#IF74Z1eyp|q%a6(i`>Ex
zmEM@k!BHS!myyOLp#XN;<-BBZ(?5`z(M~$i!|l$b`8st=75ZrFP%A~1u*Mw-X6k7_
z1zU3<Jq|f$ZLZQfQeeDfZG%C~>?7w<kBh+<>l4C)<Ms2!wqMU%w{ttf$kkUci<P7(
zUxz_sO)Qxs>->7A>wGYJ+;cA;M%7{0330z)%G-Pr&5q1q=#Y^?X0nP>TL-8)<|Gd@
znUElm;ONH{pd8jTG7g2Hf>b@51%DJC3>B3l5y=vg+c6dppcPKB1Z|DgYG?Hq$Vlrp
zCeSOMhSdtWo2E>ECnQl;P(q&kSa2v~kQ9N-jD|Z$XoSL$FAnC$paSQ}|B#RvdOkNN
zy{q8c_taZHO0R8-%@*!_(lY_q2)qq^)Sox(d?2@+XMHT>%VL%-FwpTtCbZ=$T|U0j
z(Ge^wz^Kd;ro@o~Qoq_yFXPjc%4#C|+y-kd(feDe6?r);u$~?!dL-T}PKIgLc4QDA
zp|8$)V<b-Q2(5P_m@b@}T}nghK^u`+M@G0mLl6E#J;_c;5WQ(oh+(9y!a3UP{bI!{
zPa|ii--q*SZz1yMy`B6kkMifEc?TPB9Vl(Daxh`Y`3Q#DN`J|YF~^a8Lllgzqh$)8
z#3#IsX-MZI^s45gi9p*E&52PiQyuMDDz4V!v6rJ8wbk$(#2wA!&_LkV{uSoYZphgh
z<C7xTB>h<eEp=f%UCb{QFZNd3bKLc~7Tq_*$K$&szOa_Wxo_Pjd6nvkuIi(GtGB0#
zQ9z}$7<-MlPWE-+EzWGaS?AmM4hGl)7ncqUIjMeq3!04b@{})*pXbZCX3N^sRfGGo
z)DZHUS$N@<`^4CAE=N2Q_o$nh=_;#%PANZ~*Rz>5;#0ZhiIyH}qWnNTFS<>>z#ib1
zaS0k;UFE-#9!>Q~uZpWczbc%WM7)^dR-}^$OffU6gH9(Z=VmKgI%=F(4p#gfO(11g
zt&j!qb^6xQ%7R0`x4-Seq*)?peLCTjQ^+WZ@7<&E<7XugO@3m<yRX?JLvvDiA05LB
z$0}+oDD|s_Hy_XIvFYI>Os%bp8>43>w<i<!A^NLel7{wAbg8I8iYV`S@WLN>NDeFq
zIjJn1DVsK97oHQx7jTh=dW}x|qk*ST0i8Do-q*C;20tNHhz}Qbv)V3U8-8Y-$c%Ew
zcNzCBP*o20ot+@2#w4B2t0d)G6vik}4HvgO7{#!ruc)N0T&!aT%y?E9;VArKnKhU5
zH8CAvd&rSjE%^xWRgeGN+9+)-kwzF+xO7F#%u}C;q^5~0|4muXd$gjF4OgB;hla7R
zj-HW8Wtv~(lKUqLo&>&>>sa%PPQCk4jOD<kz{{V9`zsC*ub=*qd6#SB#YbdTm-=*K
zyhN}%8n17acM*OW2WE;-UDW;Wpn#!@bCBqKmZ>9|aLXD|A%V7qH9g@O)6=+lJN7h~
z*MQnEiVH>T4S#<Qd`~)DAZGRJkI38#)S<ErpuR%**t~{tHPj1OqwyN81I>%PJ@P;)
z`!#QFAAUfm?|Tyo=6%&x-&RBLrH{|O=-f){&+FMkdA4J8!=!eFg(^Ornbbl{1fiG=
z*K42s99?<-?y4$Qtcj1OmDXGB*UOP#JZoZ1l(yU5)shV)c790=d$d<d5ulEqN;yqS
zDT)DOMm>7rV04HuRFbiF`o3y@;h|&ni=H@3pVIZ)qEcNR^wby(Ivl9O&YRpGSG5uC
zc9KFFS^k_c(7m1I0QatPY<6t^75nS<<=36Yfsa4$J0E`bnmpOuKdvk|-Cxx$-+!<U
zW#YsvSv*I%IDU9Ta)D%78rgpK*-|kqS*uVFZ!rK_7|++$I2q<-f>F_dPVGktz4)Se
z8)8xTdqQg0J11<+mh!vTBg*GumXzjQ^?Nh)sM>lnRlvF~`dcPK5DT1ur_W&j>IVwq
z9I;`IY?u+mRo%nOY0i%=PJ6mo*(?69+its!AggmLU!L08j~DyZ8W@tLDP^xV&@q+p
zM!IKps?**qS~tIr8FFgEqH!T=o7ZDlZ$~nv0d0@4SqFX}-r}PADR{iA^PA|dvvi<(
zXp0J8zzas=j6GCiwlJIOCFz<#1b*Fv_`aF}tN7@kslasOCr}1$FVg}6PW0VL4;x?B
zUAhpSrN)gItl`IZ-zu$1$xJE`zuIqBqE?ld)K*pL#{R4ogPej7p6)sio&s124kh-Z
zXA8N#j{UA;@z8N2npEGv>yCTKE-54jIFNWbwmRE2mZ#gJG-2yTH$)pK#yH0vk||yX
z)1q6y(=T#BC>ZJd9nHndvbhH&H$Q39%%^qvmM|a_qDSWd1E*qZ9>$Du_<;~nno7|a
zy{m|O^7~yN*3vBt5~K%Y2DLlQ1DnQ%{>#AIyTH?{P=`Rhwp+~XV~1Of+M}GGF<Hzh
zQ}M8@dlmz8%&1a*Rj4G3?V%BmYQd<ypHbE5Mo{RLpy!3yG!@pcW-lDwu96-CMwgnK
z<05b(Xm5(#s}zxQ?LA<%HYE0#aQ7RC!v|iEFrmzm+=pdq;vD37a;a<2N?0XS<`V4m
zTqj`=H+K*Bj_r0A(`y8wwq)*19;@==@V#uJH7%swn~@|zCb)TLQZwh&JUKhtds%f4
zhCmjtR}>cVzQEX^!$rV!N8@(`$dsF(jMF6nTo&A2{|^9&KzF~)kgj1D!oD@5I4{)-
z)k4(A%t=yiGEpSVXULC)q_wn86)uRlVh+G)EDQ?k^aAWp$*$$In6MSwi?l$1(5#Il
zq)<X@z2d^OOn*=Qyl}ws5(k+Lz^`nn(k-o8?dqF{#qG!S+wa}$zc%%EcKyB8pXePH
zsue*>bl6=k)nSxAND^tPpjjJ2XsfE)?RO4XEEY~tdo{2PCW2rV$8ojRdhcV^p8#f-
zphq>fd0I})(kv0{2~-5JJ2!V;>8Lk0U0f_4H8ZAJgK4H0jnu9~M`GCzVFsro1<ANQ
z3O~4@oI2bo#Pyl7piEuIeSu;*UPN+cqaT~qg)n(ME_(4IM2^E!T%h7=sjBL=b9KGg
zT)E})?%)4=^N;`F?!Hr;9^*Dn+5pHI5=jrck&BJvD`xSP9xA)ft_!zXYxgZp#8*<S
z;FkiQ=Y<I%sxe@aRQZ$Q0Hd|SMq<w`L(K7%GkB#NJoW`4wQm3xw!#L|0tPW*V2<BH
zLypz_kx57v#Nji5e9F2_hYt2gqcE3&{;KGHst@&5yL$bwy#3x?e<SN}?CM*t--oKH
zS1tU$5#5`}P9V;Sckn(b$uQ80>8YgKH;s3?tZUL1l_xE<`(<6X&9<QgK~(aI<Nlzr
zuPX68s$ICuSoRUa07(Lz$Xsk<U*fM_0T)NjrZNl&wCmevA|*^jop%}Pg?)7jl8c@-
zdXt2i^_4@G^odF;H+Fi(?ywTL(^->IOMn}LCgfgZ8CI3XuCZ7(f@J%UbHW+Y%xt%9
zoJw7(^A%vm;Iyi)Z>!~^TCe^3>f^sHo4@~&+dCF?P;SJXnpJs;_~;R6>WCNVba7Z{
zaj>JlI%5eDkw9zB_N1w(7r&rih*nviTcC`ca_O@R#$ZVl&|0xZ*hF3EZhpfTUQ@(g
z8ut~agtpz3(DYyeETj}PIfd3!0zqRyM-j}N0PykTfR|ab0r-_T{@&_MvwZVu`PC2Z
z`a3TFE;rw~^#@(tQTIUDn@C`kRD(o~9-*~OkS0Q&s#EWrI+w(IAVLex9%=9^Aks8V
zpqV;xzWX_;x=iCo8eGjn$BNf=6++Z(P%}F30I?8~0rBdbB55%u7t=wr8<;FoJaANw
zhKL1I2j>#~AKQr`R3vQ~6A_vky2hferYL&p%q9QYF#^&9{V3rXJJJ-rs6=OCvYs`%
z@rH>B>HwmjK#~X)kS?(vq=k^kAwZq#vVQZ`ZRM)f>V37?{q=u^yZ5P{UgTh$@8noY
z9yrbzL3qlo=eo|W6E9Z7=lDz{$7=D~`)=4Q(__Ix8-x(8;Fqpm2Un|8IJ3|iLmKsB
zS@+*47K6`LtPu%NgBiroC1#?eQ=wSYeHJfZBG6AC07au(AVfr(W=m$x>R1;*(1cB7
zEX&e;K8cg!3yK3>PB_g5;FrFfXSHeSS9gooKls~k_4;qJ`X<!hhQ*zWrP*o}p{j#-
zaG)Skv61vio%gDa@S+eZByl*gS|_DhbH5hUsXEb*u1r_}03ZNKL_t)frKXxB)krZj
zwp2}hThV1^uDdiVqGcv1OiDl^5y6G3d4gA@Ub+&X+>4boBO@uK%C3fAwQD;A2kE+^
z8fIA58ENm4oLT{}DB^&g7BY%vt@wWLME%D+uV`YmF?P38UId!*Cz7Bj*;1$VVtM=4
zJMSw0eo;UC`G15D-{*$5Q@-qkMIbw+&_0)uS&VZaRhA_}SlnlBreI)bjf9|rTcTRR
zRjN^Q)l!HSo5^xPJxr7&TXHYlOB@Uk8?Sn!l&G|eT=+)^0fTNgl8V&XEU^zjLKcU0
zW(XmFi;@ZGzBO_<qvm+!{xo2tG^<}`%?98X&H4CcQ(bTC+mF?&Z{6)*Wb@~C^$iyf
z^m}n)3Q(1*>Rgm<Gek$59n*o%VI>&?8CAMs0gozGp{X=T(sUIUUGl!?N&4ME(5SA%
z9SOmD6@`o)kslF36l_T9T3ww_pQ?>ia^j(l1nC@{YGk21?FW~q2$W?kxs8iO8Bro|
z2OYCr)!~pTDMpkho@!kESGuZQbx|iXUx>{oNMRmmFKG}WqQlEx`c6Pp_2Tw*ReOcJ
zhur;%;p01o7BVjR?+p|CTGZj)9fBq&Yz5O$g^os(f!E7CW)oe99VPbkl2n0;Tfnd2
zYG~~4W(GILmJM2nb^l;ay4qg2kFua$5h#-WGMMK(9Jg;z3<5-?v!|&~gMqOUG)4e4
zA!smzg{g9T9_i*iumOXiT~krRscx^i6L?-nzQmw-^XvWM_51qmx3d0gv-<OX^}Sns
z(z+2J#Mi!#gSW(}3=k6&qftT}y9o8s^N(_#NTqmU7KM@>p>0UQnoLv=l+GpSF@T~f
zR8>LO=4HYt4%Puc5izI1y(tk;mUn_84td9Z?y3}CJYptTp-7!$sUjya@5m)h+4^J^
zw^4&DJCsaiE$CE#1QV&puD8Hq@qbdt1P{GaCagqvb$u}n!DK`trId<EqYE9aQf@&8
zoUg8~ZvV@_#w^C?KmNDy`Mrep)VIP)8z7j7J$mr!W16l5nSJF?m-UoU1l0+(#TyE=
zy)i)G;a09%!z}=pZZnULiR_w%z+f8X-mI0dldz4cSCJ4KuaKWlnemV$*Mk==wTZ^m
zC|ScWl_a&okZ7VfA=FHI@$caP08DfK<x@YEAkMzXVb10P02oxJ&IaIDhW>7`uW#?_
zufDH-^A~RZ9Q?QRAGO|N(b9!LW9#9y6HLxUm5d2Dm%Z73@T(G$v;YMvaL!XCn8j{h
zDAYMo7n86wi$_*f?>t0PLbh{9jgnC~Dmh2qUsXff#-9uTbuLy00-~a^FsR_A<2WzZ
zi#bGT=nz_3<ffvXL2ea}sb+{lWH@L%4wJDM0wA|0NG|E<38LKPo9+ZCGrf`V$t-nd
zgkn!XF=f4wmf*+)<vLhu%ndVZr4q3?)&nMNNhheUZr=Q#|Ce9ZBK-Wv{~kWQ>nG7q
zBz`f$mXyuRLn)-L3W{ZCEHm;aT_kjw4D`)n`Pe4bMp?~DbfJE!uA*wvU5Y92B=t{*
z*4oxta47<4Xbq(8+XZBR{!%hlPh-j_$e;0xg((Zd0LGyO(K5%s_Q~*Wm)@e5*pK3?
zbjf9sFQE3rc_#3$E7|MJZ?^TTcka#K@zsCu^`ET%#^jSlb+rJ9gYybDdl6B@`HK#c
z_<kZy(~bN}az=AGdxAy40^^7-il{nus?H~IW}2$1b0Un1%b1K!Y>Fm#KFcE%fB_I{
z*=JXU4we5qmZ)nC&P`t3k1&pUPdtlHDQAd;&fg+C=7xnjo0P#wihFu@3*{e~^DeYQ
zIpl>pbDA0#(8~s4<T#Hwbx>jpMK>iUYEh>vr-^u%!Z4^f_|4|}x4#ej9WC7b`~M7|
zei$M+2I&c#5*ICGf0&CtaX6PoqU?3iEnWJVeMM<vbRb|bYmGrD4ye^H)K#V~-8k}0
z#n>_(0z;q~gkTWc)AnF1+7;ep<-KG()0m&9j!l?y`q6z23KK6z31*F?uJxqtWK<gZ
zG+8GVn7btoaswO&g9jM>DE>!I2|Ub6;9n#3)32NQ>fUX>$IV}O`=|E$uVL|yx{Ya6
z60n$>b%0rbz&Y`$Z!66zrzoOUdoGbAQk4zjR4q{zgtkqEJ8@XAq*PfavJj>GaTv3v
zQL38Tf2CLU@2DB%Rs+{r94QI<%>JY7!RqLCKsD9SFee$iz=I^qbg&FP@c3>l<Lv4i
zyA6s|bEk<j)j^cEv80gMU7w^|C<%hjo$k#>3_~;zy-!SeY%Vj#PeujOGC06*u5SPH
ze+f-vO>_UJy*=DL-VrY4l{s$m8X^igl%*S37^1gqBqcP)AY#b?IA5DOgJe;sBK2%$
zA&6OQkE68=d$C3|4{4!FK>>C0t1qPndN8|%1({{EmJ%ej5>f;-gwRzTAVxF&e(ZDR
z<={{ZCfHpP&(Ar4d7Vr4iuzD(_RBXP>Q{da^}jXiKZdIxSU;rsx{>&Ho#Lhh^Xg;w
ztyom!l|Z4Ws50gtdnoRa3TXf<0s};%;6v=<35c<PM(A(b$lDUCPAvnuK%?%Pc<&=n
zr1F2jIhPGpYz<aT>;O&RQmIkw8|dmMyUO%FqZ)Z0vk)wZh^naTvd1wgDNH$Gb_$~X
zIIq6MvoG+_PAW8O1hFUdr6WLk7dZd8V`G6~_{*1E`jiMHcD0p6mrvH1DTrpEYcOs@
zsNz)3sHFtfzOHUwz52tyhW$3|?zeyW-)x(XV@{#O)KC`zrt-yIG}Y%fiv7DhHd4x?
z+g%6!aS+mItyvpL02SOqT?KWqo6peCa!(oKU^K=-T#RZEX;5$|2o{c9=%^|*Vr`yi
z0x-FM)Tgs<a48KW7=%rnbaar#%{ic+3p&vx+&l6UTNQP29GHX)(f{0>;n@KE^DkG0
z#qIs-tM6p}r)~A`q57LtABbHDG*c#}8`8zLUKJ>m2BQRF9Hq@zHt(Ex&G9}dma1`(
zR2^UnHKA0hovW9NctnM&Nq$E})AUDGO><x(4G$oCdqD|`dGCXnsuD0WnnkI&ghEU?
z1~OLikhD%F&PXuLV$3=OG_w$B7LXE{s&Ob`N@YvQ+8%P>>>9=TIHUMA#;TUVE9l~b
zXyh!zS`3+Df-+`7hRFbCF}qS<4S<^FrmIAf^!0^CGf|C|xB~A~1SYQ9T)+Oqf93As
zyN~bMkMGzvlT6PL=sA@h===Rje?KuiHfSUs1P~o8clA~#)|j<M1Jpw+r(V^gn>~qi
z^w_##u@hJ*78qJ<8wrhQ=-4yqrN89`eg9KI5z@p0GjmzxLPW$g7%T__&qxq)N+=>7
zgr^<(e6EX=z(upzMK)j-gZrn?_g0%`^Yy2z-~Fwv|M(#PyTNx@d<q&u3yaN3s?J5K
zrK7;vJ2sKUhpKb#|7Y(_yCX@CY%yCrGO^Us-R$N%96gPs|Nmq3LDCz|)8mk%8FJWb
z6$+UVZujbgnMXvTfLfY-hfSTrA^TLLQ9uI7G;_bJd-G6<2m)f_G-i#}fZrh@Q8G*&
z{n={jD_kQf_RKuzhn8BERM3g+6!#<}f+7Y)@7yKzkLDF>sv_4ztrd8*zECS-C+RsI
z8>bHF^(8W#$jqi{g+wVnS43tTxfe`h&M2<)o>q7LG7J@|z_k^=9`g<#8h^&Xql(up
z!kHuSTK1}=Eh%WUUZsL5?bD{FLQsNqv+3r>`T5J={NwV&_uu|s|9gM^oxDXjl8;B2
z4vQ7{hKP*>=585?UW|UqzC~@nW76c!Gy{jJO=gp}mf0evtfNQ$d?5@8R8FXXSlG|(
zv)UpSVuRk{1;;KI_Kd%f0@&pY$%S56m~HhKHV;B{L|4>xZtbLywVrNEmEEA9ixYjF
z3*NE<@8>oCI`qa<Kb}tu;O}?(JFZ@yZ@>Ef>Z?EaXa91N|F-bYbigBkbk(m!<AqH!
zpRhx|sd;D@scODFnC4g{NUNMLQ@8AE6oHw6=^rz5Uqkpg4&l_;raV%>BBTFhYhfQ2
z+&a>m8AXyfPJ4mUitM#2c@&!LnqSP6L;&h8V-0}J9WgTN!JRyY!%D#Io>6VURXjLm
zppGO_Zq4<w>fVc()a`|zLRaNlF_sva4E3mHR)ky>+mBkTEjJY7g0k8p)+wBr6+yaX
zNE1P^G>;vxuYUIP&;HB*a{tZOZ{{;jccM=hJ<2=(%UbaDP&%}R-swa3VE@jQHeLcV
z7$ygocFi`ishZe$3Zjf6A+azz142=Ta@IIA?kThCOfHh7h}f=*hq@_wW$&x_QSgrr
z?j7qBseW$^iL-Gr2}*<pOhYU}A4`Jc#pK0~C&yb65IT+-<X;ile+RqqX#xEI;^1!$
z)AQ4d-+X=j)$eihfBwMVpX^l}g)Tv3a<W^QB0)_c+A4ot@-m;J*MvmxbCSC5Zl<e?
zC7Zn6)vc{fAZ8x9Cz{*TMmZOg0}xRL)XaRG1Vt#~?#-L3l2I+}q6m7+9U|^d5p&OF
zlgSUNO3Smes@lj@D_fG7Mu&iE>ZW;-0K!e(bKyua&Lb;=qik#suZ%GGtQbd;(yHb8
zVVSjTBZ~!;VQP|b5QNI8K_32vH43y$(e?9}2eEP#P>pG!*y)b;Wmv3Ll|b;iK{Sx!
zE1#ady#DIf&;RkC`rWJ3pH6~!Ad}&m1G+!uUgX|w@6>e%U}GsR)`jVgKiGh(`s5UJ
z#0-Rs9@MYdCQj)DfTpETR8%~7MGpW%7`t;3o+M79Gi9O7A`Wq;6hZQgg1SD5?I?;L
zu><OR8wVzcD%B&9PeXFya&j)Fo$Mi?I>dSmOz2Y5vz6n3J7H|P-}MrC<HeHr@FD&_
zaQ{Q5|EC4;clky?#`R~X+h6?0^)LQgT>sy%;ty}+Ro7J8DLu0YlIC0woM0x^OJz^i
zi_{8<P3}#VG$i!D&%iG^$`+cxcC!Y+Wl12zlSoMJmSXOyXcX0mn5HR*pP7~Qb}e!w
zvkI_|-q9nxwT1{F@}A+%R3|ed(ah64+B>3)yPI1U3vNV1RkmV$uj4({4_2pp8y{TU
znhsi*>zXJ|TvyrBK6YkpdeK$jB#!~>`ysyO4_VdPj5c!;8|1X!P2N)T+p3=2(08FI
z&2`eli_bp$$A3C~`}O?lJKTN$@Y#d6+FjmpKOi@8RpA(03Y^#)nz7p^yFfbT0$5Tp
z&_tUg$>i!PNdL*8!EJT<A_Se71!v+UoK+V}?D^l71JG&<_^ZGqYnaLQoshY!!Xz@3
z0x1Mi1(Zk*fR92hn-73{3U?q$``^ern1hXk|A1lu?7j;5At=zN1@QMr`S#l{U%&W=
zKk4&-IZgk3zx?s6vmaYVC`PC-dZ>vvUkh!=Gkm+UZ^Hb`n(%EfUmOr~Lf14`Rgl%&
zmF2yo=_MkPoHVtR2kAzECZ-e$_UI|s(ec01kmm<8dJj`k)5)5xO3;i1LTJf2832LS
z+)N{dt>zh|vlH4R6|zF{8O522^imR2Zh80V7S@Y6oSgibmZ2g@f2_(Sw#I!_jw0&}
zwox*$@wL}@4?vBi2tMiFN`VnnEU|E|YE)e>Ga_PsxVruF=P!TzPxJTR-u>=X8JF~;
z|K*YoxKw<~t_<Zttn|?0uTs}dB>KQTzzs0M9E0pOb2oRGa<f=Vw(>A9stjiH96PZP
z%V-67cc%V6gX2d)D32`d?Xw|>&Wo{K*(V6up@JVw0_!E_qnFm^r-u9g2*UeQ9Q5DW
z*}q-I^IyJx_NzZkU;IDk_Aht+|2>J=H2EZqh!7@5l9>+NTVw~QFecs>>`cAH19ov(
zx&|76jEMYPW`?2E8~{f}JM`Y`L(~jrmgiMXY)3>$bO2*m*ft}#A!1sJZxeMlHy0A<
zh)4<nKteI5$`z&uQs8f@Yry1IW4nf6Qii=i*AVG##G0&2a5%lzqd#}W<hn7ZyH@zZ
z1FGX-L_=)R^0K2Il)Af1aG&L=`+a=*d(ka6dh`ce2Dnk(57*CL{OULNfBujA|M(qF
zZ{9gMdBJvGD*R<n|L#`E7Ag8jcl`G8b!>=Uc?s&~uI4+bYn@sNA%X~rtb$Qt7wP0I
zvWP$v(j+fcntPW0FC3E(g_v4B4TAw5ODHcM0%MTC#ot;xE%vC;_WOB<8t2^)T>m=b
z|FKW=X#xEG;QsA;dGYJlFMspz?eqWR)c*A>Uw0K1*GW6EbS`1uRMp*3o~Knmx8;)T
z%3U6G{^e+=2vTOlb$Re%8Tk$&$i&3@*N8AP5d=uWY|5$7asebRn)HC#0MrG$hf39{
zd27Z>e>O3Ku`G+3PE&JlBm%U|c(bNeKqi}l2G}O|7F4=rTkPmc4*QyzSESi41;a`@
zS~Fp-1=f9qJn90&ZQTeVY9l?l46Iy7NY&c#LP5D<8@dt4x(k@j9;)GDR$04xWEajL
zsxnR2FF(8e`LDkJ;uq&X{ejE;DB82mPJOTgDEk7giyiRPwxC?1@Z*mG^p42p<EGxs
zTh=ge<G+RJa6<<cvI|W$D2wn+&MF~e?o#|h^HV?;{~A+rb>o$We-)?-x=2YrNdXNs
z2H80-ZoE(w{D=Xrmo~BW%^oO)-f0cn$v_|fu(!Uzrv>nLG5w9x)$;t8-~ar7`#o>}
z`QHDvPd{X+W`GNq9<sozhCGIy=u*I5=Pj(JuAP%Mi%BkyoBO>m%3X>~HTMkVL14r$
zsG23dKTQ+KSj(ZtDBUXBr6S~1^ipr0C6S2<nFzsPMSK>QOi+L!xuKaK4u?!6N?Zt$
zHcct%e-+DM3{je<n|9pgN3B4G01by1ptibjS6A0)$gBae5-hsADXiluf2>02CQr$5
zh@{vnRbW-Gj6TJS^c~qgVU}8gqE-iQ+vPS_cAN^;L`{yz>o320@sI!O*FSt4eHjs_
zZ$UkKSHcBZ!4Fap?K$B6MP&0{Bj$xYa=}`gv`y+wjHZ!KkU=-4G++VFE~?U%GjS50
zMY?FlM_*3=?ME#SqW6C6Er5G1tc^$`W!Ee$PM(U&Fl0>iP*<<e(6$Nokl<4#F#DUq
zqxlfq4)`DP_Gtn9T_8V)<@v8({p^4Koj&{L<@mesAE3*!XsE&za4~OFkR7OyhKsO+
z2Usa(061D`tZZS(1B+h`s~2AXJ<yT0j+Vvly3_Ax+m&P;SQdRP%hFm~FD1$Nj)=Ck
z13vYiPD(_y=5D?^Y+GyjE%k`QbVy|<kzXZL)XXS|=pxe0ch;<x4yY1>2$14xHMK7d
z3#<7n12pn)SD{T=gLZYoD<rgIQb>W)bUU4nf0i=qQYXmmp2C_jl-&%y2xHp;6uWS?
z!8X<jJph{yH(z}D^4Gt8^>6?Ebb5pNq^3^~y^CAjjs#t?{@pitNeMhSE$o&->4IbK
z=pmq}sk?fkHPKF0QLIhR%JhHD60>kp>B4iwUBerZSxd;vT~_NbWLMFr{gui9b~K2V
zl1XrutR)yk4Z|WB5qoap!HGKsyYk*t&ZhyoOZT`wGy{Jit?^D=;nM>6$xnYj^yj~P
z_4#lA?fB)t%*X$}=(q5k6hcvnHM2@k$`x%*HW|P!&gQLHwN+6~4xOlwDw)_=B~592
zvUCXyNMg+8YI)SHj=lHD9xPD>VX1lun47NBQ@2ZqX2oQxe~}QOb7Y0q&A?q%Ky2C@
zviA;-IZGWq!u5EN)*fEuaHYptU3^g9EAp{_fsM99Ch=N#rZpUImm09<16B4~HO_NG
zy7N6FIYL$v^&)vdH*eXttk-XVJDh0E+PMhR8{{(yw5c6$Zg0N)>iKW}%ksmwnD5_8
z`&lnF58ug4d)LFcGQP<NsQ-hDMMdU;u`F0R^NQv!t<juj)VOH>$s({=stgh{;y(Hv
z`WweA8oEyd9SIt%LvEAGJWip%cS!Dbu8!2X`~h(x=Fv}?8BYdUI=#3}|0h24MV;}Z
zfe?=o!f*e#ci>3-&u~#N@O~!w(*pQuPk)<m{n?urzy8zpSN}Dx{}9vbp&Zn#Z<NSE
z7ZCw)@UNthu|{~lb)VN-6*356rI>+8&#i(|AUt$n^Sc<fwfv=ud?Pl@Jt9=qv~fM6
ziHK>Lvj%6pe*A8-RA`;4iWms)PQ&!F0VpI=+-XLUd70B%8l#fN27wXTcCe~g_f73)
zYgY~V5X0UDKo4b-?oyG;J+0itRHR(4kc*a-ovU`lpsgRoeHh(_{MQe=tir3*r~G6)
zFpV2iqbm?&N>Odo@x{xR|L~8m|NZyN_kZ3U?H`%fkDWfpA0BFfMnSyod0-WJxHL#%
zAkGVxE*&z7SQDSbon|zZQPEi~KL}zGE{Yj&z<a-o{>EcAi`^rlJZ4dQ3kCX+3jrTM
zo#W&#LR7Ue7vfB28fX$mF5-l;^AUgV1@1bsvNwDA`#^trU=4ex;D3XUp7^N!`#;G*
z|IXg5;rQb8;x~Uj{_J0I`|nG8-A$!6<s4^A+E1aH2j8GdrZ4v%DYAU(#$S<Tx~r$H
z>00imq-r6|=zQ~CEN5wNY^6m3bcC8s(^P7o3NL1B^#pVG;UH5G2#8kwOMyJ=A2aey
zz)%(O=01`eAXErMqDOP{)<n20(Iztp8D{R@%uI&aOO;gd;px>%F5S@jyyg@Ype4}^
z;?njYx`AS&pkS+--{WKZaJhl*JQzv3=Km-kP2(9pfkN6OIrbrF(#;XJLf}I}Tl2(Q
z3xujnx3{-H|M}IIU!DH+Z+P?S5q0^y5r36StMAGKQ@8k{T>^v*2^BX&K9-K2InN^Q
z+78+#X(lcjqE$#CY5bG54xUaJ;!VUGVwSq^a?g2;{WET8k5rp|94NFwTbnF6hy^(B
zZvdo9D0>FM@m-5$P)q~FA86hFa{iQJ|Gig-N53vU&NB9C0sLf%U&Z0}{PNd-diLwz
z>5Jbl?F}Z<*vTGEq%>-2hB44n@C`)eATtItX{!x(D=!%e{LSE0aE_>$C76`fBp1`&
ze9r%rAG^|At+fmjssp>3x#>s-<>(G5<eyX@B!nseAXMFa0wC19%(O`-cT$5CAR<KQ
z?%viCN}8&A3kZ$w*&lD&E<8^8x<$2>H@L*-7`?|P;x-D7cNY`g7Y2+*NuiiFEkRC(
zR0s<lrVhVnes9@?Ry8`qp_Z#Pzd-Sy+(36^&ZMl~<q?`DfG|x+V)cHmmX49bk>_=g
zZt23)<Fgkpe)XHvpZ@*L?_ZO<Ad0tVKHnlk9)W}|V|cj2S-WDHi%Ck%9laOft*$nS
zPc%hU9!p7r5^#(j%h{uuG?Rrq_2qS7cFjcSy%uI?Vc`zJuSTD@>FTF(^K4qv0sLnl
zgDDxx4$Q!;781yu2y|6CA?SSj_`mP9enb?swvh6XWBJpeZOXOO6F-*j*0*u5Pd<R3
zF!aCNeD%Z2fB28%SN|SYKZFIFi$Y=~i-jn}00whd>#C>RB^&SCs<sRLKIeHSWX~%u
zs5J~VHS>v^E0C~zK9{U68C%{#KJ{(ARTP3h%%P^^EKgeD2>{fz`J}>h3+HljYN9%j
z?qcrl$st!_zt_aLs1)#I9X1_Qo%OdLKrSyvtd`c%Ds0}G4LCc2FWqtzMz;Yegu3ZY
z<`Sc&T=!L3JCuAQf_D`FBie5Lg>av}wuKQDxH7I(%FQI8tB#g?&n`uXQ1>L`?RdQT
z*;mIezIyW?|0?sD`?w!oP`hg;slJ`}`M~70*Na_3L;I^x9!O&eM*UJmU2GC-bgg{1
zmDm8YV^?AkbY)j@l{0Zq_6z$gFFG3bh|62mKJpNdc?t;HG1si$W`0Kyc9GdM+kg|P
zG}2Ld+}xpRyHAOScY*!zT`P$mIjqYL|M`%-hs%$-C>j2Mw@(Y;Ckp<=?a$x5{LO#f
z{PK_b?0YsSGxvN_HI*z+VyYxFLbqaVau!?tfB(|hhK<(cJRucb8^>+n-%y%a9sR4*
zWb12RbC@fZQ-%XTvc+X|w6AFjslCZWXie<gbPx)vBF!u#cWtfkQWa68uUMtE=I$9Y
zm&fTm0QxYJsqOe&p=Ks%Qqk+(I0o&ADEguhp$dG-843ggw!#X9##9=p5}Cf40#iif
z!G8y5C2K1TR66oVf+3_bBlJQz&h4MFH4Lt>)QF2%<I48lt3h|?O5R3bATkM-tsP#x
zy#Dg%uU~wzeEmmew*C`>pojSoPcg&05x>SmU0e^ibuFMH`a+}<w9zK<rl#}~AMa2X
ztoll2s4Swh$TIo>^b#l2r?UU~ao`W%g1ltc;sZ*EEUH~4Mx1K{jM&AkZe8#n^mVx3
z{=+o)xE}QB(>$Np1RuHs$WII4Ck+0)`1Q9h|M3sg=l{9rIpIij1ympkNa&dUs4lOO
z{#p9Cy~B3MNvM}El9Upzdc`_PONBZ|YCLNaa%6Vq?5o+mi!0mdg39A-I;49UUZ1!L
zRP}H;NR_~7M4V53nx?}vE$7)=Iz^>Tt(j*I8xVO<*EO+7b#iOoL<ESOYdRt_RpGWP
z3zi|2grs+PHKNs79>6G?+3~(*v#P(ML$*$uX7F6y&dsd3+kpQ~#I}&o2OtmEQpnU3
zuI{kyCcqIL0YL_5mad5y+q+gh*M%V2#%$|FB+GY1sI5JFdHvNduD|?M|Na}!@vc#|
zg*`j~()HnA+GYO8-U>k7#TZd(=)lq$y>0-05SzreX<n9S=F>Td5QMM`MWqR6ktpz-
zgO_<~hixbNk+}W1xn<`h&`VcAX}DylOF?#UrY!3XK*a^hcnG*}!vA+3+b`}Sdw2Jv
z9l+~Ye+$BTmn`VL8)ST{PYd9usQihWFJC?T<sYxV_!`GM_KuW3QnS1ZT^Q9pKH_^a
zlT!A6l(*w)FY+Ho&OznAt*n|cjFRvG03ZNKL_t)n%`N3LDi#Zw!=9Rd$=a{z6)I}Q
ztwsbRR7Bk}pv_0uqpDJn{6X)1nkEs>^K7b7=V%p?zI1bK)08n2BO^$J+3^)>dVO`>
z+`N+6zz8tJ)SRMXN>8)Y7-+RNY?P7>|4}j#&DW%9Vd81b^dMcG!KUKXK+FmPDs_jX
zA34)ZfiM;KlwnDhpN}e>9OK%oa-2=Yg(k?4v2}dwmR^x}fN@T?RqV(DrdHFkZ6she
z7OII@-V1FyTz~fY&Ch@F`gi|T=F@)kJg5bG^62`Q0hqfl|8NJaR|OCO^o3YNT+C%~
z090<Pg~g*V0Xl>rl%leTEHVz;4-g-H>|t-U>+hL@mwduQsGOsBAixeRCS8hzFcD)Y
z!F_(eKGxO6hxd}lr|@GKfXY*9&iqfhR!{uc9q?%Z{6v*M*Pq{i{@ZV!ef1~5c_R~4
zC^H3WR7J2yEEEiFpsiJ-Wjm>3;)d|5UaGo>m_rlkH%kDvytb-ptWw+uJk%x2S79$i
zvXtBTRfL)%(n1Ps-8dZLBgtDTGa+nh6NQmmL6yRYo_7V)5im+Zq>74TS<qwTJd4mw
zn`NvuNKl2ov4p8swXx9LEXS;?x!GjR-N%K=-E3;PeyTJ^>poLe!kR6OgD4((qD3E!
zeS?9=sb_cQNZBI_HPW1c<+w;(D1YQ$5*iT*Jy9TCYez<*j2gHB9tHZXX{M$WB}B#5
z4~J(jufP07d-f9NH_S|@2ZzuLo^X5aY@^B^PI`GHG;oKduQ$v<%;%WTlxs~A*qWHq
zHtu%R0#kuXuVc!75`xFLS*g-Clx*VyhF18&1KQ_7y#tYv%jTR>EjP|ZLChktMM_bT
zIiPYm>-iX?`xK79w~z4ynCd5{`}^+!pDH2$j@~d`FVBDR!)L$#`uO4-Y4FJ%p+bc^
z1>h1}XfSP@|Djb@wdV84<>}_~BD|)?yhV~$l~pQzvXVs#FyAXdR|{B<HjWQSTY#7p
zhdgBYvU{oL#6*Ou9HuE<z7-@#@n#T!fk56Qs7CcnP_Sm+On{7h$biY#e41KoO;w|J
zS36Fgtp=-xv$FU}5x9HS1LuQjSyMZ}m!>+ELaNA;EG`_KH^rm)rlT70g^F+C0hLm3
zI{vv9Mgl7;l<&%`jHwu_&{(TnlO{CHHIuq|3{*-k@|QOxBZ(QRcy5fmwfNQT@#PoC
zFMi&C_%{0MhsXZQOt(i4{*QA5TVdGaJ0MqLXPoEgi||U+MJF*A+s9bvXvKis*9Ab6
z0Q<h7=RscQ0C~8}C4Jw8=H2kT>|uS1k_>S6WXsAs*`f=O%}GC6lcOK|cOR|?ekjoY
zX#xBl9sfVO|NJ-KU4Q<)U-hnLlK+E}CNxqZCL$)_5Pg_dTHz`n;93~+6bhL@K~DDs
z8g!QiQAhji*)XOxz(%icJ=oHE*4cbp2_ueqmupXzisrYW4MoK`XM=pNQh0<>-POcW
zIXYA{YC<(_%@5O*pVL*R=5B6PXz3~%ZimUQua3>!%hSMhaxel2GXnz>2q+2ZqaBh$
z&i8SL$nRqn6>iPF6d_F2vxPuKKmbB&{<1V7Bl;+=G*MG^wQ3+RQ_Gn?uzHo`qCNNJ
z0EkS*l7YwtU}8cPIIcc^55<SOnKC5;YNBc={kc&^eVVSH-F)@S(;xpWPOsm_a~}GM
z-?11jgfqJ-^EMWg>L)OkK<}cd0&1E!fQ|drt^PSs*~@@JR3aORM$!DLV}7E|_%B3X
zxf9B9T%;LfF~BKiRXRf1-)edMP`&=e$A9Rl|G^G;G=Ji9schvmpBBL12l{`wU0(e1
z)#tzd?(pmlTq)5PiLMGYA_59F6`G>XrkQ@AbVHgzu(lhGv<7>4{FmWANtMo;c05k;
zLZ&55vuIFDqJtGW+V@SYwblDbb`XM8=}5Lbnu&<JwdSgNKA#WMWN!03x7K>^B&TW0
z(il^k8$f_=ay<C;)%9VTvU$?Yrq<llOkGVxV(CceK*Y#?o?p*%t2Qth>K+kBL}#E<
ziO}=du4^DpeQVIHF&K_5UoSwZk?N5H*R_HhR-3U3632HHPj!(<3HM7LHSAn9^z$R7
zsrtC3sO93-n)~YlP%&k5Yo;(wS(TY&_nFWnJAx%d6y;O)8sXO3&9j>?fAPb!7xVZ3
zDOsKKP_}=G@4w@nr5ol2dcM1LZpLRSDd>SE2<kMcAJnD{8{sfX47eo&o|v_}nHrUd
z*+>?$i=s;E!|c+JIzeyn=u<a<^qG;VVXgNVMG*{afxGf9H<*6lt>Z&*8~&IJ$GdjG
zrv>oSIsSXx{_OPfm#=TXxZ@#Urqa*n=yL{2f&eL|)(lHEx^D-li#*9K=~MSt^<6!H
zo9&+dL*A2T|Lk-zRWTEzah(&{wlctQ0U=RcB*mkW(U$>^(7jA(ZW@8CgjciMo2%6C
zyQ`4X<SN=)yShH!TwP5EpC)b1($fV(G&4LYKs`XIg2oCZP4kXw5ygq+Z;?4td~t*T
z)6`P=vsrhT0ea?^580HmW<QFWxOmY5q6xhtx=^x^y-m#;h~7H{%`8lmPN9NA2Fp#C
z_PCs%5HVqhxJp!s!s<b*G8q-R=C**T__i~&d3`p|o|U?fg)7?RAk14b?P<E6j?b<?
z`}y&UU!A}G&v^aqelk4F_rIiyc6S4PyD8}HJt5p8K<X};&26fpliHQp!L&qEyF&Wm
za7HTDFmRzrBjFzB(!I?8GWb?jppJT>OWhT(y!D6O-=wH2stzZcIztgA^%y8hSS*Uz
z^*lU^>|aj$-QoR#X+R$eeuftHp@;0T>3^}+_+ddpyAS)c0Dc;8syIBGU;g6m<u87i
zZtoY1e8TPY4^qm%O#9kr404C0s%*GPIdRsOyUq5imhp@GCX13!Vl<LNEUgECs+ubZ
zQdDcIa|GQmD;wR^m9Z|R?9NI@68q9sg)kMpnhw|3*8tt^>UhjYmp6>V;dnSSRT?>2
zbJM=`xd#zoMDOS!*@2E~j3EP~#w&A45y60)nitQQsJdhfb%a8^t~k{YylWFs_hzcg
ze2xfno4mQY1f!$M!ssJM8xdiyDf~2=U@g%VpkjRT%ZUhs5unK^D^^D5z)$k(A=MUO
zZnnBp^OtLx(*&A`nYgQ|dRmUn%+yU?;L5{c5}`L+rfxzvaTN*U@x|3I{-^o%>y!Kr
z=R3wMo4xh|#u?N5k&yof|Nf30u>LvbC3+VX(Pr)1+Y9B<XxR$9YHuN8P#|6GruqB{
zs8Wm~fvjOpRIK&@H|6Q(P?X1fwj?k4-t^LMV|Zjs<gLW22Sx=BxWX8L4pB<$3lV&K
zLVx&4|J|m6wV?DpO=y4dJ>b&<_^F)#@$6^km%ses*%v>^bQT5yz)fjQqLblN(ut5x
z1jZ|rqM(La<phi%%B(BWeb(b93es%&DwJl8KQon@=4MEOfI`xmPR*AE1O!n!mqfSC
zA&Ek$s07g_Qx!_6m<kGuryLFkcblf^`ugT@H~^ShyS=$}HxkRT^rf3yKb_B~H@z>@
z<e72@(%qX|^xl^)BGc5?eTL{54rEtvtqB<&5OGU7L?+kutREfdoSIK<7<!>KxO32k
zLO7o~5Yse?xzM67(R-m-HW+b94X1SJ=rA+J&|;}{^bD9#vB{dMMDNi944o#QCNm8v
zgGe&lj6kY^%r9~_We9+3I*FQU4{_0)`>8RtY=Zy}jo#dJR+&}lMsqPG<Iq0;hvRR-
z!)@Gs$N8Sinahd&%vgj-kMuU29yNKrHR9iO4<H%r=cO;5pwPWt`}ACSWoRM`gpfe#
zjx9h968S3;4TwVoVnKFF6um+(_pk&<7T@mR|3Cq;o^r6se0H40eg~BQ&Y0MuNEqP=
zw@?PygG!rvmsm(Vj`-C1OdmCW?GERA3gLZW(GQRLd!6WqGR<$N41HPvKN0lbr~cxr
z`<Gwd9iN@L<xHr}kSWK-0;V~A05`&X<tL!9(wL%ZOlN>?FM~@Rr-)geA-7Iku8GH^
z8+R*7PfQv>kA;FZO`=jk4<=+pFGK8cnp&%MbaQh(P1DuY@%i)T$;k@JGkji_`}28z
zbFZcmJ)&o(fAnRU&mxqV?(gqg^TXkIo=<bt$gs6WutJ2QuNiGnQP<@>yZhu*M4y+1
zq?t-ca~DaDQK;+-i0-C9ti!@oLEfM5g_v6N=@1cbUf&7jaG07qBF=B_IURCbHP6MQ
z60yWQ&<CP3#XJxS)J^*mnz0d}in1fP&@#KD_BIoJ8m*aIJkzlE76h&)lmH}zs*_79
zeMokK5TPRAUA#afh(HzQR8h8D``K@=pa0C_Y;nfvO~3nLdHrpF^9tuXobNf`=Q3Cm
z{Vp{&yJhepJ0O?t5`9@1U33y{qLYf7_&S=9sfMW7e^xoL2*3zN7j$YsLy8(7WNj5R
ztZLBx^p}j9doWDbSHoK;;<}1JAWA5VAzU(=V&Ff+hZ#h0JD%^U5bz<9u-`K8uYli;
z`*)A{u>;;sBR{?aKHUI*Qs_UAxAXHa?{8k5rb7f%Vfe^zau9GTn#Y+{=U7D|JNB)l
z<m=~I;hquYR!7Hb?;=G~OEU!OV$GU)M$&_z(p=P3jbL|oGanGM9uCv->TrF1b9Fo%
z4wISo9&R4d8Jth&GEqfDbTd1hPRqQQYVSR<{5;zCK1c6~Xise-;{NU~fUDz`mc3Q`
zyr?RH{K(b&p7sJ2fm#54UPMT9D%hHkh;FLhT7^}Bh~#?}z=9bOuG-v}WsdO5Tw^TD
z%t+WlBO-lo5dt8HE%rIV>D;6g0wH2em!&8EmDz4UAi^?0f}>W@kou>=Nsv{Kyfrja
z6^wK+B+Js5-j`ljkmVg9AV4UpvKfLUeI#yb)^K<x(?Quq;L+RX=c~SGEE+RTcm3|W
z^Q-UXSKsuzA2{Dj^tI1k-YSTHatG`W*kE6J%z0qW2qRN35?Ht=TvPtDKlNtqPY6Se
zDtIbB`LXgtk;j`%<^4X{jR5H7yJW~HaH9x<jC^GX`9zb~gQ|e1YvbRBXSVdWk4*Rc
zaLoBr6vR*F_-_+#K0iPI;&k<_t0m=op~~EoTid}$N2)W|8!azRGgMjYQZJ+hpa{Ba
zqbe??ektpes%zKsA1NVl&+vqz6K<}ru5PYdb8kLPleIh$PlKISQ)NUf{XEb2cXwvC
zcIuky(wFFA#XOWgG9nOlY+UB0xkZ5BVVasdfaraWxx$51r`7-<kT`hsXzn5seIcMK
zuD+^Hi9m#me@(~P`jf6wh2DLdRCS)uYI-;vT62W--aAkWGB>D5?_Efuo9c8pjJOC|
zM(E`iC8-w6LMAPd*%eGbvAU=x(~TY?$QuPS>M2z`P$^e|ny6(=wkn+_A_z!EExRS9
zE(|h|T!m_Rg9!=J#G6r+(kKQMZ}92bh50{;8T0*gy6bnZ;`AElyMFho-+v#cJIp7>
z!U*mI<DQfWU0fHiL@dD^?L~!)7;B=B_<L?nl*|WBfly{dhc=G11U><?Khl8o(Kz|V
zPGJ=S6Uj}ldEC`h!FNn`{*_LL?}vK$<Gz;ar!>%?1ph13Re%2F`R2uaJ1(#&0o?fQ
z?orJQ=FweX@!Ch7!Vzq-RF5mA$3lq+g{c|HIy@Hqqrtq~mOVIkj=3C<$HO$W<|-<t
zH@7#(>+3eP!|~W!1F_7@(&y9tsV|FCQuhd=_lVxz6WA7a&smVUbBAfleie5oLI&&<
zJ(l@Awdr^~wyB{9BO)StpQa`hZEc#SWmzJkFytkyHAzpIW;uXoGv(mL$M-JMNfl1h
zWP^pJh`D9Od?w<R?mul4iTaOy3lI?^!hpI7w`NEcF=`;tLqs5*scDt8O%yX<@I@vq
zfdqO$32Vm4gjeIJddth4TIDiz38;FNK2RvZyj3JU3W{b`{V0qqMF4uX(<{U>nHwS@
z>LTtYew6EHe)GljGL$oy`?!C#y#B7=zlt}n`~7R2-^BS%%qRARh*5U@o*jVB=wP6t
zkj%9_4y(yx4TPxk!`AZ%GG@V2{gIn>__1^J=24bM5S|Y?jpb{uJ{g6XOS&~L5QZ>D
z7x2N>c|QpAM0w=99vXi9aQ~1G{Imf6=JVfhxa}{#xIbK<#CnQ7A(x@z7tB^d0eMtU
z60GWOQ$mjlfXiN9-AO-lbL3QLt$A}$5J3{iZVppd5DUVD$H@+d$=%h=-EW`WJb(WD
z_V%_-Q$!$Q?(^N7yLp+-tS`&ye69e93{U|k&vHsJ)#yDUNVxfNng(4Vr~A`kn&{Fo
zn^|H+&GgVF7^l`$<nGlgtxRb<Oo!f=!!!wb_v%$1y_b2Oft%~=J}=09pek;iFqp4#
zLu)CqFnT9prqPl24+7pCjDGGFl1Icc_j!rv%{^5kn!<L3Ql@Fj2^hUc7o9v`-!P8|
z22}+N9l;JVLT_q`gb4C9EXWp{PEaEjtsGII7Wo0KomAt=v|_5qH>D;NK#;gmx<U$Q
zD$<cECgPd9W+GYmnKQK`L3lBn%qI6MZ@2B{i{lr+wpe7jkJGF9?uYXa-<)54y}bS*
zPH(Wx72mcSgAaFr2s$t?SQdeZS|%%{W(uoGg(>=HbTU6>Pz;QYeny;B7SZGT#50cq
zLT|}EpSU0lOlK_}i)^P+g$`7eG<3^b!F$j9kDkrnePI8%dH;_4!J|9it@nId0Dp7*
zr{VZ)zWr>OuDdo7b!(BwvK7mD^0GP<5ZQJ<0`4oTSN-DolxoXbArgsC=gY6^P|EJ)
z&E4Da>iGQS^XJc>ACFfg&+{y%0PpYb^>hNF_kKE`&-1x?^VSF~y$hK|FbZLhdFiQc
zPoSNVnr@9AY8t)w-rf8haX1{NX<BmBnl-oH7ZIHA?*T-_?d@#=+#mzze#%!d(lH^T
zl+&9NSa1+Bn2l7G!*t-lZGh0$*5n5u7?Ij100(KFVW<cKM03jlA4`M)$HPIk!zwcl
zT39x;g)kKtRhNw1QL&NtE9lW>@r{fp&^hultjuZ%RNz2ek<v{oR8d0MW5gM`vgiad
zOwF570CXE>y@HVjy9}Z)b!>MV-fk`73Pq@<=7c~frNvR0x=-#`e)a6?*%#Me{#tRy
z`TqRs+c)2Teg5H_<?aWZ?$MY0Ayi@H9&zv43Xl~=F4m;kkhN~$Wp3t50}2-4PY?^R
zIJ+n|9j9)M%O86<ejlQeuqs4JEP`3Iv+BT%JNws<=y{jN+`OyA>M2G4kGvl|*a3Wm
zPWZF{{?>0k;drwgZx)}RCZg_U(M5Ku9$ACH)@)wg8nO$)*R5u>B$~R)%(&H&Y^}VI
zRE=mwMo#T`b#-%deSLjxQxiAy<~D5=<lx-TZ|-`J&HyV!IlA=LMl3=g82L@)^*w_S
zGX9g40L2)~qGli%2ojNbLmCkXfb586nN?_>krO_j=Zpj;>F&`(2zQSNnom<xv*kQf
zsI7GR1dwP?<@R_g9aCeI@fWNKPB27>-b=Zu0>pgo?$*4e1PHw^q^&Ikls?Z}XT4dZ
zu3yzE-c6Hf*0dXB$YpD0#yYHLQKE@>g~<^VWT&qdS;6Y3RTG7l_pNup3jr#G8iDFz
zSby_eJ-g+KTknIcM^*tBd7V^C@32VZMFXLv5~lEGYJNDVK&AW5a{cV{t1o}uPjBYC
z?@!-<eg5w2<<+-wzRw@&RzjhQ06Ne~x>^%&VlHNR11L<b=yT0RpY(oZpdDjo^}>S>
zL)<<D=ivuU|Ba4jsqG|)g;-L7s<oFDqaXV(g8upTBiE1niys*q_Xz^}NxrosuAa@)
z)gp!fsG`1R`mS0C*+mAf<zJB14y%k&86~CX$4~@8D?F^YJF9V}Dp##t9gowYd28OL
zb~qlcu5NFid22oTd7fXtdY$93$C7njz4xUr1U!4X)FXmDMAS?HC`A=X0+%~gq?x&@
zm<?G+xVH@PS$d~nnGxvu4fl``BEp1IYlrF3mwtcu#!a&TK+Mf7izcfQ3>1Zl1Sp_2
z@s|1}P49xWNi~0}jDV@QyPL++NB#vfqE3kB?q)>vzOY-n_Nldy6!I@3J|voo=;N1C
zrR-T^Lyt@t1!+U)LBs-jbyA`NFLT;vy`_*06=Ww)rXpk+R=JQ(-8>CwV5h5_S7Vp}
zUCh)gG@3dLwybGx6-Ttn#8^6B725bK#<gdFYH7lfMD?J;Fp5CjRHx~9xc&S}1M}(h
z=7;(FZ|3j+Jiq#8e)U~Hy+L2tWA(mbVRR*%Xr_TW)UegjZB_M%O>|R<rkJahH=&qI
zhHKku@}6_|`>zYsQjS&!PcDF&?99@Qgn*!kCm84-f$Thz+b-|#71&kByi*3MBX9O`
zQ0UVF_*+9j(^XvE&h0RZE)h%D0GGZ5ux0V@pA~}?9;D+a$rujcJmp~Ra9Pt^R1=+X
zZ{Ez*d}`01KY#hz=T|q^slYkU^Lbugzj~#n2=s{F^DcsUKKH3LZ>rkVD!Ujo)6~~g
z0T$UZ<4q)bOw$y-_lUz`l7Ne<TaOU3xw$*K&~QG_eMXkNyZiAlP3BZHm8Rb3<^KN7
z)GDLXTT2W*4aDhc>#-z$8xcal^>CO(3@Imx^wkLv1Tr|GnXBrlpGW)})m!w%O<X3?
zmcDB<$&PsfDs(fYr0c;`7p0njn2LIHfXjIfw`rPGC_uU`TC=*8^blK9qwBSdh|K5D
zBqD1jR$TN*NyzvJ6{nGw{tq%@$yc>kIBRhb$^rIOmjg4_Bcf+|wpkWFRGXX-Ds*bA
zz*2}nk++Ugol#`bw1qb@Spxk8Gi~kW`1!Nj&wnoS>*e*=ci;Z;{Oa5J)%VNmyM8)h
zSwsb)eNkc(50NHjqRwG&H<pbNDhfdmeb4|3;7pu_XO+IIY?luNfS!nheso2Y`a!EH
zFPI#FbY)jkX-bb}w82!c)1y)UPhL$vLbUVt$bP~#_HYMWEW6!*dg~K@S^$6JHyp0w
z<{7ST#hckQso@NBw*U!qR|MDtfwh0c%*=K2=)H5C?94`)Nuo6wFQXY0kcM70y}G`7
z{`~o~=g)6$ZbUUm5j~yHiL>|UOOLEGL}1kIN|yL?0fE+<d+Y4;vOwvF$wfi1L(Qf(
z^`*~CB<z#!);`aOemER@??6n4gSurbkBUsqo8Kfi3PheZv*12ML`B5Z5RgoPNM11m
zI1|Hhrw9W!=+63z(;=cq#9^A|(@BJ;O2F7)=-Q=jMCx_c3=u|;8L*UE=IrlXR0$-|
zl0+&g9g83}yZLovnY)R!=6#t>m<iQA`qWy>gbAEZr~7GYhr_|t7(D{2l8Fw;wjY7e
zY%03i%`0&ai0GzvoZ8e(C=r1ks^ZN=B%&h^=Nxs=<S0(b$G+y{*W^uoQJ(Vi*sBs5
z#Y4&4+{lStJ%cKN{8ySOOgfa%P;<TZ=U;yQ?74D|`ybwX`{%oF{`}^<?_xQt9~e#O
zB9q!d?cj%lPt*EnOoZiMl;}iAQqnE}oIqp0f;dN<L_<a(&#2kl4!LiQy$3|^6VQ;Z
zHNZ0RUe`g1JpPL;t`G)6wWez5=~dpO)qBMq`7y;W@BS!0VFK9C@yl8Nv82eS1@JeP
z0P%1e*Uy*f80zeKYiAuSsy`(G?2KK;+PT8Ae#r<F&X@7l%cmksfFie7$CuBaKfAqY
zQ==%%+&vutOJA0y_ueA{9In)gT@lmF-xQJ5-~s5MDufXR5h3P2;*CYA(!)?n7X_B{
zIpg8xQy8U3Cowfg4JJ(#Xg#>*^B27@lGu(?Vm)6a@Rg^2jKxrA<B@@6suc7d8YRvF
z;Hqf>OKu{f5As#bEUllVr&SUJdY=bt4V(j$`{0l%!fJTQ-$-WWsb@1XUEPggTOb($
z^uCyB&gh7c=&I(KZ8vNhmHv|eQSUufxnNkfej<nn_C+9Uxy;IkR3!r>$W9ZbrP^j!
zpI(G2^7dw^_v)&86alq|)T5}Nku@YW*_`Sq&ahK~s!~FtgGOm)e$94pn|+$v)z$46
zpU?NN&ZpPY%fobat9ld_v4i>~<}v~VN4*+HS&$HEdrSOj&Otm%8AnooiSjr7(Z{7j
zUqnHyH0)}dfv}Ua%Ayv6prkL`dMILOdEbllynFgTtcQI3KfUMDppS=7d|CiMdHhG6
zSGRF>+r>JyBYIDlQ2kn^PVwfgrGy6xW-vLn^zw{c#OP0?aGIvW@#wCtwZqlb_3g9U
z+neTX>C2nb{oUOi__}g6lXt9FRiR4?QJP2)+0iaKa&ZHMDZw;YEz8oTR(9OLyex;q
zft2Xo-1|I__C)q&PP#hgrP_Cs6^IB;v3p5E(zVsRWjI|9H+L5^Awy8LGl`^EQFpny
zRBKR*>Riza(&u?(`irUd2n0+d)8e2N;G-r52Lb&&S0gYG?9$paHC0R1>>yF<$6aN%
zl@A9&)QLVhR1rkXamxB0cN3z|Gc8>Q={L&NoM4oSNbgHFP4<rF)tZ~1voABFyL+p^
zYoH5N+$<AMDZ)^ydffp>nSlW46dFeQre?!oSxLGGGPtxv!`zy;NVPJ;=8#s?67sC2
zHna}K!sgnh!{OSmpWRYkEX$o;>+$x5`B5Z9o7j|QG-mQ<;S^d&{J{XTc0(7;g0ouZ
z8Vjl%3b@?`U>~*r@h`^_E4O-`vwn4{I(YGPuT^RBqhEyli0S_nRiGbrO?XgE{Jte{
zi2{9E0DsdrGfqbwu3(-(VxVr<Zbo+n#tu+%1F1?eO{OnvLl`7_0z~fKypf!)u5MpE
zzkT-Xcs%xq)9LihH{TEpVp*1@_ne{Y$zp`xuVn%v5u+Eqaw$-RbX4vTw7OgfY0Xpv
zh~D8I(a-bwcs!*0W3nX1001BWNkl<Z*G;FZWAw$FtJ$*5HNi!Jiakgxlw@&AejyE%
zK@{tjt8;2q(kIKS=*%6NvZloA%{5~l%nZG|TZAC`WL7ejq-Ygu8Ka3=UOEDSXzr=~
z2PzAc8tA<w_mw`HmF6Y5%ve(uPE$+#N>$ulNifuGYONSm2E@E7?xhMZN5*HGmX#TI
zis(}HZ=N~UkyHV)i5?&-PHpH**Jun?vn-B-P#7Z6T6d(f)SuP8tbhdBbjK$M^V(yg
zr0Ga`Fi7<S2~_AI;zoFwNi*6+Xb2a=y&bM@+Ko@`My-i9)n<OAP0357x3O*l&|=5)
z>5z%g=)y&~2t!i|`XuGaw+{FpF?&a`W)umWWsoe$U+9Dr1p#F;>E-cUKV<a3zX1k(
z7Xk3D>HpC?;L`&5+d@E%?SOU&QMHz$3v)w|W=3246an-e%Mt+dort~$3Afe`)A4w9
ze0KBf_U6{TotOE|`FuK`Pv<it1@}Dw3QcYD)_cb;a<1x3RFSFy6!oVt9bx)fxs=7K
zp)Z-o0EC8s0>DiBJOkn59-X$^cF>M+n_6p(xG)OkCK(qI7&0vx5mL*}B(*ylX<E)^
z`GJ<CHdMs2Ie<b~)((icsEP(U$jE!UIe>hjV*|If>JKn_xT?`N<9d?64N@3TQ!+Ye
z1&|Ao?dw(Pl15j8=`c`K)SfwEs(=Vo#0W%zAk{Pjv}RLt2J#{TE^Y=y0%WmBwvs0v
z*Z~`P_?oSh+3Z79@TCf<#0G1O!Om1AZ8q{GICK7}nvRm3oX1(qTNx#yqGDB;sRFB_
zUaMnyC`~}=3h_>c3v{-A4vj3vv8f%*CNa-?m4Z4eWkC_j$e0LKP^AlJ!7LUs+yNgn
z&p-MKu>T`O0_f!I8X{T$Xn;oFS6=div_21ux*iPi_e}Yxb_Vg622Olh0Dr^juVPL=
zgiWC)=5A_6rKx4mKtu%U5@7C1=)&YRp=Q&R1tzX$uHJm|Y3hMxIi1d@(=w|WDLMbM
z?_E`*sut@4J)Uz~4U<~9u~v~{9vs1uY?IM%s-Ef;H>*7T%60dMg`_t#0i&kOd`|It
zWeyMOucAy<wgtmXFc9Psm}V@W+fd;N*#o1YD^uYpL})ekDRX)zV?Y4W)76t|dL>PZ
zw@6+k6{$89lbVNnAQo1>4-kPWG)~(9iImrCiSL;Raci!|j#_CcKaw1n?1ZEU)k^GH
z=hpNW0U3NOq?v($h&4yRlqjOR%HLOehgE>9ionLSFjhfCtc7L5bbJsQva>o(B;5c8
z6H0<;BXcK(IVlnqtOYSz>}eXNv|3cW1Os3|#Jc*Tgc$`I3zt*05NRsrIvv#yVovMh
zWKlxU>e_{9e&Xzf&jlcHS?3}jG<-iC0lH9RLL>r<VixK3LdZ)}2R|<Q|LG5Y`<TDJ
zhd)X<^l1V79c=)y7Ty;3*tv-W35X+rExxwA{??khH>G6jcLGTwB9I6y%PAun0+IO*
zI$-pipD2KxQ|9-V!JX^VahEfsqC&MinG=XwMLD;_JhLnV2pgT}Ku2^c6&|tLk=U1T
z_hp{vVh}A~aVDy+)YY_Bu2;~iu?q~u`l!+)7LlF3CPGysqM8FST+x=97(=?9<fn+c
zi>zd0^0OgIs#pC@)(@CgIzO|B*oG`h4sA+QCN0fO1&{~@0)YxcNJQGK>oLP}frHT(
z9Rx_WT8<Yu>b3!<l{X!7LYaFX*BvmBQA{cnRX1JPnN;!T(03JPF2qR2DRfU28k_B^
zPPLL#yv*m>hc&p+5!sm{Nljxy8Lv%5X`0l6niPm9DgqS`WtfHqL@BB1Oh(^KrYrR<
zhGZ}V5D2L-+dLAiEDT{6EP_Qwp#KPd=2JB_f7$CYcOQgcbmrI1v?eGZvEV@yz(-I2
z%fF>2k9@)p_&jS4?#H1(pE!V@iUg<~VBST0NjOssopqz)tMViQ!!FwnQ)`o(3v`~B
z^Ld`<d0BeQgUcm*Lj1)2=`146-CI-9zAO=;s%|b(J-*6|HrI^hlqzo&SzAe{!pK^H
z%*{ObQN((mL6Fv36OnmYasu>@2u(9o<=T!8RTa_JMqp{S&W{8$4#XL0Ad`qllax2l
z!~UG_v0OkJ$rTDJY*LuX6IJOx<cq6;KazP+toGa-(h0mGf(TbRw2FLC%L+C`^bsMK
z#4}Be>h;qr;VPFv2qP9VpIXbuEX^&yZtscO2a&F=iU4A`nrF)bVQL*ce?$v#Xe}SC
z3aG6V^JdbTDgmH(5ZN<UeKF&(ud;Qwnd*r0tgub4-jd|fr7CptMrOJKOlcq-%S%Q^
zo@sIkbwg8#sGFt|$^eO(3zR0N(wR$L%w#%fYhso$8d8{*W0Vu2qLY#Yj*-c{wnA<#
zl7EG>|Ko$XICDc68(wQj?;3q=agqA*@?(bn;~)8!q3prs;4esletJ)QS^$4j5s<Va
zy#<xbq|3|#7_#IsdcC!qc4$7S==nU~-Mu-V&dm?K$N79-mgpT>Pod@S(Ui&OK^s7v
z&v~+GR?Xvxt!$EOzL+XaOVBbj70Gv2Mc*iop&()bv`1HE5RB5OXjQ07x@z;K(!2q1
zv*w<>r>+%!thVFae)*7~1v}(1oMsH6S%z>jE73FqkXPU#?XqLiL8=VWJ-h$%N32A;
zX9ZBgM;J~<d*)Z{5yq^(G=jkq=c(*V!T#yLW@p$IWhsQJRnv<EBG=LQ<^V+Z>_JZY
zJKLT!|4)$dJR%ap+&9@TgHai2T3OO{H4>#V<ACz1qoOoTp=?2UNePsLwtOMQvk#0<
zM@EP#Qi#K$v&>Y%EEhu7F(fUoG>WI+n<}7cOzx8@8Jb$DwwQ;fZeZ4!XD*8XVye@m
zK3Nu(jS}RMdm?!h+EAgf1N8l~9^+1|KWgOjqBB4VK-u$Fn(!1l(c>b7hnLrnJ#>RD
z#gT8*yibLLe#F}NAg1>nRKceO@Hc&H6MYIZh+`aK6J}3k#?|3UudbJQIi1d@`%_=~
z`8=Oa=XqXCmgs$1IxrOS6e@(4(=9dqQu+I~nxqh2gs!H;EwsBoXOu)8{ZO-}N_9(#
z6QU~3J$k3mEko+j`(moCd5?%5`Q`f3r`B3)2_F$ai3nw-8^E>s5Nl|uP@*FrlVu}(
zu>ALVNg!ZaKPIzuNhST7+1BGGr0Ok?#9D;2DwXvKXt@l60i;jBlaNG|)E`))TY9y`
z(&3;w%D*Bs2Fy~(IEAL91{3_zEisuUL|>{~I2+2e)LcsTK4%+n{!&H6Oq&^Vt!f34
z7ViM*I4h|to)100P6T#no)`Nt%o*Ypps_Aa87f$znz&cEP%eP#>Y+j)qVA1S7L-vI
zAqg2NN$Kg&RxuN5HTuF5Oe7Q`pr}hbiXYTlE?G4(8ejsg{sN+MO$aRrs0$&6t=W;o
zxiw;X{sJsWH#~`}{3$34(bc3(2QWa;_m$jF3Qt#c^(E;4-UPSD+HI;LShupB_tL-b
zSQ4L9KtCl2$T|=Pkye2YK~ryb00W(femdRX-Mx8pcR$a)_dfC;&xj}=lG>UVM>Pua
zrHQl?CycG4k{zu<in|T^^^$a|py{L`My(79D}7M1o$iL{B-=FQr<DM++g2n92Iwvb
zrK?aPveJ<ZHFd4Wk`KycHJR#GLr#o*eO>iF<JBOeo+*Rzs3I+MW1=MLDl(C&A)$zw
zTjJ~i$@6K(EqP%u<3f^`gS<~jnj5gpG@TBI|Bt;lZIa_SvPF-3L{@d98vqGVcQj-7
z|No(9cJ0kvX(&+=Ns%CyMt4_LX1JgC!960gu#f;qjh>kRqe%qO=%p54j-RE7nw#d@
z@7|LM!+j@o(>ZnrgyD&w&|#in6x}4<nc}gG4+&PT6XLFPE1G|zMV(34NtTXg2xO##
zsVa*0fb=MZWTb%shG_LYt)Mf1Jc&0hBS}4v=$(yELIKw?7|Srl4+=6nCo_M9<OzsS
zq(*v~o0~Kh6jEK;W|(4EQ6K33s?>dz@i3~O1gFcqIg}#iE@+BHe1^@y5|p8?Uyf)4
zB#ZT|V18`*kIRUN!jnqi@LA9_Z#xp|dUvn|M8!|>bNiKe)u`PcmI?fepXYM}_~!vY
zqA1l>1JTf;MWvA-+*~L&+s&(+SFc_j4#!|FlCZ_BHM3w^#0;-Jz9Nl7bBPcrd!C~;
zXX>W{3~0+T-YaV&ia<pX1M->#3xkVwx(P^PS@LM@%~UC5383S&^vkocd4aGk%^DdJ
z)MzgvMZ`PzlU;M1C(WGZRMSg2$?7SY%CFn?3KS7>MpJPoX>>xhXk_g6veYw&g`~Bf
zfkx2WEbMVe(ls7G6}6@)(c2a{Q3O;jvy{jbOV_q4niply2F75f3XA5Qm*FyzVTk<(
z0G7;rL$})rbrV%YEbp#ytVuxxsG~$7D4(&_r3Xl!uNkp0@$j<5_MjTty`V#lB_?hq
z2?seBXAx%dTj;sFhA!_A@tRW!DLCPIbx=UvVJaapP`Y@dz(oyQ+{~9N_r1!5dR6w<
zwO+UwfyT}$Bb;nz2BQ?Wd6HJp#AmT%So24Fb%*wCl55QGCmw+Xp?r+w>qc?F(M|=6
z#$N3bD{5%|-pfSgI_bX`dCzbL{@M<qfxO8tB1rH4PCh4s{gWv`@dDN|)!k0^M^~jx
zW%7Bsdv*8f#jE?fyVE=`^J2~DZf2f=S*ii?a;Vpn6EEaY{tKXkD@aF5uF{7-XeSa`
z@2M4y6fgtV%&}xVMwFj-?hFW`^oU6BrjKEi=F7ssu#$oj6)_{gm6Sra2n5VJC8T&x
z_(7U1ssdH<v1Kd6zFq^F%}kZp|HT<>M~^I)@Q0&?8)<}`xe1`9imJ6mb7mx<Fb5ni
z8T+NBB+_k6W7P!!+d@^^60JbohfDJy(27a~GN!3~RiN~vMsjq_2gV}Q=)c*tyN@Td
zs%XiUWCUE-r^H5VNsx7ew4Xa1g-$c`0Q3Y!OZFgJ%o89V^1ggJ<CW3>J|aX$J6SY9
zDu@fTb8jNWUAtbme+NcwbRjg(F6;**r09GBb`V9GQ1@E*RYB>P4xtbYh|k<T9Eqr*
z1hyGm01GHS^<zvKw~K2A=KTut5Bp&^b|)@iB)>#|R6>kzdQ!iqzW+j5U)_t|wCsPU
zzWC>^!Q)u?33uSn4d9>J1GK76RjatphxzsE!|kiP!`<=b)!psw-F%wU)-kbYXE?%X
zax&80WqXDKH+H`n0T3DQAmXLl9V9l`Cx>fnlA%Q?fhwe8$T1v`J7qIK7`nJym?LzD
zBFk|x%--Q+lZd|$gPA!PMh0mp(-SV?9&#&@WCx|qsenmrMQ}ccXrDetFBOEjfJFHY
zlL$IV%Z^E>TM#i*J;ecccq}I>{U(@!jRp~VbAsLoOO<adM_oc8A`$OZq|<gopnx#2
z@WAxr6cZhyS5T}z1j%JpXxghfDRd7(Tt6vze*rL1oV5GSGf5Ch$6ZG=o`4$PaemE`
z#vlE~VW5W0A`kFgRx3TcUEm@8Wse|LmB5<fmLJ%W0&W@)uLh!TG-C_(Vq7Rnty8T#
z)X7Ry&F3e?U^LJaR-hG(F=nQpBz&T!5s_L@`rRrXW*rIGpRkZ;vrGHacx5l(5=PMB
z0}3w^IjJ8|wLb(N;yY0LUlM|S;KlguKJl&|@VNo}^9}&}D_%aHsW&%wKi(W)+@4;&
zx_|lV{&c@svq(nlmS?@}1`-hSo#-|yrsJV$7RUkUuSr8e)JrV5^xB%Pwz3UUWk`58
zmODu>m9%hxAV@WxOB#+iX3}S<*p)*)y2cHMtOwLAzf3V#eCHZSG}7%ze7k{A2r6hI
znl=>D?a<fu5@pe2iUr&)&y}iyZkbt9K=X%HB)@Q!Qa1@wX)i89iyw%H29PHV^vs2L
zfK=2)RJE^OKDdgcVc2j+KtS{&9qg)s!(_Zc;QMD!ig&{aBn%#5W4^|IQim!;HRnrn
zXF`9X!R1Z0m#<dg7`LDvLPV$Z%`n-*edSCm4kC2pojo89amll?GjdZ9cK{bPx}=j5
zL_}-d)!pQEVmXLL-wt83!-1x-DwXg8lD@dj@zekYY55SuHkSTD*u0KE7LNsB6az{|
z0=T=)<dV?@gizt?)<uc$tMBBy3-@m&Q+Rj#;-~e1&kf*z{FfH$&UaVy<yZIR`q}H{
zPe1(a|9=0|tNTV4P(c-EM74T)p+QAUdb=~GS=EwtU}In?z52(mkV=h(06jY(5#S8q
zCXqCmm?ZNpEF;{tv-2SI%qoFMB%dT?B1)&n@~`m@u`V+hhQjNjT1$}*Lvuxe!c75+
zFzE4grA(m5>FxoVboK2T#V+W%C`eSgC<Gy=R!Es971EbxRz#EB(w&r~|8$zltvJ;N
zwoM@=vt|glj0?{1aHN^!b_ACAX5;g_iY6M9IQeSvKRkdkms1%YJgP~J4MPi&)eoe9
z=`Q2Wg>U5QQo64_YPNnyM7lr_h?eACD6_aEGAZ+`P?%c5Fo#fCsWF)qlO7yBQ!F2&
zpuSp8(wb{lIEClt=|;C?vxsV)wC<!<6zKtXp*nV&z*J1(6%1+EVm2!++=4_Jb3Yr(
zb^N+I>lAabg3g2^&1QNS0TC3Un5j2p^u>EYou8S<-=$mFa(h0K-}!UZ|2-f4c?0+-
zPW{5NW4*GAFAkSaev<3Iy=-6q@b|9|yj{>t-5U+!;=%A13SIMclRBylHw+*A{=yrR
zT$0QNf{`Y{>#Iam5eSEcJUHic9rP9U$rhw)DP0EEwF#k4E~;<~b7X*&l1E3TCqd?w
zb(?jDE7_QjqOK%MIvMfd*AE?+2H!F|qz5;ONGUa4F!M8P%D=n7iwaRgNG9$Op^H<p
z25IS(KROW^DJ7Byx-}cj5Y*YI;4T6qUFiZxmURs2S+Aa=v6=WLejX9fnb~D2hD!Wp
zqxFt8PsF6db#XS1uhn(A)Do<o`~i9c2pW&XQNhfZ8OXJy-)NxfMF;Sem9Fm;3e_9{
zoI!Wdl_wi(ML2+_{{@DDlZtAAFi+TmF6<)Q2MJXOdIMWPH&UiBg$~{th$yv@rYr_E
zg+oG2;?3KPkb}XL;cZvg*JGUVnLmLZ6CEw&f%zzyodk<WC}tF#tVuhKXYgHs%!ile
zU;d6h;Pdo5@cJ=lS_FB!2b?VdpEH5~2M7O&yK8^&^l<UzOI-eVlD{qbt@8)-+l6z3
zo5Mw@;g02DhLRJX^xTQe`VgR*4_`J6-Bwx>^L*x5Ln{Vp+e3E%&+$23c@pgj8c>dj
zIiH1gRJuG%<K+j3FN=tEm$69M_4vRJE#x^uyKTSC=9|HdJ@(Sm<21vulH}8kmjkSq
z<XsBgL*k^PBDsNH1WG}h31qti*%r%5Jl^RYx2C`vA`vo=2=RqXSRxfslSmmZ^<cAc
zf5-<dF4oeQ9jFk!zxLQ=6}Sd@Q`bc-NLTE98d9YbK(XOqK?Nl>%}X8tItgqbcoKoS
znW$Uh=`;$wrL~Vhs4FX!>tFXU(Hpn_ktIWC=Ng5SKvY?T{eG!})z1^|$P&t+pjo3B
z-NYT?X6F`mb|@3-6j=(Cp-5w7WQGAVjc$ZHz0nr78NNudjJAx}UMZ1``fC7|IJ<P6
zai4^&Nq9jgF|BwLo6jW&+ww|$Q1$;An}+u$y}YN#_<P`{?ZWZ1zdkpBfBe*6FSvhf
z7mp9+`UV$2*~Je_`Tpd8JNOOTiCmg{gP<rC-rPBrN=QpN{Cet_Omb~u&Le9m{Cb+r
zH*fsD6DK)P0$*J^vzR8yFQFt!bOJI6ApJD8x*w7hhL>@N#e<|1eh1M2ayd_85@lUg
z7)-hq8R@46m!1%tm$$&I$kGR!eCJt<i7k%2s!UB7x}LTlBs8v+85KzhzG=TbfUXpJ
zi>qrWp8}=<P3hw4s4R>K8jnZ-2@((b9oGe_4E<VEe0By+wts*E6G{X$BFAmPNPo^<
z$|ILx)kAQci>XizLTNGsWDu=7s^>7W2f;9s0tQP`RXD_{GHjiq=?2|1mWXlI3HoDR
zx%)Thl3h110r1qnIUKN(4XFcJ9#%gN2irn#U<DLqLYY_!yCdrQfYHNziDqIZZluu{
zv?FXrF_c~Skun_WSR|Z@K5_i-M;MfRwo)qC1SaB{&P-twTjIql8zaRJEd}_8dAfb_
zug?wOA9?026L;6k{)^-O@ojzh-1mRI<6jQ;Y-#r>$EJ&UYu1{BvI|tBIh$dkXwcfj
zX%iwkyd&xE&h>uBVFtNj1LdJ_eR-!dPS|FmXK64Y{-9BIVOWP2#`TXm1$JrvIOhWC
zG7#6li1F%PTH#9&WjR?!62(w-D7ge4ch5jPq@&b59|oen;kL%)Y;D9LBrKJTOc#3p
z(JYq`DnM};qCkt3PG--D6+}h~G>7%jS-QnV*@+O@hIxjTB4&9_NivK=HT{xP&mE_c
zL?_C~jmd8;0CS5@D;%*u@uC6Xuv7*>*xQwo3Xfdiq;{=@tS%ZOI%6uqHCx-J#HW|^
zu}|?qw~OO=N<|9t)s~{NFo=%3Nk?lKT~8tz(mf(`9kc|KoB~1}YY!m3Ar=%Ww4zKX
zH9pJgNhF{P&DffosWo_w2H?v<m!njJmazIJoT3tGc<-FUKjK%%x){_{iZ_KRx?2|2
zOl(0nOMR>Q%cp+vU+N9-n(jY0fd3y){m{wlh3y}o9z1<nAOA4xw=eAb<NXUOx2{LS
zsV&fI20E%#g1)pOWzvF*HlHFdF}TM-H)k9B`FKS{1{UQ_o0I_!u@}xY@H9Z_j_VR^
zL%R}MuoSF|Z2e6%?LjkMSZPkDQcCHe^xhy+OYzW2$uLT0o*VnMw#U(gpAFo4&ZU6C
zK$ir;GjR(k8}3dvS^X7nm}oJL8-*nvq{cy6OgD(OSx`W6Q94M?EZk1Tr-Pb#HKtT?
z3oiepvdWL?OjybDDk1Luhe%3K*hhEFjkQ+IfPt{@pomD(n7xa37~V;tM%Gs3@x<i0
z9_=?3A>F&v=Euzz^MImCDMd7cF4?A11zmSGjt2_q&xpAfD&k3%a2{ef2&G;*=YSw=
z3QAI*91eGu-1Xvx0(XeRJ(Aq$3)xchkPTp>c8qDvD(*C=8O+^WLlMB)?5_Ah*gzFb
z%&-G?a_q0E{#}>T9~Q!eP0`{Tb0W5+wy@J8J`%P6M~wgHdf*Qcg?(-S|Il9rqMY`2
z_0_RHdMQ_b_p9$-^ZWbu?C7s&p6HET-6GbHNwH>!-)s{`oJQUc*Razb@15_GG-U7k
z*zR_jRFpGHv2-A4!<ftsy4x!xDBZuHxzqb;INn^wt#7C&ZXAVdi#)mKcn+ry;TW6-
z%Q3%SHrO@2iN40)a`ZIa;bYu=!W@LSlmy(dZE5*{fPiJzOLrF1?P;+4PYm}Sjn89U
zspZJAJ)aS$J5+-<&o+0qR6@n#iJ7ryiO1T&&Y5TCt#rPSb7+l1GAj^RoJiuv9!m`R
z1sZM`v0X}tNZ9&F--+1Wa8?Ib33Goq*mAvt2%66w=awP}>p%_9>O98;SYzE$HJWiA
z|5a7C*JCZ|k_I7MG`<lbEMHxk{#N3on|OmQAW?Rxm%7_a-8sexLkFrBnA&W%nCxjw
zLtDgWZ}-+-Iqp?lSQI;|yDWL9qR5&R^KK&0)*fx}Zr18gHK>vmE_C=}%Td}Xtc|R}
zQLGIw=yzK7d;n_ycCr3B4$u0h@16TU(i7q{4fG#3_!mxBe)+|5diY8%f3p4eZTjns
z@9x`+*_%tx6zv+$t>0lNFe4YRNBwd{M)X7J)_0a!#0JvOUg>j6OOAT3_iwx*R`-33
zI*W{Ej|o)V)|5!D5WHk~3`g1Rl^0!9)H#tpAn*}D8&M=e8+K&5J;=6MS@wx&aEkF*
zL^%~@_MWo_uu4)b3a?}#9KH|zwjqeL@sQs3+<WiV_dSDC^3ELT3q9kE{n9(gN25i@
z)8;9W+jLY({zYCe+y|Y1ZO!iK9sutmZ57H$?qnprN99+|z@E{KxE@JHqN6bKBg1<x
zD6a1C1g<;;g`4Y)fEv`UkokJ%ba~$&1*MapL{t*#W1mApBjuSipSE#gFozoq-e$BJ
zZom#&rA$&PyAj2j$U@rUHrwQ-uL3jtuFXG9egmA~APYo9Ean33z~_77V&1H@dDR|!
z1LO5yy3Sw$XWB`)1lJWP^x_6z`2H#{A6Wg*dcZ&NHt^XB;x}5vD(i*suIJsO*VCit
zc<}8Jf4k#%M}N`ggT;s(39{>$l^}9}!aZ>!-|Q)k#p=}d7Vj+2j7hO!7slos9Y?Ex
z+lQ%pze@LMx+{bQVME}#*bkdWcJV*9n@70u47547gcKh6fcDv4e8L@UaQt(F4l76W
z1ee~x;!MGy_edwb>JaD)0cuvAwFgM2<!FXjdG1x+Om37(8JEpySIS<>$HN&NLpKw8
z7*})?)BXun(hpwp-Jd@Dgo|-d==-HMNAt1Bamd&tDYlgL2+#13$W4jeqIIxAdmEDR
z45R=c`&))uBK9px_x?*4jUle^B-<(|QdT2qjUz*RSMjuI;w}CD?9%N_Wp%2ESB7I`
zTM$MunlX;RZH~BUpacrUyocvK%FH4=t<Apk3GOh1EwFo=pZWY8cF$tTG**qcw%(IJ
z3aNeLFKA)N$`<fQ9@vhG1`mDp&b?Z=Q@lOt^9@Vr->N>JiS|G6<3B?{|Ff4~Eu5~}
zgRc(z$3ODHH%I;Eo_}BD<%#z*W1x4Zn|HB)3bjh9YZ7+%-b8XpxWXI#l|^|M-q^dr
zDD>SoljFdc3qRLQqTdLIU37|y*d4#R&L>Ed>lf}7aKqL}$7a<G+Da~UTp-uT@tnka
zmq1sP001BWNkl<Z$qp2LtPA}INw}ul>;wj)GKTcdP4eWV2D`F5UL+AFd%z}RNrsjx
z`%8fSd175r^#0TJQ+7_YLTGLzDRb!5saV0c>r3J>K<L^!fhtHUkionP=O!J85o~)!
zdSv%Kprc`_6o`JCx0JrZr9lY$PBQ*}TFI#>3q{~9M|PL6hDhaBT&8=sPL+1p^TlV8
z^p?vnJv{8ZhX`pz5da$g`71BT)x?}eF|sW%2NXJKon)F&s;G*%XlS=xpfK8rSbzqf
zO_oLcz~u$!pI|pqW`S)4aE4T3eEKLI!;r!SNBC>B*R(s~Om}NaPR(|05o;vR=CSig
z_z&y>{P1f2#sK(nCZPP>0RExXzdrEG$H$8=p2_w12mR}je_Q0oSzaEO)~F~d;g&-)
zGI`dWCg&rF$)hACF=dRI+xGwN*LL~|lcD^NYGxxYNzkF_3=CWygNtq{J?wLB8Xd29
zgUu^QdMyhR04Cq2D?_*5>>Y$o_vrL~82)S20V8k3`-ziuI!Hv(Cj7v`cpRQIfj)7a
zfEoT~!&S()@9og4O7C0UL9g#w+s_{$54EENfe>2`+eA-kUfV#2VTOQ#<4z+udvM1m
ziRP*U!RadI)SZz7d=no_iS$=RmfZkgvMl&8mFRFzC;X=|r&|1#uFF<*=>=k(-|UHf
z;LpWk@DGMD>)5}7^AKECT5``^=-Pb%;V@4oXmhj$W}rZ;)?Jx)QgnEeLcvB2Ky-1N
ztr&c9o|bw!YrV((jPrAuUaMX<sTrP;CPMgmm$t5KU&sGV^$z6+1T*v={)+Q6+MTk&
z;a=P)TS}WVY6<VT0k3hJ-B{y;5TP^rzYGxd({*HgcU0PEFQDI!=TmmRe|*}1aiiBi
zw&|O>{`J<rJ+_xlqgoRfgAy3eNAB-&98A@y#RWLuglA9o7F)(U84jBiD(2We_zUQ!
z0P)IB<Aeb?cc=$j=vW6gbgUfbhb<X5fZ+()RYVjDjlIAz%TpJFMg_vAXp9)B4yTM0
zYNE%IFfw|4SfW>w6s9g08@LU75@Lvu!0iI1>{iRGPBJBP{U_p@L=Ypt_y{T%P<?fq
z5ck1YO%4xN3`V*(c<c%c;(R|xZ-mW#HIbfamIsDJrI7&w7!p5ZreoH5Zf8!Bjs26z
zChR9@`x)sF-&=})`x7k*<MalYE2H%4pRU%i45aC`ru=KY9Ki*ME+g&?Z#JQL{%~$|
zTARH!bwE@~88?8<@m5I{cP?(HrM4<FIJ-6zJNfaacK`i!@ptTYA`i%kGHKt{#+Le?
z^1NX}jAFaKUtH+WBjnE83qSoJxC0HY@SWN2bYGT(&^}<`eqXF3`QBdet{(6k1OA`g
zKz}pDfA^s6zqp$oKbNa-m-_Xse{=L_C(H}oo1)ZGDbg&W!!e|+iJ7p^g^9g%aGF@>
z{xh{9-XU<$F+UkX;P$kIjSg^Y^EQl!6NKq+nXZq`du*_L`gEWBgACXmTv?{wrOruT
zap{-?)0{WXf<t#E;ZCZV1EaF_wGO&<hM9LC(*g7+Lpu_1#_5={+Sy6(AHiuE->1l#
zVJbS&h`kVFSSm#YS8g%l)b55=Sw5#oZ)EBD>YK{jZx2}-eQ;p&$k7M>j!ku?t$4l=
za<c9yKRL$B1Uh8Ji#8BnJhsC-2<r+NTTOcJjgMMWfS?+WrXio{bc~h}4j>Q~)eHm>
z?;STg0ZDi`(|H=0#8qCye%$B=r?thbX+no()d37_k{a3ZVzgu9qS}Oulm(oc9iA_{
zZ|l`xWOpg@L~sQuDi!Hs`+n48tf^-qT?4ywz(gE4fUm4QYx9o<_wYs+`fi!`hg+TR
z0ege)Bky=)zHhq!`Ay(mKF`0r1bkSl_?!v++thxRo$s#Z2Txw_pL{z{f4;}pclN`<
zj$WH7n1Z8t2TiKx;YJy@iIUXse#Kph8;O)F#<j8+m-nBxxW$d%Isv84*c$1M&fZDJ
zMRIg{h4qzFgAAG6>V!I4)wNg~3(?R`C0RdJ1pR)nno}n=T(h21NzIZv8eBHTKIwCu
zRl8O>z;u>AcCKiW^s=4+QJ6;PsF_Ke1j1V%tN-+BbGcHL$d0}D@+ndADPz0psl{sx
z_tZ73$m%MefIwV96rDS}Vr7F4b+&j>MZ<AldQ#V>$*oU&9$wgQETq7OZ$CEhS`S@Y
zg?;16&Au5$y+7`X*rYT>4#}w^RmGw=P|~kEPdZ_U4G%qB=($8Q-!aHMPH&4hg9Ejo
zPBQIFnV<#I;v1t0910hQE%4cNU$rR~$YPFL9=>nKztjg0wG_dQcpzF4Y#{m2t1sW&
zr-QND;CF04+3AP2{8VwIFXRPzaXjqqUvatT&*4lTV({?JqWvqOo_Ah=KkQR}ZU7&1
zC8`(p;LE#<r_c2IF9-ea8~f|QpU<34kjbV2t-76-Ad`oIjC&vq;dK@>uWww%hY_0~
za+YL7yEyrdfIHdTWY1pK>@|0k!!+XQ9GiTD4-e5al$4E>EO|RysAR~4hgzmX5_v^n
zFY$>bQxnVyKGQa)CfXrYpoES^WaVY&9N4eN!<r(3b0Jx3IlgFC<bk|{+FgaZTg8TN
z*$<@~l$2wV>wkSP-Pc=4ezqYX@a?0teU-Q*IFic|5|B^FB0amP`)1ltEq0h}O4RfK
zv|^ZFvxq|vJoF6g&!8lyVDohL&_u{;0t9x4pN>D}RYFH^2`J6g#qwYf7h@3zRC1q)
zuy#^Y5}e;t7(quYy_rDGMa`SBd9!BC=oC@ZNq4(iD@vgh0!nQRQ){7<3zn1ZE+@6(
zN9g2Q7F&Ki-hF*>d0F*=)Q7;e5J(q?PmW0>V899Xdb#^yzW>hbW#xg^Xxf(D@os;-
zp`HBK6K_6kg#Y+*b=CtmJ_4V00H5%yOuoCGFQ2?955H@>Z;t%)q5bXPFH9v;WSd*_
z3ayg9F&3^aMY~LvKsY%@3Zdzlce%XLw?i7%iQ<XM4lJ_=2~p%tA6(&v5F#!cM~Gno
z)=A481%I2QA@qR;V;n6pLi2_x5I0J);U*N!da05@Eg-dn)jBLF27-^ynps=a0G7uU
znsO!$Oa7_A#eM4p+L1JF1VJFqT{2|t1k(R)D~pvLIGcNdV7(Y8THenRBQYh`g8rZn
zz<zw;ek=7g;}|2TAxR|~(0p%u2otzW)Zqs48P3}4J)^T?MZ1V>Bamizbjy&AAr;fX
z-aU7cS}*-QVJ^U+JY)p2AKxngx9;}DqD7=T4Q7+{Fw=8)Lqst*a&A}_*bE4YqV7;?
zWY4D)EPGCY!wt)cQ&TbFY+Rr_SbK52{f4`X2lYwShk^+txZga@=eqc{ORsQarxJ7`
zhBR=2zvl96zWaW;|4!^ReQr)``@>;>`@EcP%^Tm|Dn0_G`8DAFCk5SqW&!;czorMa
ze|XqE`bn?8IZc1K^FQC&^F>eL+C>$EH>1(vu9*S2F7$&P-boa}k6+n;qu8whO}&0?
z3iTiuaA>?%ed)@8=tJsotMB)*HztC0E!fPY>(P+XlknCL*pOSs8gX7jQxRLym9(7~
zBx{lF{{>rS{b2Y+5O8Ra+36WvZ?k<75h2qWJ|XMvL51Vd8)4=H`r@WZaC0*p4rt>;
z#z}SXrTQo8c5H(4cjXwcDVr<65Ffkr1Mzt7w@<Bxf|#-`-YMGNtXwOggK-Gq;FEeL
zc5OF93Dk`PYFfLg`zj~sJKkz9$klFt>$X5DReA_qPW>sy3I`DphgcX-i;G*ehUPe$
z92<`JJiV67Jqj@GWx9e)A}B%+yQALL=xj6E>~(S385-5C__Cb*bh9tziEt{rhB5=!
zz>cgTx6H87^~nmNg)(n9iez>zfB`db4}XpM8Seh<um8fskHrskcbks$<?ZeM_66Ii
z9}#}dfd7%E|L0j?=dZR8`aI_b6`xr^AK5|+%Wk=Na<_l{qwW9j3V*zvzn%5gs~bv0
zYtTWIFx8JJCsGszrOVsdZF^`DGXjW~%`tUg{=pdGISevBW+MrXaPYO{4J2KXCNJj+
zksIy%hIYx$$-y{8_keQ_9DkV6V_W(=Oq3|c&>@GO5~8+-O>U1F{Tt|ky8TDk99%)s
z96Y-%&xW2fxIi4qx+4xOh%_AEOdOL3RVg1y4-Bdgg`;PrzDZMQkaaIjcM{B@XWn|&
zSKV6F<yT3wHs9FPOZTQ&A-}G3-WW2+%E5k-82nNhinj1+NNXd-@CJ{qqrV0`+<Qim
zPb|^<>2`B@+9;K!_a>E~S*_b;{x!jxMn)GYk{aU(oU!D#LWH93LW&la$T$$wW;hz}
zXWre|{Z1ZzA%(iXs8^5M^i1@%6c(o!dIMCY2w`-z*=?Td9?}epXw^x4x&QXWowQ~D
z_^A7X=$F7llq<+(x>4hd@)ZzIilAAQ{jJ0k_!@kH<wxHAg)je8@4l(+m0+gV*&p2>
zu3o>Ij(2qX$m;)d1^OfBd4CJp=ZEbg{LBLS^o#H0)75<W<@4Q_e?672Z`z*^e7Wd-
z6K@_qlDRMs7upPh>i!1Ys5$uNUB<Ci)lsHp4RYw?^UD8728ec-%k3p#*fmQp2xGwS
zFbW44nAZ8jB7&QhC7p|z;e2@xJ?{Y$GiKa!v55@pNWCW*d$!^THcmuwcHWpxpBY~m
z*QK42u9E)!Av1C#Eu6}-&UMZ?@*M4X&K-Zcc7-mz&VNDokm*#;{<U>j39XDt=*S-I
z1No4cDYn@x<GkCQI)@Ui|DWWQx)0cqsUjO7Y}EgCMDI5MSy@Xfk~o9_%5zk4piP-c
zvkJ~veRv0&I?R>f6FDH{m(%edr5_`b_p20Wp_X{mO6)GK5U0DlG2AQcemT9qmHS#+
zmA%)?%l)HAr^`#<DO!VDnSi2@k`W7qq_zfGOc(Ij%prT3_V@H3PBZNG_TuVUz5Wke
z{2Syc@JQqe*ol`+4b{9{DF~Rm(+uK*lgK^z3d;{z{%*H_@t1#;<G0$Lqc!tFUeCv;
z_pcw^Jy%=oL!ti<7|b_DK)>)w^22m1YxyJq$=@AZ^SJ@MclP()!^8f|pK$f38~pKZ
z`SZbFG%?S4bR(?o;;J|3WoOl&Tj}5yw;#mAb2MQC@^;vuU*-mLk7qpt>(O#Exve#a
z>-d}zQ3K%-Ztt|I{O?*Sj$DDEG|f4BqZ=5?fE-slCp%Bf!|EqfW%>bQkZ?9;@Eu=q
zj7Y7_20+g+_6Ty!1N(N9$aSIh5RXyrSEu<^XCU1~n#q^cyff$OFj(c()yH(JiRd;u
z3BcqC4|NP5BgksmkWZlozJ-jo3^HW|a`o!p6K;mXf{awKAq*TtdQa<xig#b=H&(|L
zvLao!n<qQ;waFW@yp#{mJC}`@h>mSB(W6uhY@{EGu5lZLFpR-yIX1t&m%C|ye}QR|
z{Zt=6EDx{j<pq~pz*Lp4jtROeb<#<6M=1`r<#-fGVHHen-t>lQe!Op|7wz~1uKz=?
z{zLa))%sNQ5z3`t2b3Wbb2g1PK@q_${u=X7Jbk|${$i)^c>gy!{7wCiSilRn{k%N7
zeev-1->1_}cWL>}@3n8h^gr_j&U*mgriA=FS5QI!d;|EPr$nif?;hUnp8SC8Z|=)~
zy<Yx&^g9pfuBucD%zOOmK%DVL{eL&^_ogq~=DfS*^Q;LRI1|Bc^gC}p(;JQ;-~K%7
z&7jkAWDxBoNjtr=%cdgx*ilygA_f&_;{k^=a*ezxDC?x1-Y`43&&>ic_%_~?xPuR4
zl4+CaIM48%ckg-b-I9_NSfMGJ40AVTC(AA(u0sScprp;nu985sZcMc!N^x_^z`*f`
z<Vw=LyAWkG0CbpaMgCJh(2dwcJrJF^fCi6LL+v20X)MhVIu_JfRrtu#>fU?nt{^?-
z(^r*9s>QgPgomZ`M!Fno0m#-D8QsA|Qo#|LXZF)UH{ytR`hF1a;=SB+h5cc6aX&2c
z?R~r5>w^bURjx0~7uS4wWy_(67pnMVoT&S<yC}P=6U*dvqVb6N<TN#vNv7IZZsA9_
z7dC(A^AEB-E0@2Qi+``Xr>KviSHNz=eCuh<W@vXl|76GS?C{s+_-9|f$MRh5&WvW0
z@w)k=<K4s8&!)Sd*iQcGUjM(i1pMj`%O{ik2&k!-q|XiDtw*fv+WztV{>is?^<VeX
zf8X)%v)?0qdsK=_bvoHbt;beCJET}+!RFaXZp1OMGYi*AJ^!ZzHqvuCu<BQGnF!tQ
zK*_gt`Ftkm&SHs&1YFgzk*NEK6s;97*&Iwa!=!AKR`JGm;p&ez)`A{R-}Ch{5iCq~
zdeILSY+M53R!pvURy24cjqX|Nqkd$TNTWANv5~FLMLnTL)GMfIXaV$twswU<2!?e?
z0eae{r0)=mZ1^Hk<!p-ur3^v35pi;S3=}1lQgCJj8f8Bxf7<pD4d^I#fmjffqTvYP
z;e)4|&KfErT1tf|gEFM!V5=#>5J@(&^f?>@nv#uOP1l96=l-mlfcH8-NT<VvZrE83
zd7!QY)<_GBxL)a$d}9KNlsFQLh@brQ`f$9d<&o6uDi^!mlShXakNt30r4$zB9zGFM
z*<IA#PAYUlol2EuvHRt8hqg?YQk9UI%e}j)@12LX-0<>QyZliup6c#P)JIY-pryZ+
z2shfo`JRWDc6`=Of4BJu+B3l`_`O+cv$l3YK3tAp-ap^pK3nE{`z4QwU)KYEwzY6$
z!2Yx62L93x@a`V)xdEI#A}ss1|KjHIci-8?A8zG8Z~4m0>_Rgq1nTb177(hDdFlhk
zdEYa!fp7W7z`im*aYoqRRP&Vppo70TtVqJiU~>UT@#orX)+Qv}Ou<2)@BZo937vyr
z(=litV9pS-b~{f=bS2xy_J%=<Ic$ZoBC3Ec5vrb#Tez+}`xMVC<qluq3)muED@#1W
zPo{wuJ3)9CcbaM5s}-CKlWu9Fp4aI(T8vq?cY-w(Q&?2WCSG=I0AZ#u0JXF6c$D(E
zwaR+(9&`6d1;!@EWxd}=@^NOWOQs%sUIual7@1#MsG8_d1YU}|cCbh_>s@RT9lhe9
zN`+u-g^IvVp^70M@N^H^Ab$PYfv{Um;hA>*0in@d<2g(Z)z}?HN_um!&`B-e$&a_o
z?nd{AUA?^2UA=hv<?ZuVczq)}tBG)e7vof>T6Pnq5Ct-o3DgJPc8#~od~(h@&06OI
z6FZdC;_V*G3m*U0cGogpOT8-7rIbA){G8^t_;T?1&gR!#ZpB^~zk}Zcv%6c9W!afM
zTuzS;FD_nv$N4os4t)Q}+rXOx{y9hJLm{VMflPgF0GsMxFXxLVucoJe@`wL@>wh}P
zGb{6KW|_bQ(9GRfR7Xtq8z9`qXPjIsv%IHWcZDu__Ux}dK;t+$c8bAhUQIn^6Z<Qa
z^iqawBU7XYuMf06>Za1=3?JXzwFh?ygFo3Td{j6ex7OYPGCZ{bM)4sRNSFMOh|=jM
zjI3~r<XE^zLlv5`30t~H(9_&M{+FgO6&A2a+!fRLCwPep)X1FGfwuP#P^gBVy@$hS
zASgNty0QdGaCm5M8u$vDZS6bPg=u&$_#4#O4a0u5Y8wx2u8^C1JVm2=a<Gad8w2Ay
z<3W^_=mhMofYB~WfyM_!wy+}cCCx;yb=6rV9-C6qJ+3|Cf%_=ZgW}egvPUjtuumyH
zWIq0KPR#*}G4&2qpn)^n-Ew+;wA&fiJM1U<;_>e3)As5$c<VD2RjI;SODVMy1zHU|
zH%P6!{Z6@`mlvmHR&P7H!s%9uP4&cf<MYHidAX2!>GcA-2P!Gn7WiB^D-Xqwv=eNh
z8O@#2Fj1~mpDf4U-95W_^{w6iWOlOOyy(B94*W`d>67IJBA**T$NlU6bn(^8`o&+`
z#s4|rk9YE7DeBr<OT!y?cT>@6ry!QrHvW+VZRfjAI_IMl&wR?xCjH@7xMqKyr;Us{
zA>1(BHsdOX{Z7wdObYsjU^<vH-CAdKh?O^;u*`Og%!6$A;FRsyzTQ1ZvOyZ85tc)}
zo6zAVX_aAai?}JX0l*2j{@G06MIzCKI?6X(geqR(MW})TsOHok<9x|b4^D~_!*LIb
zQjro3Ac1~pfG9l*XNY%8PgB`YUGjew8|;5WrS0u@tJTBCua7)q@nS3pk@!xcQ-vkd
zv(hj$sX4^J=7-V0b`q1W2$M$6OF_}j1kx~SM%)slbZ&VW-VwR`3~^b0%1+h|m?+}5
z)&x!gY~68EDYovMBA)Y6?v~C0F*Q=$)t8(3`0}uOFil@v$o|3QmrwBYcv@Z<k3guz
zwW`)yoW)TfwW&y<ObTV$gRQ#N+3x5|RabQ>2i2n#^`c%TlpS@VRCfhQTND;AA=12=
zHM$jWqCB8pnLKXx<o@N=>mPXg<7_7f@e8&2=PU2~OEW(tPx!;hq94!$-uWS)8vvly
zr^|Ww==tu+H|^p-Z}EpadufF(-bf;IR_Sz>T1qK&?=G9z#8C~8H(d>X&h2N{f{r(C
z!W)jznY?J-0J`O5Xfz#LD;u0msaZyPMojMk<J!3bK7kFbuA*405W0?R(*cJ1x3>+C
z@bt}f*PUoY0~Vr<Kyaa<1NTBhn>)7CQjj^62lNV7p#mkn6By`CQK&E)K-BuGS-Xos
zl^WVoMJXr}BY%3d6%|#M2)jkLie4L|2LwP8bFyT-u59d;C9~Ex<32VTh~92j$DU0C
zSQ7}vtf$8i-XD06%tiKVbqJ`kF^DI*HJ3|fj)6EOb61ARUYzhP2Y=Dz7eO_GeI>HN
zSR|v;BHBiKcLN}>2!qk2{0z|0*H`m)tKo1W9hddK8GBzSrCXx1c_=-W*X{1vec8#w
zg7U?q{lmw2+WbyW?MAEx6G)}hQk<nl$0}ukIYo3=rt67nbFt&DwUfxKJOHPnkcnD=
z(p&+tIDLz=Am<5qT=A5?bL=5|m+K}^PVMpC?Sq$p=k2p*C&SOgv3&T%{jR$E5p*KH
z@#W;bwf>WOz`uM05cS>F>GJ9G`uGp?{{OwxZ;re%wMKCZaMs;bQA#N)tu3w1rRZ)q
zS!?8*ZajF4g1PxE-y&`e7-wVH**69~^YdJdDwz_k@!z=$`FqMrVh1Tf4UhW7bfnw#
z2jJ5G$Wwy4%B(h4qxnTMx<E<q#0~}<C$G334Z!_G&fsVOP29yz=}r^(g80V@Tsk`6
zbKX62S&Q@r(2I2yM#Y~rtA8yhiW;4uNR3)oP=vA;y;LWZXbc5oR|rrjMOA$X2*(Q*
zmju?kBhZQku{-?`=XMhU6zVw0Cc?u(3zMFiJNT~j*nfO<g6s<M9|Ic;G%fynGxjF~
z?qcbOo#HXe81|%{_68sc3aJK2B($)tV?Pn}OX;u&(#+-@?nPX!ozjWuO{yA0Z6zv6
zHBjj$<rJZKTyl(XQMEg}`{^K+rIZKLgEC#z$6xNB_}t*fqb*I$Aw{$bGl)1AJ%iH4
zTG`3PuBhzyj(ePLtr@wXkd0J}SwqA`wL}258{Etd4oDT<7kL0&G+rFr_0b;RA09sc
zZn=Ls+sWPxU^+Km`-ea@9|Q#brpM@i^&_w-ch{!}U;VUy`iF!5=be0g#BCEcOyO@1
zLNm#h$uLP17}EL?Rr-eCXYN%Qx)ETlY{)HCw5IHC0Cqr$zdpt{MZcS3GUNIB)Xp<U
z{_S@_?J=%4ycviyA^$jR1-Y`%rZT+Idt?gIH72(QhX-lL-7SeXZcH5C+>CByqtCQc
zknsg^`1L{-xYCtYl|@)+F_D$%0U9b|6tVzSQ8xc*!4%WIpsEyQEvQ9mkt(PKrD%-#
zT0C?}MX5okQRIPFA<Cju^uicDCJ~gLx}uTRq8XaLNnPy2w+zSpG3^QfswO(K)eLM~
z{u>QIqVz{_1PNLkR^XIu0HixC4<%xjy}=yjG?U&f=%jIggJC%c!r_qUbuOX>YS|}~
ztS?X%j$lU>DG{NNh?Pa|+SW0OJ&89($elMv0mOt*N~D9ux99He3Ne<58f)q&TVAzW
z+=;n3FMs!Cxw_i_@4c6L_v25en|mj!P9`N5Ls3_;xb)DAbcev=I*FhPAa2s^<jp+C
zBB#4Rt7-wv4BiN+s+8KGC+7lXxjxy`+uMtm&zAcabDRBFs;=HS>B~oUi!<rgwuO9f
z?)>K?@Gn;XtK;QY&+3<docI6dwtaoTt0vW<zBz14l*^pDQg(AjbKJPGua@n@2Eost
zwliP0jTOw>N`ju)yNazgh!fuIF2nGuyDYe_b_*ES0qKmK)%9lmy9o!8o@FV#?;~P2
zV4SeufeB5*<lP#)(QW(#Hepk50?+!6@No8u0C2oYoN&FsRZ%4{92AuTR`gn5P>U3m
zQcx6A*>r`1T2PB-15jv@5_P;Fs60ipsfaT8GKuymd)*%!Mgks*fNLjYhNGo!4E_aM
z@@}{$Cl4wcaIj;xA+c|SdG^&Io?sscT>ovSwvNrf4WW5(r@3@%HF1kSVur4}n9~!b
zV=N7Z!0kL7r05=-QMQ5DeY{9<Na%0TvjBY6kVL-pfQ0fwvEeaM#Df`>UU38N^z@D(
zoQn{ET0AHUVS^uV*r^oJi>F#IFD`%gr4vV)aKAJY0SX`*MoOm89R*TBQHQ$2z{Sz%
z4Q9oxx+A<!0ilrwV?0&Gjf<NJQJR&DCRa_L%=X3o{r>iq-@j~aw)X}Ke9Wo!ZIEZZ
z2maz`dHXBzlT7G7;C5aAWvjnWm-B<)J>Nh5({l0u-0;7Ta${Ou)L8`L&i+o7bY)l#
zCb7!!1)I^ZQ}$y{lsB%ZGDsi2G;Ca1-X@Rwn%1%suLtR~-`6%ynHT|9u#tF|3jhEh
z07*naRB*i6P}owB3y$n08Fo6Is_79|9PG^C>M&GSamA%21(PN)aicZ2nQr0@?nrw@
z3m%TZOIZ5~3Roq<{Q_2H5ijCpp!SMVq^cCbPO+<~%2K2hsYR=bM#Wde?5~PaFcm2U
zRV6@<Qo5ox8$d@sIuhR5^P($be*CsyW);EX9~oGYd7>R@AI`cX<q<2~M|mU7d0d3K
zJsZmiX$WC?FQ!5l8elRmsGf<@pa~sjaEF^%Ue;j-H&}x?tce*sQb>vBXaO;G*@aQk
zpx+Z05>==JMO4GRjY?rWURYg@d<|si#zC9Z@_2oDkB&^2aOrbJzE%xT@9)4Kc5Jsi
zmZRbYf&Eus)T{l~zkQ`;fBf;)>Fz|zu4s|im3(rjcAIT;EDM*DoesVnyqQ}uEA9sI
z2ubw@Hkw;lqB^h;ix%vzx%<lX$vi*0xw*J|#nWAL`^_f*e;|S*Yk)SlKBFJC2mFg$
zL9p!G<&&3Jzx&g2`F{@n&CzGM*ek@EkVQm_m^*0+ZLSW(*wALWE!gU1e^$(etDArf
zKe0Z%>zTvahz}>u03l!d3|DlhC;4^Kd8)jb6)Ei##(8#pf}m=z7hPl?eO`S-OdEPD
zp}`sx#J8yaA;N+ixQH9P!Iv0W6&^Ud0u`tf1(jX|g)G7fRK=uTg;l*Oi(pcefbwe=
z`l8$y?x#Nf7cE6=(SYwuVcvL^rQZOw3_xF0Aw^V0l$!Z0$b)Y9mMM#hc5(Bd)OTXM
zqhtf<bkE`IkiYBKVQ$>h#tEK%W!wg_IabpKa_s@Jjtx703QFu(;wug}!U_@3iIb-E
z82^Jz3p24sGuQ%aY9?lE#%5>+bDB$Y8YDXbVW2z5-Bv(BLGTOQyl6arLu(eV*Gz)n
z9E{JSvDouz7(7;b{MZiAm6{WXhz0Njf<`;qyv(Or_^`_5mtW|ks|jVEZFXt>o8DCs
zZ%QxbV1u2w9N6xCIrw~!`6O0~?fgVvX0tSI&R1?2{AtCsFAsLQztW3GvwU?pUEe&f
zw=b+Mr1KXFCO^II|I&c}k)QU%X`?DXACXZ1C9D6gJ$Q0^^}qhS?EmwQUmxU-yQ&kt
zd1J5)lDIsA^>CiB$n7fjc3ca$?mL73CUX9Hdi+PP`y(j~8%E~V+95-=2E8I&E%S2A
zEgTf**`VUByrU6R9c>_`VQ>xSoV4F@c%nM6Mr-aSZcGShNhy{uLQ}ZHi?|9kQ5`8F
zg{VLQRS|^!3RGnPJGJ<(Vp6FpG1O00YDFnhYpLo}<*u+6mKqyCRCz`ZsBy?usG=4|
z_3u=dfcS@aRubHgL#I+iv_yJ|Lo)|gM=GPFz6m8Y6gkvmqyN%wpM;TzIVOA=O_*;c
z(+-MgJO_G)6Rc|?VHB6~qRZT%sQx4@Iss`glf1z<xX}#OgiXAOnY0DX(2UlkH8w+Y
zn6sH!Uk+lwgS$}SLiKEBsz4z{RP#=t=|CE706t)z!F}Sk2?Xo}c-#PlDK_jT&nc!*
z7dH@Y4zsqDS4a5uX}P*OO&8aX|M$ONJwDz2@O-(wr$LAbMF?T8JmQToh?fE>)f(DN
zG%ef}RS7MH2vwa5-R-U)>gA>FE>3ds`gHl~^>llK<zTj)x%_+_wDK!)82^A1!TYhN
zbF=98+zd87;4=*rC_B6Q-RrA=`wJfa;htX~@Vtq-&<xGPL)N!>yWJ+YKX$qi_Hdhn
zvdtqU`G)#e)}WG+2sosq8#2kN$r>cPjV552WDc3@fQg7r1j?B`&iU(ui2!tPKQR56
z;u)}yH?c)*5i^fYKo=j-e-m0j`9-`aYG><fIMx7DjP^iL2{O;5oRm|MsbH$u6--5H
z#gtIKlq$7KsWKIv)ThFtQYuQN78G?YP|Y5oC3smVMMSB(CAq{cK@qk(vK{aRVYE|%
zBFQ0c9>#4@5A(=j<k{=HcfSVN%C$$QmvJ51oR8j|?$*;lh^=%y=^W<%j$nNzkG^Z^
zVm(VJ$3R1IF#EDFaUs9}gDq?eEH(p!HE9j4!3@j7)}%RS6EidmpwK{}d5XoTpyjg~
z-8By-np`N=z6Y#a^~5FDP>a=hdb=07oEeE`wx$=SFVC05^0FOGp8C~e>@KeM7d!d)
z|J7~|{_56_CzwUPu!K|)1|d~ks~5OBi_=L_cmY&ZOWl=vA@!1FZ}no<i~D*1`cPlr
z>D_D0#~A!6zdgg|W5?3-Md}xOz{hLH-q}R{#TtNCzxd+*>i0j?$NzOF|9!$sLv>&=
zH!BFzhkCfohtQqfu|u$VXP;%boFxn9dttDlw`YLu{dT=3ZmgI$AK%|Sx>o<ZybW(l
z*`9E@hU)gx@147emAK(4w(2x|3(YOP(aqi57I+h%)mlIdVcwu{6_)UFfK@>e<~bKA
zF=>U74zN?~iqypSr7EU^U6EatUBy(et5OT6f;#0yUn)w?W-zG)&ZAYdKnvq+S>oRd
zW&N#aVdDEi0m?QoNRTVBQM9|)ml$W0{kg$-;)a_t+cPF_#wn+6Sg~RtYpKtq0^JaU
z_}1#4#8By!-A!{3U2~jcde)|I44J$i{+%@F>WDh{Sr7*ry@@qi%WHu*wgy|o8rlL|
zu$asZZ9!{j#%5whOKNat(}NM85)WJflwm;{v1Ov&;V$pO$vBho<K<MMT?QasNbT_m
zIYKlY`v(9yz^t9@@OmzGyIfx1KX~-GKDeG9Kd_?n{mBpaZE<UgC6Z?V2(>natN7F)
zf=LyZU{RThRxOiE6LoLg-5l!8UAet0cXybNPX7gF%|GXt^Ml1-ANGB}4FPRh!M{=i
z5b@pB{OCV^+CBODIQ`e{=~auXp}7;zT2&zC?u4p>LQ89hKJBm7f6KMo=z@l9^X=Ew
zyPmG(`3%2ko;^v!xvNWTG4x+42+E`s_V7in3_a(z0VHQX{TRTO*G6BQ3%$XcTca)R
z3#=8kj_@E!@$jT(rkch}_%VPrxSKh8OI7R?Q`C3GR4^6U6--t3Rdy4mDwCoXOck|u
zZhmDcsFhVw3rnzi&P#ltK%#)A^?WIiLK(&f@xP_p76iWEpApe4VyX<QPZ5zaYCT2h
z<8Mhhx9aO?hsqlYkIo0`r{G_B`^v^3WE}uDdB&><IPW#d`c3^t%J^*MXN_Bag6)PR
zXZ6F4H?bD?8nGqr1hOnx7POhmf~8?@(G1}3k&);mE%-F?t;E_?@-Cqa#qe2NC&Y<J
zDhev4CKA7~wk|zLG`zD3LKRY6RVrKKYkz%rbGp7?o}B#Drpw#u@<F}2xVW0y9sHzR
zs-4tN6KxLmfjixsn}bqCc3P^IB2}asw7DLe-XF><;^yG@civ7;{zmqm@4;u@{n_9C
z$afn36XgF;OZpdT0Nh<K4}bsD!~gj6ar)!!@^UHGsOGRV_;)(NX6AIF1Ql?gF0zTF
z8X_$wjE?QtJ__^*Yr^ITu(eL>=APU}qiliUkrF;$6N2G1lmlT8p^1<2juUl2pQ$Vw
ztR8q1H(^Zr3w&nWa=n3J&(JEY!b&&>Xn+E)2+5TcP~0n6LX9O-W702Ws#*)C(xzgy
za4IrYnTqTb(}aD+u1c+_h1&+83GA@e&1qMq6p<oYB#V2F|53+9E3{C$^9_{40taJw
z?NKag@D>-%qN3qv)R%xYtTOJkijAV9Ut@$(#nPBz-2u3XdKrm>8(H59*$ubYRk%&r
z0D#@JvTLr-!<*S1*CY#lo_kh<?NATHpm8lQz`A|v0yfwzzKAz0i`ar?#xi4GFrTn2
zSQ^d59nIPDbn8Ke1v0;8NCyE>GHW>gQ9x8Zy&sY^<b<;14_1;_7vFfqda8(vRGGxh
zXOzm_Zo;h}>@Xje{ljUx-tDe0E*@S@PcJ9AfH|9EHY}D7B0)D*ffmr!3}$T2Eu(|9
zVVd>91NfEeO*_79%e~oRXuf6<{nmt^5B;!h5BSaNzW;(|_+O?0)V*Cjy?yxmZ`$<7
zdwe^?tdyY3c{rV9frLU?w&bb-%58E}`(;ngklk_1UH=O4mO+2-2WO7?+v-1T*tRxe
z!_*!tZX8ird;{_Ce7`ssCZW^Ebr;^~&D$(tx@mJV_h}+A+IxZ3z<E?lrrCO@_h1qf
zWfe{;Q<17N#lBr-Dq0J6Rj10SGOB+qG8Ilmc9ZNXY7F}YH5x#LDy75`7+O#wakkI<
znmvG8!o#7XGzD4$&q?fBG!tPV=~$lzWs2dA2NfxvxB75m*40`&je?{M{AgVR(!oD)
z@WJjB4$*J7h2AuP@dWzDuZgl12XGr(AFz=1y=~(Mjx``of^eH#pR5hQ9G*lS_1p%K
z!VIEGJpXaX-!1S3ZINZha^mTPdB!rM&1jCLVKKIlp~d;uy90$%l<?eE(#ce_H>4$Z
zk7FBQoq$7>;x3wMln57gq+uvTQ7fg0pqbOmY*|k8@l@_*cihd(asTjY+V4x*)oEX*
zi!dBQAAo{C6`x##GYcxEQYP06$AgnUI`MdKcQ?!3Plv-#r_;^S?wg;Q+ps|Y7`*=1
z_l6JWoxX3?cy|&cKkyU$Ycv2=yZ-9#`uE@Kqd(s1*9W_AQXJ|d4Y0p6GrD8-T#!xS
z@9$OiIIVowCqYwIqfMMgEv`|BXAvmpoj`g%)A(%6F>1BTM@NCzSaaW)vN>Szyb^{1
zr+6Dc0Ik6ndV?*r8Q#*O2d%(M0y_cncny+%xbDDJSb<4U1(V2LrK-d&cM8<La+;#h
zW2&-?RUjHbO~7YYF-<5HMX3d~vP{qtCdbe!rAoLR=PkGYk*xnRlD*eI%DG;<hD$MO
z`uZ;;%^><mlvVAPZ`zYhM1dk{oH-VUZOTenm%2d!TJ3?-WN(wQwUKAw9n8t|ni3KX
zMLPVv{ZiQ;1G=mC(C~SeCnmis7X``VFx9}8|JXt{tqZ0Z%Zz%$ZozVt`6#WSEtnTB
zONb1D66bwm^`09Vo)-#~I8NnU-|_zfhL3Xw%qiV{cv?mLa{o<&ry@1g15PY}iOr6a
zoQ~FRZ%$Wt`>Xx#!S(LqdYbmNRw?<UN{|F}kds`5Wkfm<aJeAN*cN$o!tr%GzM2m&
zPKOuwhnJ`MZkg}rc5Gt)3l;vuhIIb6)&J8=-x&>b<2U@T69^;9-PP&g@1H;T-5(CS
zZx(rNq){WMG?3F3D##~B-fEs3Xg&w+&H&9!l|j>ywF_XC2*@Tsef4FN&1d&K5DJ4<
zFXBBoWkW3N`6azIxb#z?Bv0RisDl{!ndmQkhRw8vZ6;fqYX-I>UIhW@hZ|1`dj|0m
zQ@^5yK1*dMG70uoCzVOD3#`BTR54AQDr?2A$W*ihzq3d!m?q>xF!d{LVW}t+q)-Z^
zh{QHff~Z4P2KXb&{Fs=(3(?X1wcK}p3M2}6-_Cks$}mR_DbonuU2nk>b_Y5>d)TBg
z!x;P00o_>t$>tEcb<SV)o||yv)zq73Y~V8jB~!jPV&<G76~l@F_N9?M>}MMh5qulz
zF=!&58wCvFj81@t(%=oUh%V3tWx+Jdazs7C7O@lOlPo9NBDTOA-D#;Klb+opfTk{s
zN)e|!RYfaNs5Rg^&zR7-Z+g#ePy(Hx8yVOpVxmqIC{WZDChDptJeu7cm+J!_9(gtU
z<?IhG<$7N)CTb-nDU+0`s&=hyh+3>?L<0~hrIhmjvG=x3mK?{G<~i;WnfKOPH_#1$
zq$Fx=M!TQ(|Nn<ETN~Rot)!8b)Q|)S;;mn+>ekK72>1Qq5t&&HkOV+bA6g45gLOBm
zs~dImdU&{>^Bf&yyvSEi)j#&-zMS5k?_Qlxug`ZcPxmkG=eJXx3e2_wZa-`+^L>-K
z?1w2nf7lh_kH|p3{rT_z0pK#$i;v!pAAH7(PYYg6Q!P$MEhatHaWBIJw)jKmKAm|@
z5BE*-w;%X$C;q0dh_<FE$13G}x0{G8RbPRcUF_Yna2x-3wIz5v6`GaT+EO>V{u0$c
zTv{>eL7m-Z_$-0iN9jQPHkDPl0-eo(Q1!$wCJDhlvS1XB%0ZaLhZyTChJ>V1_dRFk
z?5RmSnFOhgfS_tAA!nonNhab{mkdpyl8OjYOlceJv~_NX58I}fp-6OkRQVQCF6)q|
zd#0rYICRRhqo?}zY~F7CrI5mQp0EX)qo=~Ge`MI1BdZJQEBJF;32Zltelvt`1AaU{
z1Z*n_kMsg<rR%+i2kL4ESaaNZ`@aiScDA3c_=Ohe*~8u~lE|F>PT+;Cjsh>#1+q{V
z>Je#z&8!oKvzLkW0d-pSLRf0B72Mp+r0*-8R6wW^WaErj&la`d*7dO+MJNFrfxvg7
zmpH#mt<_6XPnwcsI8hzcM2ca#zgx<5Ngi(wGJpp%C&yrgwJuiHqq4uDxM?Xw;`lVy
zLWoEnuT#Fdx_)*z-!FG>uHSxhdiD96)7Q7l+sS6z1iJo%>M(y;I^%a;FMa~j!}psc
zz3&HrWIH}Neeic*=+&=J_SNhUi^0%R_-uDzb7KK;-RrfS?DjDE4*a`Y+hR?KfAmuC
zqMx=wKeu-&HX*;Sk-43rZ|GsXSgin|<gp&EK{jEJ)oAnGtJ?xA^nzNvE^fu^?6LUs
z0$Sjd1ClIp1Mq$Tta=`L_GtW>l{sNh4#FW}R2c<XeTd0V@|<Fw%ajpkKuVs}W4oKQ
zi91zX6H;PIE(uNCnINfQ8(aYOHUkbFr>@$bD8Jrf(v<<+S?hjBIX^1y-MGb#XVA4e
zY&xx0-`Ub0*JB_~q)-Tn2WsCL2SBjWd}CqC`e*F#imN)*_iEvu?8!Bsn_Goi_d1bx
z)(?Qvv_7%<^+&2-t{Mb?XIR8F{eezcCrUfm=R#p7fDwgWsC$jjf_la<u}-K5lnKk(
zml?|fS+G>lyu_y0`bbN;;ZRzgk6vHa2x(bEk`c^O5RI$RgDET~NpTT!aTNp!$x(^9
z)Q92HFF$^I`SJ7N@(8WfCsIU)T1yC7+X6Zi9p<(!$N+i~VG?P#Jf1~GMbd~1#c)g)
zPo7+SIKKV*^6rcK`>*cjHxIVd?@e+0%g%s5P5b#{hrwT*B=eph0G^NY)km*}C!a6r
zw-4oRhJx-ca8;$3uDPP`!n^uRw@K=Ecz&)N=6ApM?aWy35xx(JLc9fG+bF+{O2Ia9
z>J+xvx;0s6;|8p_<}Un>&kT2c1+2+<YOy}thb<mz4=c1HsGY?IUBj@@2<gqKOIIQh
zi5SQMO}jaSj7Kpf3~6ornWOj5QPz=?ryM^(%C3FWtEtf%LggtT`$-T16V@SqOp-N5
zJ=~O?(fFg)Vc-2q^xIu`C2MZ^R{e=a`|Oa<W(W@Df2-_4hF-@>!NQDwR{Er=Rr%OK
z_iaO~=h~DU<l`QH*KheICU_(l_BDQe9UnRoRe4i%HXrb|;cp|vP=jJ)cdxVmt}XFC
zk21n~Y}~pWHn0)~WT1eBHb9C?fiAESb%M{ZBg@&BGnO;T44se)mV&urDPC>MddKPp
zASv!5ZCunnHMZ`)-TDSVS`NJjK+j-EDXw4DteP%PGpVkN<mK{1z5M9n`21#ga)G3c
zk5@|dX(_ZClRG6<k}9(!MW^5`5U-%lW=jp>1B%odTq#m@JX{WAIvg*q^6k~(&E?_E
z?_WQ>Jk=@mQ2dEX(*DlJzn1vt|CfORKpM*N>D|S%&rABlgonjZJW&mW?kdvd{edd)
zsy$yD`X1AWz2w`!#r1smdiB@@&;@$CHa}K&-45BJU}K2i&H!{yPn<v=IIl)z>okCM
z`d{hA>*96xGJBc5F7QHBqN+m~2`Vi{QQO<DahQ|1!ehIu;#p$Hi%~cVhAcTVE3$e{
z$jJvq))?rAjE5;hlcyxn<7={%+jcjMz9Hh&b;O?_>JW&MX%%h;L;}+0@ZMYgrn_lF
z_?Y#tp5sol=MGyInJ4QouZunRBb_)02`ZozWs~>x>fg-;;T&uIVp})IZJ?`1sj+A3
z`+)7n_h`Dm{-8-sEV^Xhvp(7}A1!+C(h(60P4(H!{fY{z;rZx$DFf@y4c={9vhED}
z*G@q7{^vLpOkjnWqk;uoAO~QE&rD~eGxOwSf=p~zfeEsp6tgO^rSKZKJdJG%rLj%d
zA(b?aTZ`cAt~ZJIOmw>fYOG#bO5E&HJXJZA;}d`OH#g&lM?Vh6>JC#aNavZ;43Uc@
z2WO@vO+!jUN+aa}Nlgjh4l89k&C~s|+<QG$I~9AF>LgZGB+(K}9)~P>$j4!nH1PGn
z(~DC%Ena^>js7#!8~;I5p+C7B@E^QF_)ilEBZ7P}A3ywNc=p+Ye7(51pi}|eni|c!
zio(C;z38Op^)y&Vw>_KDS1ivyHp|!XkprNuJH4*qu{9EsCR>n)wQ!X+`Uw$&(c{zu
z#0GCycf#C?H5^-UTVRXV1%Ys|LR6teYKjJfldiDj7S&(jDo`R5NtkI_JPQX!5+9WZ
z!KfGp<ksvXMbTGJ>O+<wH-wI}_4|pM5a)rczoK9)bwlT)WJ1d{Y{iyau~mSP0p41-
z2B>ce&TZP$lYFD5ul5Y?he5>dD$%YC>J$d4D2{<RcBr7x2`ZRe5_h^!LLX_2e7yw3
zmbfo7ch61}aQ16qr*E$YlCJ2D31Aq#Ry7wY(TjUX`nP334`!gPUT&}-1E_$2W;E|P
z5M3*}1C6Z5Ksy8C%Uh(lt3!&}LM*^c6t4&98EImfA!lD^&J*SAX+oJ%7Ps&jINU2M
z7)&7x&$9K(6f8o48z7{MOQ*)MGpR%<LBD`H)u6S?S%&5Cgg2iY(i7kUo-muw#h1dx
zq}W0A!{g=0hr^A^0Zh~k$z+1(_Ig>n`{+0y{e1AVm)rUL`r+Z_e179TDQdE!HfKpm
zhI~j*p8GJ2hl?jKkMj15`}ytsXU~8?RreoV|NPHNO8xuLAo`bWT9og1jrh;A14w1K
zxzA7jVEOA}r^PMOk__55zhSg*&}ZM2{oL59d>rMt%T(!a_>J!H_yuSQNzKu}PH#6A
z(24^_N3d1zJzf8TvX1y^#eMPZ7zj*TiJ~9Vp73z>(r-$OVMn9zyRS56p@(}b3kN~S
z`9sw+CT77X7!!wtA#=#xy48GJo>F{36H=zA2eBt5Xl8I7L=h-Ai2^H>1S<Q?hoG}z
z9$I@%@rV$oddNMyLdP3lZ!7(s?a)Xy?+kz1=Q&#M?+`MIzL1GbVCb7P20LvIB?2gz
z*!^Z*Nh(-364?DZ_X_}7MLz2qz}>lRA$&hcTz5$1ZV7}=-j3dXn*#NpZt#cN+k$>k
z@CsCC0ZZfhZ4$^$d)5w}IEQovczdL{$AZcVBm)aLI16NCI-pKW3(|x#ahNckIZs&5
zC~*u-UaHj^*OiuQ?;?%+)(*&U5%(jM9hckW6$B{m()rO~@igbdJU;R3j}I3g9py3=
z!D6ytTzD)<GG1Pf&xibx%9W&}=oqiydcZf?uf!YO$O6v98N=mxe3Gu8AEvkGhd0y1
zt7X1*JXm=seon|~NLNpxiJC`dd;MEq?iR0)W<fs<HqO8ILGqVqg#L4lfG9RxJ&Yf|
zkju|!zN%P?S#dGaTtJGrS4c<tuw!wp-9Neadu=rT?X}qqLfCpM-%oy8^>6Jz-P~6V
zUtcPt1^u~)+`4u5J;<x)fOv6R;7jZDy|^t_gUq~mwES-Cs7GkpB%Z6D#}YijGnq&w
zvos0+s0=n|Rv#3j${_Irj+r?#4{YT=Pz?>xW{uvHDA_}|qY0{%<f0z#t$qNsGK-M+
zXkZ0eQ5A8@%JXTL1E_DWL^sT?Ml1H&P_Ui}Sx*4SimzFVbu4%lNKPf<07xNl1*O%C
zwZ~_iRB;%rR)U@~1Ho?l3_f-l?4OEla>%{hXJ!1YR+6qC^G5SoYx;Tsw54rt|Gn=9
zyaHwSIR#iijXVM0CXlTQq0`OY)sh;Zn~TvcZV^sp7znh&XUK?DkY?5y!;Cs{nNZI0
z;qw_~!94jgTXmLTS(t={FXGkO>$Iw;Iv<x|U84}z1h?u?^R%SHe0*w`ALYaIAzcqR
z9EzpcE|{JlhG(uv(Tkiv$myBY0aRB(V~_S@y9>HH5yT(`KAIoEIj5&-{7A=#e0<~Q
zukr9@nO-gPy<?$B%6_<Xz#%GfeDj%{U(HtP59+voX!-X4*nPnJc>uVidVG3&c={zT
zzMTAiVWhYxYEQ~_Cm=yp?k&6RR3zS2X|S%M^=@|A)&DKsqra>Bb)q{V*SSAB<!iP0
zyIC{YdV5R94xrNd0pSKO?zJ-;CM%N%ydj{tUeqex5-kOTvk}?0G_FKbcm^_~&1Ysz
z=Q$>h;m=YG+Xn{;Yy*ZdMmo^snk;&MO-?aYXoe<8ZV7|zTnAB5MU<ivHvkX&R7}@X
zH08bSceTCrV(a_nn`=%ZdN8A`)xTXXI=+VpOKK>2y4Is@7?LAYP6_J)&<aF902*c}
zK4G05t$&Zyf&w<b8Mgy~c+B_XqcBLmvoPA3z`0X;c(eJ!OC+AO;?BBJ-{QY+?SBEv
z?f^(YBsBPHla1fi0)ki@mb0mfz1;>@>YT+1f{@9%0mZ50;3$v*sR2YV&aesPjOB#+
zj57KBfa#2B0jn*}9pQ)#ztkNWtEaL#wVQL>K$ujjF)w;7hwF0nOpYJsbe%nG<!E}X
z`QtSFA|E~yy#z=1OSc;$JKdU5p?ki!y*+!bsuKz(_W@RnmGt3Q$HOzbxT*Jt<$jp%
zzpC?_#qPjGl8+bqRI=(o$E#}RH}-?}0Y6y_|5F|e+dShvJpeS%7azPGZoabN1XL?-
z4Jt#rg<DE|O>9{WS(`#|6*a7ad*8F23Am75oxSY<d^6H-asU7z07*naRGsz1r6(<R
zadK1iw|BqoaPMZ@TiTlt$bC&=EU?+@<Yn?YS)JU9!Xx)lVJe>K5v-^!hpPelL*A3<
znHWTxe!nr=Ff=}o4{BL`XdW&Pfq%|23{06({Uupc|IqMAM|d_dk3iz5+Of>ahH6j*
z4<72#b4wFgx^xroic?z$>~T|L7xZs~9a*RFQNFh`pc5h5a(Sgjux&XNNbm#+Jyhy_
zeQF{kS#JQT|DDzYU~MPcaA`eSux3R9k8;I!8zS-@xq$EUpRvh+x@e!)y&$30?{P5e
zwZQ6bI#ht-Ft-Ir^b8b7MXUZ5ZOT)l(T?#^Q{#}$cE&!D3h!8acMYrvLaJ9F0ohrp
z3ne>7`p7guGj#BBX3j_%dUj0i#cEepL`c0cFx`D&-ltSy3?nItkXme}*F4zax*nfe
zzNQ@ENh;FAGNj|j7Z<;T{H)rQV-z{S4`w5g9d1~h7DJ~N0EA6>8mv<SDk5?qJ>chn
zK~x4%MO8^T-}!QWa61oTnq_3h2er(@GUYPYa$o)!pa0LRG9RA-?mv~f2#;=?JACoC
zy<lBn`o21WC3(KOPuJhz@Ku!s&1=X|SetdYrtL^4E&XNXJbN??-0WbhzqfP1xJr7k
zv*fI;T)X4<C11<OYk_?6#;|on8?MDjR0k?MyrJd5+JdP2WpbNgi=al3x<=iH$Am{c
z$~|J18rX)s`goNGl@-XG1v&YUd`Onna*6{08Xnz*G<q5&XKI`3xVBwxlX7Zepn|9_
ziNRo`IK@Ov)J50=0iwTaFdwXfnm*Rwn&!B#dmHA<O5xw(JvXstHw(m!i6PW!=ZyEE
z4b{<i5lBGp3xFu!ssC-XpGCU^p#7o!uiKr#yAhD=RbRfk3f79?-^PRP%S1Pw$KBDp
z3yjUH(I!F-*<H6wfYw&WJ*s~(D`8R-R#+j;-AHq<j^bX)+P|83giL~@Q65K~wp5sH
z_=cFxM8vQW6-XX8jW%pgV1^D@4+B4$pM6={`NqD-3Bol*R8*9)lp`uBG4_EhE+-v5
zU&?TebXDZ2p0#o)emNZeMu%TGKLMT-m+<869gyOoQ6H=?URH5cW7);`?a>{~yMtTk
z3B06$*~TY>q<nr|rn?h;rWiTpG+jTvC_hW(A-|oy&h;nk#`&Y?KmJF21FIhK&wau7
z@Br{MF2|>@)794)-ndrxXzFFnT49TISvg*-{fj&7zhh_g-Cf{!5U&-{vkrOCMIW67
z)RDe%h%{Nx2KI@3i;7y@3w&`aj!IOqg|@gYUIX1Td7bHtdLd2GK|Mes1fJaz`i!I9
z20U;*gESszjQhvLp+P!5tLN;|`{#rqc}^}0$&i7XEhT71EB(n+0Q&n4K$677MZ`6U
z#!p#AAZiS1nDhmJtRT<s{F0r(w#)cei6Hw5x9@e=jyrHY>01XtOzm4DnYU#}uk!5^
z*6F`^tLB>ysY^xMl&byFuDb(3c5<Mw6s%cd>q<A=!s|oxNGJSG0b0X91F;FjB%}qx
z$MfMVK?kDPW)X;$uUGdaYA{(L1HFU-*u9d`z!&$$Q9vWt8-sZyPog#eNzaX-G;&VM
zH6SQ(+wBZ$x09$dI)LO%)B!d?2bU3^fQ0jdElXU6TaFH!9n9UWIyFI(XadBoEilf|
zlN_iQNsg35^&yOfN0%pQe9rXT@d5lPc<ecvR0bSZ=-QSHYfl#G*=@)DIFrNoFG+&I
zab$ibDGhMc+3RG}7uD_*g>pU|%FPFt%R^os(&>fS@&mhf{!yxge@jsQW4r%v8PIw?
z`(uAZdjHygOBd(E)7Nr*>1i^z21D+n$A0G|W8~Nf>>eWrY+%Svaam(^_qYh(*1YU)
z__hc3M_SUA1+xu<HnN*rb*t7;%<-|f8+<XFrN-E2L5;4zv^8%Z?+CmJS==)$(G!^)
zq8XXU>O<m~WC$mh`jGk$@($t9OMmXmUKzj)CTOw->|8Bf>yW2GIwgReq4{Z#VZRxm
zlbQD||2oEhXZ9u?8Sfj^LHh`3H{prYVYaDGy9)G!0Zh)!wTnm8hgdtbfe#y5LLJ=!
zKn=Zr++Vy;klL#H(IsGiRK%P|e7Ej(myVvmW(e3D#2)2$um5f;oPH=aJ&n`cNv0@a
zjHY?p1XOQ}o=P!+wV>wx>X?O=fTaQ9SO^8Gw8KDl_A!5SKk;5ZHYY)FKAVM|N|Zo%
zkO?xtGjxEAv2KE>pHE(9bE}<`N@*mxfHH~11(xPg!HMZST-bOm!&TLT`(Q}sNuftg
zH`E*I4g3mzbc}5p#t_b;zsYxrZG5Nf@o|FFKHC++x?@rpIofbt>E+>7t@A?6!dayp
zFYU?mtMlD3-^*Nn;3eSCF@^j`+#P=4=HT1DgZJ+M$Yr>`8=k!4a9dzzw04V?^)c>)
zS%|O=LtB5)g8gKVTfzR0(1HAW$3S;xKKf}GS$y|C-+|kM(GPbs3;lj;+!om4R^2A4
zledqBwgjFt!Be07h&OCQaQQPV(;Jytd=L(TAq9b%W8&C%yjeXZAA;GCJT-_La%XnN
zIv3fQkTO$dN(^Fi3`IncvPeR=(6TLo)!Pt1$}AZM&$e6L`Ddk<_;wPb33a+?GDZd>
zoyzHy-p;pz?$n*2v&%F?#L4W;VCouD>8pZ{os+co{u@fPp&$Y#r|YcAL10@mG<MJ$
zN)R3U<DRR<&Gam>4$@!We{A82+W^=Z1Or;2o?-*bP$nR)U<VJ^ces106mt{v#k+-2
zXwmpH)Il(^IA^!)UK|UNfXem>)^^BEh1rR=VInYY6Uw$9_DAzNUAHjw1SV$!8=nVE
zjpsT)V42NI?N}WTDjSnP>*5agq|odfkgxRW*&!cYkA=q>srWz>fs8s_Q!l^+kO5tl
zR}6r*I3d0Z;OLQLF}77~G`;>t-7vs#2Ae_&rCfvrIlI?+UhG_#GdYQ#@~|8(<>tfT
z?uC}KTlsT5&mYA5{L|x_cjh_%Bfpft-v@x_u^g`7=HnaW6NN3WyiaNylCX!Z#`V3f
z3XX<^4-wC<eE0Pp*kqmN-NUkB8nLc=eG~t%1vPmixY?S?<!%*gqHA2teK89+?-_Qc
z&EiYw`V+f~e+}S`_8&;_Ok{edNAhA;jN(I*A#uzc69)C6&w0Yhl?PABlUgu*QuZ85
z|B&&7lcr_xdeinKQKhIvyByZ70BEvDbj1k71+{Z~0%XcQLf^|KvDW`Jw~-n@Z6V}c
zoFmvlAt+$(d)?gY{{9Te;Lz3m>@oFy)FbQGSIFdj#MH<4?AM5uHK9B7Xvjl*`_DMv
zxC@D63!2%UrZ^J$j%lz-$F_BVLmh5i3gs&S!Y$Grs)v%8!v>0=Q$;+5RIGIv45?3n
z7qB)Ft}OJ$JpqNR^w0~{o}W+vwv&L^jevS0O-!V;UvZ<0H$Ix+NpsO5xe^0GVH!A(
zIG;G3Y*`#|l`IMus~{+nC>c<<R4#Aw)1O@*o~31eZE}xXb%bV}tC{4>!wqn74~IyP
zM_5~a##_!jARk!qxmeMTYwXW1qN8gzVx9*UFG>|0!OHQY@#zGg=C`+{oDvtvG7jVQ
zljGHsVZPP*?z_7BzmkmeuOlIS-wps9E~n$o8#&&Y#{Cv_*>b7dQxeS$UEG{-fo*~6
z9q7E}L9Mi|?#*pEOsnU<`-u0ZoABK`L)0JCHjfzZxB+-A^eVC9v)O&}I-^c36Y4~p
z)RzY3msnXgac84-5~)RWA&U>hC^9s352D}C$q(6w;5YP9PfD&D+@APBOJ!*oAB6}~
zlB87i&`wEXWx9|mptPFawDRKY{DyFKnb1@lu#*O_fd<=3zjO>dZKLb=T=xAqp3S}0
z>aVv=Y#RYNa~JunLjD9MGI{eIH1$rXgW7N(iOp%&fIoc)fSx55f5aLo&;b%_;!IBm
zTQx1c*huRsoA#$+NFQ$k{87G;>>jYt{{$;-$B}OL5;(+ZPB&O_Cure)a2LjT(6+3V
zrcMQl)4-nH>BX%Ai!-q;1KwH0mu53wCqq5|vT53c^v2dk#fIDKG^h9m3p|mUIUJZr
zY68XOY^6kMn;A(J$r+hNEgksegX^b%`{eLpw&|;44>FWAaIxaG%6OH=Yw`fg5g`Mq
zfcEcVT=Lz$U6cTPYvS$u9l(m(?oMoTL}-~+n?;i&ISwLE<pQ}*b$&hH-4iFlnes3m
z&X-Te``0p`1Xg!1-=AFq_>U2G{)7nx@A&~Bsg73<hwIlI?jdlKzIwu1YoseXw~YV@
zVRN82HD2hGMS2LwN@d%y5gq#8cPu^TXl?&P;b5I@xYFFZoWmn^y}%Z$lh?D?2{zGY
z^+mB{)J!DCgd4QTX+Z!qV;q!-w%`?vG44+sQt$WG$83GUYi-WcME${QV@lNQ8Wab0
z(a3j15+oH((pRJoajLY4NHls+Xgxu58pI&p76nZz6zMbzxP;@W`JT8FOs=VEn-*y8
z=pXrSon5%OUVhrPR(JE9I2d}HPu<)=)P67|tVZ8;fxO*K`e@@(ag@z4+@N&9auvSQ
z*ssmLw^eqVOh1x)ZuY``Rw(Gr-qHWFLqb2<JCgXE5~1xqn}yitSuq~<bxc?{*dCN^
zrCc2~D5w4ZvGkHzIuZ;0Rq03zwkhf+8Le0&79c%&Mx2CdTM4Y*iIlKRzLa996w#bL
zl_Kt=Tz>Sy2Y>&`<+FqN-TC!xwL2ApkxT4{bTb^Dz()7%u0|lzGAQm5EU##Bnf-gd
z(pa__omHy0qIuW+RPPgdYiTr4@L*6$NiU{!_4@qqvX-~NS!7Z@UtV7xuF~nXmUI1a
zBK`099p5S1`J-R?dvJul$KUEbIsho1#$~*^A1>e2bS^+cHLml^CTXBcB!9Vke{`{e
z%e!oIjeX@i(H`s=uXpczkBGeCu&f?BpN492H**UER}ECB*TrqJW%7Eaoy8ZTBw8ji
z*)*MKez8z{WVX#&gfb3_Q86Zr35P6WlB_l)8<J)9AzP3;hamanp!ZO^)>9KSi6*Fe
z2sc$hF^Id;RV0xrjF@)m(Mya}7rN54Q6N{TtV0Zu&0$0#7qU<)Wg!=M-CR;FPn?h1
zP>@)6wmto;sry?&Z`1sCCrHF<-P#NMbvGC48{qXwcnkscE*o!Vu}$L1M>etcb+8@}
z&Uc(&O={L9!y8<@ONyHujeRD)QQ`J7zDT8q?Q9~}2yYfF4~IBV;(qJSEt8Jj{_3TZ
z7n<7MqnU5*KOPAdxGjG-PEjx_xT1v`(xhpGw#dp3*{cosVKb2272?Pap^ur%gWuoV
zR3HhG>)97idj0&_NB{K~$6tJC<!<@n^IC3)BOuFCY`D5C7~GG*HE;zS!NH*owo3qF
zhM>^3iCcW@-8+qMW3M;&L3`Tvt8MQvB_tgUa4034k3f?AkzW2X-G1TsFC4dEQ9U0n
zrsH+W2d(G77P$XUmG4Ii0{&46(0{rcKpK`b-pepqDv<}(pg(Pm<<c|rNPkReXS={h
zAj>;)p4BMXB`eJxX8rCJ@RD`|@RhsLz|Q8K_S4fDE6r%d>tba_nNZKHlVDNSMALQv
zNL<}Jj#3gmQ?f8ro>`i4w^jds0JMsqJ*zjKbMm2qnj@0MC9&apl1LI!XzHQrYD`2%
zB`S?7A`*#9V0I`tNWQ30i{-b8_XI8wG*8)+02cC$MYt#zvchMxv->Qxm{;@{p}Tgw
zb<0;K^CtA%d|uWEGA^C%v)1VKcS)BSZ8reft_!j0l|2QztNXoQ5xU4{BUblG2X~%@
zH8Z$Hb#BRDvX}kDZeWcAULiQEJh(3n`xVnV_`w_&H%Pdnmf7P3WpIq+Ye{2#TXieV
zezB|Wt9PYUe=m=M$Z3$>#*0m)u!BW-qn3O73&&-etJNVa0@h*_g85+qSfXcgNW{n`
zLldUi7uaNz4EFRFfAjJG_V@YcAJ=k!|IHsxFMmIzyTh0`av|WNI0$ZlYt&21C2&Cu
zEg>ixJi^+O+Xn$HaCnPiMW4#G3(fw(-eR^FqC#M-4mt-{r6o#D<0lu_e}8}e!phew
zGxa=-r{m=~T<H0Y|A?Xg_bSxi*EakYiAdk48vuQ{nDg;ohs83*lNPDbpzW+#>w9ly
zl5o4CuMi;qvF~(0IhwbtmoV-Vd%GpL9RS-8tX2QW?Wzmw>}B$D7MsKum6F7TG3x2F
zen4n_;xDQ3J29%{fc7Mg8DqkjaY!6921Uw917amGD2Ie3Y#F>M^qtT|NlYm`Qodo@
zR6T1=;+jPdl8%+bQsq3AyVHFCuuSu^*fJMc3TlP9?7Mgo&+0?Qpg!h$80_+bH`n>*
z`r>e8N>w;jJ_u%_u=!Nk7XZ4scAM-+yQg0^Q1dpEN!`iycnu(F3yEL#{@Y+@{Uc=S
z^top|=(i34u3P1hpg6Y+OM@D0hGjMl?3x(eKx++G-8<3!M4|`HIlS63EvM7N>2!K{
zc$m-AGB35(wpy~%6G@>8p^11(JRH(+7>>vBcpOuva$88O)gMl<g3@-pEqyw{Y`335
z<4bRH=YZ3#Ln<RWK!SjE>%25EQQ%G(6VwEcmuLV6IQ?pryztFw5wFkw_M@l&_2a|y
z<8pp;|LUvr>p#%$te)yT<RRxg6wkl`KEf`b*Wd+xV1S~!O92!z3D(%0wwU;i5s9x0
z`A6o%e*2N|(?MFH2q~+Tg>s|Ue`BwoalQaSt(s1Ui_7E9c=tl;WIxT~_j?jRzrQAQ
z_uDD-@7h?uKL>zQeYhy;c*bCq1gop<V_WgX499xHVkh~m(OjMK%pL7#y8y>`v^`wA
z#HEOj_Z7Jnnh9Gk1lB$wK8#ja&ny$m#5ysmKdaILi~~1m0O#2EdXR0icqTJ_5FC<3
zNXw``CX55dj3Lz_F(;F;>R>tJs2Bt}un?It5Xq641{HBp&k33wVo+nIt5!)!m!=mB
z(lYz`9uG6_&i3Z6ym~XedUL+LTW;^{;f#645`;vAhMtkfk%=+ka+J#p++6eN2g9>x
z$7j#vgAa$NPYzdC7l+|mc}hGfXZQk`I327`)!5K#OJRJca5t2{_~rzTiBQ@O3`u<r
zAS*F~9s1TrN&Ud^6(fPiXTU0YU43g*4^`8K2<1*{z76@=dIRlg#n>gavr!^qklo@x
zo$h6-r~A|C{&YS)JUpE4Ztw2zALhB%DrU)><)bC=!Yh0siok?bqz>sJWxu>STwWi>
zK@P`saU2dum3#nZ*wQCU1p1D*Uxz_@U3QwDy0a$umVM_v(tRIe+-t3SFRJD-UZU)H
zOG;1BM61GC(jkw>%cuYF^YQt`JiS?7z9_H0mg%Lk3XP@G24HZ%(DYRF2xLdR3A7D*
zf@2ZV;niohD}`K@1@A0k*O}L&*4bU)pj+si*Z4{T>U!ky!+i0x`TTJypQ}!kb3UHO
zOVvSa_Mc!1^b-<5A93yf%x`~>ZUB-jUlctQSFb=dFXq+ggea8GifVn1Z`fr4I4yE1
zygwV<S%BGkHwnLFOxozAc|QP1gGT@>R>fXW-q6?&W(Z258|%X5!Iyij=Y(0YD65Ez
zc$;C;1*XC9kuZ8%rf2dX9EBq>raC4W69%<0VH`LN$jOqr4$jdzL_WKWKzId)k;t?J
zORfh2s?ar=COQoYB=zB77#Cbk^YQITzWnC&=@)N*|HbV$Z{&XR#j|q+uQx4S>RD<*
z?iX!h6tWha?)>G0>5HnrDdX|g#~%;B{N>Fre|i1Mhxz)T$DBr-6%VkP094%3l|NkL
z-rGfpyXxQW1gUE@Q}_C+L&@Zlee;g(7Q!*y7j^XNykgzj;$d|fZ~g%9=Rtc6xH74O
zVAmUo#tO8RFbgDy^fn^IzHL(7{fFjO$~>PRru$d-Uw-k;mtVek{r0|85vK8Qd3p8h
z=H^Kru96-^vQQhS!~+C7!zQ<>%;)pN?cMF|%Wv*rug1ZzZ^q}(u0MEwb+{gK3iLt<
zXF@d-hg2jLh(p~7@1|>SWb)WNwSl@zPd3=Osa6=S^tc)}b1{1qF$7`$Vg`>=7L+-U
zPoLg=^hy5t)x6xEKmV27J&dP2TkfFee5Ip|@VwLkdYOl(nlGKnEwr97NVAqa*-ul)
z7RTmzWVzc_!yS2PO?~RP7l%8IDul&Qz<qHy3WS5(@p$vea`*G;{9?=tWYT;$98ww&
z<sSYQW;6aU2Y~;{y@3CqVbl9^08l`!`C^e_4(6>nBL_O9H{rDD*K;&En>9(IOBi#*
ztS)SzAnYCcO(A6NXdJm_+Hdoo&eDz1e?_&<{Bc%uYgA_|XIV}xr)1}ZbHb7(`nV>F
zcPK)&hu8$5!F(d9E23J&N5vue7#z33#{sLiO9t@Z%n$%lRXHZfNi@-tS9K=1ESe}p
zb)zJv3u9V5m3o+P{PI=(&F{YX?5p{!m-E~Ex|DJD%hMvolje&&97-wh61kF;m|zH@
za8*hO(dS}<niRt**|AL1^wsq8bo$L7?mv3U|Kopu_IID$cpi><ARfS~S+hq<1G&z5
zutFEs8$if6JLjh<J0nddlLF=#;`_>j!x}u_GUhj&XEP}Tpr94~P8D4bfE@&MoBQ{S
z0^h9xc9dABG#LGw3?@Q%LJ%@Af!BJzyZ`bJU;O*8fBWj2JK=bF{oyZu{x^BJIvg+a
zaFjGUa;;+C49^jGE?(&cUIm3HwB_P*s>_4d2l%;``)R)Y-KV#|{oU6WSLtV;+&ur}
z$;I_0Z2^_yV5KzZev=LzE?8!-G4V%J9-waEur1np*En~*kh}CWJ?uBHeJ(_(c*VTH
z4|(Jb^GEveC$_wvzxl&_`*OHD*V}vYVZ0PIWs5Az;OIQKj0m&9mT*wn&m2B7;`M}Y
zbieU;PfJ#{_ofo@z7}Ll2wA~=ZdBoz#-}<yD|%INa#^VNc|496<9w@De~2siFT5@M
zq^SV!%?-dIspi9?!|bflq>~WwDA=}(?WXh$7~A>;-#yvZ9fSSJw;t*Ow}#2uZF<>>
zK<nJUcm2%^79qW`#p{IfVC4jRNSKu+u_{~y0X>KYlRyFna$tjZ4uU~33J=OrF^C@&
zG5XJmIr}(p7=qOd&5)d!DdGdGs3F4>tH9NnJZE^Lxv9vp;sAX*+ws+%efG_(uWsLb
z`EvRF7pE7m<uoOegQO8Mx+q=EFi!>U5~Zz)rP_p~ai0knS8;`rws^dU68w6q=`_jP
z2mH@}zrVXZ|MHW=hu8UHJPbNpUCd`lV?XTA0ItCO_R+Vv>)2;Cg7t+hJFb}<udRp1
ztf;d!-50I@_5Dca5wK!M{NHbYeS=nGoAo=OjW^rc>?V_G*CsQ#nc?*Hn_vIGzy9>o
z&uZb-@#D*@=f}$r$HPq?uktujv^th}8aFmkw5kFVH#18T@Hk#by0UV%dPbTCJxMw(
z<$jvpe){R%H!mM<o*th(Ib7cy4mSs?`5gF74LKyuB9l?j)koXZL{<SD)^|<sdA+Yb
zw)aJB#5Eoa>#lpk5{D!l<>I4s^)o5;?!~LSFTSjA@0YhHou*+lI_c|3UBb3a$<6^t
zU5eC;egi0dNB8Z!sLk(FjQ5kF9-_88@La&m@mdczk}j+Y;i^j>%6Q@T!k?hc|3Sa&
zTW7$JJ`vuV8-RKmY8p#QwJO9#+yZ*of}*gG3*V<W_Wu1lPUtnmtCx7AKVtodIM3JW
zZ=w2ZzZk~;@Oi;z)Cu(rJHa35lS)xqk0sm=06+vj5+gkjp7HNd1LqmaA0HFO0C^_n
z%yC2jkU($0B)6zSbI^D+WvIGH^<>uEyp%*Hm>7hX4oFuI^WoJSzIao<cv*k-o9Q>7
zJ-oVCAFh!`4C;=>1TG><io02vv~zo;aUKKw)~LUPReEl|Ypd0bnk5f%na9hE%j3<{
z3(E5K>sNL8;^8@e`HP!DN-3{FQ$;une4p#GZ@u|QzPWKaDUZ}Xd&KBF;Vm2XJFW=i
zy25T5(R_sb+^YZ1_~g6KSt9{@hq^|ZS(E=j)`zPufcvsMyn6eafBE&l{^P$qO!kXk
z{<jaF{q5oMndTc!m!hM)TJ`GHVX==en7L8b$In1_(pt){0_vK<BkGiROvCk9Pt*B0
zJ-mMN^8W7a{hO<YCm&oq|3$jG8Cb_Oq_zSRz!xAf!rdDr+V(Wl*gWhxL0f;cJ2ux}
z@U=7WcKdN;%B2i9>FTNEeE#$g4_|$Ke)-mJPjWhs;uwOJYa3cI&Tk|zg@&(XsN&Jk
zzbC9cs*pdpg!q1q!<7K$-X*Sjl;Kj+h1aB_R2#-RUK&;K7mk2_#F?=>1O8O?|8s7E
z_h$s;X{eePN#-KrqUvV0|9-{OB;sz{{%Usy?9#s0`)%9sHtTQ8V+s?AMO=H_3~a0Z
zn+z0idU2a!6U&))Mtx8_E6zzu7F*E{+DJDNv8W0^5C^eAeTdMm_(;AYeTIY~V@Q&c
z=fsr5<i*hShX-~Tq>0@lwk4E5k#|T|Im~u=I1Mjv<$wPB%YXj2x8J-Torj0|#Kvrz
zUDP{9ozCW|j-W+vIIr&Gb+Ecum+AtT3(bogYNDr@HaN{wwbA6}aP`U0o?qDf`sJ5i
zzWn;hlazBJ$6+9)^gzdz0MT@?JC)A668=tKSZ@rEvc&i(+GYFbo9jpQy=6&0&i-{s
z&z|pL1^s_}`|aJ@8^Tuh-H~@yN>Ddp1!mLRH(&nium17B|Bw6o`T5WO%VBr|xir1h
zd;vX}t6Qr;BBa2)dR@$Gh}ME)-cdK+be?chDdM3RGPv2Gez-Z*`tWdm^XkRx*RNil
z&;I<Q>*J-|+zgVU=@4@l?JJB(ql0~$WWB0T!q5N!AOJ~3K~&*!={uv<`WM*&=tCvi
zVz=oKXSQ^ipM0#tWqEsd`_&io>le6NmNyTB1G$kLq|<X7d?hY?u5jtkA2!j{J1cnd
zM~_;#*9x^)*So-1!3-HCT}Zm}Ig2W+rd0B=GV33$|Nd8!i2ktQ2>!TF_`Nv*2u)Q|
zrBp<`xO?djX}|wN1U1ZyQN|>w5G&1bivcEgDZg#A$BpxY7WdfEKj?y={*Q?pt-8%#
zCzLbmN$f0kPMDLFObfk#f3yQ}2@RGfcn}_iqhLs(=EM*`Za_CQac4$Knp!x!OQIx5
z4uh^!3^Y-s49#tsT8N4P>1M(4)g6BO`Taltua}>F@o@WaIrHjtrpW;*8?ltdtcXxm
z6Jb`}YeYS^d>oHFdq7HCsnY=plTunHfnrROm4MY+rg@nPpjYYQ+4ZvzuCK>0KK&p6
z{^^%XkxxE3$|2R|7G@&r2&j4W+9)5%`|KW%99Xh5<+9t0TVLNJoO?=Ule@~Uk!L6W
z#9`A(;l8^)AZGeoXwc5awkt&5ELYkX#1IpTtwJ+o!QI>2Pk;BT|L32+{_STMH$PX5
z)rX1^`G{ex&geFJI7{_X=_Ps9Pz{+`-%+v06-C!k7psdUp;`4(1x)GS#%h-2=KAVz
zKEM6^)7!7UeEt06tAF^1pI=^%)PO@z$axhuv$=)IonDA*hDD4+VY{72{|3nBOJGPs
z&7z2#jy_)F;sdW-UVgsZzN)u(aw@~3wJg<XRoZpBP0VN!?E-}-b9KULyII_7_43DP
zeE(6^znx{iy0F`tAnc?WIHYuyhMRiIq>!`fl629OAB|-EF^%GTO8$Wr68s-|PP{ie
z0J>z0=m%mIc(PB8MZ~a1MXbKTy?xHzzxy?dx*xaG)^_zEFz@6DcUvQeBH9~P-4@mf
z%Ng}S?410pK4mUhYN83f2lh7aX`+Y3Gm9StN97<sW)2BCFwTjCdQP4dp|y`8k0wt8
zGzZ-Qk{iHT)Ij6}O#o00%o*vj`qk_=e|Rzf>UVE{^}E~8zL@W(alufTEL{|%6?1V?
zG!GO9yf%8Co0+*uvzD?4=vaIQU=Cre?v@l3fw?cWnmE)<hJ18`oC}JN!}#QK$n)v;
z>(B2F!|P|yp3Kvfq$T}!ijMehzTc^G;(WLC^BsM6SMj&@zqj+<2pWxi-w<pW5wcwx
zx=hHM$t#{GSz`eDH(+-Z1zBok(GwaiwXfuhiu38=)i*D{`2EY@e=5^?etUcO`Yzv`
zaXj;4MjBMi&1f~mV6;kGXoWDsYME<UtX2<|0eiZ%N7%b07c3_3;?=Fzr2<flPAx^V
z5NU9GxP7_&%RhbkcYpij`SU{>2Fel3*-1(U1iti3RjknZ4y?Nx5V2wJMr5xubN7{R
z;Vm%8({Z?dmh@0hr}^%!o$ku*o!&3GvMgQ{wRGD|zp!^~PbUsG^RsMne{LMczZ9t7
zVnBic;9WHoyA1^fa7@Eh9&ZYgdnj>d%Ay)o<UcCw@mrt29Y5dxQjfF1-s>9xB?47@
zek^+V2smJO<ZsBAZ$&4tOZoe0;NKDsH1Ev%Np00@o%Y-U9bwh$!q)pgu%5F|8FOOE
z;q?{YM;f;1E@BXj>Vt4p91^lh%j}JWUiF+UA{&F@oRUj2RqF=;L?Af?BZMN+hb*eJ
zu>9!Lg_o~S>GK!!zy0p^Uw{4j4=-qXT{SJH6_Mx?8&LziT1zTtH#`ei>9iOV3jxOY
zX9jUPU=r{IQYw5Ay09wg%8I$x^IT5n<ve*Q<DgH*{H)GT?%v*>PjVPChuSj<qq6U9
zUpp?)dO6@4AN&~IgKpz`{IN@wS*!fo=3}=&ZYzyPBgB5a;C?HxTkbxZJ@`67?-nTl
zZeFLiZ(e-;#b>8CFJ&>Sx98Wd&o^(<<&%28uURA~Gh;2Z>Q+$}pC?-;Uly-rnIGyh
z*IK+*_jU6^s){hBtSQBczRk95jrGdnOp*r~tB=ca`{tWBzD)D^>e<H^7dIm%o_Ybw
z+95S!nwYzGiuKwg*`BW1{<o#Qd2Dmn5K!lcbeRrMDMLBGIo-ak_jh<W+o{qyXs)F$
zvkjHn-%pK!VHFNGL6@}~z^)kf*KhxZ^&cs?S@U1H9|)mqku%eg!<8XbM?w`W$|4F1
z-G9vD;V-ZLf94<i&yxriK1vaRh#*F%RB?C>qaz<*x!BWu+hQQFJ$=`OriR<?1h`%l
zdWhr-hO<@y8|24el{TZCSx%_u<kP@qKy8yBSSx8<srDF%fcPI8y%}RdR<2PkS&@?E
zY(wf<F0JJ^O|C;kcR>UVcP}DI5|D%{Qaw?xCcAufKm7Xh`TzXq7r*{&x}6WEqXhp%
zf`L6#Ql`2~S!%V#8QEU#7z|Z+cTjY!N+_&*Gp&siAoS3ch>8fLIL`BYcYnISKb>yR
zr*WZrdC07X>7I9Q$_GydvI50d8P9GRyDo$sk0vvX)Za-Gy;y|${1Lr*w@7$=X80Nh
zCy#o3;t{K8TRfsgo$r>vz&oRe)+`I)5O3IVhuHo3{?&`m%lWpRotnzqSLc^sk2hE4
zn5z`#>|Sk|ZJO(Os`FGHPUZf-oKEFoD)U1vvs?8DKNpCKCQU<1gX)mdkn)g|4k{_>
zkmLZUxeAj?t}ev^ui!;K;PuO|A0BQ?efIPG;o&e+2+aNX>LK;+&br;4*cs7%+|#En
z!Cj0vv(_yI+Z)WHN9YC8(W{hcncu#()154Z3*4y3w3NEcW<`3EjafCX)vSsceB-Wq
zR{*Vehc%Fu@9ctq!~xI|Lfg$IZgp`6=!krDsJRm+x`<TC47cB3ebE1>9RS}}2ibov
z7#t&FoYD>fSGo~S5iv98el8cXwLsf8_kQd8&AeR%!#E(DYrn7axW)za1%P{XR7WU2
zi`XJI)6TR>eact{){&lIjqczOi331#2t8?o_(6F{p4DT`+fur;LHtwpmf{j)pF~X_
z@J&^yw7hj`sV9<?NHqt{)Nq{b>YH2n*UwM?{hwZZ`oi!1sUHrJ9^w|nu>v@XyH}7|
zB<WDCm=!mRe%HLXZK;>7O044`(&3fntV{!$L%b3cYs=N=<>7RC`||ah<I77!QPk79
zp6zsgxP4vf&yPHGZF-Ae-^*;8g0l^UWTkR;TUKlE*V&(JYuoKGf4oB2FA`iftU+A;
zebc0R52~l{X3$&w)QX7RhXn68ls%KQ7B7q2A}nHyFSiT6xf3xgC?}krh-$SupB_$c
z-=5yQneXrG`E2L2O_R;DFOeT-n^;MyDdjPzG3l7}kjCTTc)T2kW70#?gXW{Aqsw5R
zixjIaNW(Cf>FVNUTHgNdH(w1&KKkT(JZ6YLF6-u~ZS3a4^<A*8VEHHnuf1Jbuiz3=
zY!1{*q)WJ#X)gCCS>`%TvRKxUnoiTXpr+%Nf9&R7i`B*J;#R~9S5VR;3$JgcW$;@F
z=pVc+-TJ&o?O()PkTJ`ODVHEgJcB>%0Pvr*`v2(O|Ghf^+zF_tLRc&&|2?_A>nXI$
zTFl`PN=Q~Bn`^(r-HnCf`sr@AMwhg37jKgv_u{sAKz>loir3kfv($%-DQnHJ0hST5
zy%M6&(063vpv+>Ua#TO4kK$P^XCD$(Eh}Txlf{GSmRtKzO-u?6k`IiH(7cvnQB~4J
zM(X7}9lm}o|N7be|Mlzp&%cyAKQ5XLa0$Vmw=ubOR)37Rsxcx-+B0Z0YcMjjAuYB%
z+$hl1X|7l-83&a?B+*r&t}ddBobO(~{6;k0-<~tMd~^Tuo2%>lESCV`1wtb4MVuX|
z*(6!5<@dF_=PKFQUD&u2^I+HSZzGx&MYr()A3aT-aIiwq9w}a=kzx0>hHl|jMW0vu
z{)Q?9AvCyK85EMSEK|LEwOE}oy`A4q7grRS=4Cpa&iD7r{k=^OzRWBOYZa?>7YkW#
z8-Yg{eN7s}K@NI84AaHsaJU$Ti{WrN9<S5k8u{RwBoB@n#B+1W9EWuAaC-RNufMt+
zFUH}3^}6NmwOC7LQ^KsqbY>Tp5mqT{?yu&1AOoz>+{Ok+f?UXWL(y_RFL$>*PlMIK
zKY0i(Ndi{6%=J*hP+x1AtWNM5EW*leL1=nDV{_rRGvFO2tN*!T?|)1*xn+Fs*87ae
zn2y5pYUY(q@WsDw_5Trv#BTckC;rg)<N%1)T@ZP!?3tsah|A8U8EJ$TeF{6yb9-&v
zSLIif0AH0JoBz|X$^Oke`2JRCg<en#ZDKvEoinD9bIa;-&w(;w3%X6BNti<0BQmOu
z>hY1qa`K#^>JihJ6}kPulX_Alx)Mp4R74@_RFAoDe}=78<TMmH%w>FW%K!H1=^uY}
z`@cT*d%3i9tdJUvQdDt=iyGD9Eb(SlG7~dtOK<DhgmDJAtg(k4-&vv4=@q5c*^T6Z
z93k0js-}XWSe=)0TFToxr?=mnq)2@=-T(f>50=XdNg0r~TJYwH+wE63q8a_MEz85k
zwPvvN?#;0u-@T*vYlWWs%-CIb?~nhpZ)m8EX1zW+eH{*?n*e~iH&y*MGK#M+nv)(z
zC`3I;@#Wr6%OYoccyZFfE9ZGyrn8k9ZsIXfY*|1%SRLpR@#^Np)O7_}EGIkME#qN6
zTnxvn`SLVep3?D3#-n013KT|XrBf2egWf#6z5V@fUy^w8d}M0uBT$JPM?tsFY1hkG
z2Pmwn&@LjyD!pn)g?R>#)B_y8%s8KPnZ*oE<m65CL&9ha;yUeC>5JF1`vgqjf;Q9J
zy&!w%aeHaLkNL~LTM5KRuh!#xMx+E9tj4n*Pe;?_{xvgO{wmtg_v`>*pi9us0O>ii
z5OI+<;_m_Efq{V2Yu8V#*ZKY?U**oer~LO^_eOelm{+$FST6d)GJBo1&T3QUGO!FN
znMm{u&&~vCPy*qYQdXwu>%~UJ*hc@Y+0Pj&9zk7$A}eF~lhjp^6e`eAT!!dV$*!Pb
zGG|?iNj{#-@bzo|-51mU{qJx8*XQ<to64gzg}K33|Bge<#Y{aEu2FhGcX6n>L?peq
zppu0!wzRca9E<eTtD#gc)!}B2#U#5WvxG9?tTpL0=F|L^iFbB)NUxtfz5Vd%vzzN7
zXOcS!|B739_oEenclDQCW%!Rq(~kmMoR1{mvSGvCX#@EkhXlXfLiR83O`9Hh5iuZt
zG*51Z6{O+v>C<Pw_`CZr-%RsMFGbzVYn`WB6O3NXs?jacsj-)D4iW8RcnMUQ8)}>0
z!6kBqt&nb3$~;Z={7}yK%XC}jn_;=m$15)vE#<kY(ol^mN4-ipfA!fbv*o|=`PBzm
zl0uC#knUb%fCpH6b%baMl<1&P27kNTr#4kJL_$IXWK?5Ww9H<Lm`CP)+%UbP#Zh64
z+fw=ek@u!gk|fu)-?@uNL}u33-Gc$Kae0rDDE<F`hD;wM(_6>~fdn5hGriW5nGxac
z_g;N)kF4s!5X3@|v_VbVSX*0Fc2`!WFXx`~J4uubb`C#-X2i-!0Q<9RucxBvUnU~|
zuCCDSD!Jhz(MA)VVVN2*o(RF--b3;4clM3nT>^UXHQyHrD1xktnMQ~}rOg3=2xlf{
za%XCNdOg94mH~K<{Pj2Sw<OIMDt~*+y-0g?ZhIxK<b{2OEmT*Dl29hD19|E!Po!3w
zO;F;*l!V5lNsz>o#30^b4-MSU&GgyY8KKVy|4<2$5T=xb1xz5eEpkLm%pxKXK`^SP
z#ddF>=)eBY^Z)f<j_)7%6jS9%hMmJXOu*ikrPjw44CC;C5u7=gSR>R!35rM@N}=pY
zVq<bS!!CA6fZ$s{pNDxhxRV)4cCJodi3qe{IWwtU?U$P$%U}J~&Ch;veSJL;l|Z8*
z(Tl~Ceiw^hyj<ab4{IQOzInvwmhKn#1%GiG{q{eUxALwn9<@cah-sK!{qRSB@i+gw
zo%6@(SI2iB`M9{b!;2LS9wsGL)+8zMFz}E>m6M1v3o~(J%A!`Q6{UDBUW(Te*{pcY
zZZ)c#uNE~&oui&mPO(1N{;<2c)p3tBQW|6!9Eb|&u-D1R-hcHesQ&fe{CIz*Bn&XT
z5-9`#!@4ta`{jUbN?HdbHvOj$(ED@2grW0%qQWw4<!WRI4+}3&l{^q`u*xvl>a-e0
z6I83ms7J(!Xy%rdp-T(j%X+Wh@WcMCV*#HxH`B%A00&hdqt2)&LT&d<2ZwXmAMu3#
zuW~W?4P7zcn+?Fps)QwuK_n@(M)5Yw>??k2L!#%o4l%J)fVi1h8a2Z4?MXmH0JbI6
zpQB#XZ~R7H$Sz>#HANY@PFzQF?TobM^yh(jkoK#U_r}1~M!rd6kVuLo)CC`g3aOw2
z9>h~${hRmSTTu!NZFMODb|(bF%p$~P|FES0@vHU!{I5@6J@8_?3=MelTFtz(@OX>W
z2az+opi)$#nwSRGkuXFIfkZx1Bo3xFlnbI@>i8I@=SC?8GswL)AiI&3pd46%8VCwu
z3`5*p`;UJ#{Pq9x#ee?azWCzDyR>tQx^*=ChIev*`xD|j-tsTpAukT|FMNT|@!1Zy
zjL)muzx5aPmfe1!f3XE@vzF%o`Q|!`E)&zUdzdaG1@Q{Ke*J_0b=*&fw}1AFZ+`KQ
zpT2p!&Sx`=@Wiqkr`@#M-&`MVZui&M!+x*R$Vo|snKda9!7Xwr%Q?@d^>jQRAJ30Z
z>(i;8)_SgGDeF>lsqRjQ$YxQiEmT(vOJV8;GX@cBiC9X-G>+2^1CRF)|Ih#Zi@*6l
z{^IWS4(y-=<!UE4OR5o<6`wDg0fC~0k9+<r5Dw?<dD9>Tw~if9gXUh!R}tpn1Q2^=
z%S4IFYE(?z$kr&ws1NWb&@09m7+(6U`b>hpZN&Y3m4yC3j%|qaEN~f+qn<q<;VaxD
zI6~do{aae{zmfX??Z^8a{XgHg8vv|G&B<+`P$prj7rQ`b)?8RXTSF3onWI~l!9>1A
z+~e6>=Fhpu3#Fu0`-TyW$Pfj#QeBd-1M<K&P#I7XOsQiYggCX;Uu6^;1cP{DAJ_+}
ziA}Z5@FEFGE9Mon0e}ctLO58Wwe7M1;th@5dIMToz7fL!79N8SOP>DW>-E3=!||8z
zXyKjlE(Rt?@s+^B5)clFaG*M}!$4KIOk8(@Nn)3LC%j{t$VZMgs7Qj8lo^a*y5P`)
zqDi-8MrH`7)@bEG1u{?=wz=sJH~i(FUH{}KH$VEx)vGUgxXLaixZ=Wfh-Y!<*WTLS
zeWs(0OL1vH!3%xn<rl_hMxE~<rci7*iH!<&(KTLBhkJJD<?h3m0d#aOHu^v*I%<?B
zkfpuc{_L;P;ri82|6+c8TIX}A1rftAPSY->q{A?bV;V;pMotMSkt&!twpXJS&#RTS
zmbuL5d^(rYT#u*ncv_!M=f{WB!{hw;v^=e4b(D60rD90VvX4js2v1BT9+->qK%nGB
z=BN4XSN8<Jx=pg%0V|{B0c~qUrSA3bhbaa)!qHiV@?sVst-UKY2rpQOh1;>?0@(ur
z?8a6}T<YptT+O4b!RIIss1Fzy;Lr@leG+{sfhYQnI?unn8g7-GF9$nB&z4dL6~t=w
z?D+|vBg{M6M6E<v5dAS1w?Aws@ckbG13|V*S=5Rmn3yl`@yivUqxQEUY4?5iI;u-Q
z>((x@U2GfS85iUywgyoPuY}4`+Xf)E49GjSku9N0R1H&tim0dxE6dQAekAfid|(^c
z2C2%{MIMDp^K_C3T5r2ZH~5nfC2%5=X0q$-`p(H0P@^GW2)VAdd;f(0{tusi{>yWf
zn~c37F+<p4-nc_V8vQlEA~cHZQre5(4SGB1USgMMr?iup*e1a)VN^;274P*m2!>HO
zwZcm?ILxV9I~C@L((@4vQ}V<-(s-4w?uOT29^QPpzq)0fW@ifyQ8jv=xe@RkLI0OB
z9le+aTz<tr2Lt%lHt>>Y7T+cD_sDp3he`aJf9N~RBoriVPYn9Zs@PR!A>DaiBbcw>
z9LC+@%@>i+H7{lXW=(_Y0NM6=?yWV^`XT_cN)ZI7C}gH6DeBHj<i(fOm(|WoIi1(1
z<MMc%?~n8Q`-k`U$NR@TFL_yz-JORLyaNR%77SxB7Z_D%4wXp<dH3}vVT{uoo)o1p
zCkTb-Mn8>UgayD*5ED5C5v;c!p|#kz=T8D`?UK-j`qFBpWh3RaAD$pM3|0v)UM#Ak
znq>=}J%6%%FZ(m_>Jr%V=a<LJJKXPo%6=JW+dLrj{C=kjWcRb%kx&pGK^DoXdWk=x
z1oTH1m%c|fP%E6zsjMknpdI$e9OS{o!5$8$3%2$GJqh}@Ue-ng4iER|gMYI-Y_qCp
zP8hH7N>LeAsSZ>p@rfF?#f3;!(l8`dRT1Gtk=T_?$p*23>&P~+HF-w`BFsu6TSdEc
z$}$O)v@rsQQV0i8Um!$6B$ylsck_ry5r^}vzxZnY>ODW@Yfo3AJ99XyFjTb_!0<*(
z7UraBH^zR%VW3yja5to#_#`w+JNSF+93GTa2w{wnehH`&%>r8`jN#m#<|y!tSP{ih
zLn8*km}IZJ+ud{}({&oJz+-l*K_E%Q+&X)xpS>NQ>Fn{+tsVWGez~jt`ugtwJdNc$
zHv?>;Hu=`4(e_ZS4D`9*{af$V%Q>(YIk(e=cfSe(!C-YFkaH3cLj}_yVM>kV$q_x}
zu-&Y}J>1=jMK}`!LE+@QB_ITpK#6GL(dpVXuhY8TE-Oyw`sv}rHy_@9_3{1tr_-^L
zq?I`bOSrm~yfPCF3Df{^ASACo&-QS?+`Y;v4WtB7iiptXUWDfJBzsPPbYf``GblE^
zetQKsI$yMWUWkC$0Sh<pt3SZ*;g#U*R;`#7)KXz%&G)q2b2*V35q-OP;j^*+A9#wq
z$e67s^2G)KL#$rUVP_^IM1ak-X7w7svA_M_d_3Usr?&xwlNVV}TIK=XjWMm$!+TKo
znG1i3ei6mz0>Ni$U~K)4?%@V^@{Ry%88C#kVkVB7I3~hGF_Mif@yn7#B&iOAwhe$G
zWZGuJ6odFcK5!i*RJ_SnqQs)CA?hLq_GoQhLL>@dW3~{uk|<~Z4?!ths&O`7OIdTx
zm2w{LpYV%+vbkR0yxOlkF0KO!OCW00bs9v8Dca>7a4?a9vIkfCaIVMM2Z|)F9EqXa
z5($z-Rdq<aq@qGeF^UgjgVs^&q&|oxt%-|(H8?>9MqEjQMy5%4C*$?V2~ZEtU}lyO
z0jWEO6F0*((XX3mF3WQCl11Jm{tLS6TU_Ay=T)O$Lq7F4Jw5X->0A2H%Ln<^=G3=<
zJ_sdhsj-eyAm5k?OvX$j2;t!fN=!7h4X>7n5TXPyY9mR9Aee|D((;LB2y4C{fG8vk
zUM#P*=34Sv*ClFUGXWCq<ZgGfe<MF!uaE08mmn?GOEC+8q<Sq@%oj!=+`<Z6G?>PZ
z?~f!g9e%QVbs#CQ1rg@W1jNi5A&5$-2<r-pcU)YE^hz|SLxQ(h1apXnCKq+EM~x1W
z>Y2?jwj45`u7#EygQ3i}+{gLTczDFFK(KAA8<#N%{~9dj*e-&XSJQJUm>ei5CtIE@
zpAswpGs>$hC-(Xs=k)MDT1n);-s+F|KHUJ^c{!%Mj8RodgheH+oz$KAxo4uE9hjmW
zo5`PPpm?_TP(-+22tTdjm$n1|!Wl-M+1C{7j_aO$LJTeIOEe7QFpQ!isv;~x(kwLK
zL>Q<Q{JL@|hYATpgjs}DT6bY+IC%(MbqoHAL)^JkEazG*vgNgwwPLMUi?79Uv20Yz
za9ZTU1Fc9^*eopEBAAs}ol0?cGVb68?&SU&9#ION0EP>batOCEFAEckFtacxMN%Z?
zG0~K0O4tq9kFp<Q2cNi%%mdL*hn-+bG^lF|9)m~l5J-WMsZBCS+j1Gk2DDD#XN2qX
z1wS^APi*7I?*xIxXQ7Q}P%u7c*0d{PY?<&&0SKOrqkRt`TxLQY6ZV;1JT70<9Y6io
z^Gv+6@#BK7WEmV$>q6Wv3f>!anc(V36x`|<xeZ<2ykyI{=5?LVHD|NxZMW%MT6gP)
zHNwakgW%)_kP<1S9d2LImBHLwvx>V36NQJHN0ruER~vkxto3QhkMR2b?Qx$oNsU-j
zLQ0}3kunPa3or1NOs?SquLx`PdJad^h%mH*Hh@6`%U;qh(ojX3VF5%Ou;}ccQi3Yg
zH85A1f`;sPs_B!hpJbW|D<~0Z;KBe$gl_~>`rH@vY}UPu;a~3J&toPKUEBqimAAEE
zk^zRu$d8`yy*_bNa(GQ;(e=b`@!3f~{)3&3|5Q4G!zrIrK2K#$T2)yM)vYCNrN#S&
zE+M~XZhuQR(aQ<YMs^2UrvQO_DU5eiA;QJ0cpiM-Vckm^QAc=UN;0V=ou)L7%%n`r
zA?$*xKtc?Rk!WDjKC%UfNSP#&DkUY6NJG_RfQMT(FD-IL#iF{eC7w>@yw>wlk8?fG
z`MgFp)K+&7ao#!YoRX86xly$U3j{%w+{w&9#sHId7Y{KJm5xp7QxjooHrmeHWZ8<X
zoCQf^R8AVB#xBurqTR&1gu^f%2J91EPkJT1Cm&G~vPM;}>aL)XST%^;+nksQ(NvG-
zC)(C^dTG#zjnZ@hIeiXl!b`C0CCUFB<)f_%E-rDoKK=2gWp^SH{W?x8`mN)|Uep!A
zO+nfKmL3<M(Tk{bY}L6S2el(bAvjP272yO@QV(mE&YFvr6194@sMSlhHG8R+i&Zyw
zkLZ^SA`l5HGqZ>)H=9GRCXHYs7Um=ZB8P}DQG_c)IS7uZL>}SomTOkma$D?dzEoS+
zV}L1`eL&5|O`P1WH4HC%T#Wz#AOJ~3K~!NDm62N;8=TmjELt_NGsOfR5d%Dd2Tgk$
zuZyHmfe;wpyA2`&wHoKp!m<vSiFY32?B_`D*VEU#tB<5t1OXig8oltTaY-BBMH{<f
ziwC!ljUx4V(Iff^UpCYaGXSrEfgB{bq|Z@c=Q_Wq@=kFi%TZC+!+IXqBYBB`W1Z(a
z{<eP>6ZEG8g9E58x*m7=DCtUR6lM$S<6j1XScrnXHC|gQR0{96PxLrCJ(qer2muc6
zpVnzF4YFur>ln*H$`zH7ilQjdFizuiC236Kq)7;^-rW>M!!^2Ct3pD`07%f{RVuC=
zOit{PicKZP8k|c#E$h>1c|6WfbDkH=hU%Q14eTJt=rK83w?JEx#Hk&##fcph-dk17
z>eiCO<gLAnw-_ejnU>ufzYxUUyNWv;xHYmeGeatrqw$+nI4O@whD3)!Z>Hg9r?*$b
zRplvJ;&sqv8p<^JZt@!uV^2{<ov5;Shj3Da^@MTn=89+L{R_VaT{8K7W#7=1&%IHd
zMRsX>Z>xV-;$JAofeQw{YYVLumM;ThdZ9aQ2B3CWw0Lm?;Ai7eizN!s)GV|{9YTw~
zHd>T3Rd{tP;nl5rweYBw)*SP>%*XR`Uh-PKdN?>(h!dyXco0pxQLHx-VT-@RfLdZ3
zTswy_`Bt6ojg?ZfML2~qHGsMUMik7A+ruo9^eWK~sD#Q~K?W3$vYt<+&gM0|5W6Z=
zc^G6IH4Vxl0LY6`1)Da%jwkV5#0Xb}h)z6S6=rMQ7rb@t5h2{nYSG9$9#~f8b8)y(
zj{I(Y`sHx<=d2@C+bzePJ&ar6zunJCK(wWleRC3A=-(HTsJ}o*v_kII5)m*5)m{SK
zUUzQrCGvefeMR-Ff#;~X<{{6A^)%%p-2NCV`tSASzm5L$`QP=ux&gpeT^^?S@i4tP
z>9A7Az-{K9ZSi2hw*wm!1+kO&mrA$#!}~MEBo1%1`*_wKD@A5sC-JMq2iD{!&@>FY
z{q=abVI5hODc}WB8KI;DK?A+jg4oDO22Ko3P$`IFHZOTum$}SO%j4rpIk;3`i{<LM
zqBz$WJj6(X)mbifnQo|vE|Gu~q~6O5+Jew%l=dR_e6db;UFCU1!o;nivYBSFnf5N1
zBX?p*P!;ANav>)+mdd*FC&I{ON_9V$X~1rX{TNq!xxF6muI0+{m{;W`rP%G{aM<m3
ztm;ibAn}w~lsqaTnpepq+zkkp#3IdG5`7tWVh3|jOTyaan|s*>`Z){s1@9qR&n~^#
zU^?NoXX7ZIAE_BTeY*!fN5k6Y<58nAn5gR#9uDcu>PFD8UhEzbW?srVpU<b`>G*Uy
zoz^9n5^l_-A}TT@8X#?L7U86nJj5zp@b3}U4m5p_Z2Ba;<y5#6*>I_@;{d|Lo#0Hp
zbB3D3Sj6GxAu6KGOu`UGFt;tngA(>Bjl{;>j6C5{tCiC+hc8V&l@z?AVW*UoS%?PZ
z5y9jE2snkRsjP5w2UtakwHm@Z<U5Q|m1<xKQHxS7pRl|upMK7|6WvGbs!`A+JTe8y
z+PSR(8L43zTOyI#x^L8K1#r3Hzif{{U+BZZ0CAu_f6c#|VNa3YM}Cj|3H6MM$m4q6
zEl<gFh5vgj`hUoS#P{?D0I$3}j^~H#tNBrOXV%KpBn&Wx6PPKOJbFz)lYkw>U=9zv
zbV6+E0fQ;n+}a^4I4b!9J4-BwA;!i+U{2G1HxAP@jniI+9kU=DQHa4{feIR3Ux|fz
z3MQi{UP~!uF1eP~>Qd^mmO1CO*jz9dD&1Gf!3rLOHAo!oP|qF|pV<sIs}d-}1Ep)i
z5zj_;ddabTsb^m>mIQz<KJD(hV5aTA?I;U(bB|hMW6!a$h%mDX7RE6{&QL~D+6{b|
z^yWZUd+f)U2HsDH!$GdE<xnu5t7uWNVc>DVUVID#)@I}aaS+_Ls;}58eYzawh8p33
zft0xAziUU8y0nS%3+}%Vzvy-c<GJ&<Lm&IIbs>ZIL%s*0$sD{ji1miJ4#L<l;b;L9
ziq_k8shamdH7{kEm#3%G@#(mn=e*`x&Ag!n2e08Zl%>!7+uq&J$d%DtUYAK#n>Kbk
zJZ&AN&AHHQ^4#N!eazb13&R;(PN8i89IOqb<jyFKsm&w|Rw8nOZ;j0X*(MhR5VI?S
z0V56~x5zaY^I|Lm5|eRK<q_kEaR=o_J<Lpq&=7(;xF^$?oKf78i&l;mI!a_mT9H02
zPk+z*8yT-j4}t--1EnAYa*zcIr~n(W?s;m|D0229#w~R5=|;Qsd%yZKgS7FlL8Md=
zrzr3I^sAWPQ+YzEQHGkYmQz|z<c8l31o6ici~Kv2F`s9Ef9-Goer*5%=hJZdbiF+8
z$D1ckMa2LQfeUfZA7X13vc`g-i|GAK8QZS*j6NZ7P-CJM_C<Udsq8dHrX*?D?G9J_
z!)_W<YAQK1bF}upXyG4$P^f#YUKaDHUW%=`%xgZ*%W+xHt1UHZpoTiM&02#H+OjVk
zPzQG}(xvrqQ=u=?G<U?0d-p0`HUI`)40G`!J5OB!$Frz@$wOenp$Z8Jag%;7W?AM|
z3DY<fVeG;Xu0bNOR>kJR#&gEw93P%c#RiS5y<Q*q`Wjb{v72HVX@8im4#VM)cJ6aI
z4g53=It-#JEKCfN-tE<Jr5ylDhG!%1#v%%*&&pidccmS5LC=6E>MaK^_k(Bj5N*)o
zek5o%m#v%x<l%fN5pCQUZ$-XBt<iUTF@>#pJ+Jfeyq;%U>vCR>$N6-em$iBjaS~0c
zNgDPC;Weyuv`_CxX$G{0APf(0s${RKrtt7U7>7wqDR%$DC9fW>YnQh!jAqqsNe*IX
zfpCxnHG_T|3Ne_QFL~=#lim^5*xS5CPuloFB$%jz!^2ChFpeM?6_|%pq+uX&nuHI@
zhxWKikm_!&w28?HB`jCt8eD)(l!2j8Iok58dc3poP7b%6t^spHf5HjT+D<pO)ur0A
zO{9sOE^W^nBbF}1U^c)&5u|`RG$@!Vct-i?=YPsi|A_p7%8DXZ59@k8pJYA7@8<UT
zH@AfT=GFguxB*Z(>-ppU^zm@@#gukg)c|uLk$y7ZAZGHobUD6cKgSDPXg^M&sYBEe
zidHo8D0MHiQ`%3v!)~}bO#A(A8b@Yw54bavaxjvY)oQ753rA2fn`b-E^J!imAD`A-
zYoIz+P{n9qCwAh75|ilbY=`$cENH{jZdT}c9!55K+xlSB8>H}3dEXZLxKLZ3_k$*E
zP&{7)=$YvVM(a){Y5d{KwV=P{RhgNX`mz`eS4`2!bkb(JQb}s?Y9Iu2Jgxrjsit>z
zNU__|tJ~p=H&<_7?+$sKl8I9yxxUifUQ&XHr6I;i(m)L#Nz#637T)-GeH{rRxHpxL
z+7R+HV$62$@c>C*+liai=b1OnEdv^Omb{vWcpC+~1u?i+KepFOdv&?BQZ+XB+AB@G
z<}x4WhY$Ck-hVnio@#a?Q5i*sL3bYHK~~6eH>1M5)5$LtbiJ*}!>#E#VeM{cFblV+
z=4N4qJ+n1W&c(y#(M|hJ=P-&8X$nuf*#$F1NjTaIP?S_fMMT@RuDO$m2$d;XOC}Q<
zhNKlQDYLK%L@d-e1u08|(^~ktL@92Wr$G-RPn>Qi>_?<Ci-xhmLYPE?+(8z|W>k=b
zse~4Aag<pq+3A;AZzq0D`Wm=`Nq|}6<tYC14mgVE!T^3@594ii<lXN@9%#Xz0f4Xz
z&S4*X`BgpreL4M7>nAezvMc%O^t3xaa9up&x8_a#VXObY@YNo_?dl)j>kR;2d3~5p
z?+^JW`{CxSl0!&ZF2KRkOB_4efw$A~X4_~J#4ZZ6_b${nGYv*1&x!J0{d&^Fm~L<O
zhwH0xoFEJpVjc*v+R&sPR)f}xc{!iY$Mf-YKA-1h&AC*M0DFuEav}?M5(h^+;WjS*
z#kktn@QWHP1hnOVBB<#M5zkp=3U_m_pW7g*`%(xXsPJbn&6nmUwC3OTnqulmck>t4
zx+W2ElZu#$NJK=WIbK;3i4q~WItSQTl$c4Fg&DA7Y*3L@an5)+mao3~c-S3pZ?5ic
z4nKVJ=8IQXr$Xx~fEAe2kPlaJxbkr{kqpbkA;b)!kf@vd)vPJpiV~Ycypb#=+K7)F
zP_S&XVW;iJ^W6E__e<OU_)-?uKQkhz5jntQ5lzY_A`%u3gU`j>*Li(>IDY*2>BIX^
z=cjWxO~ZZ~?!t>3nM<u?=2qJ=wuAiKqn3IpTX45<bGNV>X3cyIvna(&j#|Ph%)Hj9
zHLRkpC^@`_nVVIsZswa~9-D&JEnghO#02RsWUvq`sq&E0FsLSO^MEvnCQ+eiWjxB7
zgq1~`QH(-}l}X6Nq3+3$B9tMCK}t{<Rjv<jDc#8w)7=&JyU+(TuQ7y@kZ@=03K^()
zunXsq;#31=)nb1By3$SMJJlN+Mgo+kEu$ygQfaX@zJ+*)ioC!9UufZR34urF38Ps$
zO^GFD*n2<!eSQ49a{f8W*Hq78T*}qye0~2uogd-$YpZ|!>#zRb{iVMX`R7jn1@Zi?
zQknJq;c9uj-o1KANu<k}4N$hV%Wi>|;5HP4)5TjDy+WA5g5HD`2n$;!^1!hhWWUq>
zPWRVWhnriS_FxtjCU`AnIeD(<^Z9suTITtDKA-1#S?0X1wYmoa>Y(uGDSv9gNNx=x
z-dnMWh}|Q)2CxCIA|lFGmm2MAPn+qyqlhWE%}=piA^>70w1FVu#pyEelBj+$%#(<8
zo%<Q7^WwVU7J<4MYTCnJwt$qzq+<)?kuaEz3xtUo!d*yW5~9q+MC?Y0d&&2oPVe{j
z?p?jPo)7!+`et`^y}P<P?8xlA%=N5#PD+RUen=GDosZmm9yU&U7kDl<kM{GVjVrWi
zDecVPK=%FHr^{;p?EY_(kzcStAeIP2@#r`WA&`6Iyq02*_s0+K@8>zs^Sb6@HQWe3
zh0}S)JZB1W3#-K~HifXs*rh2*?HJO3#9`z{VK5`BQA^IN<;B*utV>y!nzPsHwR$yJ
zC9iCS!r{%}?{OKPfOzX&=?+-xXlIdj8)&U3Ov0+7!lEq7ns^vw7<EW8jM_E{Nh~U?
z-0pdz%*v986Hy9`fka3_X|vulhgtSYdm68JxV;{(uhud78SF&Fu1t~`3^z^yyHf;F
zb(b1ag0hjA&=ctEHLe1q-U{yxdIw4ZK?p*r6}R<_MmJ$SlicxbZSa}>3~o~sfe9-7
zlg+<eAO6lB{x(j(<oYShqh2lR)#KytbdNf>INraR)ARQgfBsZ*0GFSq7n$$(r}tO;
z*ZVZhl3199+&NqjLDsqx`vM6BocslVvSXlnKf0m$PrQoPN$Gl;ZuW9}HQwG{y?XO%
ze|-ZTmNl<=InKxP)8qW~P}k*nJbrq3Sk`4;)>>+_jWFp8RcBjtdYh7OV~4GMYJ*Q-
zz(s@zb9aNAY=@jnyZLi-N<;Pc-pcK@;NEhY7ox@IAe(PBAo255gkH{v+s)}&G$Y=`
z5roxZB?D9?7hQ#gRU|2^&;@T~3?gS{W@mQlMOjJMB96!9cwFCpIB6Pp`{C}@;mzyA
ztGnrH&(mnrH0*cdeqt*;BvYxQVi<T#tW7>ggd3hoorF$e6@&&Zz&rtzpcE1t5o7BO
z#xpMJxn3+jzbWwrd|l0#b)Dzsd|XbaIWPJ2v^?FP*QMs-AdxhRs0WvdQo^k=I09}S
z?oFuX9%eF+PD*e$uQjZa8G9wGp0lm1t?N3UY@KagOJ3@_TFK$ooJriu!onFZV{Os7
zHpEVlmwh+=Vne}jCOosSxN_l31Vo@pnnaTfQxfH*=y!r7O)N@-O5#XF19%`BnFfkP
z7%C*ZZOv9a*76vd_OcreuW$V3rXG*nwrV1<3J(aE<iv%zMtiCZmZin|RU&X->=!wj
z4z~b5g5D8d1A9Q>+U8zc`0jGd_h-P@b0my<hJYL`t45V$rh1I!pX~8(?eV|G>Hnkr
z4b^OQzvi3cY5(|v*OPhuqxArMzGQ!^==Wc7_5Xfu0C1yx9G~7^9lp34uO7#gg-lqS
z``bYR)&^)q3^+#%0c~f$zI<>qI=D7+3v5)}>~>$=O?Ow*&DHe!&Fh<2cQOof&hv48
z_u>BiyRSdK`|5cA(ei3dvL^zBk~TkP-BP05<d`m9T3phjTfv+Kxsx;nGqw|c1cgaB
zkt<8T=(Z6db;r-e$Jh!xw#i}tFm%H-i_i<c<##06U!){o7)P7Z(hu=X<YngmA`OHG
zMOa;IJrPk`8)O(HB}s#*l1OJ|3WM3VMb@FsZd=`;BZH2Q>&N5cKYc^{UAo@yZm)N5
z?yldwy1uy{AMayGbvM{yhy9**6Ac4YTKSubato@WKhxZ9N<D9cOYv8~E%njhGYF6`
zli)tuxSSD#5K*gDtF?N`zRdaY;pyYY`}<Fi=hIwE3^EP67Yw5`-6Bq<l<FP~5(azQ
zq5zJta9DvG!KInhg3Q93s*`i%9C@{MDd$r@oyz%C*EMPmui@6_{0#xS!A(GbbY-r4
zx!RDn{Z6Rwl-nfSsXJ1`EZBql%mLwO<#1M_Ac!k55zQ);5|5({ql`(@phHSArZg%g
zP=ZX%NoXJ%ff3M9CRZV=fUO_TB)8M6o10g6_4U)~<2hReYrBdNH~(p61q(SDF}stM
zhCFggOjy{yHp=-^347G*d*1&gQh*g0;<HuMx7@gY-saHWC>$F<c1v=ABBMTG{@S1Z
z&hP(UIsY8xYt*yZkn`2?bp7ygJb!e{|6$JlpX)#0PJaDMyT|u&0|3aX9^dVs-rnwB
zeHad_gbCo>S14f?vCejGYAavf{TFtqTZA_fi?^f4L5DYQ4nO$f_U`&{IP7j-y&8AB
z(|r2JU%mbL&wu{SH@`Zc9=*&|bF&Z=xOK<Sv-g~OC$UGPpi8e(Y-f}%fd;@KOdY9c
z;a;n|MR<!`b>U-U8~2KuCfv8jAlO!|-rb+f&HmOdJ;co)xn*TQFEh0*2+*aE)_4^3
zB4HolF!yQ}r47zmRg-EO1{H$WnrCyXX1QjpBARrVhH=!CM3qV4W^IPRR1vjiCWwfn
z6sWbHL2QItVwv;tVg2;s{B}C+#t+k|w^!q<+wslo-Rrw?w}(n*%Br#34ZGbmj>@^G
z!kQM+{;Ac%oZP9JN6&@#HZ^p@g)ob1N@)OZ9+=iGB%4Xh<8)j<e*E<A-G}>6k2zN+
zWln@4r6kNX<LSxW+zi#)b4N{zh-j=0-}V<rIJ~yrbMinh$TGNlEp=JS=~U-)ozHb%
zY+a)k?LyQxk!hq36^J-kM8}i{<w0c_v~|g-u&M|*5Hm?56otE2cQY%smbK)Z&9kG1
z6|dFY-5YhTU#vj^VVFmlTZ#2l&s>u7IOuLn!=z~voj9$kQ^>%`@Zyxh7)6*z5c#ss
zl`-uP`|F$a^{e^%!;<gYn6BT4SU^N9Ebhom7BDjt1DX5c6h%k!{4w8KUQXjWPhWt>
zN<)Ue0v#xHqp|j0`wr~iDmn3tYYjpK8KQEm6f^2W%x~lAAMD|8ar%c;-*K!ph9zI0
z=evh@)5F)4&uu&x|IyaH@5udr>rdiOV*>z!m#69Y{^sU~H`lK-t1D46!WC=tRALVI
z?aJE=Q6gHUAR`c^g!_<`VvVq!@(;ea`RPx8cy-wA_q(f`o3!8SG@YO3|MK7e$5&td
z>iGDHJP*=y?Ffr--sn;n$vq;T@8;-z+6<t1HhlB*cp&;5QV`O?kKFyAVOClxacq8%
z?pE(%weHMmH;PW2AZo|Ort$E$;xjnV`D@SO&nBeE<}s&@XAppgwHSbzo0~b1&1!fq
z#tab`C6Q4;W?r(brR3_h+Bi;W2qG6@QF4h(Wl9httkw!|`>_P1hnXqzQqQMZ2r8JS
zwBPCVVZ6DXuCCI4ue*td0h(svd$*F;rTx3MEwzd5!mJ`mG!ZLH|GkJxQq@6KMOD+F
zQu?frdrlgFyP4H$R!d#iy3Paa#%j*R+~LuX7Evo%B@fzqLz}K&Urh6T)0n)cU%k53
z@L)J<#=1ma*ZDl3PI*52n%N4uQ-n}htsWi(Qqf`D9S(=<>;293?&>fM(|+3Rc2g2b
z$|*?_7Qq(jYBx2fi~S!SQQeDKsWp4GSgWn2F6-%ZJ{?c<`Ml1#<l5*I?tPL<&1Kro
zGu6G+vbdhICf13ko$L<NxKBC}it`XAU?sN*a*}EvA5UpI+`Yd2;<o<i2lIR^=RB|y
z3xZh_Xad+HSPhb$7N*6?YITarUd0Ix7Bj2aEXpGLul43<di`S>UW0Fd9YPTu=dgKb
z`^bYrde8$E$P_dDOn!>;;K#4*@qfnYA8GkzD(}h8UQzP(a(?sl@$TuJuJ<jW82`R2
z{qOT>@h5WwKsf56r}u~B+c!5~tiz2p!-$isxM=`EZF%r^0&i3VP_MNkgsL(DQDH^N
z{_F>LfBm2S{PpXbl+t)OT;1LUOBx60$6x&8SLfs7KqM?~IjX5NL(0pF?28pKF7SYE
z&+LSW*vM90mEnj!)$CZaer#);YInaBmvxXB6On+KNa%T#$ro7*o2@?(T_ox2eBc=d
z@!~SX#3Y-F@Pe(?bSZatH*ZFk@Mb&lXbwddR}E>Yh(TITH$2v5DW$4vN*bZ;+^NYz
zt?4$bB0>lN2a+QZNx+FvOAt9x9M93Bu|rCS{dl+<cY94KKqV~KWhwLQrI=Zpssu5!
zN*dBI4&yY8WAoi>8Z-?lrIdy=4k-=WPB2ifm2U2ww&m7Zaw)Zx(kw()CFhh^lx$|v
z8e-kIj@XMY%exx4*-@<D2;tStyzdRQl&})>IZjW$&g=P<=d+c92yS;7gb<}9yTi@Z
z-RtXDudZ%yc89~Xo5tNZ?smg4rqsx@q{6Dq97NH}nhD&c@K)pFOb*nD>Q>wftfCa;
z61A3GbI$9Umw8>z%Y2%b)4DEsJ+5`FR>LjK`iQEHrL3YBlMGwMRxfi(JJvCDge8iB
zxI|Qw19{|=f0%e2#<ct5Zg{_|Sj2<F7{N;JYOaA$4iXI}BPU;(lpRsR$tf!LT+Ld_
zz0F_M@|Me6+5a$&U$WkT4!{mHY)xcnb&`ly@70W6892ipQ10vUp`700^c9_d#mhHb
zKA;?H@lvkN>)peLoBOZz{4qRV@|WL-kMHXZ00`sdetP`o)y)siw<*icnL{{ICqOy?
zHjfsDiI*85V!%mN7~$&-E3a=4KmF;Ce)7{FkJG@KblU6gU|^^Qr&7!<C{aXMwaz7p
z3$H9LtES`9g!c?8-s~8ca-;yZ2Jiq{Yqq<0EWEd##coPz`5dMoLD#PtEH5;`E)Vx0
z81V)(;>%|Q#l}JEzRxD@<Jqv&NlCb*<zjOrg}a-(o0-+>7Veg7S!-TaV=75>(3C_N
z2s5`@OAgoY<eo&8g&{)05lq4$=CB|G+)=5Oe{4-R+a#iW>%QjobYAFVfUG52g<@n*
z)be}U{`t-S!kJ}-EGCj!Othv{HI<Zxl&TJ87>cNBDyoH;n=yukg&EYIdN0N2c{Otc
zxue!-KaU8e=I9Ue&JAha!q$M;gSd#k0koYU=j`DvuDPsBndf?ZjHi1lYpuo2uz~3~
z4a4rRzrKF;>hAXD=I+(qtJkj%*VkzrS(Q~KCDlYsLBairY+I7`3l<{CLBa6GaSK>C
zO$L)Qg|LaZas&m1yVqJv$@99L=k>g-=k@eBFQ;{#^L$$KQtRqow^K+vLRG9@t$1FF
zo=7K7BTXaOj#EY~HbjaMWj>$f1Alp&4%6)yuNQhKPivGwtF>r@`WE^?_v~6EzzI2g
ziCO?7FD$Fu3SZn#r9Sxl&2aTYzWNDIKR|j7xq}`cBX!{7ur)ojj-nNQ4tw<VW90Yw
z0G~i$zxZ`N{z}WemPaZ_l*O{H%l^FHJUm{1{AxJ9x3UEOJy!qUV-EaVUJ<^(8$e^j
zoj+bZe)D>|UUn(V;7%?q5^n6R$~L&0<G52MdpeXN+`>%-Y1F^`i=Y1N&wqAxeWhdK
zG&-lX283&|(~^TkHJPneixS3hDtR?C=^{Q_w(?^1iLR&zZ_DZ?4S8F#g;@e*ZN-mj
zW>%kDX}WWig3+yg+@hIe9dFcpL&1H0zpU)Ic%kv4*%o{W|F)Pbn!gde!6w@Xk(*|}
z;cw`fuiJpcZq;j;`{0&q&Ffmrnro?bRfaN>P)Z`qC9frC_oO~*8Ywi0P>4h{35h#0
z8mR_G1h`Y<343?3Gd1(3n_HCHe3~qxEDp-y?I$ZOm(ZRiV|EtbVj+fNq1CliRcMZs
zLbS3}rb5CZ#4Y7S)G-fcW>(5JYjIdh+D6AhgnJG1DCmS)Jg1Jg9B;cBcrCTAEmvLY
zI?v~2U6!XOKR$6;r0w_w5>4YY?f2Jrx3Ay4dj0zK?W<S&{b8E+(|(uIz$`$6Hi(O~
zG@eUrdFVzr@z&DAJ=hL@iAd#W$|nVhGC=`r_?&QNAI7~5H-neGt+gz<oY(odoSshe
z({eto%Q>&Jt*e&;bs7W$xVt$gV=G|`Y(gzGX3`O1h4(@uJ$~~+5*==KU;NpZA6Bz-
zt)*?-!3nBLq89FrkI0F5XQ+sUf?*3&Zf$gkf;hno)g$u9sBdk3%hQ)Meu42dhC8Hd
z(g~zp`bWFgFUXIveDd{Up5I&kNcGcTPsk^f;uTSo)ths^y8pEQ_*PHvtS*lK2)W<i
ztNZs)?*;%Mf|tkf)30vFt3}6UOeW-D^Dt*}f^+~dm`IrWf(ds7jLZNd_~9`Ar@#KI
zzx=De2wQ^ped*-@03ZNKL_t)7bPO3axYSsdIp->x>H;NZQF5=<n$M<1x-R0+B~#X6
zHuPL&-PThkxvZ&8S_x|>YjY1L^d-2>{fN9J#)ye&YcQq8{UnMl?9kWgpwCM0E{p#*
z;C(LDi)VXKI5onY6S$8wh^dF@TIjW35CVv<g~J18UUDvZDS4@RvAon;;2@}wrljs+
zwX8L)h7PRSc4n@tnV4u_rMS_`dJR^;e7m=doB_`8&hP<kEyNI#HimC2{uWvz1`J4G
zA%;=iuo>oN&SoSUtPmw}F>l*l(AFO6y_ySdvE9h}8xftqY=H`@&E@-<8L#EJBbZ>d
zhPjZ|vgT!8=kqe3mh&uOj0mCvIMKM<-@bYC=F2Z%eevdSeX~34r`<G+ldu}g8e&dL
ztdgWLdLqm(M~;S2+B`0F=|Kg03wGndZAQr+o$!iEVZC-3PTU)AAS^0rKgCtr-HccB
zl+Vj@TF%G$__!R8Yd)JV5gEl%9OCW{Gt`P&QFD}q#)(o6U7-ht*{6ScYxwf|?s|WH
zTpt&Ls2ob+U^p4T1|mvK$-=!BN*0j*(ho%x_QI%u0V~HUekMQF`KjvL&|9QC47W&E
zBs)lAQEo4J%U;g5K1P0s@(4SUpM++{VkOrso)1=TPfyn$zLtk~m`}CN{+our{x2rM
z{-8Z0ek;mn{2trS_j&^Ws4jB)uz&dK=J4uiyk1p|xCR7aA#Ci<6wJW^kw)va9u90$
z%Jpvi^Phcrb$6%J7>)=tFvx{jL?7<Y5BHyjlyZaTbBa=HEiIg6eN46yIiE3eok?~%
z8!|zeTji722E{FAw!w=Uho?<$`2sBJmqY4~R($T;Z0@6oOSN5(7rb!vU#JlALX3*m
z@7_%&?%0qq-sTk1w~Khr8B>p$aTjXZyQ~gsRo%u~rm`$~K9_Y~*KD;8X{Vx`$PBd<
zw=)K$fmp&}L0&z8V0xL%YGeBDq1^1<1SoB~kh^<WFokf0lM@H3hft6N3#6ref;3E=
zCDgZ%Zi<XHmZp&4Xy(b6%2U%tid+Ah%`UqkM8iRqPyvge2x@rAPOffV#1{N@l(LrP
zw49F1@u@6lSZOVZByzaByMFcR=I-w1?(X{T_HcETrYQ}hqy$!HChC=;LF|nz*rFue
zIOg0i%e>tZUqn4N;#C_3Z`HR=o$9hBUD`1SLE#_+Rj|1SY4C(mG!5glr~Q>4Zibul
zTIRAo*5#orXPa}B8r6L;sK5+X!!qhh(~6W)vP%y3{FFW+c>3bc4p~p%d@>IRkx+0e
zWD-^dNi)rf7=!>g5=9};6on#F6oRF23c%-(?0g?Gh8#Q{LiWKEScww|@Cwhc8FogU
z$#aVcIjW($rCM+Ea(ler-@ny|Z(@D2b{Tt_nfb$)`hUkO#LGwjo^Jpx6ObO?UR{6r
zYInPguZmD{=3sHQ!f;|IZ-c&&c8)^?$eAI6-ER2lpZ{!sdmAc)?A>eBVrCSP^YZEa
zSMT0_HI3seVl@+5xVJ|yy=(jN;t8isG62GP>tVT2OJMG`mUXSIv+w_B@4dS$JC1A5
zFqy|(Q`H^-ok*EC!&z_E%=iBoGg|LS>q$e=f#_~@m%HYilNqt+kH~YY08t_-LZm>l
z(O5ut17)ts$cWhcw<Fn7gfIN}wh;z5$JqK(bX*4XPciqG&)gaWz6d%SA2)Ia`Ktz*
z)><+mB!hgF)VBwR9~%phd&HGDCWHtl5n=MoaE147L+QsUcc)W6pN?~>)s~^_bM8_W
zs?};)rX#s^eWzKRDd?+oSzflezpY1UJj6_{k2Mbs#s;901>nfTT^$w82@EkfV36dR
z;6RG~Dqq}mk-_B}WYY`#uDzh#tC__Dv|%G~S?mjeP{XPnr#}#gVOf0=ZnZERWtorn
z<#a6PLp>i+=B&(2GHf>2FJ8QU_43ur-PKjU+2nqdoRL!H96&&YvL>iP!~+P*2qhOg
z+QczliSWpVVfJ9%FtwQL_DAFrthqqTwIpM1zZX<d7^4CeVMumo0*P}*5|u=$mvNhH
zu4QZIu^jFvK9u8RrNGUzkvqePD)|Bww?aB|s-!}o8*v(bc(r}@+$P-Lp3rQXOq7HY
za{?tMK*&(3F@24!l2_&;JWDEy%2LIQ#7JGz3}4_U$1S*XPGE76!-xu@3cJQ@!-Oos
z)qJR)mbzI^yTi?R_f8M*t(+bH)!f)W)C%A?pZ>pN`s1(t=zr=3fQW68<Hzylm(Pa%
z`FVd%`&qd-i83ooyb+99n4Fk3-Ztc{%2{Ny?caR*$+K6l#$J^SC^Vr=^K?G{;%C43
zmw*1pyPGe^vA<I}pQ?#<%BqSWKCCRs%k(}bF>Ns9uBu&1%HjsEwbts@YN>9{!lFtI
z%P%X!BnJQMbY#7^U8HV&Ni=JRIo2@%gm}#}!K1%5sBi#tK#LJ+?(IMj7I$WWH2VG}
z@sJUjn$2l|HJn9Qlmq$0q#R2on5Wch>LmBtjq@~}4#zUhy<_P5l#{5t*-{QfxtEbe
zV-*+!AZm{77IG5jk`TuZhaes>jF5J7z|w+e**X$$VIM6L$_X4tppzMx$&6Sa4J{ff
zk+qF-;Z=pz3>?1t_F4__78FN-#H6T6e!_=9#2{O<sohFh&c}K_+B_}C2cJ*kwM)`v
z-R}0g7q9m(U+tc~*zR_@>p3M71#37`$l1XzgleHDRfY-&i6^Oqt1AK-9UkX?kes;<
z=i<;eqRQk<=44C;7)6klM2?ubSN9qwwI-!+))~NCMn=00BvHyD+6j%x`!VVEobKo2
zq1Ks7AzFx)R9O>>xfcwsth{*5Zo_b%KL29#{MGK&%VKh#id7?mCKbtUVn(W>I+)Mx
z+A8qKw4n+q<W<<*iu*!RSqoVutt8I6FdIiOJ%}mLj=>C4cp}U0oz<a~Zd$tIeSh~>
z5AU&@3T)+x{J}N<|K8~z8)5%uzM?<<0zd%QQ+jy29rn+=?cr)TYqz)pK$k1Q2;@!x
z<Px631QnJS`~469<_E7nd9%6NyUnL*8ahc?Z@#?!pMU@NKl{l~?{4oqB^mn*Jsnhw
z%}JWAK<Sbjh$l0eu!d1mPRc^;#cC;KUfe)niMX&NakumaaJYn<G+WZ8v_FxU`V;CU
z(^oVL{x}f^BIGh|$qjR}&Iwp9DOs|zau`62W*a{!7R@AqR&5N0)yWKp!Ba{}6ES;&
zWS4H>ev`(fTh81)oDL7iWm>9j#(wBi&T6$(KVvHDqo$r4t;{2QhA$R`NRMi91{R9@
zb%4bZ%UHzq9|9L=7IIJkVZ}*x-NTRrOt6*-=WL0(PDG?lN5GFtsaTh^)l3Ndv5tlO
z(nb&wC|#`G)V9OcsBKp3bgt*)ayl;OBU@n@Gji9xe)H<pn>U-Q=V`M~!$wnw2&-~c
zS7wRzj!4Ld;pSB%3y7Sk08%^!9|@O)9|MEQoLT`$L`)7?gD0~wIl~Cf<e<V-gq+z0
zPk*?(!HnDkJ_rZ3|B2wzItp^?c#!_8W9~%re15QUa$4957Xv$`L{2y#y=Ng8*LurG
ztLog3yX#k<eR}ip_U`sHFLUygHHTk5aC?O0ECwQwI0-v=but4a#@UD$a3L&Q7sM=X
zRX8ZMdj(jG)RCMzpm*PtbAPy#`ww=!@#W|?IiB>x{}l&4!v9_q@LPY(KZ61g+u-wU
zck|2ZJWgp-H_y4tlV&9pp~_?+BXI^xgKM%{PwD&L`{e)p??2w{x4{VQhAxS-t1r|4
z`X7J)<-0G(&2HFUaY8q4=4ByU+=EVAh-@YCw<Q~2EWsdU>H0p2kfYRPUP@UOxHC75
zK}h~rUNb!sYF6sQngHIc3oEW5^6>a8S?TzCE66Q6Ca$Tx>O^C#5@$TO{M?HJ0PRyY
z!)mDHFB$3WbVRt4!%IeM9vPTfb56Zv*RE*kQrGvJ&FOG|KHMMY*}QgH5)&&`Td*WT
zX09wEYAj4Ejcs)!x6rmnCDW=7T}Rm5_(w+0%<iHJf*`o~(8p;wS1`!J_oZyL3bBa8
zJrIJ@cECjLWKPv7T;hOTL{RH&tObk2vLw`>;tnfb7u4c)nU2T#d|1vWtMia`yW8(~
zyQ|&)>S{agciIoc$-r<hK?!aI7#l=IprmLF3uzThfa*;Y1~81Jk#HjOD^U0zRiSbO
z37DWVRVQl=0i3Ba7NHW6#ZL>{C4>NGEk4Z&)!Vih1cO(wIm1aQbvkT&V(zn*-pkSJ
z$*tHzRGm~g6Hlj5bSVh%snnbOa~gNs%`nJyIv#78-My%=Y61ujkre7BzqF&VM{{HL
zN(iHaP*A2!BJHxV6nQnWt8mBMnWbsM>E6x<pAMMsZF=x}cDU15!;-#*1OC5s0AKr2
zXFa?fQ-0a+JtrEkZb-P(BwZm{T*!(rxw?5}GF1BEC$In8|MsI#K7GZK9LOq(llr1b
zGwc1$tt~a}yF6@(HSeGC`Hb_j@*Y;i8@q>Y5lqzy(3D7oS-PQz`!dbTJeN|Oz)6%@
z+i-@R+{_b8QWX(12M~!@-jt*wt3)Nva7fIZo@^#pKRh1eFV-A9T=<yW0@8SG57wPm
zYZ9L1V);c~y2i?2T^xEuD1c(A;qiq=!k99Pq@<EHTk5+!j>C2{9>?MS?)G#(mO?|H
zb5hb|24Ci!I)V{#SjF0#IOb@N84kn*S&JmW{Ss)5R)Gj`VJCQ~I$aVe1MD!TV5l{g
zG;;(*SE8gjk&4GQC={_UAc!1sC%#}3R)J>-Y+9VC#7fnzmW8cYS?WBM<usj7^Z9I6
zx_;O_d$!;0uXelLcALA-Q&%XHGZzS4l|k-Q#f2o+*v<&;6}iSO7{<;QDk+i2GZ~{E
zwvbUtON?;m=;O?(5}BYfjLDdcQ6)lvQCF^rA-=~|P=IO#FflB6c4+;xIo!!D4DHpy
zLVcGqsi`mOi`Hc(H=8TCk_(8Cm=h-gyujyUJ==VB9=E$bb-Ix=TUlz$Y7hmQ5;-<c
zA_?S;qIJo5a|tYU^KWw`hLW&|B#~Z7%rGxyDRw%R<868PFdsim<y25tT*Mz>(2sAt
zn&2-5;J2^^JiOZv|AM|Vp^`^QsY)kEUc^*b$-TlM3UU3Lzy02i{`v=fW(RYS*XpEX
zS+q-8DG}5l+;6*a+g;uB?MF-x%3=$NC<z=ExqKm8CpZ~NPLdLdkS6m|%&Qp)Ev2qm
zMny%OBsg)JSeP6JkDVyNKr9>zRy^uS0r&OXd)mO_0_DBv|DR@N#X<o@PTqLY1Sb}D
zBKDwTFge8-$XTQnp-8_G@TIF*$6SDiIqD)dB^Qw_+GVZE==*W#hd!s2?r-z?csNcr
z^g8yvx!DpLd3F{SA+WnQtoLPYy<Y2V_1wm6B;+<qoMI^(JAH=v>TV9IJ}Fgm6}Dt<
z0;_J~nt+akNL49DJ)GFxN!c02-P{PqF!8un2OBAF(W|8oa3DoS%rdiAo9Fp-Jf9Dx
z77+3<?yjz%zkbvAgLHk(JtP@-N~u`@J)Q&$1*Sk8Fmq)U5Ie+KnS>$yC;`Lj_!WXg
zpcq47P7pLeR1n^XjH&ejL;;<y?e}5vTDojG*w+Ru4*gJ)`ejdyi%$_Artqk)B*NSY
zgH%&qc$(NJTMEkJnV1UEiM?<?MDl8RINzLy!*+i)44W}2nO6&K1(;WEE5w~OcMfw@
zu)B(?5GyEydzS&65u9n2lthyz$;!DdbUvRSKHlAZd3*eDn(j`v7^<zal&@kDzriNp
zcRZi}J?GcI`h(wm`s3gH2!BQefB;?&>Elm#noQMReD^jD2T$Z=z0`tQi!-s3sDI~^
zmv3IbyxMJhVuzR;c}+rD5-J?znhV#5sq~Qj_G)|etRKhotr1zTYGw}Sra6p3HDzQb
zcxBBw_q`cvanukTHA;`e&3!${IBSB{>3mj^oYG2%TcNgaj!AuFJ_YwIBEmTW62GDu
zc$Bg+IX7`4tvlxR;EsgJHrlu#K%0iCg{t9elu`OBbJPR2=0r@=l&6o$TrAS}eXW%U
z!#Jjtx~{+ZknZnp&vQ}fvL?<n&(pXWnYo&gBd+ftf)le`qR!%7`$*PaK^siua7Bo$
zxKT6!BC1YAl0t8olxlKIVhKrDlQ=+JO7VG$m}Bv5!f=5K*v%?g6@VWj*IL5l8XQ1y
zSHRrZi~(DgGEZfhYbj=R*o?dV)&BZfH*8olB)eoMtrZE#3;~?HNuVx9gNP+FZ-fwU
zLNEllHl+I;7LZ5-b|DwIz_|U6G1^3k$s&ARs1ho>QL75xyvl9#9z`T3XK^9%HuCev
zA$(NQVof78z=@+AgnuMKKp6^V5?hKF1I^?{*#yj%L{$JgPUrJs?uVfpM$JRljgl0Q
zTAhWoan30|9}7!Lq7I2mfs$mB4Rk}=NzRh9<|HCzt{>jr-M{;IeE(s(y)Ea-m+IEm
z+TTKbBc4<X{@pr&C*|eOsQ`p3^n90ZezEUHbOY~nv0?U<yKdZTElVxuTFSOh|NU=%
z_{pnJ2JSW~m0F7%F)6XvvKS_2jGMYhL6Y3<H{0jC-Cfrm%LJ;btf&M5<qDXv6T~A^
z9dHQuL)xB>2S2+kES88BEY1WrW~WtFl0-pjAQF}o#}CXZgLUorW7^^DF76ze!9*k=
zT{CIh*k@g5hD%j&!GNx6dtEyNI3iS|4Z<HEKw^mi9mu*Rba*7t#ICSys2oB-EQnX1
z!sS&es=;ecDt*@pOAs$khvR9QHbb9945ikJW@@4&(&jr)@;sir?jJJ>+De#(oV>cb
zL5PD4M(*&yT#&PqfZ3Q_1QNUnPC4h?C6z99UG7rXbIzPIazautS*dW>i?SAN!ya0h
zV1B?nf*aW?17#`GG%aNTkh{Fw?XIq`H=C`9M!ht@WcrvGdqi(336Zv&s57y+5Lg%z
zE=CD8R9yKllfcjnfY*p%jsgH@GHK6$l!PiUrpl;o2SAY|YD~bR;>%-VMg$l&vgS%1
zhqu4rt18yl=}=H}tOb&?NY2r>GEnDYbBP`cB4C9H$hbmCtSqNA70q)u)PAs(dL@-L
z%U+a)+{u|Kar2?GGAD8(Nt%aE9<QVutNHQpaJcz+`f&U3?q>RMR}KeXX7Woa_P=}Q
z|J|AZ{HG6m;syV&cE7)K4fu2H0M;5H$B+HTpI_(BDc9~LQa)0SNB|}swEOgV|HDr|
z{p9L;19Y|YZY&TG%<iYt!+9|)fA`}bfBCSSCcA$2YCCTBLq8_XWQm;3*qost29!yR
zARuYHcgm7G&gaE>wp2+>Sjn7foSzQ3r<GvnKvE`_YObtwN#tH5FNnw)#NpQQn379`
z8WVHGBVOj^4Ufyt@HI4>TLdwfMAvZwF6M!+y|A1}@btbPE&-;-w7E0|mwym0c}$m@
z0TGd$;SQ^P-|zQ(A`+JSyW44+b?8${r51;4%8kST2T@At-`b)z?;0Eq6(%FD#<eh;
zI!Tf^_&b(FoDghP@>sOC&7b>ZAg`jv{gQgg9a5LZk@}9h%qdZ8DntUD7sF=?fnnT<
z32=5Nt5l6^o#tg;W;fH6w!7_iyY0J<Ma&(<V53@DAfj+KGh!0x<&4!>{0fUW1!p{b
z-Gb&I;kLnP?Hn!zpjs3FSkvpY>%TL(P<^rkXgxtwk+w{LU<f%k02;{G;0mmLPdqLD
z_*{qR$<12|w|irc5;K!3=cF}xsVMHnh!|Xe*>gyhW7k%^R0E&VxeUY7_oHf`v*qMD
z_g&YiDnvMuWO5?X#928hY0qh7PHuj<JDl&2ckkZce*VSz%MW%wqgXrB`46S)|He=M
zzbt`&|AnyJzwJ0ZOB;GIXg|IM)oMnTl%8)lKl<#GH@mABed^1Jj`zKrSjBuU=fm;g
zc6m7T#{c(^fBg20n^Vn_HX>8M8B)%YJ4rsD$l5z24%g-<g%eYkQm>+@R2Ny6?393@
z>M~XH8h2*}F}%8amnr8;m`m}*%AzSi5WYgbn$}z3+;p1p0*^dYUPr`OFRbmz;`NQ(
zl5XQo-3XRZKEU{Oui>x<ulIcsiQTaKlNvzlf$c8gHUm5`H~^VN=s4V}yCfYpBQu*@
zwK^Y;OR3}7pU;yydQE|sae#$?&8<JiKfG#j;N*r{*{FBVVo6L0%90W%VX>M(NmxZ$
zCFbbFEREo&?sX}3p6_fCBUzm1e)N8zVNByFU7u1%sS}BP{$-)w_U`a?Wg2{>d7jHs
zYE2@;Fz$ByuJ1uqYGH9nIZ&hI$XNh4yJQ75doq!7!>MvO$XfwuTcFs4ui=+OjM(%#
zqY7G*a7^|Yar8G4J(CHn&4}3Pu>d??|0!f&j}f9RUiir%@Ns3(ibTNHypg!caq)38
z2@9npIW=Z_1xf`9kSHY~A~p)XHYhSBj#HXNa^H=8KMdn`Lqr*z!fe5!G;9YQl5_Hu
zN~P1o`R@IfAAa%v@cu)2IQmjTP4x#-cK$IWL%%~4@MpRMc>1GEa{sp1?l~)n=l*$B
zkxr=U>;3L;zw^D9L%;FU=(j!J&+p$p{Nk7Qzx?9(;p1^xreS>cqrdy?ufIFe=4xT8
zNaqt>Ki~CR%-}wer<Rcw+%~p&a;Q{c9<vToc`3P^JD+-%j))l+(;KBE+Oc%30xCdF
z=>XhUr<6=3!i3pE8ICZvtR7T|H}^g@UHg-~U%E8BOfhe2Y#6x+*rU~dlo{g*1L0r2
zhCJ54Pj&$Gl^gyVV^58e7B5g=@z)JfpebbzT93PLwp(|<Ct8lDT%3p<R4qD|w)b`;
z7GDz!n(jaL0B{g238@mzM_tOOay{g2R$(JvgpgTM@<cK637c5Vx?40bCn1$WZo;g+
zNqU&dL!A!Cd7003+3Gl2KT_|S2c{GNZO96GaEH4{n~7Pqd7f*n%#ypj*^FJzL|ols
zCojZA?Cl|{1PuVUT(Wn-AY$jX^#@(hNG%hTAI;G1L_|#OjbTmVi6{WhXd@tjMO6?O
zleNuoll_Eb2<_J5kAf<GR5jx<&f-!Gn$r;!b~$go1O*Ba?AE?i5zd_uW2s&pOLYiw
zR;rC{0wxj_5kdfkjNoOm1D{ClB&Fh^H<f;qch}>0Hs9U#*?oC9eEjgMFK>Ri9N(YI
z{n_R@(lY+zSMgsv1^QC~LjSoI05~lNx&3)Z^bF=Nzo*0g9x$rk>#zQg=T~o(>dpK6
zU;V@R?JwrfKQF)f6}|h|pC;9=biG_(Kl|?Y?}V$2{g6i;x7WMRH^V<2=HxY*B_$$v
zRA#E->;iGAS@hYEH<eM#^&tJQ+h`g!by+oQ>QdL`vFpa1cX{X}9ZG#ao&WLO`@jGB
zFH=95hv$l+5!AJEfGB*tDoz?c0cLODs}(}C;$50*C{*-u9<Ng$T8XIb?7tlSPqs!8
zXdI&Vbp_fAfUjsYme?A?0SXZj#63bcJqSA?ERQLQBqgRq7<>egRV&kcnx<jsiP)^g
z{N~&<vzh4{Td;mbU(HykMNxLiuaoQ<8=iYZr`{(XdL4S%^nI2mCv22zCw72&GCR!k
zRP9`>&I@rK!6GW4+vR+!l}qh55NM(l$vUkCi7T(iG^lk*)#@@Y0CLKGKjeM@b5rp$
zRdX`a1_U7h<`!6rb#NxpOtFYWN2lS72(d0?O@Wrj{Q4O8JIDGr=KHvmfrf!=M?Wf~
zN@MET8lKhSMdRG(b%?iak{WiXB^Sk$?@_6^q2-)bs!EuzVnZDYd*?_X5>bVCMD2ho
z(c;dY2h}7jZLAbd`iN#Qka;DpB=fl}q>#*Vmc_QOzw?}2%xf{9&UU_==9{z6^&2|x
z|EL%Jug_rdmjdt&)qv?<KKx|h`a+iU?30(nIClNt=H=z>yXog2?tb}?4?q8ZkH7e5
z`}j_er){C0I@P?L1aE&XuU@}-{a3qQGJK@vS*E-FD1ZGuD-(IKG7DL!jYW_(b*i1{
zkn?67`<#T3m6bUYr3i);QsJ!9rPOH}BnivOu}^$^*ZtExEh(Fju|gGuYC)A~apu|#
zVId1d+$xzJOo2}e6B;hYvgRJ6=BJV-Vrjsi$3-i!I?-s&mT%SrcZhhq?S54S6qy?y
zF#~YN)9t`zLew&C0b!PuvWSD+Fm5)>c6WPo(-Vsbs@H0wk{a~L1@a`IhF3YLvxpKW
z^B&7C;fm-Awqv{Q`D)V-y#`5g$d)1mPQp{)d{xn}OyrxMeHcpR<GI`&PY(;ZbRDOW
zq*^(jjv!6i<<zmJ_E2J7o5Gn0Zh)KBQfl?8BDw3jt{2hphJ<gU!cnV(MKmXM0OsHp
zL9;%n41^3e%z5mD5PDLBCAHL>7C8Y3F7{j_uLNUvB4clUV7@E{5Nm*SHxPfi$|2he
z36FFsX_Bi;u-)Uuq0J2&N)Z>?7~>Ik-tHQ07Pw;SIMy~qg-9SN?hqFu&?CZ*h|$Ui
z+>v|I1fyEY*?DoAj22DO4U&7AVpZ~u9GCwoMS;I=(Zp|G6MpS~_-_Qk<1Yo^-<t)U
z<o1_iLZ1qySDSu&b-$edpLbvUkH0_s^nZ5#(AT4vqm-h~Of!LY<G8&2mvcY7+FdWO
zvRFEw(*4K3Nx1snXXW&uY_&`R&&mQM(X2XX8gkbsO(`YSoC2{Aawj+TxS+WbDWF!l
z%m583FKlm=KI!y>6%v^#ZgdUrydKp|P$D5#CuJfb6S9~stWh_Y{OdLL<^qa{3u&0h
zoQTL}%`8}7rp;!2d2P9q$Ws|;kdfP*$BhUi5RkVHfS+suF3Uo<hNoj@5tWp?+}B|o
z>wb5hrczB4v#6Ox;9_9Ta1nrBSe=dK=E*ULY#alX4f!+WSG~R*^M2@4BC}$1t&vv%
z03ZNKL_t(#;yE-kPVAS#wV<Id29}&U&Pj%D%H2jZA4)yULM7*MP(95{)u|4fHI$7W
zr~i#9K`^+PRV%f`Z8vwFYBB=}2S-#z&^m?+kf@U(AS8|pyeJC5CDyH-p<&pd)&Vqr
z>$=1tCL@F>%*g8+NoEwQ>2~x#{uIOr$Xj06<3NcR@#4Yd7O~EM@U;_$SISOX6q8fj
zE2wc+u{v=BAlP10!Xj)gZbU-jRIODu5zZ;>eStcRO9%&c+}%@>e&hltbxM`<qIJ$)
z9(R4e*Hf=P8~#fVYnZ<AaLM273BX?pz$%7i3FS#5&-Glt{Ka&4{N>HDSjrD~SEmQ{
z6Z=dAt5A5#nuJB{?&eqbi@$jBLb^?PIGt~A{NespDKECEXg>}LY=LH)Pa;aviH^Bb
zqEZ%+cdQlF&EW>G1Q&t;P0;KvR!As|y-@z%rvJM)FY)0{-Nb3KY9bfol{Ah|<a`KN
zK^F>XTM09fc*8ivgh$qOa9i_UBH!b*!6U(rzv8^*r;z(6cm9?zhIKd4#zD-?90zw>
zY_284%!pKk!?xL0%1qrbkfSbTx8L7>{0N}yy7<VoR-%wn(PjD+zF2ONHOSyxQd(#r
zTo3t^P5-*rjW{o-dRjoHLhk0|Yi8pmvV}A<V^yit`Qey!$a#FV*$kNthx7gMp`5CA
zZcLq_<qgN9A7|tvKE`T=d$nq{FpH{&1H8I1)ZCmI8VoljVsoQX+wMghgR~u)Bw@&C
zC@9DUG!d)&#+O|;v;f$RDNcW5s{wb50zkD5hzM2O7)CIOEpbC8KpqW!jmXNEcg*Fp
z&{MNv=#H5I0X^ZAL^sq%Mk@{ru~q;mEY_mL=G9^5C@dK)DvoG#SMpRd@zE;!bVBN=
z9{~rc5uZgkb+sevw`sVdyiN63FNqDm?}Z=V((UnIMnJ#z@E4`jYd?x67UlCypMTNU
zn(iO`_CVBiEFD3dt$;WwDJi)~mpO?)=Q{YU{PZ7KhwZZHbmD35MH9n&fEO23W*1Gl
z6DKkkaAsF#&Fb!E3pJ^bflQNX7#zdwSUpABk@-gQk6v6!*OmJJ{p|L>qcn@oUQ^Oi
zD}XG?ycRg+o>E%iHAdtlvB(q_1tAph7e#0bK5JkHiZ~O(lZ9dod4mYlw#jW4bWy!r
zwEq%5G{4-+FZ*G4f6O0SDMbzz)iww+$C|(!)+W)^^}}v|bv{q$(~)WwVe^J3GY^Xb
z%bI-29L#LdBt2`Uk`@_Kezw^TiENn*7PSRd&Am1QG@QJ}d7)iklaU11fK8aW&SXNu
z>gmO1`%vh^?VTGlcV4U(i)dUH5F0B845CdqB0<v3%o0lse`0A<tAQx`04A?w5%oZB
zf#5KLyQ@Ylm^3K$n(7R!u?&&=)|Tok=`XCy?trlynFX{V`T)3*d3=kl51=^x*R{cV
zrMM``R>o@UKbqtE@#w#Vm<9;sN&4i4I)xRDg2!_-EOhR)W=|8`f-*H1BbJm!z_mIv
z2}{^gAVTaxs!JVRy-3?V%jBe_x_}tu!nWCT`{&*1Ww+cFkMH-t>L%b1ef|GS0pQe;
zWELe>a?K>2LF**Ty_70T6{11;csR~jHknm3nP*M8&)hN5qIBN$`fQNn?dQfFIdLtc
zXm%k77_7XoPsBx-s5ZX3+wokj8i5?BwNy7^a&mJ^niBJv(wH-;GJ{;mixNi75c$q_
z_`iPe{p-!gpMSjla5xz=RoZN~4jhl?VHhW)V=WV)EUp@Y4^cro`bhv;Bj!WvgNrP#
z`Ar|0^<aUl47fIT;9oOw#Kj@}6pl|{fk-x)QJW5-X+>A0WdL+!4eSzuLsWCu4TBBi
zIL}jc%bLtRUB*q9h^tHBy@(`DDRm;LBqh$QovNUES*p(ri{fDjh+X(5)(tR-o!mr1
zr^?VI?nY%XA#m5{u~&`$Oq5#Z=H6monpig6Zq%Zit(w))F0lwe24Z5jhOU7Jt)VF+
z$pcCr4O1(kkF8cj?hrxzvGaSplE)e64MEzlJjO9yjGtzJp$6^Q$&JW#9sbCgTKpJK
z&8xj2l&1WZw%`dzWX+an*MhYdp~l1F){w4L<@IId>jTzm1hWIx!3OcR=!kebVP+Ed
zCsHV-?OtDevU&D0U6)+p{njA`X3U;b-E8yrnI1M;rwae(Zqxk7E+3BHumJcCi-tet
z0>G?^h~V`rl`uGDqRc|>B1uy(q*PtzI<j>Pt(IWRd8(yC^kmByw;z`I;l;E4i`}LN
z@6xy(2B=p@;?gG<hTG)gZa^u0Kh|ZQ&WjOr>=v>!(ah|CvMPzY&+{@bGYm>1A^?eq
zlb2d67Sy`rjH~^AyM?Mppe>7-@iJ|Y{`TdweM&F-?%myess8HCn=$A4JRMKx{nhhR
zwYLuszq-5sSeBFNq+C@~*RjD-LyRwL&{M<%hv&BuLDz>67lP?!x)7Y@Rqyu|UFZ|_
zC;zJg5U`-ejfmmDz=4)A5W}LTexWBrCYGeR>%7)+9M98vp3d-AJDz|Za5-m)MMPAS
zrj%Gzl9D6_H$so`YPK~*DhNkbdKjGI<A{qvC6tRCMph#f7dBNVV>69G*Gk5WbJq!S
ziTA{#fwtCS)nfkB{L<dQ!~wLFrnn7=A4uAuEXqT)Q$XXFK8m&c;@w+?U8`pQBEE@C
z&c^}(gRKR?8reT!c1G*<AKs(@F~(W@4Oy=TkDGvo4td%Uwr5YM5kTmPX0%m{OW$zm
z0_ifOY@I{wW7v@#0kFop4~}df@&=Ytq5ZRb^{l^smG(qStva|<VHgvX=Dtt6>wI^e
z%c0ile^A-xe_meLuRHyJ!wvzzp+)$UC;)4Qqjm$Sc%5OjjZH-<WtG(BK9SHgr(%6Y
zf>E_dVYFIHosrXNo*y3WXY+IQ8Rg*R-QAbpr~UWz>h-o8r7!h7_Pr*UpQh81xM#4E
zAf@xX+}zyV-rUdTp0qMdnX+mUVI?9-sUL<sb_DJ?ZM&gMoiN9sz=6}@_;7!JWB0=_
zs*<Xz4kBES6P(7BN0ni}dEMvR-DX<K-~Q;Y+3a|CZxy@i=cj6)-`)MR?>;{s-p|WN
z^J9!6n2fn?3{ltFt*k*~RLKE1a|*4Y$Ri3GmzjTiLo+@3HLbH~YLL)N0q_tbt_Qlq
z#e-46U=BSfM{2IDBx+f?J}fH4nJnjFGY-=@ohP$6{N3G|qpUPnfwT#bs-~nliHT?;
z>Q$6mBo^2WFk%-5#GE}~t6Z^;qk|72>zG;qsvtM#TD4TpUVRn7HUOI8i9qs_`x!6=
zpp;r`6=6y0gz7FaFA=$<12qRVnBoCyfd(zuEjApjmuk>%zU06;Jz3(z+f=1x6I&Dj
za$|V#L)@%oxxgvnjN!Wa2Pv!rEn68;m!l65A&n;~++6XMJZ%bB;%v)s#zmXeM7F%r
z#%X1Y6G96cyCYsXRUr;WV7CJ(&U_KIMfwC85i9Mk``i<_LQL4rCh^M)cka4wv)A2=
zG~H;O>VHTJ^xIwI|41C6UvuvNI%oWE{8GRD1prV(S6nL1h3RVFZJwJIVrET}l91qZ
zlEd6PcA(CT&DfcQYqhB?HxKu>_qXGa$1ZRByvga){k{ku>h$4o_scJCuJ_yHY0AX?
zsHxB9rGm8U+0}`Ob*cWvmmdXq{^~_HZ1OlRRw2xZ-D}F7Ii^}Gld5D%$weGuk>#X0
zsfdh{cl~&t=Py6rK7V<&9fyii-JZRAllrk%9Bv<$hlfqA+aYnM<NXbr4YewzyiC`c
zuJ*gnHp5xv^TY9<Z*G5bbNB9iTB;`%FwM0}QXP5-Ph}|vg0gC4tq89-t(8O9mIU!W
zk9~kQ>;Nu0(TfHK{J7p-|F_GAKu92P_h6NY#4m_fi6}FXtt;b;swbsx=)0j8)mjP@
zxx>s<wT+foI5?Eiqo}aPk^{ot<($L?PRS!C3t+GSjS3WMeJ5M<V+0WMxU;r%H%`oo
zy6{qKX(=!os|Yu&N_FB@n6#eG?xhqn)0~)tD&1xx4Xyx&lQ4-hu{#N1vE$`6fl^pN
z5EiV6Zf<L0dJ^G@HF?Z0M%*AX!;LLuKOVT|$SS*B|D%tI4j`(RAb{e;{s<QmA&V~O
z$=zT0QUflcVFXq7X#rTFvv`_M)NpwhWcfOZ3@MozRg1J^euC%>SW=9MJSp#<ZBkFw
zC-a4sWnIKGh<MR7_e0)Zr~9qW_u`BH{^!g$ey{%z3xK{U<q#a-?gAi=RO)uFyW(to
zC|L5KX(MTWUKU$Sq$cuyDtTV|YJ*58YT(KJI4xfu9_D#MU2>wUO*blcS-U<{@|h^*
zRP%7C{N?>|lSb*&UOIyru}jZF=FF0&#Xj5~j`R7=t5?_CZIUFZBV;F3x8jy6fu+wq
zate8yI#F@JGYbh9Gp{uZ_uEa%>F)g(_XpMPN+jLh-w!i}VHtC`+w>?yo#!YX33C!5
zWh*6@nV2`iTh>|RdcXg4v;XmD-~YHQKYRc7=WpMBJRfqep1D$)4Nk^+4Hav!Aim%#
z3=R?2Ct1c%;>Uo;zTgR%?JGNgula;8%i+NFUxqzk_n2&(2chVqegPp=p?%+XeOH!6
zwTUKG<-+}ZBE;l2t6(QU*@r<==L%N^6H!12I1^=djih5h92F6xX6!6rSmhNu7uqPV
zW;2zbcCVw0$H0^of%CW<2ViEkR&yhyb;FL9;)IJasyQ$scs=N?4!28WVe}L1(y~R@
z@e!@jm5u-30$bJv0LU$*lGK!-7q-7&+64}07A}t8rV0}@+0P|pLR-)qWGw)VLD*6u
znl&(b8ebDAI0D*M&GBkaf1LV1QLR6o^X33S6=IOKlJ+)b0to}=#cfQoxf;5$cszPZ
zn7A<~h=~jFoclap>2R&*TV0CL?=&j;Ej2WMjMM)c)xz+%wg7;{F_hXL&(Ef1?_9y$
z`*J)9_i5<!8MVyH*0J@D&P-rr^$0pSAI(q8d{-7pbiEm$kKOZ4Cv_2ar7}-vW$h?$
zEba36{`T(b)yrpt3X04{6e2mUveQ!E-#pyhKD>GJ$!61w5@2<igw-8z&y+AbfIM{l
zcC7ARo!yDW$m1MYtkhb^u4fj>x_kEQ<NfWzwB3yN$NKKw=R=o1d-LWyuU|gD+WL}w
zUNA4}+)09BL2YRsEJEDD$DE&y!zY^WtiJB`doQluPp9_}w{MU4U!LzA$lU-=E5R$8
za^ba8XBN9SjOmGjXXQda(E_bEV64%Hc#<7+=>SBYY=3>-G`O#anuxf0yE|Tp5u%#3
z>-u3F&!-ayG1McZ`*8rieokrLq0q>y51Z6?mPyoA*xiM=W9pr9<bg9e`9dz%vaT2l
zd-1xURA(m<j$L^r6t6}eBvj%@X}hm;sC6;jObWGDcU!xG7D3zwUZLL!+%tfH@?F*g
ztroLHit~DQUasC)Lvh-IxMdAD7Ei$K;*P%-0H?-hUU5C^R)!xp*zMnifVI=3)oBbN
z2?iiH?hq5V5CW`ai5@dMBVU?`g&MVD?Eu<Ie({~Jt0pvkG1!fWTdqvxPryN9pvZGG
zgSmL>QtE{h6Sp`ZU%wp+@(RtG^04j3YdLJS92kcGuvYSqINtb;>)+q=NBY*D{yr@A
z>NE}aht0BdNr`A+?^Bn~M?U+G6OxjG2wu*p#R(Po@bGYRo;~N?ZueK8z3#JgDA^{q
zDJ8De4#%kwBMnAK#zX4Aw7W7WkEz<xrlW{z>R44JeR+HT@ymzp^^4D5e^Sr)=fgwF
znKS`joh0S$xP|$2o(r)MFRj%^trhN6eX@F*XJ)FRY6j)&7cagz96o;j?)mfQT^_ir
z-FDEvTdWMdcA6nx$!#hIlazGRE!B-GxRWjoITt5*=}OrXwlA)J@X5>DW%|kcFMj%=
zfA%mwl;!O8u$0B&tY8IeXyp(a)T9*NB%-g2f4=%Gpz-8*6(iEu3cy!90qbbz@t1AH
zEO3yJTQmyI^hClen!2tZ$JDr?4V0~yL^C`_AT!0eN>1P`!>;dp%K^k^bt0F+XkgE9
z1z5=iiEUw66ab$Yi_=tm7OL*3+#={<a4<+DuI=G=iZgbN=EQmrhP&5V(F_%2W<o5=
z-bOUS<Q#t%jy`GM0LLcvl5iOr03w%wLS8XB>*qs5uhE)O3?id84srxv>Jr-0w(&ur
z2BMP+&NHtY`@o9^zN+OdqV0hZ(y}OGYXkX2<9qpj+Ee2#M(D9`5NZ68CkHRq3FFEp
zzu-#a^>opfHo>vwp2ty`-K-iHP9FX?c1o=&sUT*abJveoL%-AW2W@1!Z`E-7n{)vD
z8z1dkSO5U6zFF#io`=(ME43d)iMF}xgbfRo6R?;hqh!Rzmt{VkPltJ#MWx>i-+lQ?
zG?9D9^C;4hla=a=iF((ap#Sjm&&}kj+ij%FBrbBYsq(z*_;f0@l!rQfxI0!*0)O)Q
zd!N33t+kSq6P9v@ju^U|(|q&sZnHVRyndm(@o+kQ{KYRo^!nv%W`2Kj^Xm0W5qWoa
z`suHJDMZ_@e|3F*eYMB=04B-(@l+l#tJqc7BgwJMeLq%%!?af;s$e525F7Qh*m0gf
z^?Eyi0Hcw4V3^S2B{S_`z5d_de0p=9e(~|<U*5ib=ZE`cIU5#sOIn2svk{r#GH;N7
z`)-7Fl^5q-_yA(|Eh0gQK#Vn>%z`fCp!j#a)EA*k!Y?!c65?=XPO5#^<*r-KllvMw
zaA`d7#NE8glMF6H?yoo9U|qXWn=`u%Orv>5RSwO#&uj~$03Z{enP$)D>gUC$;xwC=
z#<xe@#>v(jcRNrY9Z_-Ljn>9XSqO-n12ZGlCQ2fZI{TVx4;E?5-WAD*rkWuLH;Wu!
zT7%WW_mu6uLUURh&`J~50QZO%i$dX#`rjxRUugm^?E$qc(72?_YIAEB^?2lE4U?cp
zGdis#@fano!ce{ph?-dRiHu;?m(ip1Fh*ie;I2_Noft;K=z7^~H1rctmnH*NHn2H!
ztU(HK(QN&W`>UiwLisP`3jTfOKfl%b_fK^P0E3pgTWr59{pqO73FMWDIOV=0f&|s1
zr?V}G^YNh+FcNz|=3(25NY~}mWg<4KnL`z5<R+pE<WzCH*iUYb)5G+GSLxGz$0-#N
zQ+9%vGHQBvcQ`Kk`q>*6>2kgrw;ho$Ro#0{q-o0f<>~PG{qg<%f$ksvt{dMxf9}M0
zHy<^n&#tbj;ftUAq{s7d80MvaNJu2}e9TMV+Xha=TpXwAoP_sRBbd*nR5pL8`<%yd
zWHXMG0hZ!)Hr!52NyM2yet1XbSDVeV-L~&Di*}CDl_a_7t6_XIZ2tPi>xXK;y1V_!
z+b@3h{@wk#P|lo_s1(4>Ng|22nLwM#f1L*fL%+#_NScb#*I<DNlL@7_d?h(7ra({D
z1K#$rmlFVxCL5t}dy=rIXiDwBVtLFLxZHnnNuzX71)22H?Ycaga%gWNS#o6RsU|XE
zXe<=S5>q7*jBEkTKv$7d)p>FETHV~i0m*c3Yu}j8ugrs%46~}I%-w4(F=M?HMPFle
zV>;gcj^%qaNp0zgmBAWtwH0&0Z7~q6A-=Hs+VvlxN9I}^qP2<8<r$!-$bM?fR(>*|
zZ=c=c{C_kyUwWL@2T0qXue}!@<>r@ZkUvsNnvj^=75r<F&g&-t2R4+z6}&o%*9IrP
z2WBGIjDBEI7Xgd1kW~m{9ZrP`&4`MoG7NRt=WdtmxWK<X6i?s}^U=OF1pq{Bu1nFw
zd92tOlEKVboSBHLdyU9jb4>Gms%5T)-IL0;>-(<DDG9U1n>tK1Db000&r2dsc`$G#
zt;{o}2jIqS6zcn2a&oX6p?WWQnoB|Y<oUD2l!O7V=LaDpcV<l~iR3TuZr<MC)BffD
z+3UjDDdjFn?xtG4Je&Z6qyqFRl#{0fQD4`Q$_ijw&ht{Pcf0L&RN+!9l$O(p#<6Ou
z)0|a7I9q)v^|%y>Y&Sbny?eM(&9g7JXJ|=X-w)&1cfF9hVPL*a-FNrA5PjHhfAs9?
z!;k*z<2=2+zx({=<J;rInWcz0lq9oc2b`5eD>Il>SjgSYCHORLbr8rGY1CrGZIbB`
z8hW7sJsk=$GqbJZb7_o+mj1pTNKB-xosyCl2+4|>jL+eKIhuAy;o?<j=?C5HavqX0
z3ul&qQDi|UreqR!C3h9iEzZhOi*s+t$y8jRUTR&;yk)_+l%3G<fZ^gUZS?F6A<@<x
zxSRQk!fv|)4>nHZbx92UFB+=IRrW}ESVPYs@`$@ItjyOniGGcEd*o}h9f7ZP%G;UR
zF8oh6){n~7_7FeWPCwZZ`Z}b+Y6ru5*5eV+MytO(=3n$Am>?45o-k*>h9{>Bua=!)
z#71Nw0MfE4*j=b4AAyA&t{KA?oEDatRK;G!XkAL9^`<76`kXgg?e}T=AXJV1On%_E
zttIJO^Zl61T>A4_?(P$%t{?imS<JfRIa8Ae5<BU6@z3u*K<VoG>iK4;Oo@e@c=2e-
zA?(aXToYHylU1L~cBGX1l!pOj==;NP`e<j=@x`VqD$BXl$x`YVwM``5VKWPuyp%%1
z3^wLk1xahwV*2vMtH1fHAJOfBO&n&`-@SeR#jifRxPI~a*~={1&CRhuYPG=;ZdfKN
zOIel^l+!@FO*bTsAVX)|pXQI#-EufS-|vZVT$V#wD$$!yzO&tS)$oH)U#D(3P4kx@
zZ_cF-yUnxoa^K|ysQakerx;}Ov+M15ueY=C$9ekv_U5Pi?a%J+ZkGAu`FLNJDMm2p
znAIp%CKDQj30$do%NvtOvy4riFtId87_E!F*6=%l9-*L@4FOP9CGx=<i4-mXubfCQ
zNGbIySuqtiA`w`~714P901+uuB3EA+^L9-8eK&LnbPx-Xkb}(yNQeRec4UiXJ>1MC
zSLv#!s*J==R=w6*&E2X2q@r;(cXk&uF-z{^M$iywx>MV>IwYW->%|<^i6A*qgsfZ^
zytHnEC8U<&eU1HR0JPc6R;3MJM3!F}xFB2=@za8r)0V(kM^=~9|8cVN#Lv-cb$lOK
zF;YPYYS7uXucamjYJ%ByGyI4flvMzVRxxGm9Q{I%i2m^+3SHYu7q$pgh<J+tA92|C
zOql@B1Mja`bO9{tjcWMjz`_AEVGf4e)TO)`hs`b@dbPPmF2%QQ?DKmi0DtS3z+kVQ
z&P#VVcZY|*maNR6oHY$2bJ651sPS?UX5!s`KkUX%nXC|V1t-lQI?qcU#+1`sm)pbP
z;bwmI=1uA3pa1!vuE*mKzW>9lvYhA4?B*X2_mgT7n#xj(mBpNuSyU5>RWGA*f|WXZ
zT{LHr3{rxW*@x8kd3bm@-Q7Jrm);H2c_OEA7&hBypT7C*`F?*o+*+|Nb<bbDJ|B;Q
z6Oo!>D)ThY?w0zz8S~hsp2aF0Je}vUOS@q^SDYUXa2xi!XD^;DW}PxEvyeR7Y^J65
z#Gk!<1yRrXa6bL7UwvWq|0nNFo8(B2EJ1y$X67D8UbyPuHQgh#hs?_E$Nm35Vpe2k
zW!O!!E))vLGa}sGOjY-TnR|Gms+!lZ3C==FKoAKeA|oU8c=`@|b9MQvS8ujm^qk$D
zy-3kuc47J-udjaf>cw5oU)|mR_Pe*g`{Da{$Ki1pIE6{eq)I6OqNZde0EKEm@A6;O
z6Z?!#&r87S#oBI<GXylJiJhHVmOt#af&g$9NHqh~raUt<7h;wGZa$f0>Y6*r+imK%
z(kC{O3Z2w9QD|iMQ1!_5MA|N-rlkmHF%d)MLYYk^k43e>42BA2R5W`z0XL(Y1>jyF
zuN6sZ9>f~-Lbb}aV{g3!x6sE%^<?&HmbN%v(4weXu=lkeXVYD~SN*Kb*={rgD3y4B
zz7|k(Z(cz6>IPmTUh4VhOz8BP=(GrWYhWDHOzK<~0;;Ewrd6huD`C5HWA^WE9#iKq
zwZ)HAYl=oqKx546W{@huyFTnMLx={haF>y4i@9hae62+SMR@GGX>$?ME|g<dvwytm
z|JQ&;KmXAx#Q3xu0GP~uG#oMxV;b@W#r<}(k(gNEBq8RaB`ZfNRWlD`LeCtE37Cm<
zDGE%4Q!ejsA5*{C0H#1$zg_MPG~{xB_mI-|Vz>Y2-~7|<+wZ@B_kMqMl_b2ry8duF
zJ>1_PPsa~LGEP&@Q_kLr#F)A+v6Jv=JQ9o<eV0OvS}3clsj*#OUfhHK@bLJDZ@vpJ
zK6jR4cDcWN{n_Uqo(|u>e?LsqRg{j?Lq0tohG{Bk(ka<g{5X~&tC?*=xb8O_a3VNZ
z-LvY(<2FbaBDx9=gkb1npNkQ5j6#zpr4E6?V3{0!>@Q!0$?b4_`mbO8o*|ngH`f>Y
z%~raQCJo94aY>ibZTI~8m)rmJ>ho_O?*HF!zJ2#JJdq&;cN+_VNB|~hYskT36=}_q
zf9CwT@f;G_h@N$xovZ)C4PB2mXF^Xck#qU4mY<6|krS#2i>X<G(m8@ryUusJm^w*a
z@LE}$^r&(u#f;6Rk`B$9&4fC01`87lh{YsN?tRI9DH&Yye5!68Zjo@;`-3&~z4fN0
z^3Ti8e7LaL$-xMG7D3fJx;0?Eg)Z3oIho(e3#Ia`zgq4rGdH!RIhv!gX2~k$cm{)(
zJYV9om~1Z7w7~zfdTaKIok{&|S>XBng7tq@s7)Y{5&L`?T6|}z{muf^oUIf5toWKa
zJ7`ypIs4R^J@sL;?U_%tmsD<5iz!;3n8sl<f~KUKEp-=RxMQ3C5iC9ZuLv*ulh41O
z_6AVd(#0@&IN5YRo*s^*dAsjI>bj7`-Mx^Ac`zabRyBh;6>^VGe!xba001BWNkl<Z
zI*g1y#4wbMzIzy_@9sXl`|tr0f6@Qua=#DTO*ovqcyiud>^G@<`~AD8!{PG9&1W|^
z?~li)!_%0{V}7{gRF$O0DAiOm1QJ$vgA3ZBPt{zR1(A7|x>wiffx_EwzS~&%#m$Sz
z!j9M1*Ms_R|M1nr{oViho8NRCJs;n_doRK-AdpxLhcQoTMCf9=-1LDgI6$6Dxs<RW
z#G-7TLS%*lWy}P25+l)Ur{U>hd(lfERZ=5$7Hl?sVVI2%kN2lidQQj3+>fUYVTW+D
zy#R@-M?y^7tI)sd`j;tPviz4neD(X=JEzXT5w&XZ*{z@zq{T?AF}fFseYP{BkNBXg
z4S*MN(5eAoMyDGUwVHimj!9Ykh~~RA77mbV+3w|H--XB_!O!M2jXm!a%-EdW;6mDn
zo~XuSsDP0JnYb_7r`W}5G@fjB?rCMp%+yrP&hp=yOi4|5C5$s$YF-Io%ki`((X`S(
z_W;btPJo%rRt;c&XSg-4=*RPAYXG#+d#q)+&xFcl_V>kqXF;gW2I6z+Z<TsQv+}tg
zRL`I49oyt%=Z1mVqqHiATQTNEFXFUVVXUiGbq}9U&@>ZP$!7&w-C1I!l%z71pJ)8~
z5**X;$JTI^MZ2wbmr?pqPD+2LCEzcw{(lX7b?x8&4+H_VZT?jFpfcd_G(J8(iH@1K
zan~_f2bT&!h6o8B*>axpL^KBOI*FxFAP9jRF?G{0-99~8>W<@hG`|e7-^unkaZC^6
zM8kM}a}$q;X_|~|-*sPHUl-8#r_=52olB!8J7X+mQY|b>)WrbTVw&?<nTtV$qd3cP
z%3bQec=>Wt+}+*XY&Mr&(s2w#FRu14K6~}y+wX%rm%>@MX(K`QA;b`~>ftnIRS`*D
z?E2`rm=c@Yc-nO-0$x<y;1nbPRLnFN+4htA`}>FE(?HzuR)WCc+4Pu;7UvlI6o2{I
zYY&`Dx%+VU^>^<i`)60zo6ka*HYHn8+HQ7YCXO!kn-?#98aIL7P2;WV2{;s;ln|0b
zoY^Yx9u;w@1%ekFdw;(9ni<bGfRFk?Z3OdWm}zDJI(rMwWoBV8H%iF4;5WxfMn#@Y
zRreSD<@H7qIL-ifwXkVcm1vS*V>gGx%$qwX+!+CIBkPR182c2v7&_&#usT;i)ppgb
zX3xdk7B`57>7VZ$G_MA21F$(kpvuR*CHpq2PkXqFEPFBBT(^OS`OkREIW~akO!u+I
z|MA7AV)k69I)W9+X8~le;7Y!<9QQM~YX<KZ_XeDIg1N`mR0uSMhtEx7o;WeHiEut*
zz?btgTDY1yY2DrCoSRzU1-{uypHRJ6XQPQ`ElWhau#aX-B8Ni8*!7#M7&bEAGgYzK
z|9^h`n?2wYYyfa~D{7~VQ_)j-_cXjeJq=<6x<5Tp-VBs)nD;3PP=HBItz;{jrzD||
zeb3Pa0E#N9=5b2k*RNg=?(+Ebcz3@^-Oa^ii0KdSet0+@Q{>&<569#2>hgM5rfC@8
z?DyS%7akr?r_(eHPshVB?TPn6V(h!AP&O5}$qK6yQ3#S^PY9zER3C5e-y3be_~rlo
zfBfhF{@Z`K`|vLAw>R5PwA@_oe);9+$9F$$gV^y9bo$?a{j1U4A0LO)@uW88X`H70
zPBz;P0XY{nMOMq>#WvMQ_}B-Vvezq{kuqnZABNNKe|YB}?!Wuy^Ea<vy|`4^-7pS5
zC5gL`Fj41#A}O}}%U|xU0>QF=_ubddK^-F9=dV5s;5}0^hui=4<(pr=y7>D3?sq@j
zewfNF${pEYUYLrLF$z=R#*uFxVGb;)%jyh(A65U4ydvmakm~rjoRhKoQR$1QWBP1L
z)<AyKlJj(NwYzzF5qpT>EN0+puf|SbV{@s;SaN40b2d|mdx3-9*fXKG*yq@HaWsiV
zii)^!J4DQO55>${+$MZQrI|w%+-iVf<JIV5xiHuL>b*7-M(1?~G{a{fHGs28gFjmV
z=7Mcb-oTeLw|4dkUFPF6pj1mRqg@PIJEA3Lxq&+KKf2I|mK=cP2s9g0%rb?!-=1U3
z=70eQwe$9zH;nlNT_fKJR^6d|Ni=G?ll#lK*@#(@nf^rZsywM(2rV72e(?rU<}sw9
z+s3dJj$)<!BbDzzYy8KbgaY~MbB0fC@UQyVZZeE|Jf0rzpB~2X2;@E}@nJgs{&46n
zcH5AmDvFJ{oJyJ4LgX%l6hf4m911uBXp_3rRJs_iFR$L--wE^a_%!5Ksq6dg_KOtX
z1a^3_^8Txlrr{O#yA;2@zyIcVx*LXa9D4?8>W6tID{7PaFqMv(SjY_quNMD0WrK9x
zE(Dj@1;%jD(-W6*ANQACc>B%Qcc33m$DT@Z)jZnc!%^+18cOc#3~eO@+`PEDyxOT}
z_fqmG#rh~hWLDgjB_MDex+O-9;chtH9uM8?H(&nZ*I$42^&!xUeSa#$zrMZuaC^Ir
z>D6Zc<;$0eqiQL+fINlROGE&vpR^ptd>WqK-^$C2tF1^NBiJ@@BH3K*etmU)l=R(L
z{@aJU|ML5<i@7tDC<6*|I1_}3jksFNal>ks9&l!$uNuQos)eZvrKp;qEhy00b6L$q
zYCaUVP{C?6q?7w}dHwnI%|(nV6(^{NM=&ZXP7S~!XV=D`VRJJlmX=%+&7)Hap$nl;
za>^kxPcGs?7{%&MSxYH77t_>6W}ekqSO9u+XP^;PS5W>UW3J$dD(1{DZ_QxU*=X4j
zmh^(>4d4s|EpA2UbNLd|OJ@v!R#n&>|MGk&UQQUWg={tR?At;xJ3OPg)Xj+gDtLM&
z1E5t8@a0Qbl`Yu$m{iq#Bo3bwh-a3NUR+)7FM1%8)KSsSXYMs`WWKF96{3;DkhWcS
z(H}Qr1IX<YT>}0X`u{)tnEc5!04KNybI(dsPT9w&)A8=^`1I(h<B$}7GE>OcPlwNT
zyEh!NnvJ=bDWIG}41LGF5F42m=1^Z&LPVvwQ;6aE^19z&K0cjtE*~Bq`xv?|7T83p
z#1v&Xovci|w29+5ef{+~m5w+FmLO9Hu?VUYBrP)>++3|_F(Zh@i!PC4c)UM8++SMW
z?fZ*BQO7hrl)Lwm%j=69DaQ_e#q@A^+Q#G&?mp#gWsJ~^-FCO>N*Up%TEuDB@3^Y8
zRJBgD?QKCupsv#?A12M@o13d{lSbzE$J6hA`0#Z9!>?X_5o4c1H%-%+htS2WS%g$5
zI_<Z8PzxzP9)|btzrWgSV%mh_YFcu>^0JGGQh!f@IK1EV?5^a6C<B>c4d-_;5`*~c
zRgd%Qwe113vGGTHz<L{~-Z_lLt;S}b=t`Pw9G9w7^EnIvMD7YNUGj^4zuWiBPt0>(
z;w(^tgMBWZPCmO{yAzZhHLZY5$O3!dkR&9Q#2i_Ii9ni9a*d|dQgV&9M_V=g<2%-(
z6`p@;PB}BB(&;>3pT{77wnCl9d@SdY<^}Z81#qS0tqov~U_KYymLJ@*+|RiAGC{Uf
zIIL-+^WR-?C-!IKKUO_t-WBTkrLq5;VNyK+P_vlD`I1eGtE|mKYTW>A28WzX$S*GY
z{k~_JFcYv^7*30<fj_&4I=K=u%aGEh+x1~1`GM&Zj|%?NtN)+U4?g`HK+VDpQwipt
z^E3>3)cf1J@o?-?7gAE-sG8LV!|_z^hH~tvmq4V#A*E{jLovkw^J%KdaP^Q-zsO-4
z-F>&;2X}#dxV``V@9zG$fBq-99iAQ^^HE~-Y3!MjTP)>u7Y{FAmg6`wpN5kcb5(Z(
zi%1YxCn{<V2bf@F=EM*df|t^<<XonwLnM5;+xA_EIzorfFZ({ec$&(t-^6@M9A5N+
ze24A!pws>7Fpi^6$L)T*jUj+@Dbi+VBngx=n-js+h?&4n?8FL@eq&?)>Z^Y}O#09N
z^v~PN-Q#fh=KBv%$5HzI)y4G}FJEtCyd9=v(b$D!$pe`??Ty8;386~~#NU1U{iKsq
z0$GClIBb|il8$*SnR3a;lerlO1+<R;wD^KK*TK!H82OK9ENfDL=eNtXbDRU-LVt}K
z#nM)yR4m<~8S*S78L}MMcKfj1#+bxaNeC>M`6M+cvvS3jQG5{`5r~Ol#^TIiAr6oT
zNh}c@zyhh^J}o`59{$y8!1;Q*r}F^Z-1b(!2-XOeGc5k>is_a61f0cFKCe=<5m1W~
zupiYh)MHGmip^1Bx%aM~a-54jo$mzm@fT>{&=zxC)d4Hf0c_3)`iOo4EZ|SmfAP!^
z<AvUH#-x4K^=M&DRfJxNgqGZ&c1Pymn_b*&VvX3VtK1S0eFi{Qadl2aD9lrgQ@63W
z!5GB!A4C!M=bnH6O#J7QXaMY<)HYKIr@>4|Ez@bZeRt<mxw^a#U4K7Klj<hKQNrOg
zIl{N^?_No~xV}z_7*v2M>vS6Tvg;zl$lbCkoERKAKms8?sJ{R3{%#y4L?UCjm(oRH
zwfna}#3*<?y!pkKul5_dKlSb}H`|;x2cjR$xF#hQQzuh1wNgqUr^q7WWTj+tg#<uy
zo+R}*+s*am&d7_oX(k&ZmE?5O$BUGh5Y@`~#G_p}kEcN>vrVL9fW5lD+6mh<k=F6r
zO<ku#IkRvK(ahj*FozgZr(OSeJl;J$7NWQJ5C0)1gmlV}w-3jw>q}S9lT)S`<EyI|
z{>cCR55IfL2QvN5&6~>?ub4cDPzXcF#Qt=8d=lC^_c5{MQYKhtpko;ihi|@ro81j;
zwLsNOmdZPvx#Y{6_E~%w%}$>)JLsbZU}nrj=M(VR@e;EG8kUK3nNWSUv8ED(-dy#4
z$6#~S7B)-uK{CKK^Qxv4(;Nj{*QkZA%IwTq8vp`xU_{}_5+DIVz~tO~D$T5zsV$Dw
zi#J_;ge^4;t;3u{6RMJ`<!&t&pwtelhS^bbX>T~2P0Xg!t9CQ*Rg1;utjbuPy44=E
zB=0ym&upNk+^wVe`7_u513rIst<+m1|IAKq^EtO&=x4min@wxQTyWkP=Bou}hasC?
zfo#dSZw<fc)<6~#rOqX~!?dUb=jt<8mw-97XlAt5Q+Rz97Ll>rmb6dY2OFn<xT60T
zf<J%kZ~Z+RKn03JE?q9M6t(g&obC>%ahNtSZFg5uQZ`DCphi<R5|M5qd-r&FyB}Zg
z^*RPNC2(Xpo=(%G8Pz+s8vdg4Geegmb71N?UhfhloK9mIPshjm-Q~rrn6%$LKHdMX
zFJHXb_I=hVPsy|=O2r<h$;U}HQ3ygL;2<LEAdZ0nGgVTXl}cc67eyFu#WN98aB?!R
zvm50pB195*BQ5OOGlF3n1_ZT|r|}pCR~Nf&-wCOy=UiAlvY08Xr7G%N5Y=rgWt5B%
zIL6U5M2xvi+1(^cfA!+>=HhBs=y-R$_Ad3|Li#VSULSCIe}AjfRK`hWsb*wc>^HX$
zA9gIe{Uw=gQtv4h^JAvL?0y=5I37k01>_D{a{S1v>PKPKkYhcHEti1x4Pea;UH$A_
z(^G0uF>+Y_L33yU&Wv+m5n+%Sg9PR}ynM0W^b9H?0z$-<ba*ba<Y2&T_K*g-o~cL-
z1sq(fKR7ZcmVg)qoI&1&058HoV1t*ORf}m+D<a&^71g<?nFTe0LQ4Xh3t#P>4q}=!
zQx@BMKiBBlrl&D3-3g>iCf6Ffuc(nVGU`IBG+&wloo(2#8X4Qh&;q#T>=|FSfipE|
zRn^-9U}x_CnZwa+0cTI?brEWr2xvwg=N402MQv)__^alakJ?UTQT*~sLa2u)t8^@K
z0=t&RLRjK|&mFlg5v~EH@2u-dA__hwQ=q@S=kw2v|9{U00HR<Pi*}{ZG(H|rhiQB`
zo|JgI+h20*5K3_~lb9k1$73GHfnA*s2=9jJ?J#co{U!xc^Q=K6XC25BJTXh<pqV*&
z$)mEEsg|t3MEQ6)k>&)KQljZ+o9+si``va+M5jSY5u!*G%`jw4h3C9e0i=Z~)}(J!
zRW@rw8pz>+1t8PnZY<1=6iskaYsbE7Bwvk8Oij#OOU{#N-fk}Y6a$#7u+unBJ%>%|
z;b4(DA&-d&5{O0J)k(>UYAHp;?(gp}QXjZ;liT|P5IgAw(Xz8pa_LyI%ZtnFmua)@
zw&VR{o9EqLzk2b9Z@+su9A0g9k=YG^IMYbw{qgkfaJaQHb-fZ3F&pztes3c$!J3)~
z>(~!0IbuJO2S5MWD(cTT-~Ot$iB{)?`t*aq;1EREnUriI3~ye2d9h85!aV!-QyrQY
zEozga!p|f`^EQ!JRT;B0Q@!!m!Jh>zB%l~rn1sB#B^Om~!7uG_+9>>$mAcAotb}}9
zyl{LjemEZpW@jLug<>;_lIDEGSq6c{76NA-mA9(~ym>{p0y`ff{A?lN&x+5P^}mSA
z)~-G0j?w=8<$vc-iA6-Vz8e@-lG-8^pw-u21766_mPC!=OD$=+<$o>c6pQcn5@M-L
z3Ghq;TGkH#xU4UMrXXk16ie58=y+NzNI&_j@1OB^{m-ucf42ru@4ZPajH6G}@p!s>
zyw7IL;c~Ox_Z!Y;#YeXz*~$F`p91Gx4#OB?C#m~k7{59mUfx`EU7}ok%w3G*G>LQQ
z6Ehg*s!j%=Oe2XzqA=y5<SA#UUtjF6wj0qx(|8f&#pMM6%h^i_<Vqxj4x9j)MK;tJ
z5wo`O90)rrE32^Hm1z#>m|w%q-f?!5Z$mS=s^x3|mtx~IA;gP|izva0c`58<xrDy&
zQpeNE#sp|G834ePr$KX>hHbxn{rWR@cl8ug>No%L`+xoB>u<{IUtGWZLIEY1(KJj?
z!{dvWSC{*}C<KgBAryXjadA8h<!QKmcqpl7Evf4@#QQvab^q|q<HIRP3Bi=f!Cr0F
zVDQQ&F?O6C;vMwdw`5iBpJNvv{XCbl#pu!(HpqgCw9hOeApn$JPa)}>SNn^L1dPqs
zhWsp?J)dR?O!bkrSYe{t!&}{FVi2>l5C@jX5=g{@coZa|T+Gdwo!m>FtQ4G2pkNjP
zF|)Pv1<#InZ8V;_{EPd=^14_b5-ME&T<_IR4F&=)#jU9a8u(^ds{gEw@@Kx;%Qs=I
zC0owYb3eklWzYg2&9-ohTx))5<40B3(I$EW@th4n&m+^VwU60pnlOiYp=knqxp_N;
zb{8RaMqHfAx{1wxMD*+`;VT{z8IwlIU2kc_C;m6{VLsW4|3CEn`*&*qY%XT0Sjc&L
zI^Ewt91c&hi?6S5HWGx`RfjyCiX9BMMZdbgJ(A_FD}4&gL~$s1J3NKM;TJh?H)$iG
zi^&Neo}Li<>%K435N5;mzziTlQj96}M=hsPIEG!n32KzHko7_O7^ZP5T8NwlS)Iv+
zNa#F*&VAsVg@M`U)*IoVx`vuN*9p(8VVVupH5k~LtBS=`C-u=h17opqnxxxaUSG3F
zDM~qu8D*Caf!N6^aAEUXSZySbOSr$g%TYGqU%q<vpZ@uu$iW;4c=P7<yVKM6@4kEY
zc>jIBy{yKf<it=_5KhPA^f-KReUndv7Tu+k9lv_<;+=i?`kSx2kgm7;SD)`Sc0c6%
z-#t8hn+NLpiO2yVg1K1B54Jhryx|sSG0_<aTFgP$ANuhU(2B+ENB^t`e2j<I;m$w>
zKJ=YmUv;}pV4M~$!n~lYn1>beAg_|<CO4Zq1_PnGNHeiOA|$c|1feKM!8Zw$s+zV0
z$!RQQGE)(0xx>s23c~!zsp-eoPeO|Ucs`U@=4-QrBVYWWmzAj*WVC29tYyeVvr}qi
z;kF)N>#=+><UjLvoR-GoX9DQC+n#3}ET>vOM^w&DYef(`p95x_Ia(<s<_C?li`4RM
zs^AZry_`4onUlGT;QFTTdN^fr<;C%$xo+e6FpRaSMID)hr<62qn1rd=zt0Zf?tgvh
z|Jzv!g@5Pn$L2}3GpDH>o(>PU55fJ-&8y8O36)6hnx`q(syUk84yX6WsceKm1z?t3
z%)uJEyJ7nJ{{FI$UAO7`uDBI7m4KAWIH-Z0K?-wm%6THSO-!!N1TyDw)LarMMIqH`
zESd|5m^oXSnQ{iQnnPVowT5c9F>3MAqGv8(L~QeXHH#D%`6W3M#9Y+Pm2$R8DML<L
zj=5wln|`y~UjXDqgCiL2Lh77Z3CzW8*}#LuE`$Q8>WhmD8wZbRb9r?MDnuXd?@ne{
zFRp*BU!;T!lHJWk2}B(eLUy~px#~h-wGQwxCr2^Lr?Dt+Hk+>Rz__@)yt;gW*dHCI
z*xeDo&(krc5hgHRh~>T<ESFGPX8)NN@y{;-%T=HPLG$&u1)kfpO@aWhFct{kbCBug
z5`C)iHrnd>LM5M#Dw@FzX66nPSC>jSvvUL3AnXw0Kp`MTgn%FrrU>*g9)=9F02;Mu
z$t7nig+inm{i=y(mB~1RJ+mjoid$LL(KXJN7T>d39Az_Uf29Vff3o@BKd%dCC?0FC
zPk+u6U4d^nyD@vaf_rP->%YH<6=oU0(iLjmZ&D4O6<yXEZsREP%n-8m)Zey|1x;$_
z@akZVnzmrA=@^-rNyOz<*Y!kH$ZftT)tu@1^nlqx&}V+_EKMMCL5WFIFC5t>(BGh{
z{#%v$kGV4ZRR@5-2><zaZ2)j*H7TVx6ZLVJ$|)!AwlVCJM7L=ilu6B|T+D?L>vuDz
zgw&ZNPz1B-l+8gr7W(?b-Iv$bFOqK<F>>mHxlXDADQ<xX#BR=js6&-Ww@!&g%~dBe
z4Jp7$tu$*IK;0%SCINv6Ru4<XwU8FKQggLIEfc(XiJc>~YgTaGlv{cpEp>;TymIA@
zpk79`?8uB`*26eC%XZVplssp4PlRB;4JkQ!E-b<`j|5JM$+8kz5V`7mCY;OzAsr6F
zVR*Rv>ha;rL|%q1{HpIRcKtA(rgF-bEzo|q5%*xekwD|bgvjhflRE;Na3<Pa?)MiL
zPsQIpKD|8-4{9UFOsL6-4b-kQSnwP)zI1}ckZZLEJih^)Eq$IlMxdpM)iWTq@GWZx
z)C#hLAuNFfMC8S6>^J)Pn~N@Fkbo3qfSgC?R`mUBrjG`>FrQs<n4Q?M06_u?kia3Z
z2!u&MeF%XIsS6VotMM--=Pvd2jmQk<<=qaeY?OIupP4oIsAMd}r#}In_Mdvo`*I&}
zfA&YP#)H-$@#U(E_2qW9eWsZpL^|ifuOKNrKMzzNK%xals_8B(*9xA~!F*}r=bLiX
zwLn*oVNTm2Gc#C-yxrCtK!)2#@dfK&ovp~vUoe<lP*N<ZkCH@><*z&gd<v=VKU@9(
z<j3~!)Bs=}R71%z=LEMxo-@=hx-K!K6zGUD4pc@{Qv_^S&~v)#dGK&co~_>DxDawK
zN>+s5KO8?Chc~I)22PQ;yQJj9IBp0|0zjBt6~rm9dHZ!_DA8o*Ok4xO%^1WCCuqIi
z3Yvgj$e0waH94#$t1iYWv&6F1{(6}tCK!`597MX%qiaWDCsuNGs3Q}N<VVfNX$n`n
z{eDx=$qWSdVAQiPkxiKb5i_~MTmW%s&O{b__EIjHw}6-Ik58Q97Mf_fefyQ={4#c*
zUF^0I_lMKn!`)<gyXj)!kV|myI7lfBb}*QXe9|&$h7bpYzSG0>!{hN^Km2ezO_Vk)
zfx*oX6KwT;3$htw;WN1eE8zMJ;;(+kKjMkbda=e`A(uM-)xee+eybP@fk=c!0MAy&
z-G;yX{JQUnX#xtUSqaaRH0Jy)ELijcg7fTT$8h56E&!=^vJ4S~z%g)O5~ePOC<1LJ
zcw|;`o~CiP-Bn|11~W^u{izQ1br4u4a-5@bTB*V;;k9Qo_|Fk2{O3OGOKALjBEV|!
zU-5y?`$2Osnr*fh_U;+{StJ7ITkcu;OSE*5hQ@e%6g(T=;T&U0D@^8Gyjt8b$cz^6
zI-8#&b7S_@QA*A*_tGquR@VtSZve|DU9K2)6DNU2DJgl_NPc8j`$w(*f2jrZ-=_h%
z85c`a?(-Bp3rH2BDkVo^Ap#Y!hY)U$<6#_Q=s2)Y*hswYy6o}x?*3?}kUSv75Rh{&
z7J>}Q-`?K8PT}fu7lpQ)E|+4txC=rM7A8`617eIY8cqW<!JNqx!H6s?nFS&NH-lVa
zi7`8r+yxZa0~x#39^h)^1{jFIU|}+LZ&|BtjyhlX>Z_Y;SPEb@($&eW<}7j{9aM)r
zWu12W7rSk*ngbIHdm*&S1aqIt6uM49P9_{2kRX5<XqrX__Yy#ob;@2o+jeR5>iZ8L
zBJkPu_08p8bB5;A>2MqmNv?wJJE8=HYNjv9u0v6k_;~-Ir^D4QYRLrV)M*G`-QB;}
zY@3cnnnbtRvk*WADA>uFo*fsTdjYj)#b-V6kKai3_syM5tKAPdwN0zVeu10uL#+!W
zTpi)3{kH$?_0_fqvodNrxp_-BX_R=-Ty_`YNs~LxjuUkRClWLk5QIb!B8MPBSlGJ|
z`WV7gCQ}gHwB#x0Y^H%DgTaU~lxZR&VJVvN>?{1~(en(xe+=C``!fu82jh>8uS>iA
z2>DsLFZ=3*09w;T>0CQ$?Ewcr=hLs?_SKETmdmRzLNK3$MV;1DK_d^L=74gm(l+~v
zw#$!^xqFP*ZfdY*aZ<2Vt^j6M*J2$_XFjd_M|S}-;S!UDO@i<rwa)oOX8b?zVf@q|
zcKdso!PR$fE^*9hD!r9RMr7(xD`sWuA%L^lP^K(!N!&#<&KZ$Ya^4VLZ8zT^^6l;2
zVK{^syWLh&U<Rd-Vc*<6d~vn;;;Qf9DM=vWOkxa$nieZXiwOr80GU0&gjhgA$i+yN
z$s-u0T4sS*ROFOZ&Dw>Lp-jqT@ItOlC`ogM1z3h~001BWNkl<Z;XLBFFX|g}s`*$%
zE+8S6>TY9X^+|DcGKCe_sgxm45@@^aQx~;N2mygy0cKYM2?LWEB3H{A1(!Ssz$sKy
z6oy4cU=C2WOp}HX-n@M2L*Zeh>BFey?YD0~+`qegadp-AVH%Tjs`ZPCyJRMdA#~~f
z{??}9X18V2)9Lgu=-uh~sO7{M&59B;vpX-A0)PQJ%l_fd6`m^y`;We?s{z{Vm1ZqG
ztD-;iico)8BU#m2VKMmSW&h%O-vx!|iruvkLp%dNW<u8)1ev)s75{Iof|*1bm?MH1
zI7NvffwhaFPcaN-G!;(StW3E~S#t>zm?0uD#xhMr;2@qe%|N@;>Xz}GknihX`ubxZ
z8A8;|6=L{L;mq*!qT%yM@AQ-Z&O)&~UnYFjA(qJAhG-I~#XvkGkIourYV_olYP%U<
zES5pEmW<6**;$F)aR2sJS;Qi4?v^^<?*h0u6~M5F09Fv=${@*S>+0ETwe~x55sjUP
zo+-eI$Uk*Qh(BKa|GKXr{B0k)IZ6rR6oxF?FqI&ol*#k735ZrqjmQy#5vhCD;)UQi
z_(%{=T?)Jl>1KP8qflaHc*$y}?n<~jjUT4dgO0l{?Kn~)BI^5H8AgJq5S*L@rI|vo
zRw;_Rt5snayNkos0tX{fwRW$ASHqvibz4rp)OaUGYI7j%qDWml9;*{hB@9U=1y+9>
zo1;tIvspG%@~Px*({E!CqO9t|&BwiB>r5nKMm5%2m>uL?-!Nw8Bt+(#N23Yg;O0ib
zG=x|uv0~X&fA#YE<<&Oz@x^xAt4UE(FAgO|5EE7gOE`^XL%7`Ta=~euzJEOY;lqa~
zvz(&U<F5H)HRETtJ61@`xd-5*7wU5zz|TP)i)ZERX}@S}iRZXT;X1|@P~LCp`m)>a
z0`ufHwd|ON|L~kO(jEiPeEe37<|{TB2Cv&)OQ7KztHTl`1`dG&6SMRwB*wu^qEx%S
zl5@!=buQrA0BT+d^J*yqHSaR4zsNIov&QFtaymVm-IM?1Ti<^)4BDI_Odm02W+lXG
zY;NAGi(P+}3e(Cg=-Drq!|=-4&F1fFoBCG}(8^4DP8gU+h8iYeR$ZQEm07i`Gbi%Y
zVY>|kBPiIJ$#wNAs~n57EjD~jKR#bNjHO6W>72tSW(M~&L;6nyK>iyo;m;iZ|F#VP
zPEZZGgj|xDh!EIJlxZx3x%PdcVKSYFW8^M73CPrjAse$#g(MJJHthpGySW&JA2i>M
zL&=5JsF<4>=x#W@8&21|cp-twTsZ7^Csivsu>>*!Ce`955~?@37DFSPG;OJ=H}G1G
zorE9^7s^`1JSjq<Xox|W9nKWEkSY~MWh5}Q+R?@mb2IZGfg8N*3TOk($%r$tLJD*$
z#nfJ0yxPYNJ4Z=XQ^j5>NTgN`Y`7E^f&k<cIFeg&S2Ku^dnuWmf<!O^+&ueKn3y?K
zZR$n0$!<;-t2*C`nG)Cq1}|pCiL>gYA%!lc;`U(W+vD+He)w<<T)lO;M&hhJ*Bi1k
zzw^&zn>qURd1llz<)bxv_(vt>xi-wqnxQg43}-kCi8!dh3)AV<>+a2~KJdgef(lU}
zhtEd%AX~#0AaGOFqH35c)I@-ALxT)+DhmrSv#<!Fcw|%3K4H_zhl5rx1XI_dWtzP7
z#LVCr6PU@Z3IS`?)<u*+XPLyT#X|Knn4haf6!07?!}?9_KiaIY5MLJ35uP(XS6u*0
zj3q6hUuO}(QplfW63i|Wv?x5_XIl+4hl|$n_&F={d<i=@pv8m^XQFSFVppH5`dwj<
zJ#DrCS3B2d-R%4@7EB4V1+4jed9MGI5*LX%^~#aJaQ&pK|4(cHf9A^K_V=@b0FgLF
zv)(KO775N$)W$MpB2JN`Xm$z^kefy44W}W{(Way2(03#B@pLyCU0z&W_x-)<+vDNx
z{(&s)LI)=$lEC+e!*`GU=U4j|B3prrloZBJM5$AaPC^vwnG(b-Rx*l4W>kYufeRNy
zi|#WIkl-c&3+FN=@-BPK)EPQRfP=w7OeceyfL!1XHf}^}YqIvrXf{%Jbyt=G7*P>Y
zr%6pi)Ts=oLBKZ`SNpVO7o?7KVz-3AHZh4gSuvIXv+CVGhw2H}Lu3WVC6L1_Lk0$z
zxhZ*Zf=O_pp>*T~vuQFa=E@Cbm#jG(E6H&<AY1Gb85Q7G%iBDCuVw1C=5QrGQ@_p0
zW?fNxxAU3T%{~hzmfWs(n*(Ik3FfGlm0K{^EErnOfm%$>s&=mGDMUDk6OEuue)#Oo
z=U;rbA$?#fA~gGHF3cY%Xg%v!AGVo+-dtobb9n2z=1eV~k(q>@E9D3=QW72WsSk1A
zM?M_Y4T$8T+44A9E-nJ*m^zVQmRmsD9M$;jit5WXcd^;Q!d(2h_qv}e{WGYIR@d#8
zyRrl%HfE4xvD#T_<7P{qHRS*7(^d?v=H0mYS$X@>W<X0*YI-p{r!iCt(7FLF8ZvSs
z25g3q6b_I<KvK!SfTtdtJxGeV!klQflvwRN?OP3)w5OJx*Z}j{eOrMnoKwsp(IoY~
z@#%)c{8&W!kE8=|kO^D_K|rjGY-(z7@4F7hC66G7w8(E!O5lBnez7-+)<v~qCoMxx
ziAz2m?;lSOkCb)Wb=wdeq=-|Q9v;W{m-(nP!S^wN<#ssSkEcDEF<imavZ1UrA6o{q
z2m{0@rlvLRDHyDQ{~<t&m6AjfBp8cTkJ^?rKx$B9HzKZaNMgQDMvW2!ivyWdMXc|1
z)16c;J1Mf+aMHtRJd{acT^EuB0h_z2mT`<`3=s-}xpLHr1?ucBbJR$E2em?5DHr5y
zG(XT{a3wZ(n0ec5YF4W$3~&w%;b|()vFkf8^!-<F6H6caN!=v8e>#5m^f<5>B0=1h
z$b{>NI-8Bra|`?*9d$o~cF^pAe?(pJnMYdHU?78A69L%DK+;XM?_w7?@{}Y;ny#<H
z%}wgMk)htwt>9;Lxc;LyM^VjwW3xPMjyGA1g`4#PF~H10L^uQvLP0F&9659my+Ex9
z2X)se566@4_Ob7nS(sx=ld8F~1lQu{vW*o9{>+<P`6fLl;?u{Hx&?ZF=JPyT1^G&A
zdmiRjRz4p!lQp(8GkyHok;0#KqjMH9of`>0f?MWKw?II128^G}e?y$eL13Pf?4i_@
zy>)M{Yhvo<;xdY;FAmn{vk*NafYy<rW#+8BCK^IykP?zgCy-A%7wk`}{{9I!00N9T
z2N_gCQRG5(7-!l_V&!ohIV2-hRkcjc9YW|+>eA8tURBwt3#X^S%|y$_%9s1yE0-X>
zJD>7+a%c0bbR4Jq)9^tkM#PAR@uWg7p^$Nn1gH-4YHcJ0+<nYhf=Cck9dj;GTrj2J
z#F;@Z0b;{sS*b_Xa+;=ow_$>3)3HQ&B4Q^c(s|gVv%?IVV^Wwz-fh$8ulUWiX(^L(
z@u)_J<I`8)Jly>-*>rQc4~d+Mnoep0Wfn0O<2Iea0GFa5f-K&{&NiDv&ZuqG(l|Q{
zj2O&XneA=g2OvUBL~89styUn+5=`~}aQM}iUv!&pRMRN8PltE+56Wx|M+0P;YbQ9z
zetf*$|HSEXjr^WD>omg@ZTDYHY?hv2ZmL#AL38m0F&PO_WU%K~Fa7Gm`c7l4Y)d=a
zl+A8rz&e&{rUTJAnB42ZVD>VuJ%GuDA;J=ZL<vzOfW-rRld#`}VVHs>gOxlEgN##-
z<_thW>Na`Gc^V~#NwpeHJToF*P4J6KZVrxF6}O*x^V>5f&hsNLp8a;C?f6;K`|QB5
zECjynX=iu0g|pA}EW!mp`X|;H9(=Lo^z&yXcXDn)!ZdpUIT1ue&5E1NFJ`0Wfg6G`
zd*AbJ7e$5zh4N+NSv5TPibK_e74viGjm66BF&QTz`9$%be^2(&-<AdBKo(JvPzq~K
zgg(Zg#%9q0>CAE=tER4SVrU?C@X5+>I_6FoaMuV5%-1n)IgCo?n4H{^-7*m~hH-p%
z_i)+kb{{uECR1}$VI?V~Oe7VFuBo$3)uYGEpd=DQh;W~xOzwkOarY3t>u)Zv!Y_XP
z+dq6$?(RmnY^v@okx_IUB_N^(jGVKb&S0yP85t4vUA(^9{OU{j55Evn9W%1hRCf0d
z?+;IhawOR9axa0*bFnhy@oKy6DTNV2)B+RT86J#irlyc-yTmHFk#VahY((Z<=}dq-
zQ%%@nn$rjYcJbguq;={OCrmk?PNOjOec~8~JPqo1r_=4jqj!6&Y@b<KIh)nPR|RAR
z{^2>t<zwE<dgh%`prv@tRP~mkYu*5$8Z<^=2oi{49^Dg7U%u&HTu}@Y%?IOlj9k0H
zG*{!*)uN(VO_haN{^Sc>%|r|rkO(Alh$4|WLb6NIE{3aJcRw5q?xa&LS;A=?V%~Ns
zK|<=f(<$mWGRyhoeRfG&FHAF`b|s^mpTT;XdM2s+X!664tH#Qn)9EAYhefFSY)@E;
z6P`_-ORq41eGU4o{FT<1`}x^lu0YE-vte>Ldq-Gv|Aep<Gjn&Y(QVc0$_UEP-OhJg
z#Ngbrdwz;W^^7&O96bD^S3$kROEgK~0R8mvpT98m<){9b+uz#@2!JtikW!?R5SU{O
z&{Bp`i2Im^LE#A1XpzWG)f`GTj^*@Nyhn%^QFbvz7_*G-tU9SXabk*u5ke%V<Mi$K
z@85jh4dg=ZpyO%iyXak~;4<G2v2c_@PTqH^<ZM}`@8V`t`sh~|*lx^SV(dfg)AmcG
z53b+bzE@_Bp_Jm1m_@akP1N^@H){x<Eqr;#wTK{`QVhE-t}lBs&xNL9r_qMVS*+yU
zcE8{602Fg`DpO9okPyUF97>Fqjqc#;wafr&RuY;8og1~`sx9sFLAp8DEmf|*6O90d
zu{J|FHloAn`0(&}eX(J7g%{!bal9YKle#ggYGIC`S*+lj<qBpa%r-*)2y9pvBRt#N
zS1)^<L$cZ@HFDLu0XVq}RZK=W1aKscu6@v7etz}xhGQ7r&6cYv*;=$}YxsP2MXTkl
zhIx5IELIk#Er!LINvb3`vP4L5wh|>=ZNui?&5IMnoZL^RQyizT*@h4#b|EIJu9XZj
z|F}`kjQcY<{w((WIdStjUkd9(@lQS1Kl)9779x3WF-tc-lR2>@*w9*X=CjuKBPP(Z
zzT{Z*nC5f9(hL@Vi?)GPHYmU~C)mM&Ffp6CTM29+eer^?E(tWk3uc}%K6(^$zx?=u
zalSivW5mKFXy^!$|F}KF-|zhUKf?ylZvD&@qOb&17~ab?v2(ZCbg>6vDx+Bmftfin
zz}RHkfKE?G3gIShwhnP}khICojZ9F<+YInj%KfRFj0dBj>Q2KjOak5Z&JB4D%n*hX
zF&WH_Qi!BBm0~0ECgna}|L6bZ<$wImM4oFE%69+$ar*6Mf^iHnL^sP*&gy11x#t#Y
zu(Hx+%t@)$8_h5c`QZWIy_Jri$VygZD~I93H{X5u`r97etBcD%rn)XO2^Xfp)TeyR
zWL~7E#Lf&<b+bZDQsYiAn+<_#kZvJ&_uv!^GpVnYX0N^~jlGG=bWyIUUKpl4<>~e7
zS7v3RpfSF?`*1%D8iImLJ(n_wpx(H8v<mgZGmID?O{{-(c9}t~N+Fsf#>`1;;EGlM
ze+W|x=0Y#NPqIt+#pk=1*DN>)_g>u2=`rUhLp(=E<~oa&XN)!Xnzo}Dh?z*>vnUK4
zNFpSdWK9TL;fshe4ocoha`Isq<1qHB!o9>8x;}JWo<`z8US=JXoy+B{QUHE}mJTd|
zCg=FAwXzp0PitBuLaPJ9kJSPV3N){DS|V~YI>R<g-XxZXb(RWX4s!Q1`o}AQ?>rMU
zCs?c<vDef2+=i>N+gk6f)LWThPX|m%U%pH)uOldv7uX_S^Ce%#*ZfkP`#XM2OmQM8
zi-z7MRZms@haCU?AEW`)N>CVuB$EZBULu0#<M?E!E+vte*xgG#?zuZd_Az{Mb$x}P
zoC0&yQiegw6q!4C!R$Kh&dh?~uEptL817C(b!zTI0FcchNZo@wISI8_rB^PfDiH*1
zAZ8rLaohKs7dIV9fpHjr`0j`Q_WR#|`|f)S(Lu#*lcKwqQtGQ#;X=)t*PGhW&B>wg
zGP@aTx$~z#_;h@{*PM%^m>$QccOQ=5z1w%Y>+RmMA=E=IZ8-AiOd6V(1f0o1W)N_5
zktQnD1-HiGR;@s#;6W=F6_}mPoUDDcc}!BJKM^2IBIczQZ4qp{c$$h5kC5*kkB?)v
z7!}Z}zGnuByDj3L*$i%V)Wg{lXq{<J=hNrU=)z`=E@pO&tEsA)5_u)&*C0$HBw@B3
zaQxM0-PMlzl$pm|NRXJBTnR0g5TvyDBP_QF2URx7?C{!L5oR}HZo%|5AJLhe10+g_
z5b+?UmJ|496Hn7LX6d_bber-tjKh?3N5mndzVF6u&V@rTchiEOq4>M6P4`=B?!2~<
zue5awO0!sNtfWvspLFi4&-qix{kd5z`r*YP^!cBi>#8pV(CVzrcy<RqBSfo>a2+bv
z$YTN)){6cMlZc~zW0)PR!gh7tU0<aj2e`HDx%J|4c6jn17oQa;wteG;oLOTsiFlrC
z`L`<Sf60gbXW9S&DAB>qRb9R35K=de<>@q#gcz9-Tn%Qf4p?N_Mh-#t6bl72nx?@u
zBakpDnV2y_5F$w+Om0Nt?zc~e7n|Kabv<L>Zv-|>Q#I9rx)=p>Co5djf_2Da6k!$v
zT%D$ZQ}(AZPt)T#-rhfa`_<Rq{6GJ7`sQsSkeZs+xL9e{Ri!}{)#u+GRe)mVaAK?E
z6H)hZEbnh0pB^8ksi;wQJx%55*q^5T#lDwNrV=Ev!HR8=l0mA}mffiohY`amBGeM-
zKqe~;4wV$@>?VyDRD-wKYq;Rdad#NbjEFk^Haa~B#g#$ZF2Ynm)Bi`_oBl|WBw2oP
zsG6Byab-m0SzT4#GqVd4+#v~mAh7>GK!N}l;Ot_EKBlia@{Y?7GgB3L{Gev;=8@Um
zJ4aX5fQbSsBO)`>Bf?!oRph<jV_6&CuD1`_5Gqr379XNjhOBYoqa<^lzz2>8+>@&S
ze=@H9e5o1;ac1sja07dRv9TzVsE80K_lvsw>ecz_f|WbB9UK}13lEHkqqXy)W(<(!
z(aN?z6Vn9pL<AugE{c>vgr${+N<(BzMVhK-O?cSmT{2<xFmma;Zr8T6Y*iKOx=yp%
zcDo6v3Q%^+dZ44!WS$zs_)xSkLERknfc?mRvQR(5NE~iGhtG-000&1S{|Wt>_VWL6
zP&5*7Ckq99Moh$XH09#Ml<m=CVsac86%E<p0IQNHNX$tFB9@)3_+%mThNHTa=QB?Y
zBXrybu)p{4{w{>0Nfxt3O|gPTDf-jDVjcd$s{g<Av;7b(pn}HTCePUds0Gbpq^eF`
zx3%18jLhP~PD-KJFUd{FL$;KV%wZ<VCYlNA9uyH=5mhX$fsF}j@VkfY_S}sG=5>gc
zyS8tesurRE1cQ1pF%c_>ktr8+mpdWlnM8hf`|#^;Hn;b$U%!3(=FR=hZP@jT#B9VM
z7Rd~#Ff+s8xgg1nU~nccfP~`oEm^4U2%ta|4btY2Tnv;v?J{+C7VBkfA{a!01P1D@
zBCX0?i5z4ZmR+0~&LkW`426m_WfcU4Fu`jpS+(U(;N)Z=h7^I)7$rblUO^Bpu1X*g
zw5oQSHM!5L=zSMr(=p%o_P*`c&bd-ADOm%BK>&P4PPiW+(3mUE{OA%eA@cK|yEK+t
zR6)R*yF00uvtpSL2O;4ccz3qaSI<vYvqbh_*2Op@b}#!yI*KX>8I8%8qndO)V;9}%
zzIMXLRj`+p<e>os4wc4Ay*J9vW{B~m)^&%?(2is7``u>Suez#=F;;b5s|Iq22DVJ(
zuzg1w$j(QipuM;edp!ZhSrGQn9Y%?<q2q*=qiOh`_~!DI6v3G2G7kgs;*l7QUA%V<
zPZqqyOh*x5P6rmlSnCHvz$9%36P6GUXeZS!B_}Q$CN7{K0OX?n^eU|8q?{SX4F2S-
zFacEW^*?(?2oBH9K@Utqu98E@5|rt$c?0;@m-v6_`uC?b0%9f=VU^xw<A~XaRI8|U
zb-&vh&rj+)22nF0b20yAQ-VSxQ3r^~4(M~A2|}n<&8fE>Jg9jffmUwmq3<^4y?K>0
zqF6Sk%+e@RiFOepA81pMz{-+xf|F=e;>P*mm;dzspZ@3uGjF;+_vm&hW>?Xup;(W4
z%Uy=%lwrm&F$V*Vku}C5MXU)egC?-BiMWcYsu4KbuD6s{i^XczgmS4MOJ<z=z|}y2
zV-Qg>BtzJYScwdPIgzR4I^=nstLUjsea?moqyRg}oy?iRD8M4);q)g$CBKE8sI#1n
z=G8pid(LSwYmiN9&4l}|f5^5a>WMQm6}b~Lvlj33co^Ix?|8}&;~_|#KR*@xi_d42
znD~;w;H4rC7-&E_S0T--e0Cz2=XK!T^DYF5wdS1NNqG{t4lfVpP`hZFUciHR9tYC^
zaS3@w5dxJpmIRW>T4{{pfmopdfGsOo#=Psg7^5+AO5Jwbw>z58G{z7@2*KUSlvT<1
zJAi%JoCqwBM;YKh_q`gEUk0u<{t_5sy4s!yb005LM^*0dqbuV5{lI=Ss|_J7<6k}^
z{2XNm4~m3Co!T!9h9`;$i@3v!>dINQ1VXsOLZIi*=BtGO$*iQ%jgAw>QB&Is%W%*m
z0Z07N@tf+xuIi#7WlBHc1;C%aCI9;w0TD5CP*K%Z?5@vD9E2L-9JD1=<)>i;2O9@r
zVT5w=&M?4<(ik}*?n(%t2$_*&rVi9PvIsbM@LkH=E-jgn-OWNB7mJ0p57uYaKq_!9
zd_f{-VNo)I!=gl(@!bOqQq7E@W;KUKV_+%64<3_D%VC?H05>Zp1422t3WNo$!_`xR
zv7m0STEyj?t4JB?e$%;8yA87{R19Q7w%%bDh$>Ze2MUSELlu~i%!G=+mmusaR&#ZA
zcJg;$<Ldn5AAX-d+^!#5+U)A=#hsw+K}np*ilvEESVx7O1abESGg4wM*~Q4l0E=$>
z^ycn<3+hFBVHb9SNZ?_IDHwwMifw5yCl6=3PfP&(8DzoH(?j<9BovAU+>DvC!Q4ez
zqp*+w%G^Y$)P=i~Rd;b#2iXa_Qk~q>xD3%DqIi&5l;$}Ow+}Ad;uRYBtP>s@xWuoQ
zrH7Jf$p@Ag)hf+_osB3rTAkG4zVe$kFQS-R3-_+wtsi`~lB%j=oXuu^-xITF%+`sD
z0OT;U0v#e^GY5GAold`xkF(5<5ch|r>wXo$hq2N)q&vz2+pC7kf@H5g+K+a4ihme>
zh?51xL_dUy31oO%_>uhbFseB`1%yFVrleJfqQOAPK_bEmlAK)!6-BNqy1ra2=PtC>
za-Z;Ht1<}F0Amax(ns5dqYFd1sALh7Agqr(5kFk9|A};+AEW^g33F6Qs;%UQ?25bu
ziH10zb!MABtJXpY#r(mh1^4J)K+2_fMQ9--7b&wdcjh%q9i#(gcMw19cAI7vm#aXQ
z9ZFKLJRq2m!%fK;PR>kbCd?{@nP9?PiGaB$CwOcsS!k=w>n#TQ%|7XuWKXjiRS8@|
zznvik2LUH$4OCV2)%E=AFBUJJf{6Qk|N7l}{SY@zXaXxCXZ8$F4383mK)i$ns%2LP
zu@g*0$}N~!NI^=?$zu8Rl79ArFHY>^U3!1pzQ6Gg_wD^g+Ff+or|J$`RpL^59Pr>S
zU>0ZGuJ74>RyE4RObNK#b>H6HZ45aC4+`OeM&*fWe|+il<UT)y?G7V#eq8+zo8w3F
zI~+J<<5{wpmz{`IHHJcVG$oBfbu_iz`ME#6iXrTnlN4@@=hEqp^q)hql)cz-h!Ee8
zJ4VLeM9DI|iy6!;0ue6}!9x#-;%dYuNVC|S&a1nwzsp@E^^CPkZToPyTdk@XgNDUo
zvDxl&&Ke?v+<JCnVUA<I*T5~6&tjerjE2Yj(Bp;jVLSY}qasf%0W@{!9es4)4Gxm2
zafUN}0Q-J}15od9k(k^lj?_s!<YJcRA``R5z#_?<WB~gWAt)@t(|nHWCt)?`x}v}!
z_tDz>nH9tlAZVgD;-j7OfLK)WAP7;U65n+M|Do&dzeawFe{T(d1~h_HL30cn>pZ7S
zv<w=hNt<@F?Lwn-2^0mEvgHA<Z<(M%EKEU!NQFtrSwP?n3P3D?HwPpz>$Xd~Hq~c!
zWxbQayzjaoj5_p$WX3v(76Oaq#G*liGk2DtEE+ign?Pj0C@q`S*IzZKCk&Zw+VB7G
z|9bbU-&%S4xRFA}Q<*XcIs}xLXP=o77aRjqrL0_^tmZGC(U-3%=kD&|{`S6eYnmp+
zz>HFM%b24Oig@6F@(_@ReRoOBO2u6O_P+18TTSWY`ijoZ^5tcBv+h4`w!i--fA=kK
zaxf5lpI%?krQ`(S<jIvKMljyLdwVrMnbk9-Bth?!y<cy?zr9-<Thl;wfWW{93>foR
z6j%n{FAoZG7Vu>B&dkT_;C(}wZU`LvFps@xkW$JeAu=c_8{kS_vDIR=^s}(Lx~#6R
zn<{2uV=9n38~=q-5sr~s$3D1>alD5mOgKf8>HNq*7?;2%3O%d=qE}A6WptI)r?dDZ
z^ZomWY8EM|S<c(d-Ob0ks+X&irfwGVMNZjrs_HtmZtf}^MBU7?fk-v@*oPRO5F4fm
zV#i0T$1MRzr^|yJYg~r<{>_O=dtWu>XeY71UGSru8`ESxJz+^q+o(*uY@^?S_me9T
z2|-nZ6DQ9altjvNTmxlK@c!&Xzx^OUSO5SZ07*naRQh7x)LA((!}H)pA)b2ohK@63
z5*=@*4(cY10$d@8xJH#qNu>Bg|J?{c|4lCwKU4!C66VqX`kdEh<PheC%dDQIZFh6O
zsm{(rRAL}03_47iok*0RG+dXt;1>yjQK<$d7STE^t7;Zhw!1!qp@FoLXw>(8U)425
zbU7sv6@sB8z%WYzf3m9QY@R!zu9EoT$;<!zzpgGW(B+GV-7jx$U;np%=<KA>NrFfu
z&1i{SN|KC`1LZF7aD%b1mN{wad#65i)o$nacR8o;e)q@U{KJ2Hc>m$c)oG=wFct*?
zW*`z$0y{}6Gci^XWg>B70(&L}$dPg&y8HbfZu)k$+n)UGFT(kmUOt(hUp6mDSvL>&
zdH3LjRx~J73mtw?W@Jw(C_*4`*C$zsvUJWI>$}bF?fv?uO>Nzn28cR_v+$vwbBQje
z;n+6j;2s7TJj@`DmcSEv(7pi_E&TW=dB}P7oO2?gpsE6<tc+S|S<yUNCF`e`>BY0v
z#d%bHDCv&`keg`Ho)_)>o;S$^8?wef4K&${8V~VUG?<penW@|WRH1=1iiZ%YXq8#;
zU_|8epcka??zbE77@S4hoF3l2UCtMa**wO0vRZXre|O)h2G(*rb=`Nwl5vL8>HYZL
zgg^6oKdQ|GY5|W+$#ls~V}LJ_Ol}AJW%R-9J>K^A2oHHQ^Pyw5$M_I@Yy?h6oL7v-
zwSqiV(HLu1&F<Mz#ZY#?fajD{a;0{0QUC1KYCh}SdqEbND3T_6C;rSPcOMTnTsP<t
zZ&~7>q3T+(REH<wk2vJ{5tC<rz)WCf6|RC-Rcy_7DOW&EtP&8=w!796a|ps3gK~wO
zU_&OTfWmkqcd!5q2oRJ5%WO8&la<cq6?1!gmu@%PT{}}&i6n03Jg>|wBSS+<IS?}m
z3__A~PRXDOIElhjN?=O`x6rk_cYpk5^Wh^`RWXZd3<P&j6@zp=6A3vSJf?dC&hE-0
z?m~z```q1p_uV^7x4--Cht1~U?T7s4-NMj_s*?ag)B$IO5B6Rnkr0Wv?^~2Ytw9wj
zb><{NqNovtF0Eg`f6uy0Sbg<sesNJ%Gs&L1F7<5@q`E_fd{uTpoQko)7|uvJb=jIK
z3MeNx2&8(qz5Vv)zSoFYxrh-!tg14;1ow<*9_1+G$`xZU@&Sr>JOvuwWIUFK@^}|0
z5xXh(K#rjbL4=ImqWU~w5p5p2S!n;}=VvdUH6iRk9Y{-pufrM6RH7xyFhdUi)<hLD
zRbKKw=HURt1lXCa1j`gEXt4rF5Y}P{&=e?=ddlKyUd5-U&G&b$8_%nmrEI<3e|X<C
zvx}>zP2Duj>|wp``V=*2tgP=+HWgOYNhr;rU*SJ3lfqxfg8baZWeRNL39jwYH~*6&
z$_E)eV=CjEn214-8^LJfE2H?mFL2ztkIJ7|1t*vr3HxD_VDKcG&sKDGE+;FF(cF4d
zZ_09buW`Z=3uyF?OeFt@uqK+A8HUA`613bWh(JH}SeU=oE&=!f8$j6v1Zg~Ev+QWI
zC$JIKbsa*u+ib)6Nr*AG35f#-)?s)N#>G?~q}d`RwSy3qPft(e;-Y8icP$)k-+z2q
zFIMweRMFsUsfaZ}%HoFN@Pr$SvZ4S;Dh@0v1SIp1ckQo#XY+Tr?{B~P_3wAze5YU)
z302e>Qp(w-5m91=3&@5T+v1TVaZ*NP2)SDdEZh5=51YI1EWN+Kn|ZaOI45qvVn*g1
zhzx<$8SKKWfD|y6GpmS`8&H~`gTzUMk-3)2bJ)IL@8}!v5`T^A>M8B|{{BAS-#2C@
zv1YWJmvk)}MnX&yw9o0`VRO1T5ipE6Hf!+ryY9R7&gUl-D<d*@5>Xk~ssQ+q=zSQQ
z3~$SxFHB?gKk@<a{;qJ)qU`^S!?Wd-d$%M^p)?&pfhN*St)?{7&GmWu^3~$Wc_h3i
zYJnPvMWD(~%*F>%<0xA%>l2!!#P2bjlOeSq*mfYcu?G+fi$J(+0w78phyw-YK4(T(
z3tz69P1|>EOCdBGh^TwGy}Ma1R%g|Gv0Sb;o89gGO;8G<Vo>gPASw;O%nzI0y|8gw
z&L#&b9Ea*)dM4+`^YMdS;L~uP$Jc{T1*1$yvFprZ-rFbMj;VTe93K6NCZ-}90*P2Q
z2Z@Fv!~&d<m5q^~J!@V(tAp-@Tav5{VRq+7`{g4N6^@5gdz&A|85kV`45XO*6eL_y
zr2ajW`+v_j04mfcmMUl+Bg~T_F}K<3D$MHYeskYb4jf6CB@j80GkJ+d3FAG^NL3KP
z5u`vQ3PB}=zE8XDcDLDZ>fdkfpPV#Rh!P?(Z!LSuY~HYN372OAkO7iVGTgNY1VC=+
z-ruhO&;OE*Zf`cb`)#<npFx$Gh_V}LAm-Hf189waecovaA_WAb3?k2|(`FW!&~<sc
zsj|!^ETBu)8bUc)>dDwWhZux~z{=|8PR>DMR8?~8lR2|csI$8ngh(_}s6{j+!riXx
zzuj<%J+SNi{rj-n1Sd7H6&4E*F)O^+y1Pb2PVJ_BarRVpP6!g44_*6u*M0<BVPM02
zKjU{FxdiNEE|p9iR=j5i?CZzz4q(g&e2fm=pETXga&pT|t|D6ecJ5JS7Ep7luv^vJ
zuU;*$&ZVgh-ijEr6(PSCZPKuOu;IuFfV3E<@X0KDs18H77zS74{l$s%9uZn3w1v=Z
zB`Y|xk%^L8Po%3loG-$rZy!=OYa%mmQr_O*-QC_?FIJ2BVtI1X<vw-WsG>2try>*>
z>Z!;Of;Aq!alF8t$b$C13Os)AW17UH{H~)6N}dLbebQ)-cDEC(+GipNjy?yEtRH-`
zxGq0`7SRxcI~+tJQpi7Wf-&VFc~<%LRrTaaAYK!-L0p*JMw|Ggh4Ya??no3mxuG2B
zf;@4nu?!d@`Zpf|{Wa!4_^U{X!VlcTgei(NK|KaDB%)nLWjQFHE$3ak@f?=1(x$Pl
z2NIOvL^g<Rgm{3mFxAX6aBJRfw!Oqn+dbUhr(G-L?^63*FjH<sMB_I1Dfg9A#agol
zl0a-so%Ik8B19kqayEAsQuyZedxwf~Lo$~rfr5G8?j%Ze`Xpq!`}pBWrLJNlCB?}Z
z1w{^^Flnp@IWxr=t9o9|)7?W_cci>nEtJ@RoKs4f86irLFaqIojIpjOAiHHV1K>d^
z#AMdbm(|sEoG<&7x0`L(_kl@L+WzX-{jYx&Q_|hGVp4a-{#aagd@{tumMaBOQPwL9
zJBUK2@crHT{dU)?wxC>qYFvzOfP0BboJhm>abIJ&>v-Rn1L=hig2D+9f+sP*<N42v
z?TZPbtja7PhcKED8ns4j5xeWN>gQjaEb5-T4Z$@Kk(CW&iSq)%87O9jJuu-w1D$|d
z$6LvMI)EY9wycj!0HL##lqwP7AVgKjA+xepno|<x5ScA8<a`!3eb_$qOl~ZdO4sgg
zK772mey&x$T&*1b_D!F1AA^J#EvG^*5)m&Tem6Qk>_4g$d^Bx2n!Pa7u{Z0pHiF|T
z!l77yMzcE^-Qkb`44$-s$ra+!op88|_)!cDGc$*vs?uizvx*W+5%!h2E_1%R(u*^0
zY7<FBxuAtC6YDUw!-ToZQ&#n;c$;cKhj$$~uo%az#9G{EKjv8G^BV}@2dMr(LIWr%
zdsR^P*cw_(RUNwQ(rr(g%62_qB%F;!qp_PC(LhxY(7@+{L;@fS($;Ky`><_u>+XHe
zDv81k<@estpu!xPv&t3@XKgC+ELP@G5<-=bayBB4ETlr>&PbrtcgE33+tjDjTQ&hT
z5;*96*KV?V<P@l7cjv(+J3={0D3{1m2_C`*<jw5r#mmdn^MClS|L^Yi-)X3wsmn>&
z!AQBQD`hen$|Z=h_o+`i_Z(E~7$8;e)b`%j&Fnw@&lmsO|02uz=HrL--FMq}@7kM>
z&1T!|wvyXfU`snmIhqQTNNi7EELc%w5J}Lk>#XZmO-0#@A%4B<zxi<cq3b=y#3eVY
z^oQZtB||TGH0TE(201*yz-Zj+PSyb6$seLUlVRu(+04w~E<!=MpuicZSew8V`%H0t
zQGNAl@$^a4#Fl-dV$4LavSVUEAkH+zbRK2`gCh)&h{w|mSsF)JzUM9NO<`bR5idPJ
zgGf-V0vS@5*$@DMv883*oG+TYu6^itRkJddE_>hZK7RPHy11Op79d%#*Y|fHDCZ_d
zCbrZQK~+(J%S`0Xf94eUId|A(9`iVthadm3y-^E1!T22_JSTji$@gm1*^KY;Y4aR9
z{-mYw@s(n9GB9(DA*cdyc+e=S<|v1fz%Jr-&0l|Ya&{JoTGcE(;m|!QfEXJSaNP1n
ztRTv~a*Q9C+9-;cyYOXycqhO=3lZ@zdT@W41r7WN4Pe{`OBK{(=*`-MpcI@t%O$?H
zj0wTyu4c;QT;fQGbiBp^B<|#>MP~5LcBe!YlZOb^HtpW+wkNgDB!Y-yOe_kD)r`80
zyE&7Aw33|JfguQd5Hhl`2T=pJ**fn#&puKSWk~b|L`*275M#zy%iye(LNRb+BkjQT
zY;kgSF6ZZq)iTwUkbtR6U9I52oDricgWVVm7?U%BodQuPJcok()Q|`@Q(aeddA_(l
z3tzoB+3oE9F8uZn_N!l|@4unkaqhS%K1s^%*8m&jqy&cx&*#gx>$`T>E}OaMK1iKO
z9#a4MVRK`is@haZWq<BtfSFZPSh86OQyX4e`|2V^7c@%!dB|Jgi5PE;5*+jyrKc2E
zl$n`3%DqHLn6((cg&ILcX%@Pd&z8UV@_f;BQFo#}p^!;Mn8u*+M<qc9H|xGg@sVVn
zC#ugWf``e43gdflWiyMgLztK(P>4dNp;pV;vIjw6LdwgiPnOO0<BqGQ(YgoiQg?gv
zQJeWH*0b5{;^Il)?Yix~&YB?7xe=UI-Leb>@%^&49HV`I#wK$96o-Et$HPZ7=4rgl
zL4r#-b{X$K%_L^{k$m^KuN->Ekq&52^ge_eW9ocnq8O_XLN;esmf_6f0FViNrTOYi
zpIyyPR|sKSJ~C#s9V+!c%ov}<81Umg|7UJL`^gY1u`+&CDD+<#0pYLPfqskzKqO46
z5~F4dttTaptlo7eRTG3Pd)X0@DIqYxK|qe|fC~_YO6?$H2~nhWud+il0|s)5HxJu&
z)1<1>B62Iqf;9Mvs7L}G0c0!?>PyWfCN5D^(lgi3U%Yzp>h2$Zb^GhzB&H4?vvHgS
z)gGJTOBa&yS_)!PDlxlGEKb~)p^_oBUA}*yl<J_NNJgowETJlOi0n=vDdsOJ-dLBR
zx8(Bk3ZjbKy?K4}o8JVa*_SVu&z~;IX}6>KVrzc?@uRO362S^z*NOKE$5Gt^285w(
zsxDE4$tYl(`ghyy$CTGxC5>REvMr<XB{2)jzDSHR`NNsM1XB(LK?+4?wAuQg$r!6Y
z@70z7`+)s1bAyX2hhirHxm84qh-LJdw9l{c#f$jloMPCjZbS_565b3MX7^5*&>wwL
z%0N?>?0`2Lq-FbtG4jg_0>^m_NGx(MVRj)>XmqKFGc;<^axsA&f%CEo*A&<5%{K3t
zb*5GCdAELexVsBgJzp+Xt5v%@yUDHPTm_9WnmI_oV#K-!?(rT{F^K1f6$|$G9>!6%
zV?KiZ@0;&Y!aGl^JL54&bDxws#XC=?N<7&kmH8j`&xB!62y<7C%;muC%mgw5R5++c
z4NPL@p{jzYlRL5_3uW?ja^gS#Vt%%uI=TwM3lwFrWnc`C-y0^Tk#a{(u;lwppnH5s
zJScKx7lmq>0)28Z{Qu3b@T2^z%&bB|HOA1oZ{cjHNmrp3kYSf8D+^edqi8uJWY3x0
z87>4>RuNG$OAfC@E6Q%pCb5~-%O|`0+ijPVQ>EgasWZdZ?Y3qo0W%sE%BCO^>BSw+
z1T7F@fZQqa`4=x={QZCWez$x3+h4XqiO4fR8iWlJoT6|bad5ISh9CxOCI(3qX11JJ
zB;7x}|HC&ALhZ+!M!6;yc&r4T-E&Y;X3I_>4Z$-)6-<!e&IIHzO6deLleqcrcfY-T
zSO5OYtN;AJpM3dB>JU}={M;|EEi{2Ucyc!qfjcu;i|Prg<pra}VRPG7q@kXRxz>~@
zf7q;l`{Bce*kfZ7zyurN1Oxq<$AL8;?Fso{1Qr61-faxB8V9knQ;GB{mB$8SE>NVK
zg%s<=B0)uk$pxmK<`q_vma#jV_dow~{_GMWA4Ax%bi@!*8X_6k0AcnLk5Gbs8AQ$`
zB`#r1CNE_`_Q16<&Vd{b5=O~Qm$6hx*>wv$i?cwLJi10CbykEZZ15h06eWs)nVzkx
z*AKggq;;)L2oL@4_TzhrAygWpo}Zt=`j7A42!#+Mi+3qYjBf5=B?dVU3U?pmF{Km>
zkCr(c1+0S)OJF=Y|MIbfXnK9%BV+<kxN0;>1Uov1?k~H{Jow{jZ?zJD-Q1OhIFw0@
z6e~WUDs>f^*_?<&42=lPx|Dl(Vo7z(*B9~YSIwg8*)q#udUqlK$|a?s++qil0TYC=
zzwYsY0Xo<k7~`pc7|vc+MGT0Gx+um*^<&I-epCm*kJ$jqk18lvQL~5asWrr^TK5)W
zsAu!O-}auFL?n#V!>lSnL)-3%!OFCE19}cjGZ9Z7tNQfn`pL8BfBg2F-TK4*b|-bH
zLs-O`&~LVzYBp1iNGYX0pcD#s@<R6CdxQq8CX7=@Zaq_iOVAjifdr`QhI0oi{@5Xp
z(TU7UEIZ}w3B#GCUvIW;w`O9?wT1xloXnUkb17S9!*(jWl*D;r(V)uFg)Ey8*TD<$
z({lRwzRmf=!$bA#>iTCdU;XXhRNFSaf4A9gz00#$tGK0XFeV{40z?JwZls}!)$HN^
zE+bb>h>?1?E$|_=-*47y)HzfxN|g6I-C^1LDcfga;G%;%aD+DU5VN~SXN-x9#KNA9
zjEc&$@4GG~5{)r3Lx_}EJfF?uY2~$SBj11dYWCu)TFgy&L)7vhygGPyhhcBwUk^B#
zvi9(4#^R7TIetl>U^H!1nafaL#+XVej<Dcx5*>VD5=a6;d2D?SZz~GdC)F;ccDu10
zn<{R-Z?_K*cTLq)r>CpsY9V~pwcGo<o0C=4DpEF)!X7O#pE5YM%NoBB@upDa0pd2?
zT4cP`j8;27R#=TEWd3wuvlkrUQAF5OyK`*zI;f(?s4p3;>h8oIV-PUhQDo-j$1frp
z>bgnU&1p7Uiimr%Y%qgop?viOub%SR3U%eeHaw(ql_@b0do9Uu<#-&TGj@Vei8S5>
zWq3=<=&Oh}SV@8m?!ceyuYb{k0{`7XV?SO4U=re>T1UV=89Jkuyn`z%RaMt+J(~(u
z;5lg%D<|rAEeI5Y3sO!5sx-`*11S+D%3X1GrKE(mPj{P5L-XiV2Q|p1-JGo!!pxS;
zZ9D`HS4`foGs~0Tv3>vH^*{Y?{r&@-VeZ*j1Ki-nj7IEUSj+AXF(?otnp$EcWstEY
zbgA!l+jVY5>cz5(K@3InNbX7;G{8`viN%z_4z~<Ah2Q{KtcfYcwfD(9OVC)^!&=uH
ze*1Rw=H0j7zB?E8ckeZI#@3R>a&VnkLzNhg>=0%NVrGu4G7D8)ckOMT-?i=AuG`f!
zS0xp~Fz4q_yt|Jk!H?{|Of2NX{DRn-jET!`b}TE##3BUGW|mX7#OxxhY{DdN3d{q|
zE3ace)9vL2|Kh95Cud%T`xu5u%wdsvnAIG!?ExYwI!hX~JwE;w9-v}W_PzVow9i7>
z2PX_hQYMHD-xU%-$OFeH76pM290oXq4CIli5xG2_?YwQfc3#gq;gq`V{Y{8cMXjon
z`D%Xk;%S?^O}m>l&3xYUeKsGyZzLcejZ+wR@Z)f5Otmi#>SO5=u}z|S8IOxMe<n_t
zrU)HAEFbuQcKr;2;z)Nn%z{dW1!;MJL-dfj28~q}g0{(wsH&@2*V*zgBFt7PBKy;;
z=H<)zd`3YXFu0LmR52eMzXw;@fmE?yJRFHak5CzVGW0=yMj}JV-H&F)`qvcDe>qJE
zKYjz)4}z+o=AkohVHJ4e<_WVVBE)UC<?N@`jER*CG|@=dnaasoh^rzlbxQ8FYI1+L
zyG_Eo%>(uQTIq5=gL#R^a)DHVO8T@Ml23>7fiW1ooEZ$8x9>haZ128%6TlI|2F_l_
z(`?S=>Y(a%O-)0yMw?lv=UUICsYr!j-0kqNmfKssy$S8M5e`IB7&-tsL?nnJXBwG8
z%1Xd6SnkY;scB5Bu9-DI``K){=(-)fd5yb=0165C{kQkO{3ls0gRtf-f%|M^s9j{h
zrVxvam|RL`loF8%6SEL&Px`TIUvJx6aEj5#R7=?p_$LR#M-AZ99#9a<LQX{cn|e8=
zVjs;2XAyVrbD#Q7nPL!OBF{lMxYuOMisvC!ynS-+fBTDz>&rN6+8{ZI2nRlFF2Q7c
zfWFZ|>OBl|_H}PO4(=l(_l4o`-~Ow!(Gpy~fy4q)s1pf6IRv&SF$yA(2$>)burf2u
zkx%B;MXI(r_qjW*79hIWt=Au^uBupv`EtHIIeGr-)$8xR-R!oj#j=Xp_hxVs1`jHx
zg6<$<fsT(9dw3mlVLg@X_>xFRQ=Z&J;KDpzbRX6Lk122msSy*7mchrK--A40FQhF1
zl=7INWod2(Kt*GSB(h8WY`L1vSMJhh^PFK836=PZ%lg%``Ndfj?T9nMM(<t;2cq!`
z^jLj5LC+oV&)DYyjW+mkR5tw@K@&;Z4`2O1e@_3jvj3?|z`w=r`p0YlG~q*7488e|
zz<@ghQ9@<hr9Pd_1G(g!U>>X3Sx)dgDCbBC5d^TBR}w0r?Ph(uejsv9-7>Hf3ke&9
zsF^jSoXrIuRmjZ=V92pS1^_uL6SnQ$%|rX~UY%>vibb3R6v}Z^gT;oI3qCs!PcG=>
zT<0gDS%j+LIzl<Za<{A25Bl+gym?c-e-ry&`^>N)%$c~%I*5HZtB--`Ku~4jl+0Nv
zRykDt>g?6u|NZRpVzXJl`@<i*kGFpRknivO?mou4-}VkyL9Bv6)m)s2ID=T3Mcm6}
zUHY8b)JI`RfTK(35Z<@>yLH>f+F~?jXHt@psLwPN3{Hc{`4emJ!G41gI5YTzy@cG1
zqGxl<mXh@#6V;$xvUDO*&Atr23_jQPbkY9o<?^d9X0xUh*$QVN6Dkt!agEH_$5ED)
zDHg^4+&V;^JC9yM-Y19SfU(4+XfW?3t2AUSGf9!D3%Q^;!Zc8b?2$Z>E1&~qoEd?*
zW<8&4pXtrRCe{n8BwJeV*0=B9XdNKj%<Idi*XI81AAbL^UOzcKLr|DOKqa=wM<l-t
zGPOPNetg{zkXkwD><{Pm{r>YX%3(fcyM3w{#X&1I>G_}NO?d=*^0A*ns6ck941EYr
zA|gs)H$pY9m#3#OHV^mPwoAF&R@}`ZEo%FluTEb+t?Mee^%9J@XyHcn6VZSo<bD4-
z+IjDDat?`TI84|_Zrl)z3GCIb_zTtl-|B$>$>+geEe`&l^_hR{20$dtLA8o7^PTr1
z99bUPc2U*MY!2VHsb9p#gdi*$^DeP!3}Pv<xg-x1RAUO9+?A*fn#^`x>UP~j44Z9x
zwXC(6`J1}!d+WQ(vktjYJ|^nP#6ZqW5=bg=WfTmSk^+HsI1Z}FY)-QVrzdiG5uaV@
z^|hQ`%KTKSIcY_ztW=Rv?$K=)w;yM3zTbTNoxOdFcOUrfUd$C^sVVe-FK#ArcOuVb
z1V)t1oCG@+TdwHoQ@XyKGhY7ei*$RpdHeR`H{ag<;oE$38?(pk+V`@tMrskW+!3>K
zQ34GS>#UM3Jv=--IXz+3-m&X#3x3zyx2?6ac~&tQYEBt9jA*w>sPEAnnfJ(tiG6jH
z`O~P8D*3#l-ycAi`rNlHs6t?Ox1=JKYVf>NoK>{cZW*^f|6=j=%W7V)>)<LaqbDbZ
zkSp;>{ux>Rf+0qS4@wo`gG;RxKR?|1sL*AY4<8+WGY*+(|Nk*=levtfQ6g+Ll1B0j
zm=8}Tl1QAgFRLY;#<tzuZ*JzZ)2n$+ZQATM@87&O!jo_ns_N?cnt?z5_P43;MJNU}
zv2qjTal2b2SUh0;aG)IUp_zew(gNggo?#qBr3dxT<S@Ti>hs}4Qv>mF_n(w|ezYbS
z7~7@#m)vO)5oNF^c&O^L%k!#kx*lD&Y$gmLtF(Q2C11U0o}7}<4(OSo;zX{a>Wq)U
zrvs#d_jDgTo=pwoyCXXEK^l7y5{(j|pA4Y?uX3yS)1N>5=wB~0D^pa-Q9IL)5FG9Z
zDKF;BSk2zQesg}gtZLczT~2*HpY@(oN@0-s37DN|7Q!|qF;kVMuDYB|D5dUU+hTdH
zB47uwYg>lZLEMZ6cG$rT>e$B?2^)!-IszzxJX_9LW8|u;7E4_$>L-`8>#O?uiCmoe
z$%)OExmqC9#DPVXNy!vB;6yLZtLv-9i<kX3-|v3=hyHhekPq*o?U-_bdva++!|~sF
z7*x0sD1=Pb<(^VccXza$@yRMaxd^ALczHJa@{1?`!`=OV`G5R3zqh+}bdqfF1VBMf
z5S5aut|6L1gp9mTT@{r@`iwT?F8hZzf8=QOENLJa(d>LQ<oV2zadHEgsI-TpG-Q17
z7TFy@aDxG!En7-}tB{P-J%$IuJkUu+tB@CA_vQ2I<&~bV^1SZd+NfSdVjc$jg9)J&
zO7SrOj0P~%=s@5Dy>5ap#z>aj3n0NDA4gUDiPErS7^77R1_@l?a|%@ofxTj6Mjp}!
z;O>?x2|~R~b<Xcv+yDR|07*naRJDw|_iN{Bu?#-1yiIrax9^2Gh{iCh>Z|MPx~gCQ
z{ttcIX(cQyqUGv(kmoxOiqvuy81}y<mZ<c*vCWYj3nG2rwMRtKk$Q_JOXYz-bfEpy
zq_t0VMH30wV*@e<x1bN5$k|yiTh7j&oYjl@u1yaQZQpeSi((a}ixc{fzgV2idq!gF
zh_VizMI2S>{V|`W*`mjinu9QQbbn8_71&Svuoo!tPrs)BRUb+CDLkrT4T~XIbo0D(
z7vVPB%&F2CH9oYh7kWhQYZWolY^ouO7;|TyQex3cwFWvM0V)(%^Gc;l$pB^*hEvXF
zp^i}nZHr_>y~oj@696-@gR)V|N>phea7R*~UDVHC&aSS**~R?gNjyKJ(`8=HQe9hB
zd8kMOlZL_58HgisE%SL;o`ltTwR{rh7rW*(|N58V?f0_I<mph4cv@H;FajwBb&uKQ
z?&kg<|8aNwv3~h{@#+~jRa{hYR?X*4_2%h^*Khp8M<HiVY_<nB47&{~W;a;QIj0~T
zrOZ9J2fusRer!`;H6E(WLLyR>l?Md$;|0JJJbC;oVqzI&Hw-xx8E40MPPUwSA*d*m
zky&6;<p7IJt42?vpT_R$jDPmDzC58>Y@>EWoiM8e5&_^SKH-V2hcVgV?_+TGV9gR@
zFzh(7&$ih+mx>)||Neo^NuxV(zjQ_c*Ry~H5=bM5ET|lr;lsab=0PFIE_71qc|*5p
zo%^twExJfun>KehA5=mJd~vay&!1eze%F0?`zEC}u!@SZ4Ci=EVD~<BCgT0TgK<Q+
z9x`kmZ+Zvg!(jx(k3l~Blm5OR;8W5kPaSlJtuoUXyf94V_m^rVR<4)v^vTKT#p$m1
z&33z9uf6vQiK)9d!_R-#JiC%vwIy#wocBuC@evF#yF(P&W47IAeN%@eF#Zhia~~c0
z6R!UFD?XB+NCO}d4k}d)JM+#xf(6)Y+J%NE%jNCOO`27wv!<e1w#<%(0z11%c1q+h
zcW?~ags{tLm(#4St2$Ib?sAuM))0dTOVkkRiiIt;WP_wk4uMJJ<qqY=tVC{3s^RQJ
zpFhRRXW`|`=GpV=@;aPd=yH{3Giz$Af(JoRlm+Fm^AzF|<ppNa01Y#Z%cfp(UAN?%
zdTO`ary`RcJUjbH5K!5{x+Nhr<b3zx=KuOX^6Bd2Kl~l-{;s+@*TqaiMSUNXMB(Te
zAnHRDA+iCcje_qnB39k)c5S<Ds-R50S%!8buOA+6Gs$e$vgF|aISl{zA%(}XpT|95
z`aA_QhNwL%!<u1A10&C{3^xHpSeW6)W~x*xYT-qsW#!A5u1@Uh7mKGCx|;V<cS3y#
zD2sF9I2lji6A2&&I^S5*_ea$|FL|E_Nr(OLD5~Vi`zJGWIhfiA!Vq||2P=zGi0qj?
zvKu?#M5@eykk{fl;CdBl-GA)vN%^#Di~>6AZg1W=2{>?=HO=+Y7ozdQ`#1e=%|TSl
zNt#e1cFLZkKrs)aeT<r+@)!%c;t?%^$8|BLn_!-}!X_pG@I>u7bne67+BX(1{%St9
z6zq4l4i+I%fnv65o;*D}IbVW!z20md*12!RJxE&C{TI)}*RSg3tgEzB&QeV07-`RY
z?hlSOz~IN-3pkD>KKjUX_`}ng5FTG5eyD@^zsUmN-y;m}&)5P~IH<%JdPnOPL+G=`
zghf?L6%&v^O^gm#Q4uyPaY_iR^H~M+9<GEsNCnK7OA$`Hw#)f;vzalkBnA@I2vD0-
zpHt0<!iDw1#D?*1I4bN&gD=F+&f<%g^Phh`|N3Xm^>sKo!+e$MS*jb4mB+|YMWk4p
zm_%3<Dn&3TWQ;P*2|>b2IdCPJ({^|F9`_%l-?BU4MW}-@#8EkjR$0-L^+?%z?U@L&
z#{F-8`LMpZ_?xfJzxuLSEd2K2{`+t3{#KB3&OzLZ>{&#J9j+=alHj4Lx{dXHcXoEl
z@RY5C>=^Ibb`zUW&5X$1*#|(wpE&rJD*-;cM;uG74%$WdNQ-b#1~S~psnW{b;8}^3
z5IoJ4PU>*d@Iw33S@-NRzI;AgExV@9F@g*7U&-0rKpI(O&+oxuu7g1qvR~=)RP*x4
zBqft~@fa3NI7Ez(zvIbZp*%4JBtu95DU)(g_P`zn-A;_`MlcWJ^E!yC5vBX>&Bj-k
z&qSjWK6ZU~ck`BooG!1f=kvw$S6{@c{^Rfd2@YpwQ5i}#2tJ&N_wfb1k6Af9KK4<T
zGYR~9ROSyte*W|@{0JjAr8iA76UH@3QDO1{pv@@5%%XEs4YP25eR=)-k_CVG<2Uc$
z-R0IQL7=p#x}U$)uV2RV6R%@Z%1Y2tv|kQDj|DK8KIpxgb3%DNMnp^$35R_M_J@R@
z;IIFF5YT6BW&ixX@{?%*#TFnEgSxvpcFBYg9Ne|b<!Zg%+;4Zw)6=1nz{wFqaC398
zdtk0udP0CJDEF;_tm`G^*LSz8#q1=`gF--7EXAs+HvuUK4iR#51B6vrGpJ|YF6Qa-
z$;q=9s~0a%U%ZIdS6HpmY)-L(Rs{{rA*g7vmX@JxIT{j#SilT+-!sWobY98DD!#bt
zo?qeZYuP?fyDfmBeIyn+1MD8G4t?z#?t94^DLW{&e4Eg1-ftiH_U`=ZnhpK;-}C*g
zcy=Tg%8W8`7uJ-LN@SIst*X?RoOw2zfjF73bN|8e#=H-d3(El>n1v6gqa%$!e}4Fb
zkypb^g%~<s;2l&#(z01L&j2w?iN0ayz%&cGh*(8i1zSctt@@umtG{?&E$Xh)K1kNW
zZD%@cWeYl!_n?_!Y~cHYJQ0twpE1Pp5dxEsPWt2Z!D#>h?IUsb6m1@#rA|Xc3>2zF
zk>RRFn&F0Q#f2?Y%utkss0nhm2u{SCyjkDGxVVf}6#dxR?)K)5Q%d&a^7`!T{OPk-
z%VzcV^>;TPKW6f#sU#4yyJvFaVy-@9E*I+5kd!XWh1*w@lY2tP<hpb4g7F^PJnBAK
zh*>5T5;O{LCN{u53GnFn%m?B!Wph<>rN!y;<*Vmc*Ow{xZ{NJR`LOlYf?J?85ACya
z{Njt|`IXM97S^+v=(wWT7xC#m;P|wTNv7wccmo`g05E+gfJezS1pIYDaR16O{m*%5
zf8o>qiH;Y3I?b;H;{}C>07q|Gh15ZwFY49Yy?a=1cI{G>C776mKq5+{<UYjnQu$8_
z?QWOMJ-b-G%lSU1CqNArmgLl0qMT1-E!mLE>q;<K)}2|ciuwG^pFgc%zMMUOwYqvb
zJHNnknW`Ewl1A1bETYOP<pm)lW1NQEyP`MS=TO1Rk3mH0T25Db^~5jE>D^n}ZiXA|
z5HMfVNkSAIaf?*_kN?y8%S-PzH{XA=e)|S(8{EC??(WvOcw1FX{{Btuy2#`9(rMgv
zxx?X>Gm_b+-NDnWse@`VPb^!@uOBuW^Q4p=#2kc`Ne3t%??*u6>kN~D?4h8D2oArD
zn1$8h@SHtSPG-GZh7+?2iDwUG@dGRZT`#MJrV8s5#aGXkudc$$JO|yXnuu|+Lh(p*
z7b0=+IAo%+`3^aiBd8i9!jkFn#CUiucq!?Jm&Qa!&PTh&!}xmy!xaYwv646tSR-p>
zGgcFGaT5X{P69?&mRStvGX==*Z;_3g6^BM=@uu_j?ajOFW(3I9#pUJYQzi-3?B?df
zrrpkFl@#@n2;e>>6*Ga|i-Ldy%V^sGF^ZyKAbF2Jx_!3$(8tF%c_`u|;^UB+srwbs
zD6~EN&`awnf00219|ZfX>Vl`wo__J=mzS4McJ1!{hYxSQzwOq2a0H}A+oxy#AHQB)
zU&t&bp<c*^kD3#W(e?ZCeLSn5Y<iE!ftdQi9{DClHNcdj0sLgI13$z}>8I2Hh)Vdo
zD?Dh5o?smin3H2s&Em`-Zf=^>v!LoBxLJAjsR)6MibE61T!14;UUYdK(_P>Gf8@RC
zdL+k@C2Gga-6L|tS{oOUt(mXy+*g=4nfJb5&z<R>?v`2-_o~90ON6`G{4n>(NK}<b
ziK0ZRA$(K;RY(At5$0yc&T@a)uVq1CRod>yyx%{6aW030je9T?fknuu6ta}cvuk|z
z$>LX^$|s-5^^3H*q{VtniC8EwizBq`Jc1(;zAnPx9eiaZni8qi1AstKNaz>w;$pZw
z*RG$-Gn>7lml(Dva=E_vZ~u7x|NKL-LB9SheDiwy?d!u=U&zDb<IRJ<-7W~cKLlnb
zRTG$LgOc3QVk{-Yh;jdTM|oJpF01Bj1Iv!`S9f<?qXJS>$NU*pSkzknwj6{`%sXy-
z6JMA&{J^V(!X-SKwG3JY_a^c_m5G>CwS*uG!2*01%O>bq)O9G&FXFGR<K?P^@F3wJ
zf+|G@qxmx%3{X2NR;voinjuXsc`!V6i+r!XMxUGwN9$t$c1O00d3gmB8yS=Glu%(N
zCJ~{qDyt%!scMresL>c;%M=J=8eeZ8ANEE)#eOX;w9WSqcW=RY$U^+$`q{<hRkv7l
z%l^CXzTWNbiE;`Y13SP-sxGx=0yDSC#CHHjFlDzAa@xGwEEUqL=(O0G%tx!OhriHA
z|K&PWRKt{`{esq0zsa=J-6~WK)^+{n;__FYefIL@t6b=-FaPk>AHEwNM`VpOE@XIq
zuD|{`efBb)Ek@X$N{$K69K}qaHWRANPk|@L^=b8=e`qwjvs!q3y^_5@`o(5Jo}O4g
zW}^^(R==001q5ML(V)5LUM&I-yWL{3UN6_<!{cGh)Ws6Rq2%DCd=P+OBxXX0K;jT+
z9M#OA;DPP!?(t^1c(&*xF%g$Shin`oaw$NmqoI&+=@LDE!N2;X|NK|+lTXsK=Vg6i
zX*q^YIEYL|-&*KNJG)TRGRW1L6ZNc3*%O<CO*o`*w#jFk()VC-vt^#V@|g&#7%ipe
zpMJEsxS-2Rx!An;{Iln~!`)Zk{Kx<IPut)8o?pMkVF*Q2<T4E7ScF(0raF|-Sfvl<
zeIiT0>_#mGqnQn3-YahzcWPg6_lL9uGZ6_$SU^T<M#b%#kI7yW8qC#}vZ$J><JG7`
z1CfBVP#KXkl>t;h#KOw3Vpd8q3$O&+q;TG)B_8AWu<6Fnp7kF;U#z=*;%y3hiOS-+
zFyix>Tg%np%~~zkj%&*rI9>&4jaW4cP@MQeIBtuN{jQzRX`cRri7I3aHn01Dh^i6_
zD8K@1L{Kh;a>=TC>{hifC<%*%C<~DT-97I1L@`k4w1@4+?fu&~`yEQLaeVgT#d@<|
zo-NKV*Z=Z={`bSftrdlY7$iz6!>BpKxC=>GoZMz=%wjOL!f5VrP4-|$%ye{Zo!aeV
z6|FU$nTx6^w3@Ifl@{^?hHx&qlmg}yB7w#{4tX@SAdDa}hV#p-|MFk|%hmO>?c?E}
z|M_2EfBTw-9LNIMf`^YT?bo05pMMlqX;_3TmDKBbzwg>N(34d~Gp92=b+c}SpLRx7
zI-lQ@Ht88LGZLK$RQM~D>A&Rze)tRJfBe6{`k9?>Q@(f`GSw`XNZfPiQW}OqK_)29
zG;Y>o2F{>D=1vAVs~Q=&fD1^iEMvOt`@|sFQ1ZAxoGp5&X;CX=MulbUm*x4(@DHE!
zKYWIdKe6j)x;odiAWq=m2Y~0rGgo+|4c|>1Nyjym`ZZm3?8h0IOi>0oY{%E%<uAYF
z+Z*w?7V@#eHT^nJ-iwXP6fVxv*_sv$gvfoL&d$$XzIyiTMGvtzH~O&atV-UQShQWx
z!W=>|GGP-bW<s!B1QPq@*7)0@{O11gf8E~im#dtTTL1-SGGk0B@N<%nHM@%1_SKY`
z>go<NE2Wfiv^-cIsf^^=22diUQb-G1iB{GT*PC?F(~@^<*?n?}Up-4N&Uw>~XUnl$
zjFLu)B#~Jd%v5`AtA?I9>Q(Er--`G#^Y1;PwK?ExvpXMCa_q!pZ2!D180`t81g-U*
z(}UdI1FBS1r??v!JmZBy3^386?-qSG4*Tu)KtSK6MW3u>9fx5UcKiL956e~8_i?f4
zuC6a7%6`Aw?zZDFFc3H-Nl}7_s6#2R1P;RN!ATJ2I;OI}I?NCe5pibG^pfE?=S_!t
zaYHI$W^t|-z+ho;jU)C)R-#h0XfZNkCZgqP`N^lB{^LLX<Fl*lhlhuM|F_@XzP=f^
zThXzjae>{-P5y8Hu=w@I-NmX1_5nGHg#h24aeIk9tg+b((ky%EILXZ|?`9U*n7l5m
zWqY=0<7W5eyA$dT<Js;Z?cSEMJ&@{O#}4|Bb?bjT1?&Sw{6`Xs0{!gDKQTd=qliWu
z)ec%h<okSxkh6ZV8xDhxA|hQ!WAQ|GQ)gx~tBPqd?pQ{yaqXFCJC1jU!`)#>M1AC5
zx-9YbZhO91#Mqa-SIF2c$CoedvtQ|FpW?*}J-^KTMnexIATs&Q1D@z5?n6dqo*-pt
z13>d4oQjFHAUXpP71N^1L<J}SACpzIQTmjknUuqLDBsHAf2B8%5Aw;!FMj=bT(6jE
zwdm;6SN!_5{aaUVNXM~^gVszbW)UGVDq|@HNUN1HZf@SB5WA2B(L&m*eY4;F{{CSv
zG73ryHLxn*oyL(l2mDwvo$t=a6e)8@yqvR@%&NiJk{~0~QdBcaiA;UKGGLu-8TKob
zv$TJ{){idb*#?_MS)?Hal~61YOS{Q=rpTH}d)k6?O8l#f=Q)CWv^0Jf)IWO09BCwN
z^?Mu(Tw?6I88p8@REJYfqcIhN8pJr5C<Udc#6+55xmrg+jjWJSWMzUS*7G2b<IQ+?
zAYG?rT8I0C-VKlYo8fidk{vFtF3vB{&NrLB`|R?3^ZL8*ZeG9MKR&A1GW8(@Fj+C5
zMa`&aAs92;jHhc>7Y2UqlD=DDj&?pC!Caetk7`jf)w)Dx4j?rvsvh4t<}sHnA)KFG
zJbQNi>Z2FWo?WF7Zf<V>@Vno?{_+ntQct<(yo%%1D*yVU@X0kU7CFkm$Z+~wfU!9^
zIBUn}l+B~iZ7%u62@SZtR(6z(RZ87^R>!Ba!_N?@|7&4WKf43KFGyw*;h<8YX4Oo1
zC^?iNA#oS;P_k)cF=hc7OtTumZrENdfI9GjZLe-gM#b!57;bjE1rWLGB$c?he|T8-
z%ao#yMZ4wj{6+rkbA0~U`0Aydoom0+upsn|1caK0!hX*;UZJxjs+)u!H90nAVAWNy
zQx4c+WG$BSa2SR$XM%)i#g`A0e#ulyNouNP`}Y2yZnyvQpW>&V+kgM>tLGQpx?gTq
zq%@9u9S=fEWhBi$V`S14n2bu%LZ%@iMgepzrsyQHq`mQj={LLKi-%oF-3ZE1g*wE}
z5C)Mp6SNZ{Sbd4O-b-3-EZUn#A~W0|+u*#?Ql#VnT?jTEZz3(j*kiv*!}AS4zlfKs
zvP#+~?Rq2024$&)Dmse#8(-6G23$;>$jKGVW@kWUl~~&bzwaKK0#+K}V>6oLyzJB@
z98V|#gOmwk)on`5g0fO*Wa8|WW@;W|4Zw=2W@gngM##moi?It2hqt@$MqBrbi!Mom
z-R1GHyZ!QCUf*3_zWC(hXRlsu&d**xe}2B+++RNX?%Ox_H@AnwA&;6w0*g21rV0V$
zNDV!*=5^}vn^&A2^<bFMdcg)j8*OdUdLIWMz)VZdqZZ!^ELWS0%j=I`y?Xib`T6+@
zus5$?|NFoF>+7$+Kq*1<I$$aJa+yDU&YwN!^L_}FBV}P_AtEb^kbKE+)zfw6@p+68
zqNi*hIyHjE30`-c#3u%k8J%2GHb?n>egx3J%G=Kn0-EX6E0AJYtAz~AqOdS)E{DT`
z$eat5%@m|YMXjikQ8A24qfurW*$fmxJ!Bc;QbNzdM)%uYzgnc!<<RHr=i_Iem(M=a
zSFiH<W$xD&mk2#`5)RA^0R?iedJ=$rWId*3H(J?b!EDut&><iXnb9Izq>R|__OD;>
zzxrBlZiRp@QA$oK1w$EI=q?30JIf?PE=I6n`0jVVyMO(yL|Jr6fBT!)|NsBI|Bv5<
zaSUV<7{Y3%xwKi{NMr<$pi+vcQYldqg>+Z!i~ab2Zti}w+Yig-o@HdVYEsI=0jSJQ
zFy^tn74}dEw6ti>dCcROb1tex<YEp1NQ;_k$)qKaEd;BG^A6`p&tpE5-Lu8;>YQGj
z<8qZ3Y3x((lKW^VC*?>81Yt<CB=Ym1tzjoI+FU(d_vdpk@ko8Q)58D68o3_gjqhZ$
zAhnrKrd4L-lr3&%$8TsS4@X93s>Ng3z%>#<2_|gJ2C^XNq6C2s`?B99;V1$k9S4Sv
z``yjW+uNI4GU`&lUY}i@U!85vQ%J*DcDrF1M>8Wfg&Itvu&}m-_qLX)y}W~#GZBFQ
zCG!!@^t?+_FYZ=7VW$bn%yQ19C;<{ezg%5iKmYiXPe1+i)0eMaZO+ejyZyia=HLJ2
zU;g?2?Q6=1MC0WG7u|TZ96r9H&tAyYx+ER~k10@Kl?Y-}($Kllk%`bTQ`A{q4fz48
zbvNkL(rC64o@9J8f<QgBD}SJFfJLnv#<T5x+P%%X`w1YR_ZD>fbN|_onHB!%(eksL
z02-%61i@H?3`GwGFy(SE4J!#j;(oi$FsI=chN=P_SqcgnMQC7;iiL+&95mk^c8`n2
zm<xy_LP}{+-ASbDXXD48<WD}y&tK@~oVuk*AGi}FhA`OR)O@PJAV;o3<JdK-_=(nV
zMn{+_R10Yy^Z0PsA4I~-7vb3@Td`rl{$SgEdEA!W_Mqco(aG6n-w(Opan2p{$_D%T
z4>!BJ;h+C^e7HY+_idLCfn|RfvXMwkAq5gr0#V|aB^c<tn|o1vwO$Q}qQxlSQ0&Xw
z+pq2(c7y}bNR&<8H^LMGLA?o$)U>87s@HydqN5~YfQ79=L1m<@*>YwwA&M-EfMuXn
zuuaTop`53Dwa|+dov-w4X^Y++G>n582ktsf0vWi$0tN$55U|-(0*HG-HP)b=nw&kw
zd}!uqM<<Q{tj;y-;T8u81z<i*w#Z9ZUD}uc?xE=!hNSK)WgcEvtmGD*1u&CY;mE>-
zJlZ%eIEH0h#r|=t_v54Ku;e~1yIt1Daoi8(a6`Wx#y8*HTwFanJHI?zpMU)EuU@|V
zc(>iYdGqbtH{U%x+>YbHpu$KYMhVU7q7e%SVDXY#tXM0J)4pvYMEVK}6g&rqh*Zls
z=2ASC0uWBATdg;jmsihTytul$N?mst4{zVz{PuUhy}7-)d;4bpc$aMGxvXQpTH*QH
zo^SB-0+(xLI`pD3kg9Srg0heV%32I0O!HUIFrNVEm|~1~0vzW#(5G166R&4G#>Lb8
z?EV?yKlUdS@juo2?H6+ZP!+atU{jG2ZBW};#+a#;2rN=quGX(_--_l=xR9Bt06`Fy
zO(~Fx+dP0sp}?V(yTf5u%22dWVbF55D*bYIc`YA*GJf>&`0RP!oLgG5^pIqb)<ZbG
z)QlS{VNMTh)&nPl=gdK+0Y%kMn7Jwyptk5&&z^Ou3%?#COvpHA97gO8_PFEQoBr-5
zEEbE;Kfhcr?Dp;OyWecT{aS{D9(MNjTl@O=<2Z(_ftX<sR^Mfpu~TLx0~ggX=XAE#
z{b78(PwTZBX|W;e-B`Z3z5jZ<-FMv~7Y(9TOx0jkbW|-MBE`&W7foo?Hp5m|=Qi`v
zS2Hc86xJL`7g3g7Tt@DgdX$yqs}9%8c)8?FqE*~4yRwLu0)Ytu(t$fsf7Zc<GCg~Z
ziPV;VGgq*7xhUqGzb2_WvOkTEiGe3*&%0o-Rc>fY0;t;7<FV(9DpWZblM1mlKR>HU
zmmZD6MuYEF%>#d7S`%y{6CwpI$)uOCmUx!=Hsdyr4{8y#>_g_bEqZ(V`t{wz{hOQ3
z`PJFQ)!EtkW^;D7IXgSseDc|+`(gXAy?=Z2`tIiK{^8-U-;)`@!XiOLWFpe~rk7_a
zZ;j0B@STlC%}llUhyDS8zFVv|o6XtT<<-@*=g%)LFH`Ea+sB88hc`EG?;h^oy!r0-
z=IvqkC_1j#deQ5(ygUn6%Y4?2mkV7b3$VZ?1rnhGGa_cAP&ZEOMAoO`<o6-=_MwV7
z&$4{yFAWpzlL=(3MyeqDY0Y+i=5Iga0{{ePvWTfkE}DyOi?Z6H<OJ^e)aCUqXQR@G
zRLX&2fMuSV9}+VrV`HK)s_n?`4#UuwBCN2mIU6po^2?9n%a4Yu>#{l1Zb2bIqOlmG
zFp)D)#FM(rWAG-^;h7E*EsWeI@`;x$AF!FhOo1)JqKU-Nr(`cYKG-Xm@=$OXXt&eb
z+j#p{LH(;&VZG$x#qjF-{>``f_3QDQZ|u!me%$KKEp({y3E;?7%uI7u5@IDDjK)Ht
zbfP(!^-8(W9(c(5&36Cwes@DO5Dj^>5z1yvAcn$7w3-TgOd;3e!62TRCK$15sjL_B
zXiQ_%L}e9qBi2do0{XxU(RC<ion0>IVu5u}%Rou2i<%;ZKokrBh(LG00TL0SDyy-Q
zG*in~7XW*b-#8-)+No*4tXSJSRG{}aTgOMh(J}zlWMNXi9qkWX=K%)PO{it^EjBbg
zV1<IzEnd~~jB%=k36X_Oiwy=^q_{{}D3-ar*=~0uXI_@TOSTpGVH~&jZ*K4J-+uAM
z>f-v@i<j3go^Q@Ki`8;{zPhlh>zB`m{eE}<xV^m}4u{=#x8Lu^@o*RiYvN`w354sD
z31&~TH&sUrNsWs8WD2LQ?-$F}dbwV2F3!)-&Ni#{s$cY7*Rh1dFuuLJ`R#9i^VOGM
z>~@b#7GP@|SDZHqt5}|`!}BvfUr--(k#ZCTSqOj-F@#-CZN#J?k!F30;{<?Hj{h<K
zYqpJn?gIb-AOJ~3K~(ZR0rre&E)<v~VTQQ_HvE}TP!TO;`nRk8Kk!R_8vf7E{Qx)?
zapoWtqZQRrb%5<kN#mjCcz$;Nhu3fNFq~g3hcQF5Q6Z>t^(YZlRtk_ztb|PE^~3#c
zvmQgz7|P}K_|eDu@*};v&g+eN_2=MaPMHc9b4Hr~m%vsD3yqCD#RuAyk-`l+cW_mN
zg~9$`Hh~FgOeWoufWlN@>du`-Wylx~cKsN(_qyK^Ss4$uT*QmdFF$!UzIn6#^4b1(
zUzFeezB~+2rBWQ&6p*+DgJuPfkjz5Nw{O15_jgxu9gB*ZBHR`GkK4O@Fs)W5B19z@
z5i_y?M1oKO2bKU4|LKWQ$ckFl+RcJI$z8=v$b=NCOqzsOk*|`S%b08*sB~s4!TBPb
zFXOsHA9AF9M2UeyVo4^6I1)u7DTE;i5Zvs+Xwuoy#P(@L-)3mQ1OPQY(98y&j@A`;
z(ns29)>ZQng4W!X7A#!ZTdvjMO8lypay}UOKN3Hr8gijTYEWaPU??yp)zXd-bpnsF
z5}a{Q8Q>5?7kJ5fzaO^4en0k0S&rRe6XbrNhhaDr9p8TU#pC_A-+ZyUI6uF>I={X=
zyF5F;xLS0Hav2_Xhu!Y+ar^N2@c8(++wBg+K97THAuFV6TFfe<$pDO_NazBGh!{C_
zsb4JmZnapfSF6=}xmvH5%Vpnn5ZNB~U%meB55NEYAHMwk?b|owekWv6I0^O07Z@&O
zJWsY+(pjH3f)$r8lrC5d6e1v1mcRlI^;vb*#{8A4RJz%#JhyPeET{g&=&fRaXbOBc
z@n}o$W}hv}q!1M=umUUkw`u%;YTy6AhXa6!K*CUSR%ke=?sV*!V<FYN4y#4q?{Dwk
z-rX%@07C~g)h>0TmS_}+B9KTjSte7nLn(K|us&OdtLyRQN9EPWc70ve8|s$uE3_K<
zm{)(_N-?n$c*qDOsFkPCQFG#MDlFhizZMo|5fSkbz#~?SU`kfB>c|SHuxEL|*o+H@
zj=P>WYaDjEeYE>~y?<1UCOJO4xOjHGJHLGU<#$ZN6vaSPYKEEn+rz`lg<}`G?)BY0
zl_AEwyT4=Z3gmVezk1vai$#i^A&`+m3#+jTStNt85el)9jU{VV^%Tw7C96fDDnyad
zF?FyQEDHKa>u5_IR{C(!<7^pMy(F>3CCRQMjZ`8^3<$v_fCVH(qF{p<aUnk9YU&}g
zb8evD(XIEN8wEGx7gQ<hWLa}U9kdVMk5l8{G6?<qyZw&M@=$Pe!~u*T?h8Z)2*?<u
zFhV4DuB_5gWsu3Tk~T@MnQNTQikUH?l(8f3yLg`Z-AH$Pz1=-*4|}2*(5?DzTl6vS
zxBK0GxI1ib?ry&O`m5z)vs!P~>-G9_b9TPotk2FaudhX<s1D<J*zXR*p_IY2SQ#~!
zQpPf7D}{-Z#4dJS>OxGMy0}~}*PFiY0z-2ihGBQuee?ReySuyl`-hvm+q?VQ-S+;l
zf8;Xuq=_j3J+S6-o%A}{CYE(i%cRRdNi?uB6eoH~Oij5}ca4)3kC$pXodEEJA37@%
zHfb!I3E<Jn^@#ycZU4n>8cQ)N#h$JdeohO3pBPs9Sswt?HaIX@V6&iVL(%PM!bHRv
z_UD@on7{k>+mD}Jg<@dt2tzK3tS9WjnK*-U>nKK|w?vEO+3Lkd`uvq$Ueo%FQZFG2
zhnA(GzI4)dU78sw&+Nn4gKgb(tuj{yfjNW_TyZ0CB@I_GjjKpWtAL<hn7)W&uRUyq
z#2^|1Vn?Z`v_x3g&6{%ft?3<*!&vn7H;4PXxF6zJpr*_|4J#2b6$m(Fu#u3VC?)9-
z!Y*g(`>pEjFuXk+wh{)h5#|e$LNG%nD(b%%J7j9`M%cp%JVM8qEWtXVj?o7!7`<p>
z>V%S@7h6j?4{6hdWiLrgkl9Ma7{yXTiX0+^KoW=pSPa4tg&QZxtTfOuL(*M>C+o*|
zs{iy!d+H&H*@MlM!0*`)*H4(e=LS4}mu8#bY)}xX)@6Xti0W{^fdi3}Da441mqAm4
zWt*@=G#h7AG%YfyP;gU|K5QcI3LeMuFl-;n&~aM#vNL`x<HKRU-{0<U!(-pyEta8M
zY&Pd-XXnf1a<yJ97R#7A5s}nymdhAJ457va)XSXMTuDb%tQ5_rN_H3z54*?1ez)6h
zw~yP$-Q&ak{oUQ|<HOzk-HqiT3M~Q_LJOf4+cMBP$U503(JIn1(4w<0S_~9KMNEX)
z-<cpp()#>b`sXS0@2m1puz#Bmb0_4kqdyeQd_ku#m_B1L<)Wmc{@4lNr*8lM62ZT}
z-~+%(Cd3qpDYzwx4mv&%F<|4+r_?PHR_Q(;&O#Rwm%||zEvg-;hh*Y`D1($yh;!`j
zHy3x;&-mF3TwKy(h1jt~_7qtcZo>W8CO;`|Mn0s+cp@b$MoLCt7Dg0_Axa2ME{qw)
zj%unbU<@M^uBU)&iM*^Sk+Lb6Oo-JuFn25+kx&`)?PI>Xv#-D2{qw)t{aZflF&0$v
z_T&riKYbwPTxkEeXSEbN3L%3t=yuq>**+ZdVHn~_7*RY-ON$vR%*qr@%uH3fW`GK*
zpaeG0zgk4}OdVUt)<Ju*WuQeuAGs4+1zE+eV+!mj*C?E0uoNjpimm$l1ONd<E7{7G
zvaC;(y7VL!WGd-TJ~`i6*KxuBy1HY2xbL#}wqeaI6LVVWWJd3qx9->P3t|5xyM2cH
zQUxLfDJbepW@eh_6P0%d{(K8apv0sA2d1T9X;=nZhP)n!osN6Np29+~4zyS7R1b$d
z?zacxyRX0cBBr=lEmy1Ma<g2m`o*GO^!}bw3c?{sa5F3CM;d7<<2WAn!(luO<6*bk
z-rwKd-`zgm-|u$YJdRcrj`9b@5F(X@*gD!-pmo41&?@L6SPCVC5`#)G310L~f=Q$h
zDFnE@gX$SDna$cfNc2ynK)!1jT@Q7e_5L;s{4fvuFxEnrk12pZ)3^WR6Tox^fSr~n
zs&QNNK)O>Brn~(^m%{b4i?6@<x<5-X1UihJpp+7g77|9oP*X@qV@H>l`Q@v_vlqkp
zB`;TqiCKt6*$<i;`^QGC&0@EDP#KY`TaFtYd7;b#jzMCGAvF7hW)C;TQ8igQa}7eS
zS`;|&;{vJ*Eg2b`s)7r%B*^(WA&<Jtw}04w_qKffbs7ick+f7kIa(AHK^>0fkaOAJ
z-A64c1^`Hsx!gTIzPb4pG$tEH1-K}<I^b6(tGOu`%s0ZuYyygGQ78o@=ET&A^<q6+
z$0eaG#Fh!mB#T5*I0Au`$v_!4GLJD>j1(h86s!`MLv03KS5ddV+$?|@^YD@rTlXXI
z|Gl%c&smdyjNzSFfa#H+>hRx{jM|B>SbhAe^_x7CiJ7E@4c9@k@`BI|Y*eSYhK|H_
zoB8v&*B(sOvKn=S5P6w+G<i7WhjG{y>?xM6A1LlKZ4db{>cM#6FpOm!_P4ihZb`tx
zL0AGuU*|}uZ^9yIPN}7ooO2#VEu-pKbR;dL3bSCAOnuFh7^^;YOo?nEwuyEYX(iqV
zl!)xcD-tXS1tAgmNgzTjfYZICDSr95t;cLmJAr$?zbeiTQJTct$4nT5ne&<JNb8CS
z^P~=?zuXr1uUGy5f`RhCj01ospE!~(QBmFNxYg2!__*Imm)4v0{oVcB+Z*dQ=iNg0
zyFk>DWRuQpuNqAUVcu-g#~-CvAK~h1TrMSb5&}f5ZSNGy1en5@)pe1z6nQKwS$1n@
zHWMJQ1eREDDW37Ec?#yR$x#7~&q98>)L`3+Ojen|<U{Wc)uv#IiPmc#FAld~j^n_2
z#C{)4!KPxw=J%=)k@*9w(~ov)lyis>sB)%6BZmF3U3AbiCZPeMRKp91iQ&i*2`qr3
z_`$|OD6j=8Oe&;8B|?`0>rR#_^?~|eooHZ%jZ`ujfj9^=7jR+L$eIK(AVh=+4#vTa
zUtC{3RfHOH4lwXTk=a>mKiNj=`#%5P(*J|*KG%{oF6op@V%4o4M|T=#gPeFT7pp)J
zQ9A{iGEK=U+qQKK9E1^EGpv>gCXB!!h8hZCwT@R5b|c;G^TYmb(0IljEjy*OD|D~)
zsJhR(AIp%78WF^m%7r--?JFPh3EPes5C&O+mLL?E*ernhD62j#q9it^B6dj7MX+VU
zDqta+pwWu>GD}nvaq>A2Az2*-g3~9+e8R)g?`uZnw;y55aBT2frlnOWfp<4HWuUQl
zcV=P+D{ip;({|Z^!Fv6lbOJcRf`q#iOR=#GJIzTj=s1qU<;BI#_;xr9nFE6a90-9B
z&63%H5jSgl{-S^WQm(Fby%|&Q7=%>dzv^|>imFJ<xg)?B3R0N*eQe6r1T6&N5ZEoY
zj$be_t}$7JVg`B|d)%Xu`Uvi1Lvt$$5SePJX3p*)2cj5gxeDuzu2$$%3NgiE&<s<q
zGHGgId1Rn6Qnp^C5ZDTkO;ET<8ZNJqV!Bt_Lr0?Gev#GO1`VXOKq^duC4eKN3rLCk
z5W9fLB&Lxqu?1G4ER=(mK+4pVuT_Dn9-`}^E+KMEkO)ZgZWZ;$-?-_xnq%W+T{-Q3
zKZFr{2;O<p^1mCB^?gMJlN;zv+%e4}4ZoODxO|ZhGBzb*1Bn?a2Q~$3T~*34hgi*t
z_&Tv1p;}Ch0SP2vqheGl%fLv8JQfCo*oDh377JscLmtOG4$Mp7Q7A{&g_uPps39wj
zO1WrhlpDWXn45B)NLYeM3?WHiQkbG-wvt2_OiSiYD6%HD$eP3wYh(+i!AgJ%j72$+
zPk$j&j1~il&w1S9p}9eoP2Jtt(nd#H3c?2tW_#Bi^vO{TI*RbyY*yQ=x=w}>lZg_m
zLVtSv=RMW`L*LPUg5%`-RtUeO1HjLKAlw;g7gWo3KeEUnXMWgTEmyQT-`nGEJoEw+
zh9VFWAu+lb%lWxnKkKfpWxdg^&ml02YhIh~-{0Wo=k<<e_mtK`s#ZY7-KVQFsPM@J
zdrS<e=Af7W0vz+vr*ICdy}EglNrPh4sx__wg`f&EFvTve)_J|QMUNyn80lnwqei6g
za|NVDm7vrM7vV^SQH<@N+As2_uU0#b+d>0zCKOT^)3yVEozpGELMBYY#!LYef<@85
z96(a}+)7qp8J3xfs4=u|_E>9ZVleiK(2)cqRzp3UT?9m8o~KibLS^0@v470BeKXsI
z<1S$4`FsqkeCKTVqicW<HkS7E?mTV<<}L+3uuU*C!<Xw|kFyC*PBk}bo|L!*vusu-
zX_nutrI8}FHK<ciJJbdybP_snHRNC`OhqsnAAkdRBr1kdXjBxXtd!M?nEJKl(@4!Q
zLbJOg5lVq#0BaFwVstD4Dl|k;Vv0hMiAfpCq-;e<g-!g07GvM*1Oy>z5Ky~TCjJDW
zy-!dN-jQejk%8<T&d!V@I+_2?5@4p#P^&9GHi(j_q88IXd(rv>z6y-L<pl7{RRaH!
zc|QnuF=)|kDMKO2#G1#UtoojE+1}nt>?jBdq#%O3Aj4`=&d$=sWmum}-&1g4@)$cY
zHCbN$6$TGmDyC2+Emn+*z*snlIND#!{X{TpRru)taJ;c6^O;((edtv>dMg;2s<!Ab
zH7lt1EEzEnICa+d<1$JjppX`Ic9Oev35>~#nHFXVEXpj*krmL4JlH<=xDM$+GAd=`
z0w27U0ftSqdjU=F%zi`>Ss@)A*bcrzBqO-tGqwFWTC|z5z<E9rEkp_t9EezzA;Oq;
z01WVC`C>=UQ9CBUR$2$o?&+g9GpxqH*E7IAEEWCJIw!(AkWpJMR&^NDL~CSX;%Y|V
zFPU#;j3ElErvqFBT<v7trNk6u#SBVRcSMsdvyoMYHdx&(l{#IKmXaSuIU!04ppdnU
zK!y!k#;l|1s8j$ISYQJiQP!d@G{=ajT97*uM{aq=Y)Q~Z>4O9isj`*;6DBJ@F}8J)
z7)yirg(Of2#sLyY1R}(IQt>CtPjFp?@iDCO&v>2ip)T4^ZAE8<QfQR{2h}FP_$k-3
ze}47<@uSHPc!Xcz0YJn+6t)yp(_wdDvZcuV!{fzz6=Fc(Od4Wj0BV6Lgcw&#-E3^N
zLFz?f0Q}1H+fSRjbCtfc6;h+>|KgNzGi6v17O<~+3GP4O#xRrF^GOV~x}lD*e0B0t
zuEJ8KDKEgO=W3>=3aDCjlOfd>DMrMcQ#dRFuf-k;?=w}Od6<Z@5VI1gT8dpKX+I81
z1Yr{#XdIDU`4bG%cE1J%lwnd^+KPvPRBS5FsFwLH??8yjA#79lK}KqI6YXPuMZ+Ox
zpyF7XKoSsv*r*^f6$P7?@I-jW(`B;vJt-5l?$73c<CTw7?k3(3{=B#A1jy|Dn3A0Y
zNa`deoAgUw>22PXPX0tdaZzw}BLJLj=5Z0eEG}k6nNWS(zy?<D^y|6f-k;f#HW6YP
zg$mga$Y2PBNTdQ2p<alCzXs~B7bkLv$Fqb{Ltu!=1;JoH_zgBXODzxy*Ox{~LB>p6
zNn+I_L;^`9NhA@d6fb81H7~!Tvv;*u;VGP@1ynZoZM>iC^B$hp2ddoBtqP~1@YH??
zF~{kO5uvtYe_Q<LZ^Rw?<sATi#Rww?>AE<Uk~I&-KxMn%C6>i{b$55a>Z6D-3PZVz
zyjfwrMBkBc<)PI}z^%WGy^^SZr~n)Mk7{b(90lP34&Z7o*m`_zSGYAPx*NlID)3}u
z1+x=LOQn|9j?#{{p{i8;Bp@r~F~ucQDW%v5?7L{oxZK20jQ2#!Fjm7@2ol0_G42my
z#6^c(I0zz-$h$I*NtJ6g;^wzVP(X!@{Tu=tPwWY*a8_G{a$8+{yH+(@D0Q8|Uay?&
z0f<om1w$Z?1UL8$fK*p)r&zhi1lZ5hS^a)rdk364{!TQ|;||g2NFO>ijHI?m_`ci2
z-s2#4+%`{I1e<vK3{s<d$=I~R;7QabM>&BxL$rDE9Fq+|RIFK6PE~8N3X#*DwLzv=
zrYM!lO&|i15c%0l2t-PddPKKN(TQ$W(ZA;Q${sI&RBJUhJ(>j|Ad@wlIjLU)g-9Wi
zMB)GmK!jKSN};Plde?P>xNZV$e)`UL!glJ=1j2i!IGnyzcp~6<S2<u+XXd{-vLa{G
zTuA?lETA7<{eRFr@uz&3U*rMccb71y5c)2S#kQJ5kbM~hNrDh)dl;5MLI{VVw&-lV
zvem-6;J2KU9obFY+Q4qA#B8RfP`~<BtrQ{?_NYo6BeJST45rxk7Fk=r4opy;(t?i{
zs~0Ft?go{zQjY;uGBqov#oIn_#z_mADwz5eUA`(MmgNIqJmP+b?O?mX3Kb<aC}Ee?
zEQ>%@McAZ_q$8EW9?(_HP;XE7w4vgrNtL`v&78e*pDIS&>Mc)wTBE{foqwiD-ywbh
z0=y$dGza}n8WC_}e7fgaTh%%Ca@6zKoPXb-m-k)sIKl1T*%`NN03!Pyd}zX#-ghJ6
zsrcZ@58D<>MqpR7)~ym7kq{AyH4J6C6e@`1gA)65@0XO;y|SA!V}c8-0V<p})({;J
z^Eu`qdyAXN#D7YeIFj`c)ppbzGc1n1b)&9LGTRD0`ODF&f9?GvaUcoCLJ(r{tm1l@
zxWZ#9{U>G)ADY7K`}m;tLmEYzA*^)+>`UNWxD0ATravE|`HSYs{DAzgzj*ck1s?#u
zT?xc}3R=pc=)Mpcg60HS^vnC(hapSf_ZCH$%d%dLi{63=$T0IX)|P1v1v6CL3#OK4
zEo3@{>H(+eUN)@_=xF_KN6%RoSUQG&Y}}5vlxSVQP2Z2|&aXIA;}|(C1PCuzn`a+&
zp~H(uxxdHVEpBgddz;_f;C{#3vFvrX-*2~Dk&Zerl-Y`vOrwfRO{<v#z--iP?J7CW
zqv)F|UmFo~LVxU7pRE=<np#DlDQe#dM1~Lta4>{g{o7W7NE~{emVx#8!_>*wbTvET
z0-$4v$$NAFC;rejt%qk5Lo3<%0qjq+W0;#wDKzvRVKAOPF;nh}lA%7MY}IK3L~I5$
z^U`+mdD1c!b|i*8-J%BJ)V#Uob<yIkS{hm<FwElAj|kQA*<l>ZV5^I)6Lp~_Z=F0r
zHlc14;|Xw!brF&P5tB$9!OryzR*}8A!KWLia+`(mUIOQF%MaksTH8Ev1DuxZbaa<i
zC^1NkL<{R!bj<c+=%;_FGvIHxB>p8I07MLmB3+6l>;3Lv?%8a-?3d#%=j~x&;9{+-
z^<lZ%cO8T~H|Zi%82bgTW?YW}V}iEK6H`)ShA;wqtUwD9!gO~`y?>n}{DIK`o)$+w
zb6uwsL*jOHXmcp{?$GL817aqIGD8T`g|pS#o_%EFL3a=N;U?d{9pApuZ@(SC{+7Re
z6J9^=Z+1EkZZi~+S#qYa*a)fUJo_?%W=wTAGX{vDEI#xzIXcvWu#W4sdKR>NaWDNK
zHV&@!2LdB9#cBZH$PfGGK>)V|K<y5j&F8VYVPf;2;si7g2%Hx0b_{+wSpym{(KqW+
zSO4+%B0zRB0i3LYrx)}H3eA+le!7C2qJ%st0Cm$t^=Hy!epySBa2%<)X^uxJD;0yf
zcmUIB#1q^xB_&!btX6kg?PFiERuyGy;#=eYzB0?MMysQSxj(2wP(G?K5i^NU2<)U!
zKL8Mj#3-Voe8F1*)B`{!H}8|4ejcXup>p^~eR^i$U$9wd+~n(84FdgQRjLq>ny8AF
zY=1WX^8=dkrw#khQg8eVJ^&gJL@9>S>qE}_qM>Mn5n<ggA4Yv7<Ha&BR)^FdLX7Ul
z$)pbd&p=+)M#v;JM}EwNnI-rr-<C-*LQw<EY1E#h=#rijemG5GibuDZW=-g6;xmIo
zvxdDw+B-8<D|aY!0SPREJBw;sczwwi*YWvd_jo_vyxIQY_v3GWWB9%9wlPs4MH!ft
z*%VqRGZVwa+|9yTvavPcfCn8;<}8rPnzoZ$wX$@MJZ>-`0KB+YHV8#VWC|6CW+9Hm
z0v7YG&=s>_;wK<I9iI?8+1uJwJ!S?EPnLlb+5dg+UN#L6_B}d)cXk9%Sc0=dy`~H{
zEXQVHRG0;t8<=<+9fa8XQLiM_STV({IB}Gyz%o%ORE!iTN`8cCb-<X#9r{+2Tz7m-
zN;90MIM346CzjI_w8h62la?{8=0v55x#~Xp3}FgF9EiR8N9S}I1tUlQz52IA4opBF
z+Ax7*<lnK9pUwwAkg_|`zHEMG9G(66`0CgAWYHoela5Bkery+Sf9+u5zwD0Tmwf>E
zofeo=3|*JTvFwZWM#Gr<5YnRGG9SAB&@IN8GFQ79Wn_Te!ks1(4%BMQt!W`u@%WP}
z%`!zz_tnYhU5$?609qZrOj+&d1~K149Z|{Yt&K9wfmuW%BQOi#yv())Qv!p;xy(i|
zQlrsqfxMR0IWI3Lt@a%9;lOwIaTwxWNi*?itc7x+43LlyIetg#3^AzGdu>3AkcO&S
zJ#kfoo!qM~8}mlbt3M0-?iayG%-vu(m@tWuI5miAZj*s`ns+)TEBJ3bTMXB_Kgn`&
zx}bf!L41ck@_j=$-dho-?)7~<BC1KVZTAdoBg~|0awFLKRD(>(l*+V=XVOAcpi1V(
z7=>&kD@2))jbP9wIMZ3`T)iHu_TWU~izcWz#=jVzP?iX%+&aJn<Qr;du_{$rpLZw5
z3})j%B8q_aP8LDl^*ag_h+F|MrO)7))(Jd)asCu5pm&Y@o-BN45n|Py+n+7BcM&pC
zlahZN2lVH?EB;S(0Qlt`Mfxu0F%QM|BPA*kkgnsd+opaOyOD#oJXs|!#D%DkNd;{h
zX{@Mffm$O+0}ZL4ns%F%N)5q>Hn$gbqBqx=?Wbgv36*rbsV&x+g*n6+MLbZ~Z=4of
zO>RDFbwFVQ85Kp9R5AC0RgaFc9v&aU+ncc4^SHAzs%0b1$c2ih)BA>yF-73cZWPC^
z2}Z_hF5N$gR%|U~EiBD7!l|6_l`lKbr*>N2^?L-aW5=~1)EZ#bk8D;5X84cqQcpl3
zn>qd3DY)OTAo~z{a0H9Kmjv|T!t(?Ingc;?13axOTn{*X5;bShs?qF`m^3X&waUk=
z5LhYK^a&J0F)FSMtD%$C{dGDZPtr$^hZ$(@M`csa{p_hg3pw?~A3lD0ojW`L+p5~j
zM?H^laNIw_|4d>ebqzpFP5p~G*fV`w%sA8dqwYU;x|pV?*TM`1ngrQ2`D{%mj}s3(
z-AOd#)Q|6PSnhvN_5X>~WPcwA05K!Q(Di9QmfcuZ687V0X@S-1(D(ZovNP{$BgL+#
zQKMpNN*;l(MwW}I3LubL#p`aMu8LjgRW(UYBC6QGGNz`l{&%|TW|OXyPSwmeY3|Gw
zV~jznLnBXtt=2TdE%izjleLLKje-e-*i3oB>FTif^zQNNFX_!&yWi;uBPyl?tN_|Z
z@Kz}%nv9{wgVfq?_7onrsfla49;?`{ziT@K4DR_A2*JR_Vj{+3RZTEcgC4gD6|<h^
z4|{T>)4MenlN+dgpeTRn^FQo<{G(*_4-n5mr`ziZ8*0gLW=g~`RjoD*HZ5d*HvuIN
zQa1KW)p;u*ul|KdVTDKuN~a*^>@u5kY@Dz>9k-Z#N1w*yR5Fqg9Mj~=m#Oc;Yq}wT
zxng=24Us4sf>yq7JpceEk{X)BIEsFqVKB`Ec9NX>?k<-;e3sk0ufQY-X~d|C_}9A-
z?e{U!B6)z0e<2s3_g*bOZ~^eQK7jrn4ghkC2<AS;+~*<dK~+(T&@RS(N(YwQ2t4%w
zFg8P}WN3q_IR&#Qj6}lJA3648r*GVdqf9y_Y`1oA!vE*_f^}Q~nUFb1X`KK7AOJ~3
zK~ynFSZdu5DTL61W9H;Vn<jPw%(!|iOo_GidwBH)g30nCoj;40SNUvhZy$B!Y&H-L
zqB&5m-jt3a^AvS8qfPh?tB&}piPgn08CRBP&2O359YP!${a*~zkr0~yyZ92@)0ACF
zP?u;kXkfa5?Ig`{qPm<?TrhV9_~30+Q99sHy3dT}L{WQM;LX1G(T*oHj?|^P@nt4*
zC6#X}*m#Otb{dt|D}<C3W^5{+WCT)J0Toa-N06#Eu!%|LKRcfUrto}iek}Xb&o(c{
zrdG4q{7N+wVsR}oS)KO40t$5pfS?qK8^IU82ddD&9b=qpU}j@tox=Tw?==8@at0jN
zzji_lm~r!F4o#Cu3qi<4mGW3LE1CW|2>zeijQ@42|DSc3{hb^Den~}<l;WW)54*e&
z&LP}O*oLrYWYSQVw6zgvK#US8JSVRdHVQ0F3~Or2#!5$~CwqV@skv5Dr`&gIo^S04
zXj@il{!}0nkcdQ)5MoS8LX;rP!Yp7urr}MRC)lxJuM@R5HkGLFTtOu%969vTEz@dA
zt0nrR`!W_BgmMrQQyKv#k2tTL;X4Bg45Z#L8aF_wwt*lJRc|kA7L&x@^}A%XC4OKk
z{SFyVp#KSOK97K!b%S<%5~g{c-mU&<s0U_Td^@2PVmd*{=5xaziv>e#hUcK&M4W8X
zinSywJGCjY){Rf7N7D*S)!0D93gV+&*gQj2+cuY!)D%?Qc1K7RT9_16$ONQ54OHbg
z>5Le3lx$5!M(JJd{Y<++AcD3ntx_FBDqEKVOn`vq+6@9ssOtNIk9|$f?FJ8i%~X*G
z!1ML*aS#0Txc+lW9zO8NDY4s;AGnm0NMKS_#v*xC&E*I9ivNHW^dB$fKiA&>@9zKr
zGj%bP6nBSWkRoXt;#R^Q<c(F+YJn7_Wa6k!F)f-i%vxj-sgLZF13`0%Bdcv%-TF58
z-@J5Ei+*e&R!$IAGmr)05Mqik#TY`65LsrWf7aJj7rCh`YX=O~+o!tkOafwcIDm<S
zrAr~j5@?ih<grLm(aJ$_Dr8lG+L7SdIOdfCRCgtC4ttGecG3<LM9F)6u4e$Gavvc8
z0I3!+Tz7^*Tl^YZ;ns9EIVj;630q6YI}5=HPCMGYPe%q*v&m_pzBK)LK1|fA0Q)d5
zG>Onoe55DmHk++5>rNWeD?>B-DA@$Jqv<RhdYMF3{vrF~08n)Z$RG{~nS$6*gjA_0
zQ6Ve!0JcI<qD(Fop9rC3RX~9GQng}ervxX=o@7j8pObcss%t+WM2*u~PjoTHamYh(
z-j`wK_0}vu+mqLfp6a4u2AklNdqqENC2UW)0@GdvCr82**=*+Nc!4b$b*kx*!#Iwr
z_UDjze#YL;|EUjv$_NsPDeO~t99bofF%8Tkfysg^Ctc2>L~2%4p{m(()>4Eya1A7^
zqIe>wY?v9FvFpWvR`v@s*V&*NfGSU$zRBUA41kD430+EEj4=cemqN9H;VCf!lLzKB
zK@bd9TEWI_I#4q!Hj)*EIgB)x;XwB#788RQp|F1$h=~+sV&;(#1+8Jik=m~$#O)lY
z(qYz9<cA=b48>6YN6dv;xqjZs;6B5cwUGjtEEA@p-EP@d!k@CkrxmNswu;)8z$fMV
zon1nE5PND4eZq3WyoIC_;^eyv2y!>Lld@z-S|XZPV5L*JO<Y^wYQ>0{z>FG9f<|EU
ztHTIJrI2acsd`GWPXJ6-NCl?VlA^i{mgDm_bFrT5I0&;`v!+6rA^!eaH!3G;=_jy>
z5VMKEo&H(};7)Sp9P5g-<7oLg!Hd(jVlqWNmg`AndF0DIwFrH3a!(E*R@Hi#|EhHn
zVD4=g$P#O()@kmBA?9(kVn2Ctx4#Tn^war?{+%5F#Ecju_VJD|MBWD;7?~m9GTExs
zUP-NJp{#kZT;N9Sts!+WuJ`X;y(Z24&#KIx>O^Yl=|YC8YBDV+j&NqoNGbJw*TtAZ
z@R0Z^J7DU^nyw0FGx*_{LSpV1X+DCeITTd!U^CNE%b;Z>En14&Xt7u<H71g3w2X1%
z#X*lhg4Hg%)dHepnf5p~e>b!O!7{A@YK|lO5Wo}uOPHBp`)-@u71P~i+8TPcrK|+e
zx{+^QUh^ig5|x0H?Ey9Owq|KCx%|Gjy{rG$W*nZ`-8TbArtSN?ivnwEzR8fM>DHLU
z2QF(q1YGSkykYf$%8f)DCD<#ndJVVWzqa_RL?HG<!%YXX+YOOJimayU1|B|z5`<A5
zrcOtJdCv@*Gcx_gAsAXNTb<`>eQ$BTY{KnB@r5udzBf<x;ZukoG+Xz~Poxiqz~G5j
z#5*kEcMjs&K+`}!n`}!x($peZfJH4~9FPyiO8GHG|3@*1eg^3O-{Aq^myQHUDT1&|
z;W6+S*jTJywoRH<wZ55bD0!r!F$Av36sEPS*Gjvr|7WIVP#4KGS_`Td1Y3)fZ~k&H
zVGc2LDfM0IQi?&qT*F_vnoCUgV>L#gN$oT-P3hQLIu~_<pj@=3#k7zPs)Lo$O4gi-
zlp{1wIJ1Ik`F7Li`3e>@CZHcfb>%E=KH;OUFEK;Z`$1xYOeLV!2w(X!GrK!9H7-p1
z$-!-2a{Hj8e?oh<oh%AFS@u;#rCHdUJz3ZKgVy1|caC<dgL>cHH)WBW;?Z+@&HGFz
zsy)O}DM!bXpltzai2XYrrj={eNK7?^g4E0ag{Va$RC6XRU}GgxhA<TWm%TS_lH|Cy
z#O~q|nYHwWjeJ~0&ODh(X7m4lh4f|gWi)2eY;On>B+y$enGxal9(}m(9v+!l4G;uK
zu!VkYV85#F>Z<CDyPSI##KLAAZk}GeLyENoIg9r;vlRmBDff)70aT!>A$}T8uF||5
zxQVyxTZ-mGAX-!Iq}Y1<nvuZ8?W23KJ(cJ}8wvnF0Riy^=2cH(K>ISgw-+Li#(xcJ
zF17%R{jG8EKSMx2%_TrZ#@(29qwjXpPEBJX)o`J#rd{rCPBYmI%SD~q(p#I@i#!Bk
z0tZ;4Gr&a<^DeqGZ~4HLkCs%D>V6#eyWKdXRD8553`HRa<rXD|y1jO*db6I0`rsZu
zF)kFQ&+dRl(Px`wUNA4VECl03BEo5n#EwkmSOQo&$fL#8FjbO1A&R&1YSk&lJ3bD5
zbpxo%ULj$yc+?1Ch_v97R%MzUK<Q&uKqb{?x&r5D{tz34rD0{ok)N<B$*AXxA_ZM7
zLO*ONb|wwLQ#GgK&!9-Cx2J)6bdZ$+Ko{oR0#OL92}H%ENui06JRE}@;!NUjFoa#W
z*hDd*2*(0rTKkAgcsLa#s>}~U-R-2#*HTr(9e1Ht^M>6;Is{h<x5WCT)$>D$g^3|j
zdY05~-pl<uI@|WU{(<W*pO=1|z6EFfpwL{4YatgkixLV!6(nYCvtcnhPmcJx0elQS
zKx7!wu)CG<8fk#Wu&s594gXJvW%x`!D<C?Q>h13F5-!fn;p6B<urI`pu=A3#{4*GE
zZ)r|N)~jh8hy8B18+S<)v!J*_7Dc94o{2C~SUWm8qpylE)LkU<VRG>ZWjMo)EW>hC
ze_m#pCZDEdnVC&TvJ50p1iKfj{zBO-zvi<{D~>pFL^=#ftNy4ZzO4BY_7Ck{Qdc64
zQPM#mAz_iaM-)+P8L&NUZpzeOrD)Z61`KbM@#f`UC(G4sAFHyd>B_cIzpE8Db%Ns4
zVqZ%Js)tZF|6f=D3V2iD{;g=CU_9IrgRmk`s4n2^CAnNL1mwjyNQ#S*kV497Ih;Si
zZq$;!*eQ-Oh5qQV>1o{^J(x@2t$lX+rU^InF;;-8Z!A%6tJ_D+{^%FMFjcS2PU7OT
zSwrcV`9sVe{<df~uBi}xvpBJVJ#&>?bq?_jQG#;VgFy+&k+P>84IukZR0jNW1Nhq;
zfD9w=cNoS+)LBxc+6WVq3mX%;FK!FFsi?3Jhl76vwH6FD<X_YtT!)Cbhs9ff*39Hy
z!CWCqDJ9kYZa0oYN~zB!k2E60gTvzC9`C5yobGbhY#75N&YfTm%P=GNA|`X#LU|!y
zI4`_RHcxpv&daP~G%(m9h88GTK7|6=uQ}#Ylh~zdfmXC9e&O7r!m742ezU9r0Bu4<
zuNDpmM&Z@VtW2b;ELwOuvWlp%<_)yl!1m@B?`Venjo#9k)fHW79DJC8O1VV4iFyU6
zO52UUM}n)1BAO#!4+h<a$<-RWg^w}uMnb?H*QIbXn`K}Z9aAiifRz9MQE2%GXJ7jt
zb6o(5oGl2Tk-|_T1PV*QDdH<|nV`7!V~eGiJ(4TK>L>mYM5J=Js-asGb4a@rv>dli
zA6^&)=sx#t_i6vmmliB;SGx70bK+XDt^R%XORN5c^eJ4%{{$$YPRWrhQ$8+k_O~>E
z?{on8YYCv=?*ja{wXu(~0VwZw7<QJDAq1(+LMoJ$2jxKl4#OX7ua#=(u=008BPI-w
zmf%h-MBYua9gW_>%$m}W(m0I6FsLfCG^Gx;A-kHlH?)$y*t>UFe{~x5h$AZr0fxoM
zP!vFrk`@pOEOucqy9$j$d%_V2?QoZ5QtCu;ssJ~FKR4=L{e^N5>z5-1mx|D80W*uD
zOoeNQsJIXnH~5+hUd`Xah(4ZdZw&G3X3r&|knogAWL>7VX;0J{HuSQC#y2f<Wx(s5
zGPz<SrO#}UYOYyT1v!z1_7#EJ`Wu0jWZNHZdWQygFQ1LKGjY{LgkIf=Eg+`i{NxQf
zW5}RH>;{jxcqIv&AVZw<-J3X}GY~oXW)#TH>wTr&?TZC$_;yegbG1D8V({5iU1ew}
zoF7Q%`ng_x`2?h`YY%_tYRjjxflCaps&Q}CUxDIE0a7P*4B0g=ZqouYV*2SrKtFb#
zaQgVlKdI0#Vi+=~Y*JpN!YRpaH(c*`DRIt=FJ7~^#mnN`l$9*a+tXK~borlh7iDH5
zi-Q6&(Kw9bFpR?(_vGeE>sTMfU|L6%Vv)szc;nlSE+nAw{0;6v_L3lua-36Pji*)F
z*g5n3+&=lt9=^8ut>eAhv8EBXjFd9$*C?w3-Et#t7jI`O5U_Yf^Xoj=EPX^+Ane>R
z{iPE#$0*5AK_Unvg^sADU~YVA3Kk(=Ok7HucdrSkhLjZYr}8&dI#XvT(;961WIBy8
zN`msHh%gx2F`s&;N?w<Th)knq<ghk?q7o0=3p6mVe639&AZQLuh_tuTNY(>MSX9-&
zT%f`(q)a9-b|x#{5`s`}u|b$9j#m<ZQ8V-a_spj1?_XYZT+OK2xt!(W`a`wQcl#7m
zrTjPQ?w0n`pfBcgqV1OV$@JG0;4_cElkvYJ8&$?}`0CMm14!UxNI5UQ1hw|(A0Occ
z01~BffF?j8>?9<jNygoHeSLL%bHn7vgHPe#EaF7gg1%8@ULf%{M7f1kaxu~@NC^oS
za|z;c7{+lJcVik73u8Snag%3CQ2|8~ABrlz_laxUCA?Dq;pN!tK#urF6;7OzXv?K1
zHu8~19mJCz4>lcaVm#8r1Uqz>-ex^tZ<Z3qFWkoePzx7Mh<Xp~RGXvdry?slgv$4*
z>p?tnHQ*pS!v!u}vroc$qai+0QKiT!Fo6k5nhLkrnL;)tW{1^Xfrz!BQuUM#2FTi7
zmiZ#{1gEFr)sjwHL#aHP4nJ!4`T-Z!irV=FGGewaw<ZqCaZP+6s<Db5d85{{47pht
zbGyF?v$Ck@$Y~%5W-PfhB6g<g63T%^HVN8R08qX$l@wGb>PiPH3|+3MrjSqorsxeL
zinp^=a#R!dcK6=Ww%1yJdC+ItNWN+1r+)Z8%um26y!{zIg~IWRNdKecG@5J9*|Tjg
zMLz=m^VfgSpBumr^g|fq=t(^bAk54nn$o!2U0vVY+}z}4J{}(3V5@0(;f{FROINq%
z0;uvDp|@H+kd^aqh<nFzOsc^UajgD9O{KZMu>`G12SBWGQ>CnUu>0e`k=FuMNl8;m
zgQmnOM90Jc8!+-Pq?86FB?p$p9w|R!ng}Lc(wD>>SK<C(g`zZrrv5FK{UX)JEsnrk
zON6qNBk)@KnN(?DsM3xwSf+WlX}06!^KA2+v%#$kX(1H(QMhxL#KDLmFT03{M0Y8_
zh#tYpak?mE+D=p#ZHcvD_2s_F4XmlQGwAZKDqp99Je`M3JI1f9`cldx$H!5zI*0it
z-p$AyX6}Y;@a*p7#BSy#ZJNwr2De}yGqHm*v8nLL!yqZC4k?Wzk9!{Wtb3ASNQqp@
zg`BNvZoyO%0qTW%!&^FGQ<VyhMz@vKrvW0oAqWt*AR%?vqn<?2>^_<wR_g%YrMi7b
z`~UUid&&Y@xdfp+l-dKzPeWQV+w8D^+yxjvX!ZY_zlx8r0YDSR(IvSHdDuE@O2ase
z!!WW)&UT#UY02g!#h0;p`%`cF<_?j-{sCf-kf$=JyTch6QW}O~97mCY3{aywRtun-
z^zG~{VZ2gjuDX`DvQeE8LaN|KAYo3*Ni~f+j7gI!tCZtu5gj-&3+YJd+2>bq^JShM
z=i@ti_kes?DU>X$H$946vjRRieV(bvdmEuMfUmGI<;Dt+dLeLT9(Tj-^hkGie0<c0
zhy4Cwc{naprp07&&EV{z2WYe@(xx-xa36pQQs@cR2C$OK%gv(}taf;i)}_dVb9q;6
zE6l_Nw5v87UR-^utf0k8fwT_k6}E9WMdnXK{|k!c0ELfiapZs#8?%E;iFfvlZ0sg+
z#WgEwk8pMntQJ>iW+%?Xi!#)Ba8E>|&~C`rS9)_JH_v7NjK^yo_Jol$6U3Zg3}bNl
z>Z_FbgeF_>s`a&3oi$e23r*6+>v90B={E5KSpB@4yLU_9I;l>~>%3g!gnJ4Q_r#!Y
zZ4baU_GL|cY`=j425Z1RVZOzjm<PwOWS%FVj|*k{(c%A#rTMSb1^@WA6Cd9VfJxPp
zx}*r%C=yjs7IoloobDbT?jH{Gl7r~(&LRb<2_`{tdn=ypB4wv%2@NK%xO`F>QYxT-
zlaN&p>5!6fkc6r&Zak(1ux{FcdMD^2f(!JZB11~!kWx||M3b_r6ywf7qAl2i9ux0?
zbo=T4)5oj(H`BX6VS4S4cf8)9+rwOrBdDYf>8<*s`g4W6s+qHJGzB6e6&4jBg3Jfj
z5k5RV(3@|T*MGs?TYb3a`$u_PhRNt)IJg~w1yqnMUPE9tDhZP?Ctx599JZ-k1#{fF
zOGag<1~n9oQu$p_GUY53kv{EUBb`y}$}(xQay1fSX9X)DYsPbF03k1cTl<Hq{|%ln
zV4%#rFdI=Z7>B#T0>g9i^2Ta7fmT_$^ddH4ON7CAkMUY|*D~(Kcf)+OKi)j2=by;4
zS91G_44POy!;95Td}Uq`kV^%0C7sqKuh5y+dv}d!uG2~74wULoyq;?+i%7VO%h{Cj
z^LVdI<WT-AW@q$AVCwRII~1t%rK9R#7r_OK$vkB{F5f>1@<+mde!c<xfJb03n}~4*
zoQXhWjye0|aq@Y-d;k97@!-Ia!mEY5@xMkq!r?VaHReY_W$G6NmM{%z9EL$e;D8j2
z$KA^--ecY@zQBwSa>C0T#eKYM9V|UQ3KOa7kTh<~g;pd4DNs~(oQ^E@P$h-dF-f`}
zZ(m(~^2PDx=l1sbGBs&c+;W3!$0eS;uFFjcwqAm{zHJqYaXIr6%FrG;;XE?N<B`Am
z)BT_R`0)B`eR#N@@@_Ugx;!ra?l8YS9Pg)mbYy0eN&$)`VEf35mlIycooW~bF;l7p
z#CW3?r<w@TK@v(_!f;D*l9IAOw88MGLFE0xri8~*C)9208Q_$&yT@Wsxmp$9H_!rJ
zh>g0m=vB7d37T+fL|L{$ArTsxu2i27>E);|#<V9NVS`Tl_tX13`*cc>{fl9cy$Gu#
z{CUEMf&%dF#8amQx13B`O9=TnOF=@V#5EKwsakn-(?j`mxyE0twf?m9_x<*V%1+#>
zg|RVwF3%a&tfKPG5RkfSHp!Fwl)v`{_$Orl@B^I<KE@kB_=9mF`@xaTr+K-5c+B&%
z9FNDt!;-U#S|LDJ{3lk*at2s=9Uua^TgiuUH@FMaIF92us%nS@O0c}geoqqB->h<z
zJ+7EuRYKBv&}@1DftgZDyCIF^I1FP-NhOI$IQe*;h64K)_Mnnf^#Btm9j<m)&vrM@
zr}4_ArIeNFFYMO3>K`SRf`urR`5oYoNCS-viV~=ilQWSHgUZO*J>Jt-Up@Sf|Nij$
zwLQ$cN7r{#zI&MNkJIB~kC`S=X2Fms$r?!x2vN15FO|o{7q;GOd8;NxXd$S&feI7n
z=m%gHa=<plX=5)6GWUy*Be!(2J_r*hxd5BF6;%t~syd5`Do}Yve0p<s_og5?-(SNo
zZ-yKex;sv<$!}!1Re8DRS2rUgP4DhaXBkNcx_zZ81B);jOL5c_W?4<(`V068-V&~I
z^((JS2+C@>lB!zO?|DAWIIzQZ=n|g8%uiW6V4F#aC(C^wXV58rw=oCYdFhFBNiZOY
zlRAk(@`8L^e4hT63-C|n{QCnfA|D|HRJ=YbyzcHf=i@XH{K%T8$t}lA)+@Q+oFcZn
z+v};gy?78nCF~mA%-xwNaDP?hYEBTCPsuqix86qJE(c35X@JZn0IOaV*E3dNKEr-D
zRtpJL(Fi9l{J#3cA{a}EtdM9^P6h+SS!4*zNF*+|C6lCZ|4YnFm+n$?VYy}7grR?d
zfJ)_$tFI<8U%;FOWl~$@{r&QXKRkT%wLKn(cMHBg9Nr!AaF~zTGb_fCMTH~>!>RN4
zr!^O=IHH-T>0rF7nRpXt=+!sBhIdsWPT`h7DzJ5K7_foH%h<b_Ro#7o=jzAG+xo^t
z<Ys8`lFjk1k>5$ggqxE`O>=0zY*p=0M~kkU5>s4-lSbgW*h161Ji;fFg=8jNjgUtg
zUN1V5?yhfkDFw2~hLZA7{!5!kYPrC7>ZA@uHz8f6=S}VI<#}s`uS~6{p!^Ra`zMWo
zFW^Ere{XXZJu%R2FJ(oIQWH|51gKMt|F9|hy!><AGXE~V(;wdkP_$NUTrgm<%oA)`
zgqX4`Q%X`%S(4RpCx|*!JsVbZID!G(+|5BWM2w>*CTZRcq3Lx2M|k7<0B|@jtd5&)
zuddDofx~LBm4;y#=5a$(EjWCahSC(O#jv7jOoLV!HrHwn^Pq)@G@a3E+C|}>)=Yr8
zjMB}&CfMxN(s=!(i&u=2hZnT6EqHib-n^aOzVT(=9VU7EkiU7z_r|kDDGfX<d<m*C
zTovq7vpOhW49C3YMU&A&R#4cte3Bp44ch33_Y+6T)2XQ{`EZg)!jed&Cm0gRs-*&v
z>UN{p*xYl(x)-rHR-7wDB_)%fcspRd&DL~-vaUENXJTT`g6!_u?LZ65=c8!G+dI=S
zU)|(!pY|##1(hKeO^USg*?@WUq|j>1*S%qNZR2(7?>&5KhXZ&1O4VHPBA|b9_V2TZ
zPu_(~JJx0ih-d}0ir;+@G(R{2B~U6U^(Z~SjF)4!<3fL%2Kal9=RX<y&yTzTurP_#
zSvPElk<DP9gB1)JlCTF+BZ68ZnJ)}=0dI*<6;S~>k(*mKB2Fm{LmE<wRlBe|*QmyF
zS`6!Vsg`dW*JG@&-}dTI6;<7h<8C*O!>FkQ#Z(>6TJ=!K+~g$^EM|W)4|S+>Hea&O
zi!C#ImU?Zj$PU(Zx%gOvxFd&jR`#Vsw9&8VkI30YSrZeJ5#2o;-@bjEXK}x}f1KaG
zw+F+l;+i5}z}(%d4McZ?<u0$U)K6}%Z!Fl>0B}`Utpjekf3!LU5E;mLopgEA05&D2
zW+9?egfSEA#y`Jf9D+zg22Gt|-wNtCj7{oa-!_%@`<ym8X5D9lLS2QMxw(gnl^W=1
z?z21d&FyY5)g$iS<K3J2`eqnL9aK~-!;5&mv!bZqni4|RZ%pgUuM&}X>k*3{W3TIw
z&_<fK`G%fdeJ@r2t#i}qof?;b{u9u@Ujm{fM2izAafp*5;_3^bSOK+#^I`VGO!g!D
zKjR<4FZ#IwbUcQNTgT~-+|5yjeIX$+7D0qNI<QUsLVe)F3ACJ%-92YBvy_H$NaHYy
zXq=1d1=%Tp{t(i`Lnam~+eVXUQwpv4E0|bSlIU(6_q+W#4pPh&+e6tuaVUQG?&M(S
zpruFkx9prvmTc2x$AisB*wSo~*F}PXxT6-a51J9s8r>dZg?0SrY7_x5%q=AmWfInL
zI4tws!;*cR=5+tK+#hKfHA@)&C=;_qhCyLlu1NuH3hyR)uE90s{MaEz@r`t+KKic@
zQf8_g`*y%Qo%)*x1fA#rT9Pm}U4p5zeB+acu=_<-bQo2dDRDpAR*_dHSl&7`#067o
zw<|$HqKVDjeKtQF>Fz#XY1+#$AD8>P<?(*Gx}|g#fy3@(EV7~E6x-FJ179-&ik~Uf
z6EMomRGV?18dlkxjT%(W8J94h4-xdbD#qV}3ta?%Al-YVC;#+G_U)D(j9!Ph@iKXS
zn0%VnC+{bG0KnfXckE+40tb<;Pz4=;g@-br1Sx?Ty2AadTVt>4EO<q{H|LylW|kr8
zkWx~q47$jb<9Ja4B@nU!=?-i!k=@wi9tNYT0H8o$zcT2!+wI43mr`P0JsG?%GF&lZ
zCr330ih(a81I^*)o{g79rXxSz`@{Qud?25>K}YRj5wHYc+;E;c@>iqCjjK=R>0XYE
z(VmnwsrX1dEt%%bk4HZod7;5oGsB(2sy<H3%9VNOxpdxkBIyEDs9aNcTP>U2J5sa8
z;d;1T9e0Sxi(2&@g6_TBPEUbdE%w@bIwP`LK%2E&Z$3fQw`Xtw03ZNKL_t(*);U1P
zC>Eb5P!VlRDYnypd^~jtL7tLlcXxt2xv@cs#WCHR?{=i@l9wZvg|d+WF4@E#af9NM
z>*{*Py=bV})LTpxp?Uq#&~@dLKYw2FFLM0PkdUXH-EfKO)31x*Q{C_ByCj^SiHZ(@
zNX>bfvL7ep<)7OE`iEXGKEe$kP@tfz7p7zoH$4pJgRt2ooU3hD{~F}#$3`GCpO=Mz
z{eB$MAQBAmaOK?i46uN`$dAh44|L_f`V`cmkeNhvNW*To8^=*Kf!K?DxrFC=_k1|q
zISgdTEren)hdHvjTgEc;bdcj6?%(?TYdhYtPwNGsj7MD>Om*&U9uK7sN$(g@{p8Db
z0A`XTBw%JyU9vlzMM%<Yv}DS}Ikd}h_(0HCR{*Q|-jr)YR|=}1TFJ|;6`*3}#Uqth
zd<Q4CGABSkw*On*aXJbLs0(!Lk?-D3C!8y~C8f;^CnU#`ILggLb}eN6zEO`ks2-V}
zt+J8Sm}oDhIFu~JguKABkSVf|6On>AlQCr|xc_c#{?1yRu~~+wU#`}CI;_j$O2p!(
z<l10pTO6xfJT8%c@ZFi9-?93)OMrmbA>MM0%R-Qh(wu2NWIN83?H_>u;0G$=KLWV)
z@il-(#VFFBD4gM`;2>xB0{!?I8H~9`(?+EZG48TtFW}FRRH_t!om`}b#J~X(NOAX!
zn_Ls%cC!*!Cjn+2hBOSrZoeDGK~);Q-*h-Y6Zyx;8g|gI5@ioF%a*fQw#D;I(?O1R
z{P2yx`?J6Q3r}ywk1P@<7Aua=w4No(YJU>q*d6z(+dPS{R>n*kb`X(eE0o40gJdiQ
zE4FAwM-i7h5h}FY+8|3RZiz+c2~G$I=yZ6l%GC(MTruO0iN50T<@}EB?ulMY+8I)A
z%sSV<h}T3O?z7p>tSQS6=?=klTcFA;T{QqznE;}VDQxKhD6iPiF03CsURhp(04h4k
zDk37~YY;GptK0Uhy#?Pl9ga6gU#ches_f-8*M{lDRbqR^<+Dol0l&|uH38f0h}Y^*
z-S@P0@(TY|`v;-~QbrM$fYnK7q-o*#;J(-oCr9}1Rr@E(|M^%UAQT3;L<oR1hb>;+
zHL+TAb?WjeeJYYz0$?5mRyFOz>W5aZpXOy1fKfm*k*7kiE%MXHl$T79Aq~SY?)LkT
zlASEoz*a9*j0eogJzAK-vPT10Y{|=n`AE~fJbokZ|K#t!#ND5Cdc&B?Rh(AmFLc00
zbxuahgj&6>SMP%sw?!1;m>DvT!eWMD9Cuf{VK?*O3(YPh5CNFjDLafDA}TFzijCN6
zEPDJe6DhC5w9_`OX`9$cn{U@<;6-1rcx75~+b*i`6?D!+Y>8eq9GbhBVBmBR>jegA
z30nwu?fO0D)#a@`->V;f|Am#;ln}GIGh%}x5Bq-tn4Cl2?#@i?!lJ@SScM_%+?<c3
zpIgri7}l@%teI7jU<<A0?g64xi|#&`xxTk_=t6_y4WYB`2LNA$!8SJk;La(LnBXg=
zX>FZoriPq|20{uqYp{USkR}_Z#g}9DzjFrU_v82b-xZ?z=vYAQg)OSWsvgU9BTITj
zX%yKOdNWxO7Lj7HSsggtU4+LW4MP&9Li(u*!SOJcEY|2e9q8ZbAekCb2w<im4g39m
zzwbbQl+FT=zr$%oNvfg&=AHxhvFvVUX4#gUr#u}nJ@Vll?!LnNFZtb<^7v=Y?}=t!
zIW(0tv%0c$&R|3>9ctC|7q^0r1KNTt!*xY9jl<RTes^<Zop;yD!(vA;7-p)JL_h@3
z4r0<Wx7F~eC~;J*3@+mY-{KK-DOY?2v~apWKRLDbZ!f-?_`svgPY~B>Wzuf2D?U%O
z+J01N^FjD-GME8!uCJN$;ua!yFp)YZQh^GovTdjaXNU}6gzQfoJ1=yI?V@n<uI_}q
ze%tC-+c{4FPf|rcv=wZ4NGF%!&7KfiUqBp6NX&^zL29Iiluf6j<>LhNAASM&yE#Mr
zIDgT{)&SaEP#i0(w+U)&ZxmTyb^PVrRow5HRf-QTyx5funvy1I(Y3Wwvpb5FT)fJ?
zFz#CeXhNg%7kM}+j6>S(LPcD-r0y^w0ODSFC(e)pd8}Sz$gsuDVCLB@FP@j2r#v5g
zdZ5F5eteC0f28++(1$<D^o`(wI9Fhso078&gGG=0a8K`Ei76)!Zh6|>%p^-<Rk^*{
z-`-xQG~L{cX>WLR20XhmsS1S69hBqaJ6s|U0d1%Ej<JJFg%VG6`z@DnQ)JHn$eGIb
zX%ONfc6;7?w$*BzCV%>2!Kdk5IQ#TaU%g-fv2!u4EA(Au8ia*i1Uk?#l8(>;sti`Z
zTU)>IbunFnuz1@5PSm*_n-g372z)Z#cTJ)$PP}@Fp5}0#XqCHbOpotlJr$jZe&cmq
zh#ghP9|FJ#A}R*}$B<_%hsBQ*xfApEs=fH<YZ(83g@7uUBcw{I5b?&AcaQ-_MFQ4>
zpW*>imPm3};mF>G2|-gz!OLt7CZggweBlUEW5UYL%S~BXu%DXG>LQ$U7>98;?viTc
zas`hF4q*tqcyCdtnYrY@M*a6F{n>N&Wwt!~a`gGpr+XaU(c>Gr`wQQF$q!%3{Aa;i
zris`aTD7{sx9U&pquX@?UOAe?jYZl(viL)0#=;54jO*+1`HQQo>-RUeX}1?)Llb-n
zgi2^(ahwRO147Npi_7ZE-9Jj#(($1h&8Kl-=>M|;k8pAkJ}uL@piJ8SrG2FE_K&xV
z^+{m;S-0TRa(@Z|L<0bO=ub-i5Lf{v-X%`rDm0GRUGumn9V4Pyn3T`*)VI_6DT057
z3vIreXX^s<lPl2XyT|<0q|e{F(Vfx!Pt*X-|60QBr&^*YLn9nX;*C&u$*#+k^ZgOa
z^8JeMhpPXF-t|vV{Xf<Q5W(y$hz5Xm4s;?f3G2nxy$oE$Dw0&kG>p5HMBv6CGLJNY
zlH=65Mhg)+L5Qv7JeA=~I!R4o^2EmB%&a=>hG933sm=Z%Fna`7d-aZ3@dGY-@Ie7G
zL(ZPFEwe9^FGtJ|nBLLhEj@fAcYooBuk`UxDgQ<3Ez6N3t){N=yy7|K@Z0%5V#`?E
z_`Gyl+pt(Dp2~o`XTq}I?_a#wzx?ECTIl+kb^|7WWMDX(5t9~5i=pO^apVV*7wZg0
zkIXYJ6j`Q|`f{2V%T2zA7S~x0&CPqRHNyg|anB68ylbp~s^R$?=w?lpZ}aU_ivn+@
z%GB|axZx+!JYgt<1qoQ3*eMC^2N}du^4%4#Ze_e?9aq%=GtQ|t+;e)EJ{Z<cCsq71
zDD>2Gw^3p@v)AqA0Q5oUpDpdDy%8sGmy$tTexVEnsgM$>kc365BP}yc4>>;^$bM)G
z=pUh)KY0N7(K^RR*8ouKFN+GPgrj{0tqD$UF6M5<wynHKRdpDKaksnLk4ePx0(Unf
zD|ayud!P8}07C>}X<$8%4rp$>w1Q70%tK1Maomk#Ql*wE?p{7Q$BOh8h9EmpX#j=t
zW4<iDEI!XZA22`A@f{t$k^4XE!=L5xt2BKz;I;BS%M__pTt_D~O)+<h<hG<#@)H-{
zDcUDe?cl3}X{maRL1XSYjq?2E{<F_-9v&WUZ*X;u=@Fx*P+~hWOL$ispiBYLGB*nZ
z_O|Dv`gmTLrce`IP6{>SL{-H>HAU~8(VRCrgM^d5@<C9DpF;ne$<Gs-9wA&_U(l^1
zeMWTEHI#2Pix7z;nGa06grrEL?{DS$xs2D$2~Gwl5oH3yTGYe`u`KSI{rOek$sX`+
z!<Td;Gp_=K?sk6mz2q%Q*Yv%eaFHt)4Q&Znojyy3b#(v@77$#`be?E=T<lN}06+iu
z*c(81(IpZURS~TKe!1(KdHYd`62*sS9EY7sXu32aNUBUMO20FOmrkkORAWRse;;^F
zdxSeVL?tX9cH^k3kw|Mby_<<7c%?CzcZ7Bac@O>MoR`Jt3G<PT4}5sbkKf4sSNizJ
zVgA#QzgE0aI<V&AhXn3Mdeq7tDIXvP^W|r}1wvs%D3lWeHzp9W*{nOex=EjYe)IbE
z;l&HOeMavdATSXD)TtyQx;qn#HqQs@CeyInXCkjxaXzm~O%%2%XH8Ou4&tiR6-LJ%
z+y+51R{t69NrrSfv!DF7^QpBN|C}D9&!GR!PEhxrPX7w6+sK*~;Lhd=*eBWz*bUfU
z)Ae(@dM0TPN&yy$kT9Y0YtONM{+5%+_pJGwE{Ss`7y1$QiBAdq^b*k7g)~2tQvJ15
z|FC>OqObrWAtWbVOy`3y4-@A3A7A}{l0gC=R|61ji>ky1pb|et+)EHQoIDnQ*aDg%
z1ec5}b`*7$SL4b;>2|P`B_Q%*rD=+sI#bB<;*D;@D2&f>93^Rd{K91SLSP0~w$KU-
zI9W6RH}l1O$$81s(dGjmAN27(-+!(5e;f{9j>{hh`daxt^HP0sxz{=II*_%9-OdxU
zmxir&?{#@-a;*AMxveiCc+NH_KMuq7%a`M;Pliw5j-R}<*KgfyVNXIVl*|_bOYxg5
z6!=pcwZ`ekWxHPP3T5|h-&Bqh1Ok^1win-y4U~_Q8TDyG(7FLU%}KZn0ad+i_s;}D
zc=^<Xc2aR6b9L+zUGMpNhwE$HKIdmIb$=^7xQkant=yq5K{fnc;P^8L=m{qux>(Ko
zTge&`(=mWf^u15JKHvoWIZ=U?phx1G`Cfx0xS9WuI#M>B4~Kl5VflwY0Q}wXpPw7R
zcm3fO(0;IbGy(-xVh3<xFA-W^7?fs~<A2;8X1-)+UI;!<^SmtCyeT!Q62loDJ9@wg
zk+oZa=5VYmj?#fKjl(#M!#ED25*QTKsCX8z6S~74)9OtDryzd1W%I>svSqUA0f#$&
zd@J{_hx<Q{hd+$|hk@US9GI*(Q)r%cwboa`m#or%UM(IQdli+tvBlSWD7N&9P|BI*
z$(F+~4mUT$r=RWL-7l}-+v~UU>(@(OkaQGLw=5*ZJkD})>+S_od=88}X{pF3?g4zc
z+J4VD7N?)jw`UbT!7b|cFI<L?s8V0Tth<B}AyjZeB2XbACnegCe0#;$SAKI#&tJ;3
zm*aRNl-$L_e6DvUy#&^O>s$C-=zHlmTs+1%zQei)@Cl9Vq&<Ky0c<D#;+qYi856b(
zFp*-7|1F&$HUsmtEWA9<KFvS;^!>5qf_;ofV7NqJA+fS3vkI$-3zLK+S-|_2v*na?
zPGOySoHNO^EJCn6&v{uqcw;ze0AM(rgc&h;5%ZcW2rddTBVZiIuz3)X5*p<w=sXJp
zB;ba7uI4yF8HJmhnR_;yY&l?hpyPXec$4n`GTi@hcl>fke@gmZcrH&15N<TVPonO+
z%Z+`%ay%PQfZp8qw01Q1#cBlR5e8QHO`dZ;>Tosg)2mPRpWe@(zq7Y@>GAR5ewta5
z(qJxNS5}ZOd6Ak=)Bh!)&G-3qBy5gxHMOO`4O}kG+uQGY&OLcMI)?^+Vq>6hdHWLw
zO+2}96im%e+8!5`I0*?@1u6i62BoV#-QLjtim#vH_J!U&8`4go3$e4Plo8Ugq5n7Y
zI{pq<-0$(M@!79C@!8f8qM2T74L<3KGk}~J{(!l;iLYk1HT;X9b@oqAgVB&pkB_$8
zAN_dz$JgthYQy;G8i0F)EtEx-HN^75!t5=9#odBTvq(}+Npw~gcDJNVaJL*zW?bXD
zT8b+H;w}=!HWJ=Zhvsk|@^JG_DV6H48qX%!i6w$tBgmaMVS$b95SjDt=5E<+@qG08
zo)7Qz;q`F$)$Z}j-TdXquai7fH;SNU3tBD;ucT_;Qad|99pIAzjDeHbZa#-}$!nxA
z!96eYLDPQR56@o=pMG}ra2zJLyZbpGCo(9pl7d7WBp6d9g&QC}YP{;_`Wr8B3i|`R
zEvu*89p0b}ThpIytHC;kqdzi#+q{2~ebE1og6yBQ3u*Qh)Y2HYh!C?dgalBcfr*gk
zk#T!PFP`!97kYD>Uwt~h`t)jllZcn<k?jr$bv_>-z;^zsm1u*A@e`7`)8Brf0f0J|
z7oT<}^Z+QGIo9=~0=MiJu0@}y#yFEQC*qykxGXe3Om;XRFW<Lle{a*C9~A%jF`LK7
zxdCv=6Q@%8r6|Hm5d;BlW|^~!&Uw*ASeOWAIVsn;?zoW(3)sV5sQBU_g5m2!3y$j>
z3NzBov#Dy$@)fF-Nff7uc=A!x4rz60tK}7Lh$dy(^W^g*9p9zLZ_@iejgS9xpZ_rO
z>%?<dKRTqaUP`#VcU7`Gp*3DVb!4OV|C|*LG)Cs;VJ@o$gNrdHJK3D`almfaU%z~{
zdpPRd<MOLt-9Fyi-Pf6+%FLqf3*bql$l9vg9j&Czel6&ITDJlLobhVV!9(B^Jf~CS
zf;$cncg<rB$^D>*%|!%cLmx$DThZAKW@XfNAorF$sZ2uL<bXm*LL<|&XY%~HT;Jf?
zOM3oFZf-S=oY{#H2DBifVg&IaIO^M%mP_UQ68-fepv7kioM)Mi+ds(Lo5&`;a(mj}
zkb)}cU-GQu8XWzA2cu#3G|fKWJ=$^l-U-0pvm*cVRR52#0YutHP=0Fl4{JqkQ!q+?
zmYe6rM6>8p7@TG~sVK8BYj`m7>gW%aQfR|OqCo}-SI}Dh&6sFNX}8;{YTS#%9Fn|f
z+gr&fBz)%e#tD!G?Q`+Gc%FSe(DYs&U+cqH<Kchq?B7QDW+0PlL{!N=u~lS3^bk<z
z@vyD<{Y}qTAJF#p^0@WS@=BZ+B4H_3l};=Kz--QT9LC}1+3w}UukP*FzrKC<cAoAY
zmWhN%Rn8U&SU6@Et5fdlYBlXC%+4MYJE^&+2h}bErMh%-MMG9>=PagVbM@@9;Zb68
zP9JBc6Ut;u59mP*bcu{xznp#~#_GIT?<x>xAvl}?MpnjdpzA%oc%jdq^VRM0;xoQ|
zA;T3oc^Occnd7w7AAmoE_yafx-+O1gGdsDmo#E8f`oh8h^t-|nnT{*eQ(HEG6YhUI
zJN2~XmXiV5I6qS&N}$0hWlB@l<Kwd2A22U){J_B1NA%+(+yEHWQmcCVsH(1AfC@D)
z5O%gjmgZ9Lo=hc`qp_$mL_jPeQ7G#o&mPjtbx>s#XSU2tyKy&+V@ioij(km4iRfAs
zN0&mVDFv@&39|#9$riHN^Mv_8)4d$tr2DUShkx7oA4Ywx?1kiBo>yg35)fNA`+LnL
z=WfC-I7jh(t2FS{w2n_6aqbkL+)d@HPY^p3!<K2DQW|&T{_4f6{TD}Ga(esb`0(!d
z=Pz@B8!FraPils*aINInjLg95w2V`Z4R`UhX9H8z9^ZDo-rBjhYV%GACiS;*_s7rw
zh85<hnZ*~Gw57f`f4U9I*4&uAeQ8qu89*p5t4yr0#Qy4~zI-XqUi!0F{POeh=B1_`
zam{_HhHV9hJdK;X)Bx%W{=&4*Oq=S=7Y&p6>65l>dH?4}g4XZk!gAHqVryL6M*mfR
z7ROjpW+f;{i4##W8fF`g6OIqF9p|v6`@7;l|5O*_j}ig`BQCzAB~qP(2_z;i%wAbG
zaI?JR8Z{m&F;!O`RG<p5DnNpuFNR77a3<{x3Cmf*%(B6ehBS`jFbvFbEe45m1hIQz
zl?!UY4=AOW5=E4}ku7W!Efbal%@1;TJKTS@fBc_U_;SZ@l`}w*K*r)g@!eljr&^j;
zWV~z(S8*feC-4DmE!3XEj#2w;LAKd}WuBJlaU8F1Zf-vN?E3ER-EV*M{P4){U;k;I
zmb~~dj){k5nb%dUP;*zq$tb^!*2jF~-C3>k(eY(Zz7mxC>N<M!+2r58B)#;kRw>^T
zxJge&>QvNR1Db2aSrcw9sRyt!<m;NU#<2-06S)ig>WaSjZ2#(&KYMAfKG)k<I$SfS
zlkU#_zwUQDUTpTe%YJa%h4C^Cblu)6OQ-*c4A7-*;IuJZP*`vDz=Fd5RATK_U^Vwq
zzzRwRofbJh9H)1Wn2&#N{O7O#{r?d5=f~RsB23C%96~I@r3a{}ib;im0>y!wGvyqa
zUJQ^YBqumS2_V%D0}!bkp!$Eb4sBu54<waw9LHg(Q2}1O>zRr#KLWBvmx5aie?s%i
zwusG~kGwq6{J@9z!^5BVk6&KrFGqc^oC(4B@PgAw*a@{4n^tzJl_h|w^8u|!Kx-xA
zOEFc<yai-w1J%|%!4e3-!H9C3r-SSshpYX~v)!kk?L5oF!|?9y?!W)PGb}U0uSQln
zKl|$F-|(L`Dt#@<T{~)K0;rh<e0~G2`@uSVcaz{HqfcxQ9>(Qzh%HjIIr*+r>&f97
z=ke!T3$&`X?hJ*5j0x8_^ouX_)hl}O3BCASUwo#!8|KknBe#t@GjHia=PpLC@b+r4
z`n&e$S>g-1UA>va_DhlOJJQ9&qo?`SoXKq(b4S2hv9fcxKdkVuAq5rgKUM`mLV<u%
z_B2g&ykGL&gMVNDpC59TXa0Eu_`6<!$&7Ml_fP_hiioJP#7|>z@z{-S;RIt}iY<W?
zrA=^SedRF$5j$GYi?V%7G3;~zDl(2kRR2Jf5Pc*3+fgUxQUcMQelN-@BhQp)<Rj-t
znIHK0P9DD5J^pFG{AtuX6=%|N<}F1oqJ5ioN>N}~U%8&WrSldErVEfb*5H-(S;Yl^
z&B~B+^B`pqQO@&ne2{dN#^IAMZgYNrJfz3t^EYq5zW;`h7k3B`^>47q4Ga1^ZG3~V
z9;+{@NY}FUga`nqGcBLo56;K>lTLVwUW3+2^(3im1$Nd8&!)bA>+uv=A$X7w+;BD0
z=b!6uezkx3!k@pS7oQH-FGcr`WFgj&$e%|$FgK&LCk_Az93Q8&uI-uU<oom__rLYx
zjmY8r{=IUHvD)#S$-!3ekDKFc82)tCe}#bJ<cnhepr8awA^tiZY`Qzz;Xsb>Y0Cct
z@_+u8>i^?+j*k%n%9*B_^TOE04Olf!!G#a%!eKugOMpAEu@Nl{iqlg4S#^hulCu;x
z(BU@9VZO!8aC0J2NvdN&|3v0NmUm)_)>7Ot$%z8OUpL_JNr>@Z^Tf-eEcYo6zmH$-
z@}Eb&7v=J_GXWkevQX8P6-ZQ~B^6N^6SLQ9+Y`i5AEz~RgPG}DoB(hEEFr;4u3>ju
z@+|XV9IkI(Jby7wd70;oH?I%>%^vT*4ti1}_VF49e6hZ4N&4$=IH}Fm*KSjqE^1*f
zetDNpq8qg0q{?@>hXuXbLSrZM_gSq!9S|FTzLZFSg~;f|Oa9d_cfb6_)%ET4?4{j2
zm)$iZp(KBGT5S+B>C^Rsze{O5GwwhC_I#Idw>Q){IqIIDkuPe*r29oD2!IyWKbqUK
z7Vu|10?V9fx;rfI?=a8*c=hj3UN81BHUM{;C(2n6C{T0(4k>^ziwMNM7EU5^I6KTB
zgpAc`FkZ4|VeKzno?w{GMS4uc022|Cs;W{j{_8_suDldJYc0_ZJ&+I{MP!+5#&VG5
zp!0(s-pb=&cFWfzKd1x@+ESMS;9n1oC5xVzz2tLL<E%#UtbldrTg2PkzM2vPe5>B6
zQC!Nw67FDzvzytHXITzI8eV?7GhdE}{2%_qzdStr`S|X=n|iM0Sqe3(RqtAVT7+6H
zaa+rT(<3KuudEy1(8-PRvft+i21R~?PZM?)Cl<+VXX&Y!CnR=S|J}-a+eeFql$lbZ
zn=AU&uWtV3msc-d((Mbqd5-bQWhB>-x)jM+oQ=XWG?+kgdf@r44d5v+)XU!$@YAOS
z>DtCA+|QeD)cHAKTm75mXOKQQUNKGfRRq8&d{8x$e6Z!=;K!c;`v08(3;f&we%K#O
zW;8EsE{Kq?lABru0V3h)BZ%2M0$1EE#{Wz#5y#3c9i5z6#36!eTUqU+Q_%d)mg;TO
z_T0iY#hSh=Ynlf2x!@G}V{D7&ndeFJL5_EFcr(o340NyJREs)_TZ4dwSW%9SLO}?0
zsu$E+M^`x#uQ$Vn{<8$fMpoiqivYxhLtpz0NB{`4iUQ<h<YABJY?haWr$<gQ+}yl)
zHQMpYmgSef7~cIw-u@XWkz3rn>v1A}g#tG5DYSk{RXnHu*G=N|^L}z3<`eJ-T}A7M
z)84PBvzMba&zR{vyqM?`TXc)VuMX2S)PR}50wEf9{M+B({_5BJ=da}YHa~kQ`)5hV
zg{5VVMn&>U*A-^|Ya-Xb%a!<P|2SMa0-v@4-Y}$a!ZqTq-*6Y(S)5!ph=1ez7uct_
zhig3`nWy6-k9UXV?(rv~{{3h8@iE>2+{v<-6@EbUfN%s-F<}vLadGm>y{v)ZZf?qK
zCYf!GNMYib^UXz^ps_{_DUG{vNQsD+MY83<aeD9bvI;~(O?z;wX1JwA!i_AeExb&+
z9CW_d<J&a79`K;*EK>i7bQ7`?7-g$y0DpCp=Ptmb{-SVas=a;noGwdBV|}87g**Sv
zJ|(ziwN~$KlIlUg$Zj%`iY%<A`|I7y&u)(QkH7!z%lB{n?k{hIMM%s-XstwSaj_6K
z^9XWa?-Ah>3pH%@VAxs%^+(vt;MG>=T=zgmWYl1-JL|txy-5I_-{rXr5T7*`-k{_}
zsByg^9;_~eM4TN=5T^YNefCTK)o+GRf1$T8arHuW&nWFd8cRaG`g)Zi@~NHDcP;U;
zg{`fL&*og-?tHTOou`ft7i46>$rYS0x0WdSAdX`hZ_M{fNM@=2>waDd4N5eCc9ZWO
zkM!{FxZFRI=YNJ;g`XS1kMn(<XUUe_lR}wQNQCMQKt&({Ax5%S2?q{;N;h`4yoz&#
z*}_%M!A@RyKq{KjFb-o%3Gi$gnX(nWF!g5u03ZNKL_t(?{>sD;FJBQV=Fe3K#&toB
z1E^)m6WcT_kGuJ9JiJcRH_6|tWRa@O0!tH_dK6n_;z$oJltZc3W7X4blTC~IxmCAG
zbVF!W;WMFf%xTrM*7;c0F<Ahj>{cTKn81nI4al=+*g}|;uZI2Y{_`)AFZ=iJ>FuA7
zZ~lBF*T~RR9t=+8VfT_@tgIj|mL8jMr~-I^JFkbXP@JX$@ROmw<>Gp|av?Z4RjO5c
z9(bj7f_lGI=5xb;#>yydNL&<rscVifJXCxI4$DLs_w?x(^t<2Dr(fh}pX%)ky?&l_
zm!SxBGq%%m^63m*v4vMIF_?HWzHf3N=+yLKr9W&w!kNR*Q>;+lYJmCFOz^CEL`Yn7
zd1_Q9FaI1uRLvepD{&&YsY*1Mk5e8Wj?47!(WmKqkN<zS1HezA`hT1a0B)QY$vK%1
z1Erc2CqiKoEhZvfZkCa`S{HP<8)ar<t0ygCq7am+3u>5TA$)@*Ec>$~yPH?qL8-q&
z1mQjd3S5nkJx;;|cGJ8_o`?K6F7J2K+o=9Y7nXP^Jb+}ZPiDI!R5kB91opHFH2>xb
zlk-Zi1Q%nq5)K&>q6@*W+jPLTUpP)Yy%6^hz#Mt;WttC4yi4Q$>ebEd1AhOz7iRh&
z|BwH2|0XjjIlCD-cDoUb$LW9~@#NK7yNe6<2;k}U!5_LI_c=27;8nZ*DPPZ+jCO75
zf+rio*V1xMBy-gJ3UNh>S_g?N1{DI4Wq?SP%zarrDQV)*eu01YJNeabhEG1%+h;W1
zKzE?QSrK{FwTbh$0bLirRPJ=b=e7+eAlu1i#T!Qu@RR2L7Y@tkJ)`ai{VieT|McnY
ztK2te#HC}BFe_L=>Xa6wX~OaS(H<X=|3UVj_`Cm&KR19&M_^FSWdk5e%qkS_4j~O@
zaVaXoux}`TsG#v6i~W(AoyeGpwOUG;NHLMlp3Rmen@RS(EIFH-qc?u6*2=}Cz0i(I
zA7CdkB7&<M+oCp&`Egv{5A&Pk?~_b5hq$lDmA%6ZaxNs&Zdb<XopNRJ^)7JS8`rc?
zST@;^C{2btpkRx6pN)+5w~{k0FwTq5gagx!j@P%J>^=u(n%_S>|Ih!|o9PXUurEGv
z5@!;*9<F9P3Y-xKd#;4n3XgL+7pyrq?A+tXWoSjaw_ivLUf*$UHytJ2s?+zHc8>01
zPn&S`)y}$h0}yw)4vbUEC<_ZSxx2+zmJ-~^!2j}_>)-!gfBhSL{zZEJV!XPR-JXUW
z%0D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%0Ac>7Y=3UM`OXH)$nVJkJ3j0cY
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
Qt;PTZp00i_>zopr0AvkV`Tzg`

literal 0
HcmV?d00001

diff --git a/assets/hutbot_medium.png b/assets/hutbot_medium.png
new file mode 100644
index 0000000000000000000000000000000000000000..b6268312c558e36e279987a70a78960abbb9921c
GIT binary patch
literal 50065
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

literal 0
HcmV?d00001


From 1b73401e155b92ac42ac2b0c446c13bd6d532770 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Mon, 10 Aug 2026 14:57:53 +0200
Subject: [PATCH 16/42] feat(assets): add large background image for hutbot
 development

Added assets/hutbot_dev_large_bg.png to support the new visual requirements for the hutbot development environment.
---
 assets/hutbot_dev_large_bg.png | Bin 0 -> 206443 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 assets/hutbot_dev_large_bg.png

diff --git a/assets/hutbot_dev_large_bg.png b/assets/hutbot_dev_large_bg.png
new file mode 100644
index 0000000000000000000000000000000000000000..adda208d0d6d7cdffe64a103f9e9f158c413557a
GIT binary patch
literal 206443
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%0Dj=Y?}!rl`VX%$S@^sE
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
KWVtdb?0*2F+LE3C

literal 0
HcmV?d00001


From bb2812ef50aec580b2b43a325f1949db1d25db9d Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Mon, 10 Aug 2026 15:00:49 +0200
Subject: [PATCH 17/42] docs: add Hutbot_DEV Slack app link and clarify dev
 setup

- Add link to Hutbot_DEV Slack App in README
- Clarify that dev bot uses same variable names as `.env`
- Update documentation for registering second Slack app credentials
---
 README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 08dda24..1a4d542 100644
--- a/README.md
+++ b/README.md
@@ -274,6 +274,7 @@ python -m hutbot
 ```
 
    - See [Hutbot Slack App](https://api.slack.com/apps/A07RQ54Q5H9)
+   - See [Hutbot_DEV Slack App](https://api.slack.com/apps/A0BN19HUTAP)
    - Hosted at `nexus-cli get projects p-knksv4 -olink`
 
 9. **Invite Bot**
@@ -369,8 +370,9 @@ All chart resources are named after the Helm release, so the dev release gets it
 Secret (`hutbot-dev-secret`), PersistentVolumeClaim (`hutbot-dev-pvc`) and NetworkPolicy. The two
 instances share nothing.
 
-Register a second Slack app for the dev bot and put its credentials in a `.env-dev` file (also ignored
-by git). It uses the exact same variable names as `.env`:
+Register a second Slack app for the dev bot — [Hutbot_DEV Slack App](https://api.slack.com/apps/A0BN19HUTAP) —
+and put its credentials in a `.env-dev` file (also ignored by git). It uses the exact same variable
+names as `.env`:
 
 ```bash
 export SLACK_BOT_TOKEN='<dev bot token>'

From 0fd2fd762829a5b55f9577c4e14b02bd8d1a9230 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 09:09:48 +0200
Subject: [PATCH 18/42] fix(hutbot): enforce pinned image tags and improve
 button concurrency

- Reject 'latest' and 'main' tags in Helm chart and deploy scripts
- Fix race condition in button press handling with atomic claim logic
- Split Slack messages and action blocks to respect API size limits
- Prevent legacy forwarding for non-reply scheduled actions
- Validate config rule existence during UI updates
- Guard against stale channel selection in WebUI
---
 charts/hutbot/templates/deployment.yaml |  8 ++-
 deploy-dev.sh                           |  4 +-
 deploy-prod.sh                          |  4 +-
 hutbot/actions.py                       |  8 +--
 hutbot/buttons.py                       | 88 +++++++++++++++--------
 hutbot/scheduling.py                    |  4 +-
 hutbot/webui_backend.py                 | 10 ++-
 tests/test_actions.py                   | 14 ++++
 tests/test_buttons.py                   | 96 ++++++++++++++++++++++---
 tests/test_deployment_validation.py     | 59 +++++++++++++++
 tests/test_scheduling.py                | 22 ++++++
 tests/test_webui_backend.py             | 17 +++++
 webui_static/app.js                     |  1 +
 13 files changed, 283 insertions(+), 52 deletions(-)
 create mode 100644 tests/test_deployment_validation.py

diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 1e2f316..67ceabb 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -1,3 +1,7 @@
+{{- $imageTag := required "image.tag must be set to a specific image tag (e.g. v1.0.9); floating tags like 'latest' and 'main' are not allowed" .Values.image.tag -}}
+{{- if has (lower (toString $imageTag)) (list "latest" "main") -}}
+{{- fail "image.tag must be set to a specific image tag (e.g. v1.0.9); floating tags like 'latest' and 'main' are not allowed" -}}
+{{- end }}
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -20,7 +24,7 @@ spec:
       {{- end }}
       containers:
         - name: {{ .Release.Name }}
-          image: "{{ .Values.image.repository }}:{{ required "image.tag must be set to a specific image tag (e.g. v1.0.9); floating tags like 'latest' are not allowed" .Values.image.tag }}"
+          image: "{{ .Values.image.repository }}:{{ $imageTag }}"
           imagePullPolicy: {{ .Values.image.pullPolicy }}
           envFrom:
             - secretRef:
@@ -89,4 +93,4 @@ spec:
         - name: config
           persistentVolumeClaim:
             claimName: {{ .Release.Name }}-pvc
-      {{- end }}
\ No newline at end of file
+      {{- end }}
diff --git a/deploy-dev.sh b/deploy-dev.sh
index 138df20..f49abac 100755
--- a/deploy-dev.sh
+++ b/deploy-dev.sh
@@ -36,8 +36,8 @@ esac
 image_tag="$1"
 shift
 
-if [[ "$image_tag" == "latest" ]]; then
-  echo "error: image tags must be pinned to a release, 'latest' is not allowed" >&2
+if [[ "${image_tag,,}" == "latest" || "${image_tag,,}" == "main" ]]; then
+  echo "error: image tags must be pinned to a release, '${image_tag}' is not allowed" >&2
   exit 1
 fi
 
diff --git a/deploy-prod.sh b/deploy-prod.sh
index 291cf5a..1549a9c 100755
--- a/deploy-prod.sh
+++ b/deploy-prod.sh
@@ -46,8 +46,8 @@ esac
 image_tag="$1"
 shift
 
-if [[ "$image_tag" == "latest" ]]; then
-  echo "error: image tags must be pinned to a release, 'latest' is not allowed" >&2
+if [[ "${image_tag,,}" == "latest" || "${image_tag,,}" == "main" ]]; then
+  echo "error: image tags must be pinned to a release, '${image_tag}' is not allowed" >&2
   exit 1
 fi
 
diff --git a/hutbot/actions.py b/hutbot/actions.py
index b0192e4..2753292 100644
--- a/hutbot/actions.py
+++ b/hutbot/actions.py
@@ -154,12 +154,12 @@ async def run_action(app: AsyncApp, opsgenie_token: str, channel: Channel, confi
     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'):
+    if posted and posted.get('ts') and config.get('buttons'):
         await buttons.register_escalation(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config, context, posted_text=text)
     # OpsGenie is just a config property: any config that runs and has it enabled alerts.
-    await maybe_post_opsgenie_alert(app, opsgenie_token, channel, config, config_name, context, posted.get('ts', ''))
+    await maybe_post_opsgenie_alert(app, opsgenie_token, channel, config, config_name, context, (posted or {}).get('ts', ''))
+    if not posted:
+        return None
     return {**posted, 'text': text}
 
 
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index e441061..921734b 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -28,6 +28,19 @@
 from .models import User
 
 
+SLACK_SECTION_TEXT_LIMIT = 3000
+SLACK_ACTIONS_ELEMENT_LIMIT = 25
+
+
+def _section_blocks(text: str) -> list[dict]:
+    """Split message text into Slack-valid section blocks."""
+    text = text or ' '
+    return [
+        {"type": "section", "text": {"type": "mrkdwn", "text": text[offset:offset + SLACK_SECTION_TEXT_LIMIT]}}
+        for offset in range(0, len(text), SLACK_SECTION_TEXT_LIMIT)
+    ]
+
+
 def build_button_blocks(config: dict, def_channel_id: str, config_name: str, text: str) -> list | None:
     buttons = config.get('buttons') or []
     if not buttons:
@@ -45,10 +58,17 @@ def build_button_blocks(config: dict, def_channel_id: str, config_name: str, tex
             "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},
-    ]
+    action_blocks = []
+    for offset in range(0, len(elements), SLACK_ACTIONS_ELEMENT_LIMIT):
+        chunk_number = offset // SLACK_ACTIONS_ELEMENT_LIMIT
+        suffix = f":{chunk_number}"
+        block_id = f"{BUTTON_ACTION_PREFIX}:{config_name}"[:255 - len(suffix)] + suffix
+        action_blocks.append({
+            "type": "actions",
+            "block_id": block_id,
+            "elements": elements[offset:offset + SLACK_ACTIONS_ELEMENT_LIMIT],
+        })
+    return _section_blocks(text) + action_blocks
 
 
 def _escalation_kind(config: dict) -> tuple[str, str]:
@@ -178,45 +198,48 @@ async def _run_escalation(app: AsyncApp, opsgenie_token: str, entry: dict) -> No
 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)
+        entry = _claim_pending_button(key, owner=asyncio.current_task())
         if entry:
+            await persistence.flush_button_cache()
             log(f"No button pressed on message {key[1]} within timeout; escalating.")
             await _run_escalation(app, opsgenie_token, entry)
     except asyncio.CancelledError:
+        # Cancellation alone means shutdown or timer replacement. The caller that
+        # explicitly consumed/replaced this record owns cache updates; shutdown must
+        # leave the persisted entry available for restoration in the next process.
         return
     except Exception as e:
         log_error(f"Escalation task failed for message {key[1]}:", e)
-    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()
+
+
+def _claim_pending_button(key: tuple, owner: asyncio.Task | None = None) -> dict | None:
+    """Synchronously claim a pending record so only one consumer can dispatch it."""
+    entry = state.pending_buttons.get(key)
+    if entry is None:
+        return None
+    task = entry.get('task')
+    if owner is not None and task is not None and task is not owner and not task.done():
+        return None
+    state.pending_buttons.pop(key, None)
+    state._button_states_cache.pop(key, None)
+    if task is not None and task is not asyncio.current_task():
+        task.cancel()
+    return entry
 
 
 async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None:
     key = (posted_channel_id, message_ts)
-    entry = state.pending_buttons.pop(key, None)
-    state._button_states_cache.pop(key, None)
+    entry = _claim_pending_button(key)
     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:
+async def reschedule_escalation(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, minutes: int, *, _entry: dict | None = None) -> bool:
     key = (posted_channel_id, message_ts)
-    entry = state.pending_buttons.get(key)
+    entry = _entry if _entry is not None else _claim_pending_button(key)
     if not entry:
         log_warning(f"No pending escalation to delay for message {message_ts}.")
         return False
-    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
@@ -265,7 +288,7 @@ async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str,
             channel=posted_channel_id,
             ts=message_ts,
             text=posted_text,
-            blocks=[{"type": "section", "text": {"type": "mrkdwn", "text": posted_text}}],
+            blocks=_section_blocks(posted_text),
         )
     except SlackApiError as e:
         log_warning(f"Failed to remove buttons from message {message_ts} in {posted_channel_id}:", e)
@@ -288,12 +311,20 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
     src_config_name = payload.get('config') or ''
     index = payload.get('index')
 
+    key = (posted_channel_id, message_ts)
+    entry = _claim_pending_button(key)
+    if entry is None:
+        log_warning(f"Ignoring button press for message {message_ts}: no pending button record.")
+        return
+    # Persist the claim before any dispatch-related await. A concurrent handler now
+    # sees no entry, and a restart cannot resurrect an already-consumed button.
+    await persistence.flush_button_cache()
+
     presser_id = (body.get('user', {}) or {}).get('id', '')
     presser = await slackcache.get_user_by_id(app, presser_id) if presser_id else None
     presser_name = presser.name if presser else '?'
 
     channel = await slackcache.get_channel_by_id(app, def_channel_id)
-    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
@@ -312,13 +343,12 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
         except ValueError:
             minutes = 0
         if minutes > 0:
-            await reschedule_escalation(app, opsgenie_token, posted_channel_id, message_ts, minutes)
+            await reschedule_escalation(app, opsgenie_token, posted_channel_id, message_ts, minutes, _entry=entry)
         return
 
-    # Every other button stops the pending escalation, then runs its action. A config
+    # Every other button has already claimed the pending record, then runs its action. A config
     # run is attributed to the *original* author (presser=None ⇒ orig.user_id), matching
     # the timeout-escalation path; the presser is only used for the log line above.
     run_context = await _escalation_context(app, entry, posted_channel_id, message_ts)
-    await 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/scheduling.py b/hutbot/scheduling.py
index e5ba788..540dc41 100644
--- a/hutbot/scheduling.py
+++ b/hutbot/scheduling.py
@@ -13,7 +13,7 @@
 from . import slackcache
 from . import actions
 from . import persistence
-from .constants import SCHEDULER_INTERVAL, TRIGGER_SCHEDULE
+from .constants import ACTION_REPLY, SCHEDULER_INTERVAL, TRIGGER_SCHEDULE
 from .models import ScheduledReply
 
 try:
@@ -44,7 +44,7 @@ async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel, config: di
         })
         reply_message = (posted or {}).get('text', '')
         forward_channel_id = config.get('forward_channel')
-        if forward_channel_id and reply_message:
+        if config.get('action', ACTION_REPLY) == ACTION_REPLY and 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)
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index befa234..56a475c 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -330,11 +330,17 @@ def get(key):
 
 async def ui_apply_config(app: AsyncApp, channel_id: str, config_name: str, payload: dict) -> tuple[bool, dict]:
     """Validate and persist a single config (rule). Returns (ok, errors)."""
+    config_name = (config_name or "").strip()
+    if not CONFIG_NAME_PATTERN.fullmatch(config_name):
+        return False, {'name': "Names may use letters, numbers, and - _ . : / only."}
     clean, errors = await validate_config_payload(payload, app, channel_id)
     if errors:
         return False, errors
     async with state._config_write_lock:
-        state.channel_config.setdefault(channel_id, {})[config_name] = clean
+        configs = state.channel_config.get(channel_id, {})
+        if config_name not in configs:
+            return False, {'name': "That rule no longer exists."}
+        configs[config_name] = clean
         await persistence.save_configuration()
     log(f"Config UI: applied rule `{config_name}` in channel {channel_id}.")
     return True, {}
@@ -342,7 +348,7 @@ async def ui_apply_config(app: AsyncApp, channel_id: str, config_name: str, payl
 
 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):
+    if not CONFIG_NAME_PATTERN.fullmatch(config_name):
         return False, "Names may use letters, numbers, and - _ . : / only."
     async with state._config_write_lock:
         configs = state.channel_config.setdefault(channel_id, {})
diff --git a/tests/test_actions.py b/tests/test_actions.py
index 0c8220b..4429129 100644
--- a/tests/test_actions.py
+++ b/tests/test_actions.py
@@ -133,6 +133,20 @@ async def test_action_group_dm_resolves_members_and_opens_mpim():
     assert posted["channel"] == "G888"
 
 
+@pytest.mark.asyncio
+async def test_run_action_fires_opsgenie_when_slack_post_fails():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "opsgenie": True}
+    channel = _mk_channel({"src": config})
+
+    with patch('hutbot.actions.action_reply', new=AsyncMock(return_value=None)), \
+         patch('hutbot.actions.maybe_post_opsgenie_alert', new=AsyncMock()) as alert:
+        posted = await hutbot.actions.run_action(app, "token", channel, config, "src", {"text": "DB down"})
+
+    assert posted is None
+    alert.assert_awaited_once_with(app, "token", channel, config, "src", {"text": "DB down"}, "")
+
+
 
 # ----- action_reply threads only within the same channel -----
 
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 258ac57..84556d5 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -81,6 +81,24 @@ def test_build_button_blocks_structure():
     assert payload == {"channel": "C12345", "config": "src", "index": 0}
 
 
+def test_build_button_blocks_respects_slack_block_limits():
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [
+        {"label": f"Button {i}", "action": "ack", "value": ""}
+        for i in range(26)
+    ]
+    text = "x" * 6001
+
+    blocks = hutbot.buttons.build_button_blocks(config, "C12345", "src", text)
+
+    sections = [block for block in blocks if block["type"] == "section"]
+    actions_blocks = [block for block in blocks if block["type"] == "actions"]
+    assert "".join(block["text"]["text"] for block in sections) == text
+    assert all(len(block["text"]["text"]) <= 3000 for block in sections)
+    assert [len(block["elements"]) for block in actions_blocks] == [25, 1]
+    assert actions_blocks[1]["elements"][0]["action_id"] == "hutbot_btn:25"
+
+
 
 @pytest.mark.asyncio
 async def test_run_action_reply_posts_with_buttons():
@@ -120,12 +138,14 @@ async def test_handle_button_press_routes_to_target_and_cancels_timeout():
         "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, \
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons[key] = {"task": None, "buttons": src_config["buttons"], "orig": {}}
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
          patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
          patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
          patch('hutbot.actions.run_action', new=AsyncMock()) as run:
         await hutbot.buttons.handle_button_press(app, "token", body, action)
-    cancel.assert_awaited_once_with("C12345", "10.1")
+    assert key not in hutbot.state.pending_buttons
     assert run.await_count == 1
     assert run.await_args.args[3] is target_config
     assert run.await_args.args[4] == "tgt"
@@ -140,13 +160,15 @@ async def test_button_press_ack_cancels_without_running_config():
     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, \
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons[key] = {"task": None, "buttons": src_config["buttons"], "orig": {}}
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
          patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
          patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
          patch('hutbot.messaging._post_message', new=AsyncMock()) as post, \
          patch('hutbot.actions.run_action', new=AsyncMock()) as run:
         await hutbot.buttons.handle_button_press(app, "token", body, action)
-    cancel.assert_awaited_once_with("C12345", "10.1")
+    assert key not in hutbot.state.pending_buttons
     run.assert_not_awaited()
     post.assert_awaited_once_with(app, "C12345", "Thanks!", None, "10.1")
 
@@ -166,7 +188,7 @@ async def test_button_press_config_passes_orig_context():
     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()), \
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
          patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
          patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
          patch('hutbot.actions.run_action', new=AsyncMock()) as run:
@@ -186,13 +208,16 @@ async def test_button_press_delay_reschedules():
     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)), \
+    key = ("C12345", "10.1")
+    entry = {"task": None, "buttons": src_config["buttons"], "orig": {}}
+    hutbot.state.pending_buttons[key] = entry
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
          patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
-         patch('hutbot.buttons.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
+    assert resched.await_args.args == (app, "token", "C12345", "10.1", 3)
+    assert resched.await_args.kwargs == {"_entry": entry}
 
 
 
@@ -214,6 +239,59 @@ async def test_register_and_cancel_escalation():
     await asyncio.sleep(0)  # let the cancelled task settle
 
 
+@pytest.mark.asyncio
+async def test_cancelled_timer_keeps_persisted_record_for_restart():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
+    config["button_timeout"] = 3600
+    config["button_timeout_target"] = "escalate"
+    key = ("C12345", "10.1")
+
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()) as flush:
+        await hutbot.buttons.register_escalation(
+            app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
+        task = hutbot.state.pending_buttons[key]["task"]
+        await asyncio.sleep(0)
+        flush.reset_mock()
+
+        task.cancel()
+        await task
+
+        assert key in hutbot.state.pending_buttons
+        assert key in hutbot.state._button_states_cache
+        flush.assert_not_awaited()
+        await hutbot.buttons.cancel_pending_button(*key)
+
+
+@pytest.mark.asyncio
+async def test_button_record_is_consumed_once_for_duplicate_and_stale_presses():
+    app = AsyncMock()
+    target = {**DEFAULT_CONFIG.copy(), "trigger": "manual"}
+    src = {**DEFAULT_CONFIG.copy(), "buttons": [{"label": "Go", "action": "config", "value": "tgt"}]}
+    channel = _mk_channel({"src": src, "tgt": target})
+    key = ("C12345", "10.1")
+    record = {"task": None, "buttons": src["buttons"], "orig": {}}
+    hutbot.state.pending_buttons[key] = record
+    hutbot.state._button_states_cache[key] = {k: v for k, v in record.items() if k != "task"}
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    button_action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await asyncio.gather(
+            hutbot.buttons.handle_button_press(app, "token", body, button_action),
+            hutbot.buttons.handle_button_press(app, "token", body, button_action),
+        )
+        await hutbot.buttons.handle_button_press(app, "token", body, button_action)
+
+    run.assert_awaited_once()
+    assert key not in hutbot.state.pending_buttons
+    assert key not in hutbot.state._button_states_cache
+
+
 
 @pytest.mark.asyncio
 async def test_escalation_task_runs_config_target():
diff --git a/tests/test_deployment_validation.py b/tests/test_deployment_validation.py
new file mode 100644
index 0000000..45e94c0
--- /dev/null
+++ b/tests/test_deployment_validation.py
@@ -0,0 +1,59 @@
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _helm_template_command(tag):
+    return [
+        "helm", "template", "hutbot", str(ROOT / "charts/hutbot"),
+        "--show-only", "templates/deployment.yaml",
+        "--set", f"image.tag={tag}",
+        "--set", "networkPolicy.rules[0].port=443",
+        "--set-string", "networkPolicy.rules[0].cidrs[0]=0.0.0.0/0",
+    ]
+
+
+@pytest.mark.parametrize("script", ["deploy-dev.sh", "deploy-prod.sh"])
+@pytest.mark.parametrize("tag", ["latest", "main", "MAIN"])
+def test_deploy_scripts_reject_floating_tags(script, tag):
+    result = subprocess.run(
+        [str(ROOT / script), tag],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert "must be pinned" in result.stderr
+
+
+@pytest.mark.parametrize("tag", ["latest", "main", "MAIN"])
+def test_chart_rejects_floating_tags(tag):
+    result = subprocess.run(
+        _helm_template_command(tag),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert "floating tags" in result.stderr
+
+
+def test_chart_accepts_pinned_tag():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3"),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "image: \"hutbot:v1.2.3\"" in result.stdout
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
index 91f2604..8064d7b 100644
--- a/tests/test_scheduling.py
+++ b/tests/test_scheduling.py
@@ -182,6 +182,28 @@ async def test_schedule_reply_forwards_to_configured_channel():
     )
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("action", ["dm_user", "group_dm", "post_channel"])
+async def test_schedule_reply_does_not_legacy_forward_non_reply_actions(action):
+    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": "Private text",
+        "forward_channel": "CLEGACY",
+        "action": action,
+    }
+
+    with patch('hutbot.actions.run_action', new=AsyncMock(return_value={"text": "Private text"})), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        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_schedule_reply_skips_forward_when_not_configured():
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
index 0027e7e..eaa9de5 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -160,6 +160,23 @@ async def test_ui_create_config_rejects_bad_name_and_duplicate(monkeypatch):
     assert ok is False and "already exists" in msg
 
 
+@pytest.mark.asyncio
+async def test_ui_apply_config_requires_valid_existing_target(monkeypatch):
+    _seed_user_caches()
+    hutbot.state.channel_config = {"C1": {"existing": DEFAULT_CONFIG.copy()}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+    app = _ui_app()
+    payload = {"reply_message": "Updated"}
+
+    ok, errors = await hutbot.webui_backend.ui_apply_config(app, "C1", "bad name", payload)
+    assert ok is False and "name" in errors
+
+    ok, errors = await hutbot.webui_backend.ui_apply_config(app, "C1", "deleted", payload)
+    assert ok is False and errors == {"name": "That rule no longer exists."}
+    assert "deleted" not in hutbot.state.channel_config["C1"]
+    hutbot.persistence.save_configuration.assert_not_awaited()
+
+
 
 @pytest.mark.asyncio
 async def test_ui_delete_config_refuses_default(monkeypatch):
diff --git a/webui_static/app.js b/webui_static/app.js
index 957efbb..1a21b61 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -144,6 +144,7 @@ async function selectChannel(channelId) {
   stage.replaceChildren(h("div", { class: "stage-loading", text: "Loading rules…" }));
 
   const res = await api("GET", `/api/channels/${encodeURIComponent(channelId)}/configs`);
+  if (state.channelId !== channelId) return;
   if (!res.ok) { stage.replaceChildren(h("div", { class: "stage-empty" }, h("strong", { text: "Couldn't load this channel" }), res.data?.error || "Try another channel.")); return; }
   state.configs = res.data.configs || {};
   state.drafts = {};

From 3c664bbb8d303948dbe8c45bd09f60be6b5b154a Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 09:45:01 +0200
Subject: [PATCH 19/42] feat(persistence): support nested configs with new
 default field names

Introduce a backward-compatible launcher script (`bot.py`) that delegates
to the package entry point, allowing legacy invocations to continue
working. Update documentation to reflect this change.

Fix configuration migration logic in `persistence.py` to correctly
identify legacy flat formats. The previous check incorrectly assumed
that any key matching `DEFAULT_CONFIG` indicated a flat structure.
This caused issues when users had custom configurations named after
newly added default fields (e.g., `trigger`, `action`). The updated
logic verifies that values are not dictionaries to accurately detect
flat vs. nested formats.

Add tests for the new entry point delegation and the corrected
migration behavior.
---
 README.md                 |  4 ++--
 bot.py                    | 10 ++++++++++
 hutbot/persistence.py     | 10 +++++++++-
 tests/test_entrypoint.py  |  8 ++++++++
 tests/test_persistence.py | 20 ++++++++++++++++++++
 5 files changed, 49 insertions(+), 3 deletions(-)
 create mode 100644 bot.py
 create mode 100644 tests/test_entrypoint.py

diff --git a/README.md b/README.md
index 1a4d542..c3ef1f6 100644
--- a/README.md
+++ b/README.md
@@ -487,7 +487,7 @@ helmfile sync
 ## Development
 
 Hutbot is a Python package (`hutbot/`). The former monolithic `bot.py` has been
-split into cohesive modules:
+split into cohesive modules; `bot.py` remains as a backward-compatible launcher:
 
 - `hutbot/state.py` — shared in-memory caches and runtime flags
 - `hutbot/models.py`, `hutbot/constants.py` — data types and configuration defaults
@@ -501,7 +501,7 @@ split into cohesive modules:
 - `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`.
+Run it locally with `python -m hutbot`. Existing `python bot.py` invocations remain supported.
 
 ### Running tests
 
diff --git a/bot.py b/bot.py
new file mode 100644
index 0000000..887518e
--- /dev/null
+++ b/bot.py
@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Backward-compatible launcher for the former ``python bot.py`` entry point."""
+
+import asyncio
+
+from hutbot.__main__ import main
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/hutbot/persistence.py b/hutbot/persistence.py
index 7dc3330..b41def1 100644
--- a/hutbot/persistence.py
+++ b/hutbot/persistence.py
@@ -20,7 +20,15 @@ async def migrate_and_apply_defaults(app: AsyncApp, config: dict) -> dict:
         # 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())
+        # A nested configuration may legitimately use a field name as its
+        # configuration name (for example, ``trigger`` or ``action``). New
+        # fields added to DEFAULT_CONFIG must not make those existing configs
+        # look like the legacy flat format. Flat fields hold scalar/list
+        # values; nested configuration names hold dictionaries.
+        is_flat_config = any(
+            key in constants.DEFAULT_CONFIG and not isinstance(value, dict)
+            for key, value in channel_data.items()
+        )
         if is_flat_config:
             # This looks like an old, flat config. Let's wrap it.
             log(f"Migrating old configuration for channel {channel_id}")
diff --git a/tests/test_entrypoint.py b/tests/test_entrypoint.py
new file mode 100644
index 0000000..41d8a9e
--- /dev/null
+++ b/tests/test_entrypoint.py
@@ -0,0 +1,8 @@
+"""Compatibility checks for runtime entry points."""
+
+
+def test_legacy_bot_entrypoint_delegates_to_package_main():
+    import bot
+    from hutbot.__main__ import main
+
+    assert bot.main is main
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
index 7e600cf..f7cd9b4 100644
--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@@ -25,6 +25,26 @@ async def test_migrate_and_apply_defaults():
     assert migrated_config["C123"]["default"]["pattern"] is None
 
 
+@pytest.mark.asyncio
+async def test_migrate_preserves_configs_named_after_new_default_fields():
+    app = AsyncMock()
+    config = {
+        "C123": {
+            "trigger": {"wait_time": 60},
+            "action": {"reply_message": "Action config"},
+            "buttons": {"enabled": False},
+        }
+    }
+
+    migrated_config = await migrate_and_apply_defaults(app, config)
+
+    assert set(migrated_config["C123"]) == {"trigger", "action", "buttons"}
+    assert migrated_config["C123"]["trigger"]["wait_time"] == 60
+    assert migrated_config["C123"]["action"]["reply_message"] == "Action config"
+    assert migrated_config["C123"]["buttons"]["enabled"] is False
+    assert all("trigger" in value for value in migrated_config["C123"].values())
+
+
 
 @pytest.mark.asyncio
 async def test_load_and_flush_replies_cache_roundtrip():

From 76efc5611dcbbb04af22777bd807d28654c28ee8 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 10:38:10 +0200
Subject: [PATCH 20/42] feat(routing): handle bot channel membership changes

Track when the bot is removed from or added back to a Slack channel.
When removed, automatically disable all enabled configurations for that
channel and cancel pending scheduled replies and button escalations.
Mark these configurations with a specific `disabled_reason` so they can
be identified later.

When the bot re-joins the channel, post a message listing the
configurations that were disabled by the removal. These are not
re-enabled automatically; users must explicitly enable them via slash
command or web UI. Ensure explicit user actions (enable/disable) always
override the automatic disable marker.
---
 README.md                      |  19 +++++
 hutbot/buttons.py              |  26 +++++++
 hutbot/commands/info.py        |   8 +-
 hutbot/commands/setters.py     |   2 +
 hutbot/constants.py            |   8 ++
 hutbot/routing.py              |  90 ++++++++++++++++++++++-
 hutbot/webui_backend.py        |  15 ++++
 tests/_common.py               |   4 +-
 tests/test_buttons.py          |  43 +++++++++++
 tests/test_commands_info.py    |  19 +++++
 tests/test_commands_setters.py |  14 ++++
 tests/test_routing.py          | 130 +++++++++++++++++++++++++++++++++
 tests/test_webui_backend.py    |  42 +++++++++++
 webui_static/app.js            |   9 ++-
 14 files changed, 424 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index c3ef1f6..b9bbd9b 100644
--- a/README.md
+++ b/README.md
@@ -102,6 +102,23 @@ existing configs keep working unchanged.
 
 Use `/hutbot [config] run` to fire a configuration's action immediately (handy for testing).
 
+## Leaving and rejoining a channel
+
+Configurations outlive channel membership, so removing the bot from a channel would otherwise leave
+`schedule` rules firing (and pending reminders/escalations coming due) for a channel it can no longer
+post in. When Hutbot is removed from a channel (kicked, or `/remove`d):
+
+- every enabled configuration of that channel is disabled and marked as *disabled because Hutbot was
+  removed* (`disabled_reason`), which `/hutbot show config` and the web UI show;
+- all pending reminders scheduled for that channel are cancelled;
+- all pending button escalations are dropped — both those posted in that channel and those posted
+  elsewhere by one of its rules (so nothing escalates into a now-disabled configuration).
+
+Configurations are **not** re-enabled automatically. When Hutbot is added back it posts a message
+listing the configurations it disabled, which can then be re-enabled with `/hutbot [config] enable`
+(or the web UI). Configurations that a user had disabled by hand are left alone and are not part of
+that message.
+
 ## Web configuration UI
 
 Hutbot can serve a small web UI from the **same bot process** (no separate service) that lets a
@@ -242,6 +259,8 @@ is the operator's responsibility — Hutbot only consumes the resulting header.
      - `message.groups`
      - `message.im`
      - `message.mpim`
+     - `member_joined_channel`
+     - `member_left_channel`
 
 6. **Enable Interactivity** (required for buttons)
 
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index 921734b..4ebad8d 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -234,6 +234,32 @@ async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None
         await persistence.flush_button_cache()
 
 
+async def cancel_channel_pending_buttons(channel_id: str) -> int:
+    """Drop every pending button record tied to a channel; returns how many were dropped.
+
+    Used when the bot is removed from a channel: a message posted there can no
+    longer be updated or replied to, and a record defined by one of that
+    channel's (now disabled) configs would escalate into a config the bot is no
+    longer running.
+    """
+    if not channel_id:
+        return 0
+
+    def belongs(entry: dict) -> bool:
+        return entry.get('posted_channel_id') == channel_id or entry.get('def_channel_id') == channel_id
+
+    keys = {key for key, entry in state.pending_buttons.items() if belongs(entry)}
+    keys |= {key for key, entry in state._button_states_cache.items() if belongs(entry)}
+    for key in keys:
+        # Cancels the escalation timer and drops the live record; the pop also
+        # covers a cached record that has no live counterpart.
+        _claim_pending_button(key)
+        state._button_states_cache.pop(key, None)
+    if keys:
+        await persistence.flush_button_cache()
+    return len(keys)
+
+
 async def reschedule_escalation(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, minutes: int, *, _entry: dict | None = None) -> bool:
     key = (posted_channel_id, message_ts)
     entry = _entry if _entry is not None else _claim_pending_button(key)
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 6750c38..5f296b8 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -15,6 +15,7 @@
     ACTION_REPLY,
     DEFAULT_DATE_FORMAT,
     DEFAULT_TIME_FORMAT,
+    DISABLED_REASON_REMOVED,
     ESCALATION_BUTTON,
     ESCALATION_CONFIG,
     ID_PATTERN,
@@ -190,7 +191,12 @@ def _button_label(b):
         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'
+        if replies_enabled:
+            enabled_label = 'enabled'
+        elif config.get('disabled_reason') == DISABLED_REASON_REMOVED:
+            enabled_label = f'disabled, because {state.bot_name} was removed from this channel'
+        else:
+            enabled_label = 'disabled'
         quoted_block = (
             f"> {reply_line.replace('\n', '\n> ')}\n"
             f">\n"
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index ad1a1ff..9c43e0e 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -66,6 +66,8 @@ async def set_replies_enabled(app: AsyncApp, channel, config_name: str, enabled:
     if config_name not in channel.configs:
         channel.configs[config_name] = DEFAULT_CONFIG.copy()
     channel.configs[config_name]['enabled'] = enabled
+    # An explicit enable/disable supersedes an automatic one (see DISABLED_REASON_REMOVED).
+    channel.configs[config_name]['disabled_reason'] = ""
     await persistence.save_configuration()
     await messaging.send_message(app, channel, user, f"Replies are now *{'enabled' if enabled else 'disabled'}* in configuration `{config_name}`.", thread_ts)
 
diff --git a/hutbot/constants.py b/hutbot/constants.py
index 9d12d0a..6a5c572 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -39,6 +39,12 @@
 
 BUTTON_ACTION_PREFIX = "hutbot_btn"
 
+# Marker written to a config's ``disabled_reason`` when the bot disabled it by
+# itself (instead of a user running `disable`). Removing the bot from a channel
+# disables that channel's configs; the marker lets the bot point them out when
+# it is added back.
+DISABLED_REASON_REMOVED = "removed_from_channel"
+
 # What a button does when pressed.
 BUTTON_ACTION_CONFIG = "config"    # run another named config (an OpsGenie alert is just such a config)
 BUTTON_ACTION_ACK = "ack"          # acknowledge/dismiss (cancel escalation), optional ack text
@@ -72,6 +78,8 @@
     "pattern_case_sensitive": False,
     "forward_channel": "",
     "enabled": True,
+    # Why the bot disabled this config on its own; empty for a user-made change.
+    "disabled_reason": "",
     # Trigger: how the rule starts. "message" keeps the classic behavior.
     "trigger": TRIGGER_MESSAGE,
     "schedule_cron": "",
diff --git a/hutbot/routing.py b/hutbot/routing.py
index 719ecfb..8116bc8 100644
--- a/hutbot/routing.py
+++ b/hutbot/routing.py
@@ -16,7 +16,13 @@
 from . import persistence
 from . import buttons
 from . import commands
-from .constants import BUTTON_ACTION_PREFIX, IGNORED_MESSAGE_SUBTYPES, TRIGGER_MESSAGE
+from . import messaging
+from .constants import (
+    BUTTON_ACTION_PREFIX,
+    DISABLED_REASON_REMOVED,
+    IGNORED_MESSAGE_SUBTYPES,
+    TRIGGER_MESSAGE,
+)
 from .models import ScheduledReply
 from .textutil import extract_message_text, log_debug
 
@@ -224,6 +230,76 @@ async def handle_message_deletion(app: AsyncApp, channel, previous_message_user,
         del state.scheduled_messages[key]
 
 
+def is_bot_membership_event(event: dict) -> bool:
+    """True if a member_joined/left_channel event is about the bot itself."""
+    return bool(state.bot_user_id) and event.get('user') == state.bot_user_id
+
+
+async def cancel_channel_scheduled_replies(channel_id: str) -> int:
+    """Cancel every pending scheduled reply of a channel; returns how many were cancelled."""
+    keys_to_cancel = [key for key in state.scheduled_messages if key[0] == channel_id]
+    for key in keys_to_cancel:
+        state.scheduled_messages[key].task.cancel()
+        del state.scheduled_messages[key]
+        state._scheduled_replies_cache.pop(key, None)
+    if keys_to_cancel:
+        await persistence.flush_replies_cache()
+    return len(keys_to_cancel)
+
+
+async def handle_bot_removed_from_channel(app: AsyncApp, channel_id: str) -> None:
+    """Disable a channel's configurations after the bot was removed from it.
+
+    The configuration outlives the membership, so schedule triggers would keep
+    firing (and pending reminders/escalations would keep coming due) for a
+    channel the bot can no longer post to. Configurations disabled here are
+    marked with ``disabled_reason`` so a later rejoin can point them out; they
+    are never re-enabled automatically.
+    """
+    if not channel_id:
+        return
+
+    cancelled = await cancel_channel_scheduled_replies(channel_id)
+    cancelled_buttons = await buttons.cancel_channel_pending_buttons(channel_id)
+
+    configs = state.channel_config.get(channel_id, {})
+    disabled_names = sorted(name for name, config in configs.items() if config.get('enabled', True))
+    for name in disabled_names:
+        configs[name]['enabled'] = False
+        configs[name]['disabled_reason'] = DISABLED_REASON_REMOVED
+    if disabled_names:
+        await persistence.save_configuration()
+
+    log(f"{state.bot_name} was removed from channel {channel_id}. "
+        f"Disabled configuration(s): {', '.join(disabled_names) if disabled_names else '<none>'}. "
+        f"Cancelled {cancelled} scheduled reply/replies and {cancelled_buttons} pending button escalation(s).")
+
+
+async def handle_bot_added_to_channel(app: AsyncApp, channel_id: str) -> None:
+    """Point out the configurations that an earlier removal disabled."""
+    if not channel_id:
+        return
+
+    configs = state.channel_config.get(channel_id, {})
+    names = sorted(
+        name for name, config in configs.items()
+        if not config.get('enabled', True) and config.get('disabled_reason') == DISABLED_REASON_REMOVED
+    )
+    if not names:
+        return
+
+    config_list = ", ".join(f"`{name}`" for name in names)
+    singular = len(names) == 1
+    text = (
+        f"Hi! :wave: I am *{state.bot_name}* :palm_up_hand::tophat: and I am back in this channel.\n\n"
+        f"I disabled {'this configuration' if singular else 'these configurations'} when I was removed: {config_list}. "
+        f"Re-enable {'it' if singular else 'them'} with `{state.slash_command} [config] enable`."
+    )
+    await messaging._post_message(app, channel_id, text, None)
+    log(f"{state.bot_name} was added to channel {channel_id}. "
+        f"Configuration(s) still disabled from an earlier removal: {', '.join(names)}.")
+
+
 async def handle_command_event(app: AsyncApp, command: dict, opsgenie_token: str = ""):
     text = command.get('text', '')
     channel_id = command.get('channel_id', '')
@@ -244,6 +320,18 @@ async def handle_message_events(body, logger):
     async def handle_reaction_added_events(body, logger):
         await handle_reaction_added(app, body.get('event', {}) if body else {})
 
+    @app.event("member_left_channel")
+    async def handle_member_left_channel_events(body, logger):
+        event = body.get('event', {}) if body else {}
+        if is_bot_membership_event(event):
+            await handle_bot_removed_from_channel(app, event.get('channel', ''))
+
+    @app.event("member_joined_channel")
+    async def handle_member_joined_channel_events(body, logger):
+        event = body.get('event', {}) if body else {}
+        if is_bot_membership_event(event):
+            await handle_bot_added_to_channel(app, event.get('channel', ''))
+
     @app.command(state.slash_command)
     async def handle_command(ack, body, logger):
         await ack()
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 56a475c..afad530 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -36,6 +36,7 @@
     DEFAULT_CONFIG,
     DEFAULT_CONFIG_NAME,
     DEFAULT_OPSGENIE_PRIORITY,
+    DISABLED_REASON_REMOVED,
     OPSGENIE_PRIORITIES,
     SUPPORTED_TEMPLATE_VARIABLES,
     TEAM_UNKNOWN,
@@ -340,6 +341,20 @@ async def ui_apply_config(app: AsyncApp, channel_id: str, config_name: str, payl
         configs = state.channel_config.get(channel_id, {})
         if config_name not in configs:
             return False, {'name': "That rule no longer exists."}
+        previous = configs[config_name]
+        if (not previous.get('enabled', True)
+                and previous.get('disabled_reason') == DISABLED_REASON_REMOVED):
+            # A draft loaded before the bot left still says enabled and has no
+            # marker. Do not let an unrelated stale edit undo the automatic
+            # disable. A draft loaded after removal carries the marker, which
+            # distinguishes its explicit enable toggle from that stale save.
+            explicit_reenable = (
+                clean['enabled']
+                and payload.get('disabled_reason') == DISABLED_REASON_REMOVED
+            )
+            if not explicit_reenable:
+                clean['enabled'] = False
+                clean['disabled_reason'] = DISABLED_REASON_REMOVED
         configs[config_name] = clean
         await persistence.save_configuration()
     log(f"Config UI: applied rule `{config_name}` in channel {channel_id}.")
diff --git a/tests/_common.py b/tests/_common.py
index 7f37370..6411cd8 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -15,7 +15,7 @@
 from employee_list import get_env_var
 
 from hutbot.models import Channel, User, Usergroup, ScheduledReply
-from hutbot.constants import DEFAULT_CONFIG, bot_slug, normalize_slash_command
+from hutbot.constants import DEFAULT_CONFIG, DISABLED_REASON_REMOVED, bot_slug, normalize_slash_command
 from hutbot.textutil import extract_message_text
 from hutbot.datetimefmt import parse_time, is_work_day, is_work_time
 from hutbot.persistence import migrate_and_apply_defaults, load_replies_cache, flush_replies_cache
@@ -25,6 +25,8 @@
 from hutbot.routing import (
     route_message, handle_channel_message, handle_thread_response,
     handle_reaction_added, handle_message_deletion, register_app_handlers,
+    handle_bot_added_to_channel, handle_bot_removed_from_channel,
+    cancel_channel_scheduled_replies, is_bot_membership_event,
 )
 from hutbot.webui_backend import (
     validate_config_payload, list_user_config_channels, ui_create_config, ui_delete_config, ui_meta,
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 84556d5..372d9e2 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -494,3 +494,46 @@ async def test_button_resolves_from_snapshot_and_strips_after_press():
     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?"
+
+
+@pytest.mark.asyncio
+async def test_cancel_channel_pending_buttons():
+    task = MagicMock()
+    task.done.return_value = False
+    posted_here = ("C12345", "1.1")
+    defined_here = ("C99999", "2.2")
+    unrelated = ("C99999", "3.3")
+
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[posted_here] = {
+        "task": task, "posted_channel_id": "C12345", "def_channel_id": "C12345", "orig": {}}
+    hutbot.state.pending_buttons[defined_here] = {
+        # posted elsewhere by a rule that lives in the removed channel
+        "task": None, "posted_channel_id": "C99999", "def_channel_id": "C12345", "orig": {}}
+    hutbot.state.pending_buttons[unrelated] = {
+        "task": None, "posted_channel_id": "C99999", "def_channel_id": "C99999", "orig": {}}
+    hutbot.state._button_states_cache.clear()
+    for key, entry in hutbot.state.pending_buttons.items():
+        hutbot.state._button_states_cache[key] = {k: v for k, v in entry.items() if k != "task"}
+    # A cached record with no live counterpart (never restored) goes too.
+    hutbot.state._button_states_cache[("C12345", "4.4")] = {
+        "posted_channel_id": "C12345", "def_channel_id": "C12345"}
+
+    with patch('hutbot.persistence.flush_button_cache') as mock_flush:
+        cancelled = await hutbot.buttons.cancel_channel_pending_buttons("C12345")
+
+    assert cancelled == 3
+    assert list(hutbot.state.pending_buttons.keys()) == [unrelated]
+    assert list(hutbot.state._button_states_cache.keys()) == [unrelated]
+    task.cancel.assert_called_once()
+    mock_flush.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_cancel_channel_pending_buttons_without_matches_does_not_flush():
+    hutbot.state.pending_buttons[("C99999", "1.1")] = {
+        "task": None, "posted_channel_id": "C99999", "def_channel_id": "C99999", "orig": {}}
+    with patch('hutbot.persistence.flush_button_cache') as mock_flush:
+        assert await hutbot.buttons.cancel_channel_pending_buttons("C12345") == 0
+        assert await hutbot.buttons.cancel_channel_pending_buttons("") == 0
+    mock_flush.assert_not_awaited()
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 3b99f78..3eada84 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -259,3 +259,22 @@ async def test_need_help_yes_no_workflow_end_to_end():
             await hutbot.buttons._escalation_task(app, "tok", ("C1", "R1"), 0)
         post.assert_awaited_once_with(app, "C1", "Here is the help doc", None, "R1")
     await asyncio.sleep(0)  # let the cancelled timer settle
+
+
+@pytest.mark.asyncio
+async def test_show_config_explains_an_automatic_disable():
+    app = AsyncMock()
+    configs = {
+        "removed": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED},
+        "by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False},
+    }
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+    hutbot.state.bot_name = "Hutbot"
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Configuration*: `removed` (disabled, because Hutbot was removed from this channel)" in sent_message
+    assert "*Configuration*: `by-hand` (disabled)" in sent_message
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 73f2686..d820cb2 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -282,3 +282,17 @@ async def test_set_trigger_valid_and_invalid():
         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]
+
+
+@pytest.mark.asyncio
+async def test_set_replies_enabled_clears_the_automatic_disable_reason():
+    app = AsyncMock()
+    configs = {"default": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED}}
+    channel = Channel(id="C12345", name="general", configs=configs)
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await set_replies_enabled(app, channel, "default", True, user)
+
+    assert channel.configs["default"]["enabled"] is True
+    assert channel.configs["default"]["disabled_reason"] == ""
diff --git a/tests/test_routing.py b/tests/test_routing.py
index a4b2bff..9870581 100644
--- a/tests/test_routing.py
+++ b/tests/test_routing.py
@@ -366,3 +366,133 @@ def test_register_app_handlers_uses_configured_slash_command():
     with patch('hutbot.state.slash_command', '/hutbot_dev'):
         register_app_handlers(app)
     assert app.command.call_args.args[0] == "/hutbot_dev"
+
+
+# ----- Channel membership (bot added / removed) -----
+
+def _membership_configs():
+    return {
+        "default": {**DEFAULT_CONFIG.copy(), "enabled": True},
+        "nightly": {**DEFAULT_CONFIG.copy(), "enabled": True, "trigger": "schedule"},
+        "off-by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False},
+    }
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_removed_disables_configs_and_cancels_replies():
+    app = AsyncMock()
+    channel_id = "C12345"
+    hutbot.state.channel_config[channel_id] = _membership_configs()
+    hutbot.state.channel_config["C99999"] = {"default": {**DEFAULT_CONFIG.copy(), "enabled": True}}
+
+    task = AsyncMock()
+    task.cancel = MagicMock()
+    other_task = AsyncMock()
+    other_task.cancel = MagicMock()
+    hutbot.state.scheduled_messages[(channel_id, "1.1", "default")] = ScheduledReply(task=task, user_id="U1")
+    hutbot.state.scheduled_messages[("C99999", "2.2", "default")] = ScheduledReply(task=other_task, user_id="U1")
+    hutbot.state._scheduled_replies_cache[(channel_id, "1.1", "default")] = {'channel_id': channel_id}
+
+    with patch('hutbot.persistence.save_configuration') as mock_save, \
+         patch('hutbot.persistence.flush_replies_cache') as mock_flush, \
+         patch('hutbot.buttons.cancel_channel_pending_buttons') as mock_cancel_buttons:
+        await handle_bot_removed_from_channel(app, channel_id)
+
+    mock_cancel_buttons.assert_awaited_once_with(channel_id)
+
+    configs = hutbot.state.channel_config[channel_id]
+    assert configs["default"]["enabled"] is False
+    assert configs["default"]["disabled_reason"] == DISABLED_REASON_REMOVED
+    assert configs["nightly"]["enabled"] is False
+    assert configs["nightly"]["disabled_reason"] == DISABLED_REASON_REMOVED
+    # A config a user had disabled keeps its (empty) reason.
+    assert configs["off-by-hand"]["disabled_reason"] == ""
+    # Other channels are untouched.
+    assert hutbot.state.channel_config["C99999"]["default"]["enabled"] is True
+
+    task.cancel.assert_called_once()
+    other_task.cancel.assert_not_called()
+    assert list(hutbot.state.scheduled_messages.keys()) == [("C99999", "2.2", "default")]
+    assert hutbot.state._scheduled_replies_cache == {}
+    mock_save.assert_called_once()
+    mock_flush.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_removed_without_configs_saves_nothing():
+    app = AsyncMock()
+    with patch('hutbot.persistence.save_configuration') as mock_save, \
+         patch('hutbot.persistence.flush_replies_cache') as mock_flush:
+        await handle_bot_removed_from_channel(app, "C-unknown")
+    assert "C-unknown" not in hutbot.state.channel_config
+    mock_save.assert_not_called()
+    mock_flush.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_added_reports_configs_disabled_by_removal():
+    app = AsyncMock()
+    channel_id = "C12345"
+    hutbot.state.channel_config[channel_id] = {
+        "default": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED},
+        "nightly": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED},
+        "off-by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False},
+        "running": {**DEFAULT_CONFIG.copy(), "enabled": True},
+    }
+
+    with patch('hutbot.messaging._post_message') as mock_post:
+        await handle_bot_added_to_channel(app, channel_id)
+
+    mock_post.assert_called_once()
+    text = mock_post.call_args.args[2]
+    assert "`default`, `nightly`" in text
+    assert "off-by-hand" not in text
+    assert f"{hutbot.state.slash_command} [config] enable" in text
+    # Nothing is re-enabled automatically.
+    assert hutbot.state.channel_config[channel_id]["default"]["enabled"] is False
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_added_stays_silent_without_auto_disabled_configs():
+    app = AsyncMock()
+    hutbot.state.channel_config["C12345"] = {"off-by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False}}
+    with patch('hutbot.messaging._post_message') as mock_post:
+        await handle_bot_added_to_channel(app, "C12345")
+    mock_post.assert_not_called()
+
+
+def test_is_bot_membership_event():
+    hutbot.state.bot_user_id = "UBOT"
+    assert is_bot_membership_event({"user": "UBOT", "channel": "C1"}) is True
+    assert is_bot_membership_event({"user": "U1", "channel": "C1"}) is False
+    hutbot.state.bot_user_id = None
+    assert is_bot_membership_event({"user": "UBOT"}) is False
+
+
+@pytest.mark.asyncio
+async def test_membership_handlers_only_react_to_the_bot():
+    app = MagicMock()
+    handlers = {}
+
+    def event_decorator(name):
+        def register(fn):
+            handlers[name] = fn
+            return fn
+        return register
+
+    app.event = MagicMock(side_effect=event_decorator)
+    register_app_handlers(app)
+    assert "member_left_channel" in handlers and "member_joined_channel" in handlers
+
+    hutbot.state.bot_user_id = "UBOT"
+    with patch('hutbot.routing.handle_bot_removed_from_channel') as mock_removed, \
+         patch('hutbot.routing.handle_bot_added_to_channel') as mock_added:
+        await handlers["member_left_channel"]({"event": {"user": "U1", "channel": "C1"}}, None)
+        await handlers["member_joined_channel"]({"event": {"user": "U1", "channel": "C1"}}, None)
+        mock_removed.assert_not_called()
+        mock_added.assert_not_called()
+
+        await handlers["member_left_channel"]({"event": {"user": "UBOT", "channel": "C1"}}, None)
+        await handlers["member_joined_channel"]({"event": {"user": "UBOT", "channel": "C2"}}, None)
+        mock_removed.assert_called_once_with(app, "C1")
+        mock_added.assert_called_once_with(app, "C2")
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
index eaa9de5..50ade04 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -217,3 +217,45 @@ def test_ui_meta_exposes_bot_name_and_slash_command():
         meta = ui_meta()
     assert meta['bot_name'] == 'Hutbot (DEV)'
     assert meta['slash_command'] == '/hutbot_dev'
+
+
+@pytest.mark.asyncio
+async def test_ui_apply_config_keeps_the_automatic_disable_reason(monkeypatch):
+    _seed_user_caches()
+    hutbot.state.channel_config = {"C1": {"rule": {**DEFAULT_CONFIG.copy(), "enabled": False,
+                                                   "disabled_reason": DISABLED_REASON_REMOVED}}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+    app = _ui_app()
+
+    # Editing a rule that stays disabled keeps the marker...
+    ok, errors = await hutbot.webui_backend.ui_apply_config(app, "C1", "rule", {"reply_message": "Updated", "enabled": False})
+    assert ok is True and errors == {}
+    assert hutbot.state.channel_config["C1"]["rule"]["disabled_reason"] == DISABLED_REASON_REMOVED
+
+    # ...explicitly enabling a draft loaded after removal clears the marker.
+    ok, errors = await hutbot.webui_backend.ui_apply_config(
+        app, "C1", "rule",
+        {"reply_message": "Updated", "enabled": True, "disabled_reason": DISABLED_REASON_REMOVED},
+    )
+    assert ok is True and errors == {}
+    assert hutbot.state.channel_config["C1"]["rule"]["disabled_reason"] == ""
+
+
+@pytest.mark.asyncio
+async def test_ui_apply_config_stale_save_cannot_undo_removal_disable(monkeypatch):
+    _seed_user_caches()
+    stale_payload = {**DEFAULT_CONFIG.copy(), "reply_message": "Updated in stale editor"}
+    hutbot.state.channel_config = {"C1": {"rule": {
+        **DEFAULT_CONFIG.copy(),
+        "enabled": False,
+        "disabled_reason": DISABLED_REASON_REMOVED,
+    }}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+
+    ok, errors = await hutbot.webui_backend.ui_apply_config(_ui_app(), "C1", "rule", stale_payload)
+
+    assert ok is True and errors == {}
+    config = hutbot.state.channel_config["C1"]["rule"]
+    assert config["reply_message"] == "Updated in stale editor"
+    assert config["enabled"] is False
+    assert config["disabled_reason"] == DISABLED_REASON_REMOVED
diff --git a/webui_static/app.js b/webui_static/app.js
index 1a21b61..e5e2fa0 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -56,6 +56,8 @@ const ACTION_SHORT = { reply: "reply", dm_user: "dm", group_dm: "group dm", 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" };
+// Set by the bot itself when it is removed from a channel (see DISABLED_REASON_REMOVED).
+const DISABLED_REASON_LABEL = { removed_from_channel: "Disabled — the bot was removed from this channel" };
 
 // ---------- api ----------
 async function api(method, path, body) {
@@ -221,7 +223,9 @@ 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";
+  const title = !cfg.enabled
+    ? (DISABLED_REASON_LABEL[cfg.disabled_reason] || "Disabled")
+    : (cfg.opsgenie || cfg.button_timeout > 0) ? "Active · can escalate" : "Active";
   return h("span", { class: cls, title, role: "img", "aria-label": title });
 }
 
@@ -336,7 +340,8 @@ function renderEditor(name) {
 
   // — Status & trigger —
   const triggerRows = [grid(
-    field("This rule is", h("div", {}, toggleInput("enabled", cfg.enabled ? "Active" : "Disabled", { onAfter: () => { liveRefresh(); structuralRefreshLabelOnly(); } }))),
+    field("This rule is", h("div", {}, toggleInput("enabled", cfg.enabled ? "Active" : "Disabled", { onAfter: () => { liveRefresh(); structuralRefreshLabelOnly(); } })),
+      { hint: !cfg.enabled && DISABLED_REASON_LABEL[cfg.disabled_reason] ? "The bot disabled this rule when it was removed from this channel." : "" }),
     field("Trigger", selectInput("trigger", state.meta.triggers, TRIGGER_LABEL, structuralRefresh), { hint: triggerHint(cfg.trigger) }),
   )];
   if (cfg.trigger === "message") {

From 782bac74e1045530a8db6481197b5cccf44f198f Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 11:06:37 +0200
Subject: [PATCH 21/42] feat(bot): improve config display and timezone-aware
 scheduling

- Group settings by topic (triggers, conditions, timing, buttons, alerting)
in the `/info` output for better readability.
- Replace generic "Action target" with descriptive destination labels per
action type (reply, post, DM, group DM).
- Resolve and display the server's local timezone name and locale for
orientation when no explicit config is set.
- Use `datetimefmt.describe_*` to show timezone offsets and locale status
clearly in config output.
- Pass config dicts to `is_work_day` and `is_work_time` so work hours/days
are evaluated in the configured timezone rather than the server's.
- Add helper functions to detect server timezone/locale names from
environment variables and system paths.
---
 README.md                   |   4 +
 hutbot/commands/info.py     | 144 ++++++++++++++++++++++++++----------
 hutbot/datetimefmt.py       | 114 ++++++++++++++++++++++++++--
 hutbot/routing.py           |   4 +-
 tests/_common.py            |  15 +++-
 tests/test_commands_info.py |  73 ++++++++++++++++--
 tests/test_datetimefmt.py   | 111 +++++++++++++++++++++++++++
 7 files changed, 411 insertions(+), 54 deletions(-)

diff --git a/README.md b/README.md
index b9bbd9b..7f09f4b 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,10 @@ Opsgenie date/time variables support `fmt`/`format`, `tz`/`timezone`, and `lc`/`
 /hutbot [config] set datefmt "<date>" "<time>" [<timezone> <locale>]
 ```
 
+The `<timezone>` is also the timezone the config's work days and work hours are
+counted in. Without one, both fall back to the server's local time (UTC in the
+container unless `TZ` is set).
+
 Opsgenie alert priority defaults to `P4` and can be configured per channel config with:
 
 ```bash
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 5f296b8..089cd2f 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -1,5 +1,7 @@
 """Read-only slash-command handlers: lists, team lookup, and config display."""
 
+import re
+
 import aiohttp
 from slack_bolt.async_app import AsyncApp
 
@@ -10,8 +12,13 @@
 from .. import slackcache
 from .. import opsgenie
 from .. import buttons
+from .. import datetimefmt
 from ..buttonutil import normalize_button
+from .. import targets
 from ..constants import (
+    ACTION_DM_USER,
+    ACTION_GROUP_DM,
+    ACTION_POST_CHANNEL,
     ACTION_REPLY,
     DEFAULT_DATE_FORMAT,
     DEFAULT_TIME_FORMAT,
@@ -113,6 +120,41 @@ def format_table_value(value, key_width: int) -> str:
             return f"\n{' ' * (key_width + 2)}".join(value)
         return value
 
+    def format_target(target: str) -> str:
+        """Render an action target as a Slack mention when it looks like an id."""
+        target = (target or '').strip()
+        if not target:
+            return '<None>'
+        channel_id = targets.parse_channel_ref(target)
+        if channel_id:
+            return f"<#{channel_id}>"
+        if ID_PATTERN.fullmatch(target) or re.fullmatch(r'<!subteam\^[A-Z0-9]+(\|[^>]*)?>', target):
+            return target
+        if re.fullmatch(r'[UW][A-Z0-9]+', target):
+            return f"<@{target}>"
+        if re.fullmatch(r'S[A-Z0-9]+', target):
+            return f"<!subteam^{target}>"
+        return f"`{target}`"
+
+    def destination_lines(config: dict, action: str, trigger: str, forward_channel_id: str) -> list[str]:
+        """Where the message ends up, phrased per action instead of as raw fields."""
+        action_target = config.get('action_target') or ''
+        if action == ACTION_REPLY:
+            # A reply threads on the triggering message; schedule/manual runs have
+            # no message to thread on and land in the channel itself.
+            thread = ' (in thread)' if trigger == TRIGGER_MESSAGE else ''
+            lines = [f"*Replied to*: <#{channel.id}>{thread}"]
+            if forward_channel_id:
+                lines.append(f"*Forwarded to*: <#{forward_channel_id}>")
+            return lines
+        if action == ACTION_POST_CHANNEL:
+            return [f"*Posted to*: {format_target(action_target or forward_channel_id)}"]
+        if action == ACTION_DM_USER:
+            return [f"*Sent to*: {format_target(action_target)} (direct message)"]
+        if action == ACTION_GROUP_DM:
+            return [f"*Sent to*: {format_target(action_target)} (group message)"]
+        return [f"*Action*: `{action}`, target {format_target(action_target)}"]
+
     message = f"This is the configuration for #{channel.name}:"
     for config_name, config in sorted(channel.configs.items()):
         opsgenie_enabled = config.get('opsgenie')
@@ -129,52 +171,56 @@ def format_table_value(value, key_width: int) -> str:
         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>'
+        datetime_timezone = datetimefmt.describe_timezone(config.get('datetime_timezone') or '')
+        datetime_locale = datetimefmt.describe_locale(datetimefmt.get_config_locale(config))
         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>'),
-        ]
+        # Settings are grouped by topic, in the order a rule runs: when it fires,
+        # what gates it, what it matches, timing, buttons, alerting, formatting.
+        # Each group becomes a blank-line-separated block in the code block.
+        groups: list[list[tuple]] = []
 
         if trigger == TRIGGER_SCHEDULE:
-            rows.append(("Cron", config.get('schedule_cron') or '<None>'))
-            rows.append(("Schedule timezone", config.get('schedule_timezone') or '<server local>'))
+            # Same fallback chain the scheduler uses: own timezone, then the
+            # date/time one, then the server's.
+            schedule_timezone = config.get('schedule_timezone') or config.get('datetime_timezone') or ''
+            groups.append([
+                ("Cron",              config.get('schedule_cron') or '<None>'),
+                ("Schedule timezone", datetimefmt.describe_timezone(schedule_timezone)),
+            ])
+
         condition = config.get('condition') or ''
         if condition:
             negate = ' (negated)' if config.get('condition_negate') else ''
-            rows.append(("Condition", f"{condition}{negate}"))
+            condition_rows = [("Condition", f"{condition}{negate}")]
             if config.get('outlook_subject_pattern'):
-                rows.append(("Outlook subject", config.get('outlook_subject_pattern')))
+                condition_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>'))
+                condition_rows.append(("Outlook body", config.get('outlook_body_pattern')))
+            groups.append(condition_rows)
+
+        groups.append([
+            ("Pattern",        f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<None>'),
+            ("Included teams", included_teams),
+            ("Excluded teams", excluded_teams),
+            ("Include bots",   'enabled' if include_bots else 'disabled'),
+        ])
+
+        groups.append([
+            ("Wait time",      f"{wait_time_minutes} minutes"),
+            ("Only work days", 'enabled' if only_work_days else 'disabled'),
+            ("Work hours",     f"{hours[0]} - {hours[1]}" if len(hours) == 2 else 'all day'),
+        ])
+
         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_action, value = normalize_button(b)
+                return f"{b.get('label')} → {button_action}" + (f":{value}" if value else "")
+            button_rows = [("Buttons", [_button_label(b) for b in config_buttons])]
             button_timeout_minutes = (config.get('button_timeout') or 0) // 60
             if button_timeout_minutes:
                 kind, target = buttons._escalation_kind(config)
@@ -184,13 +230,33 @@ def _button_label(b):
                     escalates_to = f"run `{target}`"
                 else:
                     escalates_to = "nothing"
-                rows.append(("Button timeout", f"{button_timeout_minutes} minutes → {escalates_to}"))
+                button_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>"
+                button_rows.append(("Default button", config.get('default_button')))
+            groups.append(button_rows)
+
+        groups.append([
+            ("OpsGenie",          ('enabled' if opsgenie_enabled else 'disabled') + ('' if state.opsgenie_configured else ' (not configured)')),
+            ("OpsGenie schedule", opsgenie_schedule_name or '<None>'),
+            ("OpsGenie priority", opsgenie_priority),
+            ("OpsGenie message",  config.get('opsgenie_message') or '<original message>'),
+        ])
+
+        groups.append([
+            ("Date format",        date_format),
+            ("Time format",        time_format),
+            ("Date/time timezone", datetime_timezone),
+            ("Date/time locale",   datetime_locale),
+        ])
+
+        key_width = max(len(label) for group in groups for label, _ in group)
+        config_block = "\n\n".join(
+            "\n".join(f"{label:<{key_width}}  {format_table_value(value, key_width)}" for label, value in group)
+            for group in groups
+        )
+        message_label = 'Reply message' if action == ACTION_REPLY else 'Message'
+        reply_line = f"*{message_label}*:\n{reply_message}" if reply_message else f"*{message_label}*: <None>"
+        destinations = "\n".join(destination_lines(config, action, trigger, forward_channel_id))
         if replies_enabled:
             enabled_label = 'enabled'
         elif config.get('disabled_reason') == DISABLED_REASON_REMOVED:
@@ -198,9 +264,11 @@ def _button_label(b):
         else:
             enabled_label = 'disabled'
         quoted_block = (
+            f"> *Trigger*: `{trigger}`\n"
+            f">\n"
             f"> {reply_line.replace('\n', '\n> ')}\n"
             f">\n"
-            f"> {forward_channel_line}\n"
+            f"> {destinations.replace('\n', '\n> ')}\n"
             f">\n"
             f"> *Settings*:\n"
         )
diff --git a/hutbot/datetimefmt.py b/hutbot/datetimefmt.py
index 7652a27..fcfef54 100644
--- a/hutbot/datetimefmt.py
+++ b/hutbot/datetimefmt.py
@@ -1,5 +1,7 @@
 """Date/time parsing, formatting, locale handling, and work-hours helpers."""
 
+import locale as locale_module
+import os
 import re
 import datetime
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
@@ -27,21 +29,26 @@ def parse_time(time_str) -> datetime.time | None:
     return time
 
 
-def is_work_day() -> bool:
-    today = datetime.date.today()
+def is_work_day(config: dict | None = None) -> bool:
+    # Work days are counted in the config's timezone, so a rule set to
+    # Asia/Tokyo rolls over to the next day when Tokyo does, not when the
+    # server does.
+    today = datetime.datetime.now(get_config_timezone(config)).date()
     # TODO: add holidays
     return today.weekday() < 5
 
 
-def is_work_time(start_time_str: str, end_time_str: str) -> bool:
-    now = datetime.datetime.now()
+def is_work_time(start_time_str: str, end_time_str: str, config: dict | None = None) -> bool:
+    # Work hours are wall-clock times in the config's timezone; without one they
+    # fall back to the server's, which is what this did before timezones existed.
+    now = datetime.datetime.now(get_config_timezone(config))
     start = parse_time(start_time_str)
     end = parse_time(end_time_str)
     if not start or not end:
         log_error(f"Invalid time format {start_time_str} - {end_time_str}")
         return True
-    start_today = datetime.datetime.combine(now.date(), start)
-    end_today = datetime.datetime.combine(now.date(), end)
+    start_today = datetime.datetime.combine(now.date(), start, tzinfo=now.tzinfo)
+    end_today = datetime.datetime.combine(now.date(), end, tzinfo=now.tzinfo)
     return start_today < now < end_today
 
 
@@ -75,6 +82,83 @@ def get_local_timezone() -> datetime.tzinfo:
     return datetime.datetime.now().astimezone().tzinfo or datetime.timezone.utc
 
 
+def get_local_timezone_name() -> str:
+    """Best-effort zone name of the server, e.g. ``Europe/Berlin`` or ``Etc/UTC``.
+
+    Python only exposes the current abbreviation ("CEST"), so the IANA name is
+    read from the places the host keeps it. Falls back to the abbreviation when
+    none of them is available.
+    """
+    tz_env = os.environ.get("TZ", "").strip()
+    if tz_env:
+        return tz_env
+    try:
+        with open("/etc/timezone", encoding="utf-8") as f:
+            name = f.read().strip()
+        if name:
+            return name
+    except OSError:
+        pass
+    try:
+        target = os.path.realpath("/etc/localtime")
+    except OSError:
+        target = ""
+    marker = "/zoneinfo/"
+    if marker in target:
+        return target.split(marker, 1)[1]
+    return datetime.datetime.now().astimezone().tzname() or "UTC"
+
+
+def describe_timezone(timezone_name: str = "") -> str:
+    """``Europe/Berlin (CEST, UTC+02:00)`` — the zone plus its offset right now.
+
+    An empty ``timezone_name`` describes the server's own timezone and says so.
+    """
+    if timezone_name:
+        try:
+            tz = ZoneInfo(validate_timezone_name(timezone_name))
+        except ValueError:
+            return f"{timezone_name} (unknown timezone)"
+        name = timezone_name
+    else:
+        tz = get_local_timezone()
+        name = get_local_timezone_name()
+
+    now = datetime.datetime.now(tz)
+    abbreviation = now.tzname() or ""
+    offset = now.strftime("%z")
+    details = []
+    # "Etc/UTC (UTC, UTC+00:00)" says the same thing three times; keep the
+    # abbreviation only when the zone name does not already carry it.
+    if abbreviation and not name.split("/")[-1].startswith(abbreviation):
+        details.append(abbreviation)
+    details.append(f"UTC{offset[:3]}:{offset[3:]}" if offset else "UTC+00:00")
+    if not timezone_name:
+        details.append("server local time")
+    return f"{name} ({', '.join(details)})"
+
+
+def get_server_locale_name() -> str:
+    """The server's own locale as ``de_DE``, or empty when it has none set.
+
+    Only informational: the bot never applies it — date/time names come from
+    :data:`LOCALIZED_DATE_NAMES` and only when a config sets a locale.
+    """
+    candidates = list(locale_module.getlocale(locale_module.LC_TIME) or ())
+    candidates.append(os.environ.get("LC_ALL", ""))
+    candidates.append(os.environ.get("LC_TIME", ""))
+    candidates.append(os.environ.get("LANG", ""))
+    for candidate in candidates:
+        candidate = (candidate or "").split(".", 1)[0].strip()
+        if not candidate or candidate in ("C", "POSIX"):
+            continue
+        try:
+            return normalize_locale_name(candidate)
+        except ValueError:
+            continue
+    return ""
+
+
 def get_config_timezone(config: dict | None, timezone_name: str = "", local_tz: datetime.tzinfo | None = None) -> datetime.tzinfo:
     if local_tz is not None:
         return local_tz
@@ -195,6 +279,24 @@ def localize_formatted_datetime(value: str, locale_name: str) -> str:
     return value
 
 
+def describe_locale(locale_name: str = "") -> str:
+    """What day/month names a config actually gets, and why.
+
+    Unset means English names — the server's own locale is never applied, so it
+    is only mentioned for orientation. A configured locale without a translation
+    table (only `de` has one) also ends up English.
+    """
+    if locale_name:
+        language = locale_name.split("_", 1)[0].lower()
+        if language in LOCALIZED_DATE_NAMES:
+            return locale_name
+        return f"{locale_name} (no translations, English names)"
+    server_locale = get_server_locale_name()
+    if server_locale:
+        return f"English names (server locale {server_locale} not applied)"
+    return "English names (no server locale set)"
+
+
 def parse_opsgenie_datetime(value: str) -> datetime.datetime | None:
     if not value:
         return None
diff --git a/hutbot/routing.py b/hutbot/routing.py
index 8116bc8..829765a 100644
--- a/hutbot/routing.py
+++ b/hutbot/routing.py
@@ -151,10 +151,10 @@ async def handle_channel_message(app: AsyncApp, opsgenie_token: str, channel, us
         pattern = config.get('pattern')
         pattern_case_sensitive = config.get('pattern_case_sensitive')
 
-        if only_work_days and not datetimefmt.is_work_day():
+        if only_work_days and not datetimefmt.is_work_day(config):
             log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because of a non work day.")
             continue
-        if len(hours) == 2 and not datetimefmt.is_work_time(hours[0], hours[1]):
+        if len(hours) == 2 and not datetimefmt.is_work_time(hours[0], hours[1], config):
             log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because it was sent outside work time.")
             continue
         if not user_matches_actor_criteria(config, user, actor_is_bot):
diff --git a/tests/_common.py b/tests/_common.py
index 6411cd8..4581e60 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -6,16 +6,27 @@
 import tempfile
 import asyncio
 import datetime
+from types import SimpleNamespace
+from zoneinfo import ZoneInfo
 
 import pytest
-from unittest.mock import AsyncMock, MagicMock, patch, call
+from unittest.mock import AsyncMock, MagicMock, mock_open, patch, call
 
 import outlook
 from slack_sdk.errors import SlackApiError
 from employee_list import get_env_var
 
 from hutbot.models import Channel, User, Usergroup, ScheduledReply
-from hutbot.constants import DEFAULT_CONFIG, DISABLED_REASON_REMOVED, bot_slug, normalize_slash_command
+from hutbot.constants import (
+    ACTION_DM_USER,
+    ACTION_GROUP_DM,
+    ACTION_POST_CHANNEL,
+    DEFAULT_CONFIG,
+    DISABLED_REASON_REMOVED,
+    TRIGGER_SCHEDULE,
+    bot_slug,
+    normalize_slash_command,
+)
 from hutbot.textutil import extract_message_text
 from hutbot.datetimefmt import parse_time, is_work_day, is_work_time
 from hutbot.persistence import migrate_and_apply_defaults, load_replies_cache, flush_replies_cache
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 3eada84..1ca1a85 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -21,13 +21,20 @@ async def test_show_config():
 
         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 "> *Trigger*: `message`\n>\n> *Reply message*:\n> Default message\n>\n> *Replied to*: <#C123> (in thread)\n>\n> *Settings*:\n```" in sent_message
+        assert "\nTrigger" not in sent_message
         assert "OpsGenie schedule" in sent_message
         assert "OpsGenie priority   P4" in sent_message
+        # Settings are grouped, each group separated by a blank line.
+        assert (
+            "Wait time           10 minutes\n"
+            "Only work days      disabled\n"
+            "Work hours          all day\n"
+            "\n"
+            "OpsGenie            disabled"
+        ) 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
@@ -37,6 +44,30 @@ async def test_show_config():
 
 
 
+@pytest.mark.asyncio
+async def test_show_config_resolves_the_server_timezone_and_locale():
+    app = AsyncMock()
+    configs = {
+        "default": DEFAULT_CONFIG.copy(),
+        "tokyo": {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Asia/Tokyo", "datetime_locale": "de-DE"},
+    }
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch.dict(os.environ, {"TZ": "Europe/Berlin"}), \
+         patch('hutbot.datetimefmt.get_server_locale_name', return_value="de_DE"), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    lines = mock_send_message.call_args.args[3].splitlines()
+    assert any(line.startswith("Date/time timezone  Europe/Berlin (") and line.endswith(", server local time)") for line in lines)
+    assert "Date/time locale    English names (server locale de_DE not applied)" in lines
+    assert "Date/time timezone  Asia/Tokyo (JST, UTC+09:00)" in lines
+    assert "Date/time locale    de_DE" in lines
+    assert "<server local>" not in mock_send_message.call_args.args[3]
+
+
+
 @pytest.mark.asyncio
 async def test_show_config_displays_multiline_team_values():
     app = AsyncMock()
@@ -180,12 +211,12 @@ async def test_show_config_displays_forward_channel():
         await show_config(app, channel, user, "")
 
     sent_message = mock_send_message.call_args.args[3]
-    assert "*Forward channel*: <#CFWDCHAN>" in sent_message
+    assert "*Replied to*: <#C123> (in thread)\n> *Forwarded to*: <#CFWDCHAN>" in sent_message
 
 
 
 @pytest.mark.asyncio
-async def test_show_config_displays_none_for_missing_forward_channel():
+async def test_show_config_omits_forward_line_without_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")
@@ -194,7 +225,37 @@ async def test_show_config_displays_none_for_missing_forward_channel():
         await show_config(app, channel, user, "")
 
     sent_message = mock_send_message.call_args.args[3]
-    assert "*Forward channel*: <None>" in sent_message
+    assert "*Replied to*: <#C123> (in thread)" in sent_message
+    assert "Forwarded to" not in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_show_config_names_the_destination_per_action():
+    app = AsyncMock()
+    configs = {
+        "post": {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL, "action_target": "<#CTARGET|targets>"},
+        "dm": {**DEFAULT_CONFIG.copy(), "action": ACTION_DM_USER, "action_target": "d.grieser@mittwald.de"},
+        "group": {**DEFAULT_CONFIG.copy(), "action": ACTION_GROUP_DM, "action_target": "SGROUP"},
+        "scheduled": {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_SCHEDULE, "schedule_cron": "0 9 * * 1-5"},
+    }
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Posted to*: <#CTARGET>" in sent_message
+    assert "*Sent to*: `d.grieser@mittwald.de` (direct message)" in sent_message
+    assert "*Sent to*: <!subteam^SGROUP> (group message)" in sent_message
+    # No message to thread on for a schedule trigger.
+    assert "*Replied to*: <#C123>\n" in sent_message
+    assert "Cron                0 9 * * 1-5" in sent_message
+    assert any(line.startswith("Schedule timezone   ") and "server local" in line for line in sent_message.splitlines())
+    # Non-reply actions title their template "Message", not "Reply message".
+    assert "*Message*:" in sent_message
+    assert "Action target" not in sent_message
 
 
 
diff --git a/tests/test_datetimefmt.py b/tests/test_datetimefmt.py
index a2d84b7..a817a8e 100644
--- a/tests/test_datetimefmt.py
+++ b/tests/test_datetimefmt.py
@@ -26,3 +26,114 @@ def test_format_datetime_value_supports_go_layout_args():
     )
 
     assert rendered == "26.04.2026 08:00"
+
+
+
+def test_describe_timezone_names_the_zone_and_its_current_offset():
+    import hutbot
+    assert hutbot.datetimefmt.describe_timezone("Asia/Tokyo") == "Asia/Tokyo (JST, UTC+09:00)"
+    assert hutbot.datetimefmt.describe_timezone("Nowhere/Sometime") == "Nowhere/Sometime (unknown timezone)"
+
+
+
+def test_describe_timezone_falls_back_to_the_server_timezone():
+    import hutbot
+    with patch.dict(os.environ, {"TZ": "Australia/Sydney"}):
+        described = hutbot.datetimefmt.describe_timezone()
+
+    assert described.startswith("Australia/Sydney (")
+    assert described.endswith(", server local time)")
+
+
+
+def test_get_local_timezone_name_prefers_tz_then_etc_timezone():
+    import hutbot
+    with patch.dict(os.environ, {"TZ": "America/New_York"}):
+        assert hutbot.datetimefmt.get_local_timezone_name() == "America/New_York"
+
+    with patch.dict(os.environ, {}, clear=True), \
+         patch('builtins.open', mock_open(read_data="Etc/UTC\n")):
+        assert hutbot.datetimefmt.get_local_timezone_name() == "Etc/UTC"
+
+
+
+def test_get_local_timezone_name_reads_the_localtime_symlink():
+    import hutbot
+    with patch.dict(os.environ, {}, clear=True), \
+         patch('builtins.open', side_effect=OSError), \
+         patch('os.path.realpath', return_value="/usr/share/zoneinfo/Europe/Berlin"):
+        assert hutbot.datetimefmt.get_local_timezone_name() == "Europe/Berlin"
+
+
+
+def test_describe_locale_explains_what_names_a_config_gets():
+    import hutbot
+    assert hutbot.datetimefmt.describe_locale("de_DE") == "de_DE"
+    assert hutbot.datetimefmt.describe_locale("fr_FR") == "fr_FR (no translations, English names)"
+
+    with patch('hutbot.datetimefmt.get_server_locale_name', return_value="de_DE"):
+        assert hutbot.datetimefmt.describe_locale() == "English names (server locale de_DE not applied)"
+
+    with patch('hutbot.datetimefmt.get_server_locale_name', return_value=""):
+        assert hutbot.datetimefmt.describe_locale() == "English names (no server locale set)"
+
+
+
+def test_get_server_locale_name_uses_lc_time_then_the_environment():
+    import hutbot
+    with patch('locale.getlocale', return_value=("de_DE", "UTF-8")):
+        assert hutbot.datetimefmt.get_server_locale_name() == "de_DE"
+
+    with patch('locale.getlocale', return_value=(None, None)), \
+         patch.dict(os.environ, {"LANG": "en_GB.UTF-8"}, clear=True):
+        assert hutbot.datetimefmt.get_server_locale_name() == "en_GB"
+
+    with patch('locale.getlocale', return_value=("C", None)), \
+         patch.dict(os.environ, {"LANG": "C.UTF-8"}, clear=True):
+        assert hutbot.datetimefmt.get_server_locale_name() == ""
+
+
+
+def test_describe_timezone_does_not_repeat_the_abbreviation_in_the_zone_name():
+    import hutbot
+    with patch.dict(os.environ, {"TZ": "Etc/UTC"}), \
+         patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Etc/UTC")):
+        assert hutbot.datetimefmt.describe_timezone() == "Etc/UTC (UTC+00:00, server local time)"
+    assert hutbot.datetimefmt.describe_timezone("UTC") == "UTC (UTC+00:00)"
+
+
+
+def frozen_datetime_module(moment: datetime.datetime):
+    """Stand-in for the `datetime` module whose `now()` always returns `moment`."""
+    class Frozen(datetime.datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return moment.astimezone(tz) if tz else moment
+
+    return SimpleNamespace(datetime=Frozen, date=datetime.date, time=datetime.time, timezone=datetime.timezone)
+
+
+
+def test_work_hours_are_counted_in_the_configured_timezone():
+    import hutbot
+    # 23:30 in Berlin is 06:30 the next day in Tokyo: inside 6-18 Tokyo hours,
+    # outside 6-18 Berlin hours.
+    berlin_late_evening = datetime.datetime(2026, 4, 26, 23, 30, tzinfo=ZoneInfo("Europe/Berlin"))
+
+    with patch.object(hutbot.datetimefmt, 'datetime', frozen_datetime_module(berlin_late_evening)):
+        assert hutbot.datetimefmt.is_work_time("6", "18", {"datetime_timezone": "Asia/Tokyo"}) is True
+        assert hutbot.datetimefmt.is_work_time("6", "18", {"datetime_timezone": "Europe/Berlin"}) is False
+        # No configured timezone: the server's, as before.
+        with patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Asia/Tokyo")):
+            assert hutbot.datetimefmt.is_work_time("6", "18", {}) is True
+
+
+
+def test_work_days_are_counted_in_the_configured_timezone():
+    import hutbot
+    # Friday 23:30 in Berlin is already Saturday in Tokyo.
+    berlin_friday_night = datetime.datetime(2026, 4, 24, 23, 30, tzinfo=ZoneInfo("Europe/Berlin"))
+
+    with patch.object(hutbot.datetimefmt, 'datetime', frozen_datetime_module(berlin_friday_night)):
+        assert hutbot.datetimefmt.is_work_day({"datetime_timezone": "Europe/Berlin"}) is True
+        assert hutbot.datetimefmt.is_work_day({"datetime_timezone": "Asia/Tokyo"}) is False

From 609b070a35325bd9cb178da240d16a8afa9a8ef8 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 11:59:49 +0200
Subject: [PATCH 22/42] feat(helm): add instance-wide timezone and locale
 defaults

Configure `time.timezone` and `time.locale` in the Helm chart to set
instance-wide defaults for date/time formatting. These values are passed
to the container via environment variables (`TZ` and
`HUTBOT_DEFAULT_DATETIME_LOCALE`).

- Add new `time` section to Helm values with `timezone` and `locale` keys
- Update deployment template to inject env vars when values are set
- Update `helmfile` template to support these settings
- Implement fallback logic in Python: configs without their own locale
now use the instance default
- Update UI hints to clarify that blank fields use server local time or
instance defaults
- Add tests for deployment validation and locale fallback behavior
---
 README.md                               | 23 ++++++++++--
 charts/hutbot/templates/deployment.yaml | 10 +++++-
 charts/hutbot/values.yaml               | 11 ++++++
 helmfile.yaml.gotmpl                    | 10 ++++++
 hutbot/__main__.py                      |  4 +++
 hutbot/commands/info.py                 |  2 +-
 hutbot/datetimefmt.py                   | 48 ++++++++++++++++++-------
 hutbot/state.py                         |  9 ++++-
 tests/test_commands_info.py             | 13 +++++++
 tests/test_datetimefmt.py               | 37 +++++++++++++++++++
 tests/test_deployment_validation.py     | 31 ++++++++++++++++
 webui_static/app.js                     |  4 +--
 12 files changed, 183 insertions(+), 19 deletions(-)

diff --git a/README.md b/README.md
index 7f09f4b..608a21c 100644
--- a/README.md
+++ b/README.md
@@ -23,8 +23,27 @@ Opsgenie date/time variables support `fmt`/`format`, `tz`/`timezone`, and `lc`/`
 ```
 
 The `<timezone>` is also the timezone the config's work days and work hours are
-counted in. Without one, both fall back to the server's local time (UTC in the
-container unless `TZ` is set).
+counted in. Without one, both fall back to the server's local time.
+
+Instance-wide defaults for configs that set neither come from the deployment
+(`time.timezone` / `time.locale` in the Helm chart, `HUTBOT_TIMEZONE` /
+`HUTBOT_DEFAULT_DATETIME_LOCALE` for `helmfile`):
+
+- `time.timezone` is the container's `TZ`, i.e. the server local timezone. The
+  image itself is UTC, so without it every config that sets no timezone formats
+  and counts work hours in UTC.
+- `time.locale` is the fallback date/time locale. Only `de` has translations;
+  every other locale renders English day/month names. The server's own `LANG` is
+  never used for this.
+
+Neither has a default: without them the instance runs UTC with English names.
+The `.env` / `.env-dev` files the deploy scripts source are the place to set
+them, e.g. `HUTBOT_TIMEZONE='Europe/Berlin'` and
+`HUTBOT_DEFAULT_DATETIME_LOCALE='de_DE'`.
+
+`show config` prints what a config actually ends up with, e.g.
+`Date/time timezone  Europe/Berlin (CEST, UTC+02:00, server local time)` and
+`Date/time locale    de_DE (instance default)`.
 
 Opsgenie alert priority defaults to `P4` and can be configured per channel config with:
 
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 67ceabb..b0da639 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -34,8 +34,16 @@ spec:
             - name: http
               containerPort: {{ .Values.ui.port }}
           {{- end }}
-          {{- if or .Values.persistence.enabled .Values.ui.enabled .Values.slack.slashCommand .Values.slack.botName }}
+          {{- if or .Values.persistence.enabled .Values.ui.enabled .Values.slack.slashCommand .Values.slack.botName .Values.time.timezone .Values.time.locale }}
           env:
+            {{- if .Values.time.timezone }}
+            - name: TZ
+              value: {{ .Values.time.timezone | quote }}
+            {{- end }}
+            {{- if .Values.time.locale }}
+            - name: HUTBOT_DEFAULT_DATETIME_LOCALE
+              value: {{ .Values.time.locale | quote }}
+            {{- end }}
             {{- if .Values.slack.slashCommand }}
             - name: HUTBOT_SLASH_COMMAND
               value: {{ .Values.slack.slashCommand | quote }}
diff --git a/charts/hutbot/values.yaml b/charts/hutbot/values.yaml
index 795fea5..9d20f85 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -19,6 +19,17 @@ slack:
   # Empty = the bot's default ("Hutbot").
   botName: ""
 
+# Timezone and date/time locale the whole instance runs in.
+time:
+  # IANA zone name forced into the container as TZ, e.g. "Europe/Berlin". This is
+  # the server local timezone: configs that set no timezone of their own format
+  # date/times in it and have their work days/work hours counted in it. Empty =
+  # the image default, UTC.
+  timezone: ""
+  # Fallback date/time locale for configs that set none, e.g. "de_DE". Only `de`
+  # has translations; every other locale renders English day/month names.
+  locale: ""
+
 opsgenie:
   token: ""
   heartbeatName: ""
diff --git a/helmfile.yaml.gotmpl b/helmfile.yaml.gotmpl
index 82e0e5e..d0c2067 100644
--- a/helmfile.yaml.gotmpl
+++ b/helmfile.yaml.gotmpl
@@ -8,6 +8,11 @@ environments:
         imageTag: v1.0.9
         slashCommand: /hutbot
         botName: Hutbot
+        # Timezone and date/time locale of the instance; set them in the env file
+        # (HUTBOT_TIMEZONE / HUTBOT_DEFAULT_DATETIME_LOCALE). Empty means the
+        # image default: UTC and English day/month names.
+        timezone: ""
+        datetimeLocale: ""
   dev:
     values:
       - releaseName: hutbot-dev
@@ -17,6 +22,8 @@ environments:
         # slash command. Must match the command configured there.
         slashCommand: /hutbot_dev
         botName: Hutbot (DEV)
+        timezone: ""
+        datetimeLocale: ""
 ---
 repositories: []
 
@@ -34,6 +41,9 @@ releases:
           botToken: {{ requiredEnv "SLACK_BOT_TOKEN" | quote }}
           slashCommand: {{ env "HUTBOT_SLASH_COMMAND" | default .Values.slashCommand | quote }}
           botName: {{ env "HUTBOT_BOT_NAME" | default .Values.botName | quote }}
+      - time:
+          timezone: {{ env "HUTBOT_TIMEZONE" | default .Values.timezone | quote }}
+          locale: {{ env "HUTBOT_DEFAULT_DATETIME_LOCALE" | default .Values.datetimeLocale | quote }}
       - opsgenie:
           token: {{ env "OPSGENIE_TOKEN" | quote }}
           heartbeatName: {{ env "OPSGENIE_HEARTBEAT_NAME" | quote }}
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
index 4e0dda3..846c54c 100644
--- a/hutbot/__main__.py
+++ b/hutbot/__main__.py
@@ -8,6 +8,7 @@
 from employee_list import get_env_var, load_env_file, log_error
 
 from . import state
+from . import datetimefmt
 from .constants import DEFAULT_BOT_NAME, normalize_slash_command
 from . import persistence
 from . import slackcache
@@ -26,6 +27,9 @@ async def main() -> None:
     opsgenie_heartbeat_name = get_env_var("OPSGENIE_HEARTBEAT_NAME")
     state.slash_command = normalize_slash_command(get_env_var("HUTBOT_SLASH_COMMAND"))
     state.bot_name = get_env_var("HUTBOT_BOT_NAME").strip() or DEFAULT_BOT_NAME
+    # Locale for configs that set none. The timezone counterpart is the container's
+    # TZ: a config without its own timezone uses server local time anyway.
+    state.default_datetime_locale = datetimefmt.resolve_default_locale(get_env_var("HUTBOT_DEFAULT_DATETIME_LOCALE"))
     if slack_app_token is None or slack_bot_token is None:
         log_error("Environment variables SLACK_APP_TOKEN and SLACK_BOT_TOKEN must be set to run this app")
         exit(1)
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 089cd2f..5d1b21f 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -172,7 +172,7 @@ def destination_lines(config: dict, action: str, trigger: str, forward_channel_i
         date_format = config.get('date_format') or DEFAULT_DATE_FORMAT
         time_format = config.get('time_format') or DEFAULT_TIME_FORMAT
         datetime_timezone = datetimefmt.describe_timezone(config.get('datetime_timezone') or '')
-        datetime_locale = datetimefmt.describe_locale(datetimefmt.get_config_locale(config))
+        datetime_locale = datetimefmt.describe_locale(config.get('datetime_locale') or '')
         opsgenie_priority = opsgenie.get_opsgenie_priority(config)
         replies_enabled = config.get('enabled', True)
         trigger = config.get('trigger', TRIGGER_MESSAGE)
diff --git a/hutbot/datetimefmt.py b/hutbot/datetimefmt.py
index fcfef54..69bcc7c 100644
--- a/hutbot/datetimefmt.py
+++ b/hutbot/datetimefmt.py
@@ -8,6 +8,7 @@
 
 from employee_list import log_error, log_warning
 
+from . import state
 from .constants import (
     DEFAULT_DATE_FORMAT,
     DEFAULT_TIME_FORMAT,
@@ -176,11 +177,24 @@ def get_config_timezone(config: dict | None, timezone_name: str = "", local_tz:
 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 ""
+        # Instance-wide fallback (HUTBOT_DEFAULT_DATETIME_LOCALE), empty unless set.
+        return state.default_datetime_locale
     try:
         return normalize_locale_name(configured_locale)
     except ValueError as e:
         log_warning("Ignoring invalid datetime locale in configuration:", e)
+        return state.default_datetime_locale
+
+
+def resolve_default_locale(value: str) -> str:
+    """Normalize the instance-wide default locale, warning about a bad value."""
+    value = (value or "").strip()
+    if not value:
+        return ""
+    try:
+        return normalize_locale_name(value)
+    except ValueError as e:
+        log_error("Ignoring invalid HUTBOT_DEFAULT_DATETIME_LOCALE:", e)
         return ""
 
 
@@ -282,19 +296,29 @@ def localize_formatted_datetime(value: str, locale_name: str) -> str:
 def describe_locale(locale_name: str = "") -> str:
     """What day/month names a config actually gets, and why.
 
-    Unset means English names — the server's own locale is never applied, so it
-    is only mentioned for orientation. A configured locale without a translation
-    table (only `de` has one) also ends up English.
+    Takes the config's own locale; empty falls back to the instance default
+    (HUTBOT_DEFAULT_DATETIME_LOCALE) and, failing that, to English. The server's
+    own locale is never applied and is only named for orientation. A locale
+    without a translation table (only `de` has one) also ends up English.
     """
+    notes = []
     if locale_name:
-        language = locale_name.split("_", 1)[0].lower()
-        if language in LOCALIZED_DATE_NAMES:
-            return locale_name
-        return f"{locale_name} (no translations, English names)"
-    server_locale = get_server_locale_name()
-    if server_locale:
-        return f"English names (server locale {server_locale} not applied)"
-    return "English names (no server locale set)"
+        try:
+            effective = normalize_locale_name(locale_name)
+        except ValueError:
+            return f"{locale_name} (invalid locale, English names)"
+    elif state.default_datetime_locale:
+        effective = state.default_datetime_locale
+        notes.append("instance default")
+    else:
+        server_locale = get_server_locale_name()
+        if server_locale:
+            return f"English names (server locale {server_locale} not applied)"
+        return "English names (no server locale set)"
+
+    if effective.split("_", 1)[0].lower() not in LOCALIZED_DATE_NAMES:
+        notes.append("no translations, English names")
+    return f"{effective} ({', '.join(notes)})" if notes else effective
 
 
 def parse_opsgenie_datetime(value: str) -> datetime.datetime | None:
diff --git a/hutbot/state.py b/hutbot/state.py
index dae2c26..554a90c 100644
--- a/hutbot/state.py
+++ b/hutbot/state.py
@@ -20,6 +20,12 @@
 # Name the bot uses for itself in user-facing text; set from HUTBOT_BOT_NAME at startup.
 bot_name = DEFAULT_BOT_NAME
 
+# Date/time locale used by configs that set none; set from
+# HUTBOT_DEFAULT_DATETIME_LOCALE at startup and already normalized ("de_DE").
+# There is no timezone counterpart: the container's TZ is the server local
+# timezone, which is what a config without its own timezone already uses.
+default_datetime_locale = ""
+
 # Live configuration: {channel_id: {config_name: config_dict}}.
 channel_config: dict = {}
 
@@ -60,7 +66,7 @@
 
 def reset() -> None:
     """Reset all shared state to its initial values (used by the test suite)."""
-    global _scheduler_last_check, bot_user_id, bot_user_name, opsgenie_configured, slash_command, bot_name
+    global _scheduler_last_check, bot_user_id, bot_user_name, opsgenie_configured, slash_command, bot_name, default_datetime_locale
     channel_config.clear()
     scheduled_messages.clear()
     _scheduled_replies_cache.clear()
@@ -79,3 +85,4 @@ def reset() -> None:
     opsgenie_configured = False
     slash_command = DEFAULT_SLASH_COMMAND
     bot_name = DEFAULT_BOT_NAME
+    default_datetime_locale = ""
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 1ca1a85..ecdb8d4 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -339,3 +339,16 @@ async def test_show_config_explains_an_automatic_disable():
     sent_message = mock_send_message.call_args.args[3]
     assert "*Configuration*: `removed` (disabled, because Hutbot was removed from this channel)" in sent_message
     assert "*Configuration*: `by-hand` (disabled)" in sent_message
+
+
+@pytest.mark.asyncio
+async def test_show_config_marks_the_instance_default_locale():
+    app = AsyncMock()
+    channel = Channel(id="C123", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch('hutbot.state.default_datetime_locale', "de_DE"), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    assert "Date/time locale    de_DE (instance default)" in mock_send_message.call_args.args[3].splitlines()
diff --git a/tests/test_datetimefmt.py b/tests/test_datetimefmt.py
index a817a8e..df6c07d 100644
--- a/tests/test_datetimefmt.py
+++ b/tests/test_datetimefmt.py
@@ -137,3 +137,40 @@ def test_work_days_are_counted_in_the_configured_timezone():
     with patch.object(hutbot.datetimefmt, 'datetime', frozen_datetime_module(berlin_friday_night)):
         assert hutbot.datetimefmt.is_work_day({"datetime_timezone": "Europe/Berlin"}) is True
         assert hutbot.datetimefmt.is_work_day({"datetime_timezone": "Asia/Tokyo"}) is False
+
+
+
+def test_instance_default_locale_applies_to_configs_without_one():
+    import hutbot
+    with patch('hutbot.state.default_datetime_locale', "de_DE"):
+        assert hutbot.datetimefmt.get_config_locale({}) == "de_DE"
+        assert hutbot.datetimefmt.get_config_locale({"datetime_locale": "en-US"}) == "en_US"
+        # An unusable config locale falls back to the default, not to English.
+        assert hutbot.datetimefmt.get_config_locale({"datetime_locale": "nonsense!"}) == "de_DE"
+        assert hutbot.datetimefmt.describe_locale("") == "de_DE (instance default)"
+        assert hutbot.datetimefmt.describe_locale("en_US") == "en_US (no translations, English names)"
+
+    rendered = hutbot.datetimefmt.format_datetime_value(
+        "2026-04-26T08:00:00Z", "date", {"date_format": "%A, %d %B %Y", "datetime_timezone": "Europe/Berlin"},
+    )
+    assert rendered == "Sunday, 26 April 2026"
+    with patch('hutbot.state.default_datetime_locale', "de_DE"):
+        rendered = hutbot.datetimefmt.format_datetime_value(
+            "2026-04-26T08:00:00Z", "date", {"date_format": "%A, %d %B %Y", "datetime_timezone": "Europe/Berlin"},
+        )
+    assert rendered == "Sonntag, 26 April 2026"
+
+
+
+def test_resolve_default_locale_rejects_garbage():
+    import hutbot
+    assert hutbot.datetimefmt.resolve_default_locale(" de-de ") == "de_DE"
+    assert hutbot.datetimefmt.resolve_default_locale("") == ""
+    assert hutbot.datetimefmt.resolve_default_locale("Deutsch (Deutschland)") == ""
+
+
+
+def test_describe_locale_flags_an_invalid_config_locale():
+    import hutbot
+    with patch('hutbot.state.default_datetime_locale', ""):
+        assert hutbot.datetimefmt.describe_locale("nonsense!") == "nonsense! (invalid locale, English names)"
diff --git a/tests/test_deployment_validation.py b/tests/test_deployment_validation.py
index 45e94c0..ee1c537 100644
--- a/tests/test_deployment_validation.py
+++ b/tests/test_deployment_validation.py
@@ -57,3 +57,34 @@ def test_chart_accepts_pinned_tag():
 
     assert result.returncode == 0, result.stderr
     assert "image: \"hutbot:v1.2.3\"" in result.stdout
+
+
+def test_chart_forces_timezone_and_default_locale_when_set():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3") + [
+            "--set", "time.timezone=Europe/Berlin",
+            "--set", "time.locale=de_DE",
+        ],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "- name: TZ\n              value: \"Europe/Berlin\"" in result.stdout
+    assert "- name: HUTBOT_DEFAULT_DATETIME_LOCALE\n              value: \"de_DE\"" in result.stdout
+
+
+def test_chart_omits_timezone_and_locale_by_default():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3"),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "name: TZ" not in result.stdout
+    assert "HUTBOT_DEFAULT_DATETIME_LOCALE" not in result.stdout
diff --git a/webui_static/app.js b/webui_static/app.js
index e5e2fa0..9b9d0ea 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -573,8 +573,8 @@ function formattingSection() {
   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") }),
+    field("Timezone", textInput("datetime_timezone", { mono: true, placeholder: "Europe/Berlin" }), { hint: "IANA name; also counts work days/hours. Blank = server local time.", error: fieldErr("datetime_timezone") }),
+    field("Locale", textInput("datetime_locale", { mono: true, placeholder: "de_DE" }), { hint: "Blank = the instance default. Only de has translations.", error: fieldErr("datetime_locale") }),
   ), h("div", { class: "toggles-row mt-md" }, toggleInput("debug", "Verbose debug logging")));
   const details = h("details", { class: "section formatting" }, h("summary", { class: "section-title summary-toggle", text: "Date & time formatting" }), body);
   return details;

From 911976f288be177610f71eb44aca693c2d730886 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 14:10:32 +0200
Subject: [PATCH 23/42] fix(info): improve action description labels and null
 formatting

- Replace `<None>` with `<none>` for consistent lowercase null representation
- Remove colons from action destination labels (e.g., "Replied to:" -> "Replied in")
- Update tests to reflect new string formatting in info command output
---
 hutbot/commands/info.py     | 24 ++++++++++++------------
 tests/test_commands_info.py | 14 +++++++-------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 5d1b21f..c255e13 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -116,7 +116,7 @@ async def show_config(app: AsyncApp, channel, user, thread_ts: str = "") -> None
     def format_table_value(value, key_width: int) -> str:
         if isinstance(value, list):
             if not value:
-                return '<None>'
+                return '<none>'
             return f"\n{' ' * (key_width + 2)}".join(value)
         return value
 
@@ -124,7 +124,7 @@ def format_target(target: str) -> str:
         """Render an action target as a Slack mention when it looks like an id."""
         target = (target or '').strip()
         if not target:
-            return '<None>'
+            return '<none>'
         channel_id = targets.parse_channel_ref(target)
         if channel_id:
             return f"<#{channel_id}>"
@@ -143,17 +143,17 @@ def destination_lines(config: dict, action: str, trigger: str, forward_channel_i
             # A reply threads on the triggering message; schedule/manual runs have
             # no message to thread on and land in the channel itself.
             thread = ' (in thread)' if trigger == TRIGGER_MESSAGE else ''
-            lines = [f"*Replied to*: <#{channel.id}>{thread}"]
+            lines = [f"*Replied in* <#{channel.id}>{thread}"]
             if forward_channel_id:
-                lines.append(f"*Forwarded to*: <#{forward_channel_id}>")
+                lines.append(f"*Forwarded to* <#{forward_channel_id}>")
             return lines
         if action == ACTION_POST_CHANNEL:
-            return [f"*Posted to*: {format_target(action_target or forward_channel_id)}"]
+            return [f"*Posted in* {format_target(action_target or forward_channel_id)}"]
         if action == ACTION_DM_USER:
-            return [f"*Sent to*: {format_target(action_target)} (direct message)"]
+            return [f"*Sent to* {format_target(action_target)} (direct message)"]
         if action == ACTION_GROUP_DM:
-            return [f"*Sent to*: {format_target(action_target)} (group message)"]
-        return [f"*Action*: `{action}`, target {format_target(action_target)}"]
+            return [f"*Sent to* {format_target(action_target)} (group message)"]
+        return [f"*Action* `{action}`, target {format_target(action_target)}"]
 
     message = f"This is the configuration for #{channel.name}:"
     for config_name, config in sorted(channel.configs.items()):
@@ -188,7 +188,7 @@ def destination_lines(config: dict, action: str, trigger: str, forward_channel_i
             # date/time one, then the server's.
             schedule_timezone = config.get('schedule_timezone') or config.get('datetime_timezone') or ''
             groups.append([
-                ("Cron",              config.get('schedule_cron') or '<None>'),
+                ("Cron",              config.get('schedule_cron') or '<none>'),
                 ("Schedule timezone", datetimefmt.describe_timezone(schedule_timezone)),
             ])
 
@@ -203,7 +203,7 @@ def destination_lines(config: dict, action: str, trigger: str, forward_channel_i
             groups.append(condition_rows)
 
         groups.append([
-            ("Pattern",        f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<None>'),
+            ("Pattern",        f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<none>'),
             ("Included teams", included_teams),
             ("Excluded teams", excluded_teams),
             ("Include bots",   'enabled' if include_bots else 'disabled'),
@@ -237,7 +237,7 @@ def _button_label(b):
 
         groups.append([
             ("OpsGenie",          ('enabled' if opsgenie_enabled else 'disabled') + ('' if state.opsgenie_configured else ' (not configured)')),
-            ("OpsGenie schedule", opsgenie_schedule_name or '<None>'),
+            ("OpsGenie schedule", opsgenie_schedule_name or '<none>'),
             ("OpsGenie priority", opsgenie_priority),
             ("OpsGenie message",  config.get('opsgenie_message') or '<original message>'),
         ])
@@ -255,7 +255,7 @@ def _button_label(b):
             for group in groups
         )
         message_label = 'Reply message' if action == ACTION_REPLY else 'Message'
-        reply_line = f"*{message_label}*:\n{reply_message}" if reply_message else f"*{message_label}*: <None>"
+        reply_line = f"*{message_label}*:\n{reply_message}" if reply_message else f"*{message_label}*: <none>"
         destinations = "\n".join(destination_lines(config, action, trigger, forward_channel_id))
         if replies_enabled:
             enabled_label = 'enabled'
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index ecdb8d4..ab8a624 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -21,7 +21,7 @@ async def test_show_config():
 
         sent_message = mock_send_message.call_args.args[3]
         assert "\n\n*Configuration*: `default` (enabled)" in sent_message
-        assert "> *Trigger*: `message`\n>\n> *Reply message*:\n> Default message\n>\n> *Replied to*: <#C123> (in thread)\n>\n> *Settings*:\n```" in sent_message
+        assert "> *Trigger*: `message`\n>\n> *Reply message*:\n> Default message\n>\n> *Replied in* <#C123> (in thread)\n>\n> *Settings*:\n```" in sent_message
         assert "\nTrigger" not in sent_message
         assert "OpsGenie schedule" in sent_message
         assert "OpsGenie priority   P4" in sent_message
@@ -211,7 +211,7 @@ async def test_show_config_displays_forward_channel():
         await show_config(app, channel, user, "")
 
     sent_message = mock_send_message.call_args.args[3]
-    assert "*Replied to*: <#C123> (in thread)\n> *Forwarded to*: <#CFWDCHAN>" in sent_message
+    assert "*Replied in* <#C123> (in thread)\n> *Forwarded to* <#CFWDCHAN>" in sent_message
 
 
 
@@ -225,7 +225,7 @@ async def test_show_config_omits_forward_line_without_forward_channel():
         await show_config(app, channel, user, "")
 
     sent_message = mock_send_message.call_args.args[3]
-    assert "*Replied to*: <#C123> (in thread)" in sent_message
+    assert "*Replied in* <#C123> (in thread)" in sent_message
     assert "Forwarded to" not in sent_message
 
 
@@ -246,11 +246,11 @@ async def test_show_config_names_the_destination_per_action():
         await show_config(app, channel, user, "")
 
     sent_message = mock_send_message.call_args.args[3]
-    assert "*Posted to*: <#CTARGET>" in sent_message
-    assert "*Sent to*: `d.grieser@mittwald.de` (direct message)" in sent_message
-    assert "*Sent to*: <!subteam^SGROUP> (group message)" in sent_message
+    assert "*Posted in* <#CTARGET>" in sent_message
+    assert "*Sent to* `d.grieser@mittwald.de` (direct message)" in sent_message
+    assert "*Sent to* <!subteam^SGROUP> (group message)" in sent_message
     # No message to thread on for a schedule trigger.
-    assert "*Replied to*: <#C123>\n" in sent_message
+    assert "*Replied in* <#C123>\n" in sent_message
     assert "Cron                0 9 * * 1-5" in sent_message
     assert any(line.startswith("Schedule timezone   ") and "server local" in line for line in sent_message.splitlines())
     # Non-reply actions title their template "Message", not "Reply message".

From 87acf9eb5989ea3ec18f2807e47928ae63af22e8 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 14:53:44 +0200
Subject: [PATCH 24/42] fix(dispatch): handle invalid wait-time input and
 improve error handling

- Allow `set_wait_time` to accept string input and validate it locally.
- Return user-friendly error message for non-numeric or out-of-range wait times.
- Wrap command processing in try/except to prevent crashes from unexpected errors.
- Log errors using centralized logging and notify users of failures.
- Add tests for invalid wait time values and error reporting.
---
 hutbot/commands/dispatch.py    | 20 ++++++++++++++++++--
 hutbot/commands/setters.py     | 11 ++++++++---
 tests/test_commands_setters.py | 28 ++++++++++++++++++++++++++++
 3 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index 8e26f1b..2073b89 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -1,7 +1,11 @@
 """Command dispatch: match a slash-command string and run the matching handler."""
 
+import traceback
+
 from slack_bolt.async_app import AsyncApp
 
+from employee_list import log_error
+
 from .. import state
 from .. import messaging
 from .. import opsgenie
@@ -19,8 +23,7 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         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)
+        await setters.set_wait_time(app, channel, config_name, match.group("wait_time"), user, thread_ts)
     elif (match := patterns.SET_REPLY_MESSAGE_PATTERN.match(command_text)):
         message = strip_quotes(match.group("message"))
         await setters.set_reply_message(app, channel, config_name, message, user, thread_ts)
@@ -134,6 +137,19 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
 
 
 async def process_command(app: AsyncApp, text: str, channel, user, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> None:
+    try:
+        await _process_command(app, text, channel, user, thread_ts, opsgenie_token, allow_test_message, command_ts)
+    except Exception as e:
+        # Never let a bad command take down the listener: log it and tell the user.
+        log_error(f"Failed to process command in #{getattr(channel, 'name', '?')}: {text}", e)
+        log_error(traceback.format_exc())
+        try:
+            await messaging.send_message(app, channel, user, "Sorry, something went wrong while running that command. :confused: Please check the syntax with `" + state.slash_command + " help`.", thread_ts)
+        except Exception as send_error:
+            log_error("Failed to report command error to the user:", send_error)
+
+
+async def _process_command(app: AsyncApp, text: str, channel, user, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> None:
     text = text.replace(f"<@{state.bot_user_id}>", "").strip()
     log_debug(channel, f"Received command for channel #{channel.name}: {text}")
     command_ts = command_ts or thread_ts
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index 9c43e0e..c9954b6 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -235,13 +235,18 @@ async def set_datetime_format(app: AsyncApp, channel, config_name: str, values:
     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()
+async def set_wait_time(app: AsyncApp, channel, config_name: str, wait_time_str: str, user, thread_ts: str = "") -> None:
     # check if number and in range 0-1440
+    try:
+        wait_time_minutes = int(strip_quotes(wait_time_str or "").strip())
+    except (TypeError, ValueError):
+        await messaging.send_message(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
+        return
     if not wait_time_minutes or wait_time_minutes < 0 or wait_time_minutes > 1440:
         await messaging.send_message(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
         return
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
 
     channel.configs[config_name]['wait_time'] = wait_time_minutes * 60  # Convert to seconds
     log_debug(channel, f"Wait time for #{channel.name} set to {wait_time_minutes} minutes for configuration `{config_name}`")
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index d820cb2..3a6f013 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -30,6 +30,34 @@ async def test_process_command_set_wait_time_custom_config():
 
 
 
+@pytest.mark.asyncio
+async def test_process_command_set_wait_time_invalid_value():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+    original_wait_time = channel.configs["default"]["wait_time"]
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set wait-time 30s", channel, user, thread_ts)
+        assert channel.configs["default"]["wait_time"] == original_wait_time
+        mock_send_message.assert_called_with(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
+
+
+@pytest.mark.asyncio
+async def test_process_command_reports_unexpected_errors():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.messaging.send_message') as mock_send_message, \
+            patch('hutbot.commands.dispatch.parse_and_execute_command', side_effect=RuntimeError("boom")):
+        await process_command(app, "set wait-time 10", channel, user, thread_ts)
+        assert mock_send_message.await_count == 1
+        assert "something went wrong" in mock_send_message.await_args.args[3]
+
+
 @pytest.mark.asyncio
 async def test_process_command_set_datetime_format_with_quotes_timezone_and_locale():
     app = AsyncMock()

From 40be80ea003ce57d657829fe96a5dd246102b430 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 15:22:49 +0200
Subject: [PATCH 25/42] feat(hutbot): add 'all day' work hours and group help
 commands

- Allow setting work hours to "all day" via the `set work-hours all day`
command, which is stored internally as `0:00 0:00`.
- Reorganize the help message into logical groups (Configurations, Trigger,
Condition, etc.) to improve readability and match the order of rule execution.
- Update tests to verify the new command syntax and help message structure.
---
 hutbot/commands/dispatch.py    |   7 +-
 hutbot/commands/patterns.py    |   5 +-
 hutbot/messaging.py            | 137 ++++++++++++++++++++-------------
 tests/test_commands_info.py    |   7 ++
 tests/test_commands_setters.py |  29 +++++++
 5 files changed, 128 insertions(+), 57 deletions(-)

diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index 2073b89..5e2b105 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -56,8 +56,11 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
     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"))
+        if match.group("all_day"):
+            start = end = "0:00"
+        else:
+            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)
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index ae710a2..d18aae8 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -31,7 +31,10 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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>.+)')
+# `all day` is the spelled-out form of `0:00 0:00`, which is how "no restriction"
+# is stored. It has to come first in the alternation or `<start> <end>` would
+# swallow it as the two times "all" and "day".
+SET_WORK_HOURS_PATTERN = create_command_pattern(r'(set\s+)?(work[_ -]?)?hours\s+(?:(?P<all_day>all[_ -]?day)\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)
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 7704595..afa82d1 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -180,61 +180,90 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
     command = state.slash_command
     name = state.bot_name
     mention = f"@{state.bot_user_name}"
-    command_rows = [
-        (f"{command} show config", "Show all configurations."),
-        (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
-        (f"{command} [config] disable opsgenie", "Disable OpsGenie alerts."),
-        (f"{command} [config] set opsgenie-schedule <name>", "Set the OpsGenie schedule name."),
-        (f"{command} [config] set opsgenie-priority <P1-P5>", "Set the OpsGenie alert priority."),
-        (f"{command} [config] set opsgenie-message <text>", "Template for the alert text (default: the message)."),
-        (f"{command} [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Set date/time formats."),
-        (f"{command} [config] set wait-time <minutes>", "Set reminder delay."),
-        (f"{command} list teams", "List available teams."),
-        (f"{command} list opsgenie-schedules", "List OpsGenie schedules."),
-        (f"{command} [config] on-call [schedule]", "Show current on-call user."),
-        (f"{command} team of <@user>", "Show a user's team."),
-        (f"{command} [config] add excluded-team <team>", "Add an ignored team."),
-        (f"{command} [config] clear excluded-teams", "Clear ignored teams."),
-        (f"{command} [config] add included-team <team>", "Add an allowed team."),
-        (f"{command} [config] clear included-teams", "Clear allowed teams."),
-        (f"{command} [config] enable bots", "Respond to bot messages."),
-        (f"{command} [config] disable bots", "Ignore bot messages."),
-        (f"{command} [config] enable only-work-days", "Respond only on work days."),
-        (f"{command} [config] disable only-work-days", "Respond on all days."),
-        (f"{command} [config] enable", "Enable sending replies for this config."),
-        (f"{command} [config] disable", "Disable sending replies for this config."),
-        (f"{command} [config] set work-hours <start> <end>", "Set active hours; 0:00 0:00 means all day."),
-        (f"{command} [config] set pattern \"<regex>\" [0|1]", "Set message pattern; 1 means case sensitive."),
-        (f"{command} [config] set message \"<reply message>\"", "Set reminder message."),
-        (f"{command} [config] set forward-channel <#channel>", "Forward replies to another channel."),
-        (f"{command} [config] clear forward-channel", "Remove the forward channel."),
-        (f"{command} [config] set trigger <message|schedule|manual>", "Set how the rule starts."),
-        (f"{command} [config] set cron <expr>", "Set the cron schedule, e.g. 0 9 * * 1-5."),
-        (f"{command} [config] set schedule-timezone <tz>", "Set the cron timezone (IANA name)."),
-        (f"{command} [config] set condition <none|outlook>", "Gate a schedule on a condition."),
-        (f"{command} [config] set outlook-subject <regex>", "Match Outlook event subject (stub)."),
-        (f"{command} [config] set outlook-body <regex>", "Match Outlook event body (stub)."),
-        (f"{command} [config] enable negate", "Invert the condition (e.g. no matching event)."),
-        (f"{command} [config] disable negate", "Stop inverting the condition."),
-        (f"{command} [config] set action <reply|dm-user|group-dm|post-channel>", "Set what the rule does."),
-        (f"{command} [config] set target <@user|@group|#channel>", "Set the action recipient."),
-        (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
-        (f"{command} [config] add button \"<label>\" ack [text]", "Button acknowledges/dismisses (stops escalation)."),
-        (f"{command} [config] add button \"<label>\" message <text>", "Button posts a fixed message."),
-        (f"{command} [config] add button \"<label>\" delay <minutes>", "Button delays the escalation."),
-        (f"{command} [config] clear buttons", "Remove all buttons."),
-        (f"{command} [config] set button-timeout <minutes>", "Escalate if no button is pressed in time."),
-        (f"{command} [config] set button-timeout-target <config>", "Config to run on button timeout."),
-        (f"{command} [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
-        (f"{command} [config] run", "Run this configuration's action now."),
-        (f"{command} [config] test", "Preview configured reply."),
-        (f"{mention} [config] test <message>", "Preview reply with <message> as {{message}}."),
-        (f"{command} delete config <name>", "Delete a configuration."),
-        (f"{command} news", "Show what's new."),
-        (f"{command} help", "Show this help."),
+    # Grouped in the order a rule runs — configs, then trigger, condition, what it
+    # matches, timing, the message it sends, buttons, alerting, formatting — with
+    # lookups and meta commands last. Same grouping as `show config` prints.
+    command_groups = [
+        ("Configurations", [
+            (f"{command} show config", "Show all configurations."),
+            (f"{command} [config] enable", "Enable this config."),
+            (f"{command} [config] disable", "Disable this config."),
+            (f"{command} delete config <name>", "Delete a configuration."),
+        ]),
+        ("Trigger", [
+            (f"{command} [config] set trigger <message|schedule|manual>", "Set how the rule starts."),
+            (f"{command} [config] set cron <expr>", "Set the cron schedule, e.g. 0 9 * * 1-5."),
+            (f"{command} [config] set schedule-timezone <tz>", "Set the cron timezone (IANA name)."),
+        ]),
+        ("Condition", [
+            (f"{command} [config] set condition <none|outlook>", "Gate a schedule on a condition."),
+            (f"{command} [config] set outlook-subject <regex>", "Match Outlook event subject (stub)."),
+            (f"{command} [config] set outlook-body <regex>", "Match Outlook event body (stub)."),
+            (f"{command} [config] enable negate", "Invert the condition (e.g. no matching event)."),
+            (f"{command} [config] disable negate", "Stop inverting the condition."),
+        ]),
+        ("What to react to", [
+            (f"{command} [config] set pattern \"<regex>\" [0|1]", "Set message pattern; 1 means case sensitive."),
+            (f"{command} [config] add included-team <team>", "Add an allowed team."),
+            (f"{command} [config] clear included-teams", "Clear allowed teams."),
+            (f"{command} [config] add excluded-team <team>", "Add an ignored team."),
+            (f"{command} [config] clear excluded-teams", "Clear ignored teams."),
+            (f"{command} [config] enable bots", "Respond to bot messages."),
+            (f"{command} [config] disable bots", "Ignore bot messages."),
+        ]),
+        ("When to react", [
+            (f"{command} [config] set wait-time <minutes>", "Set reminder delay."),
+            (f"{command} [config] enable only-work-days", "Respond only on work days."),
+            (f"{command} [config] disable only-work-days", "Respond on all days."),
+            (f"{command} [config] set work-hours <start> <end>", "Set active hours, e.g. 9:00 17:00."),
+            (f"{command} [config] set work-hours all day", "React at any hour (same as 0:00 0:00)."),
+        ]),
+        ("Message and action", [
+            (f"{command} [config] set message \"<reply message>\"", "Set reminder message."),
+            (f"{command} [config] set action <reply|dm-user|group-dm|post-channel>", "Set what the rule does."),
+            (f"{command} [config] set target <@user|@group|#channel>", "Set the action recipient."),
+            (f"{command} [config] set forward-channel <#channel>", "Forward replies to another channel."),
+            (f"{command} [config] clear forward-channel", "Remove the forward channel."),
+        ]),
+        ("Buttons", [
+            (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
+            (f"{command} [config] add button \"<label>\" ack [text]", "Button acknowledges/dismisses (stops escalation)."),
+            (f"{command} [config] add button \"<label>\" message <text>", "Button posts a fixed message."),
+            (f"{command} [config] add button \"<label>\" delay <minutes>", "Button delays the escalation."),
+            (f"{command} [config] clear buttons", "Remove all buttons."),
+            (f"{command} [config] set button-timeout <minutes>", "Escalate if no button is pressed in time."),
+            (f"{command} [config] set button-timeout-target <config>", "Config to run on button timeout."),
+            (f"{command} [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
+        ]),
+        ("OpsGenie", [
+            (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
+            (f"{command} [config] disable opsgenie", "Disable OpsGenie alerts."),
+            (f"{command} [config] set opsgenie-schedule <name>", "Set the OpsGenie schedule name."),
+            (f"{command} [config] set opsgenie-priority <P1-P5>", "Set the OpsGenie alert priority."),
+            (f"{command} [config] set opsgenie-message <text>", "Template for the alert text (default: the message)."),
+        ]),
+        ("Date and time", [
+            (f"{command} [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Set date/time formats."),
+        ]),
+        ("Try it out and look things up", [
+            (f"{command} [config] run", "Run this configuration's action now."),
+            (f"{command} [config] test", "Preview configured reply."),
+            (f"{mention} [config] test <message>", "Preview reply with <message> as {{message}}."),
+            (f"{command} [config] on-call [schedule]", "Show current on-call user."),
+            (f"{command} list teams", "List available teams."),
+            (f"{command} list opsgenie-schedules", "List OpsGenie schedules."),
+            (f"{command} team of <@user>", "Show a user's team."),
+        ]),
+        ("Help", [
+            (f"{command} news", "Show what's new."),
+            (f"{command} help", "Show this help."),
+        ]),
     ]
-    command_width = max(len(command) for command, _ in command_rows)
-    command_usage = "\n".join(f"{command:<{command_width}}  {description}" for command, description in command_rows)
+    command_width = max(len(command) for _, rows in command_groups for command, _ in rows)
+    command_usage = "\n\n".join(
+        f"# {title}\n" + "\n".join(f"{command:<{command_width}}  {description}" for command, description in rows)
+        for title, rows in command_groups
+    )
     help_text = (
         f"Hi! :wave: I am *{name}* :palm_up_hand::tophat: Here's what I can do:\n\n"
         "*Show All Configurations:*\n"
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index ab8a624..b659396 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -137,6 +137,13 @@ async def test_process_command_help_uses_compact_command_reference():
     assert "*Commands:*\n```" in sent_message
     assert "/hutbot [config] set wait-time <minutes>" in sent_message
     assert "Set reminder delay." in sent_message
+    # Commands are grouped, each group headed and separated by a blank line.
+    assert "# Configurations\n/hutbot show config" in sent_message
+    assert "\n\n# Trigger\n" in sent_message
+    assert "\n\n# OpsGenie\n" in sent_message
+    assert "\n\n# Help\n/hutbot news" in sent_message
+    assert sent_message.index("# Trigger") < sent_message.index("# When to react") < sent_message.index("# Buttons")
+    assert "/hutbot [config] set work-hours all day" 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
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 3a6f013..fb7a790 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -324,3 +324,32 @@ async def test_set_replies_enabled_clears_the_automatic_disable_reason():
 
     assert channel.configs["default"]["enabled"] is True
     assert channel.configs["default"]["disabled_reason"] == ""
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["set work-hours all day", "set work hours all-day", "hours allday"])
+async def test_set_work_hours_accepts_all_day(command):
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "hours": ["8:00", "16:00"]}})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert channel.configs["default"]["hours"] == []
+    assert mock_send_message.call_args.args[3] == "*Work hours* set to all day in configuration `default`"
+
+
+@pytest.mark.asyncio
+async def test_set_work_hours_still_takes_two_times():
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set work-hours 9 17", channel, user)
+
+    assert channel.configs["default"]["hours"] == ["09:00", "17:00"]
+    assert mock_send_message.call_args.args[3] == "*Work hours* set to `09:00` - `17:00` in configuration `default`"

From 4a815bbc1da4926da1d0c7e8af5be18ab1e2eff4 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 15:37:47 +0200
Subject: [PATCH 26/42] feat(scheduling): preserve original wait time in
 scheduled replies

- Store the initial `wait_time` in the persistence cache when scheduling
a reply to track the config value at creation time.
- Pass the original wait time through to the rescheduling logic.
- Update logging during restoration to distinguish between the remaining
time, the original configured wait, and any subsequent config changes.
- Add tests to verify logging behavior for new and legacy cache entries.
---
 hutbot/routing.py        |  3 ++
 hutbot/scheduling.py     | 28 ++++++++++++--
 tests/test_scheduling.py | 79 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 106 insertions(+), 4 deletions(-)

diff --git a/hutbot/routing.py b/hutbot/routing.py
index 829765a..722b835 100644
--- a/hutbot/routing.py
+++ b/hutbot/routing.py
@@ -177,6 +177,9 @@ async def handle_channel_message(app: AsyncApp, opsgenie_token: str, channel, us
             'user_id': user.id,
             'text': text,
             'send_at': send_at.isoformat(),
+            # The wait this reply was scheduled with; the config may change before
+            # it fires, and a restore logs both.
+            'wait_time': config['wait_time'],
         }
         await persistence.flush_replies_cache()
 
diff --git a/hutbot/scheduling.py b/hutbot/scheduling.py
index 540dc41..07c14f9 100644
--- a/hutbot/scheduling.py
+++ b/hutbot/scheduling.py
@@ -22,12 +22,30 @@
     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:
+def format_minutes(seconds: float) -> str:
+    minutes = int(seconds // 60)
+    return f"{minutes} min" if minutes == 1 else f"{minutes} mins"
+
+
+async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel, config: dict, config_name: str, user, text: str, ts: str, wait_time_override: float | None = None, original_wait_time: float | None = None) -> None:
     opsgenie_enabled = config.get('opsgenie')
     wait_time = config.get('wait_time')
     scheduled_message_key = (channel.id, ts, config_name)
     actual_wait = wait_time_override if wait_time_override is not None else wait_time
-    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 ''}")
+    if wait_time_override is None:
+        verb = "Scheduling"
+        timing = f"wait time {format_minutes(wait_time)}"
+    else:
+        # A restored reply keeps the deadline it was scheduled with, so log what it
+        # is actually waiting for — and name the wait time it started with, which
+        # the config may since have changed.
+        verb = "Rescheduling"
+        timing = f"{actual_wait:.0f}s remaining"
+        if original_wait_time is not None:
+            timing += f" of the original {format_minutes(original_wait_time)}"
+            if int(original_wait_time) != int(wait_time):
+                timing += f", config now {format_minutes(wait_time)}"
+    log(f"{verb} reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}, {timing}, opsgenie {'enabled' if opsgenie_enabled else 'disabled'}{', but not configured' if opsgenie_enabled and not state.opsgenie_configured else ''}")
     try:
         await asyncio.sleep(actual_wait)
         permalink = await slackcache.get_message_permalink(app, channel, ts)
@@ -146,8 +164,10 @@ async def restore_scheduled_replies(app: AsyncApp, opsgenie_token: str) -> None:
         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))
+        # Written since the cache gained the field; older entries have no original.
+        original_wait_time = entry.get('wait_time')
+        log(f"Restoring reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}, due {send_at.isoformat(timespec='seconds')}.")
+        task = asyncio.create_task(schedule_reply(app, opsgenie_token, channel, config, config_name, user, entry['text'], ts, wait_time_override=remaining, original_wait_time=original_wait_time))
         state.scheduled_messages[(channel.id, ts, config_name)] = ScheduledReply(task, user.id)
         restored += 1
     for key in invalid_keys:
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
index 8064d7b..696cd69 100644
--- a/tests/test_scheduling.py
+++ b/tests/test_scheduling.py
@@ -324,3 +324,82 @@ async def test_schedule_reply_always_routes_through_run_action():
         await hutbot.scheduling.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
     assert run.await_count == 1
     assert send.await_count == 0
+
+
+@pytest.mark.asyncio
+async def test_restore_logs_the_original_wait_time_not_the_current_one():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={"default": {**DEFAULT_CONFIG.copy(), "wait_time": 60}})
+    user = User("U1", "d.grieser", "Dave", "T")
+    hutbot.state.channel_config[channel.id] = channel.configs
+    future = datetime.datetime.now() + datetime.timedelta(seconds=223)
+    hutbot.state._scheduled_replies_cache[(channel.id, "M1", "default")] = {
+        'channel_id': channel.id, 'ts': "M1", 'config_name': "default",
+        'user_id': user.id, 'text': "x", 'send_at': future.isoformat(), 'wait_time': 1800,
+    }
+
+    logged = []
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=user)), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.log', side_effect=lambda *a: logged.append(" ".join(str(x) for x in a))):
+        await hutbot.scheduling.restore_scheduled_replies(app, "tok")
+        await asyncio.sleep(0)
+        for entry in list(hutbot.state.scheduled_messages.values()):
+            entry.task.cancel()
+
+    rescheduled = next(line for line in logged if line.startswith("Rescheduling"))
+    assert "223s remaining of the original 30 mins" in rescheduled
+    assert "config now 1 min" in rescheduled
+    assert not any("wait time 1 min," in line for line in logged)
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_restore_omits_the_original_wait_time_for_legacy_cache_entries():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={"default": {**DEFAULT_CONFIG.copy(), "wait_time": 60}})
+    user = User("U1", "d.grieser", "Dave", "T")
+    hutbot.state.channel_config[channel.id] = channel.configs
+    future = datetime.datetime.now() + datetime.timedelta(seconds=90)
+    hutbot.state._scheduled_replies_cache[(channel.id, "M2", "default")] = {
+        'channel_id': channel.id, 'ts': "M2", 'config_name': "default",
+        'user_id': user.id, 'text': "x", 'send_at': future.isoformat(),
+    }
+
+    logged = []
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=user)), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.log', side_effect=lambda *a: logged.append(" ".join(str(x) for x in a))):
+        await hutbot.scheduling.restore_scheduled_replies(app, "tok")
+        await asyncio.sleep(0)
+        for entry in list(hutbot.state.scheduled_messages.values()):
+            entry.task.cancel()
+
+    rescheduled = next(line for line in logged if line.startswith("Rescheduling"))
+    assert "90s remaining," in rescheduled
+    assert "original" not in rescheduled
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_caches_the_wait_time_it_scheduled_with():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "wait_time": 1800}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "d.grieser", "Dave", "T")
+
+    with patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply', new=AsyncMock()):
+        await hutbot.routing.handle_channel_message(app, "tok", channel, user, "hello", "M3")
+
+    entry = hutbot.state._scheduled_replies_cache[(channel.id, "M3", "default")]
+    assert entry['wait_time'] == 1800
+    for scheduled in list(hutbot.state.scheduled_messages.values()):
+        scheduled.task.cancel()
+    await asyncio.sleep(0)

From c9e629b8b86e910028e3aad239793e05525d6df7 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Tue, 11 Aug 2026 22:57:44 +0200
Subject: [PATCH 27/42] feat(k8s): expose running version in help and news
 messages

Pass the deployed image tag via `HUTBOT_VERSION` environment variable from
the Helm chart to the bot container. The application reads this value at
startup and displays it in `help` and `news` command outputs.

A normalization function ensures consistent version formatting (e.g.,
prefixed with `v`). A fallback version is used when the environment
variable is unset, such as during local development. Tests verify both
the Helm chart configuration and the bot's message generation.
---
 charts/hutbot/templates/deployment.yaml |  5 +++--
 hutbot/__init__.py                      |  2 ++
 hutbot/__main__.py                      |  5 ++++-
 hutbot/constants.py                     |  8 ++++++++
 hutbot/messaging.py                     |  6 ++++--
 hutbot/state.py                         | 10 ++++++++--
 tests/test_commands_info.py             | 14 ++++++++++++++
 tests/test_deployment_validation.py     | 13 +++++++++++++
 8 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index b0da639..5bddaed 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -34,8 +34,10 @@ spec:
             - name: http
               containerPort: {{ .Values.ui.port }}
           {{- end }}
-          {{- if or .Values.persistence.enabled .Values.ui.enabled .Values.slack.slashCommand .Values.slack.botName .Values.time.timezone .Values.time.locale }}
           env:
+            # What `help` / `news` report as the running version.
+            - name: HUTBOT_VERSION
+              value: {{ $imageTag | quote }}
             {{- if .Values.time.timezone }}
             - name: TZ
               value: {{ .Values.time.timezone | quote }}
@@ -72,7 +74,6 @@ spec:
             - name: HUTBOT_UI_USER_HEADER
               value: {{ .Values.ui.userHeader | quote }}
             {{- end }}
-          {{- end }}
           {{- if .Values.persistence.enabled }}
           volumeMounts:
             - name: config
diff --git a/hutbot/__init__.py b/hutbot/__init__.py
index 59d32fa..458f9bd 100644
--- a/hutbot/__init__.py
+++ b/hutbot/__init__.py
@@ -5,4 +5,6 @@
 (``python -m hutbot``).
 """
 
+# Fallback version, used when HUTBOT_VERSION is unset (running from a checkout).
+# Deployments get the real one from the chart, which passes the image tag.
 __version__ = "1.0.0"
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
index 846c54c..372f376 100644
--- a/hutbot/__main__.py
+++ b/hutbot/__main__.py
@@ -7,9 +7,10 @@
 
 from employee_list import get_env_var, load_env_file, log_error
 
+from . import __version__
 from . import state
 from . import datetimefmt
-from .constants import DEFAULT_BOT_NAME, normalize_slash_command
+from .constants import DEFAULT_BOT_NAME, normalize_slash_command, normalize_version
 from . import persistence
 from . import slackcache
 from . import scheduling
@@ -27,6 +28,8 @@ async def main() -> None:
     opsgenie_heartbeat_name = get_env_var("OPSGENIE_HEARTBEAT_NAME")
     state.slash_command = normalize_slash_command(get_env_var("HUTBOT_SLASH_COMMAND"))
     state.bot_name = get_env_var("HUTBOT_BOT_NAME").strip() or DEFAULT_BOT_NAME
+    # The deployed image tag, so `help` / `news` name the version actually running.
+    state.version = normalize_version(get_env_var("HUTBOT_VERSION")) or normalize_version(__version__)
     # Locale for configs that set none. The timezone counterpart is the container's
     # TZ: a config without its own timezone uses server local time anyway.
     state.default_datetime_locale = datetimefmt.resolve_default_locale(get_env_var("HUTBOT_DEFAULT_DATETIME_LOCALE"))
diff --git a/hutbot/constants.py b/hutbot/constants.py
index 6a5c572..37eb306 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -128,6 +128,14 @@ def bot_slug(name: str) -> str:
     return slug or DEFAULT_BOT_NAME.lower()
 
 
+def normalize_version(value: str) -> str:
+    """Display form of a version, e.g. "1.0.9" or "v1.0.9" -> "v1.0.9"."""
+    value = (value or "").strip()
+    if not value:
+        return ""
+    return value if value.startswith("v") else f"v{value}"
+
+
 def normalize_slash_command(value: str) -> str:
     """Return a usable Slack slash command, defaulting when unset."""
     value = (value or "").strip()
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index afa82d1..64daf8c 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -151,9 +151,10 @@ async def process_mentions(app: AsyncApp, message: str) -> tuple[bool, str, str]
 async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
     command = state.slash_command
     name = state.bot_name
+    version = state.version
     mention = f"@{state.bot_user_name}"
     update_text = (
-        f"Hi! :wave: I am *{name}* :palm_up_hand::tophat: Here's what's :new::\n\n"
+        f"Hi! :wave: I am *{name}* `{version}` :palm_up_hand::tophat: Here's what's :new::\n\n"
         "> :robot_face: *Triggers, actions & buttons*\n>\n"
         f"> Rules can now run on a `schedule` (cron), DM a user or group, post to a channel, and carry interactive buttons (with an auto-press default + timeout escalation). See `{command} help`.\n>\n"
         "> :calendar: *OpsGenie date/time template variables and defaults*\n>\n"
@@ -179,6 +180,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
     supported_template_variables = ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
     command = state.slash_command
     name = state.bot_name
+    version = state.version
     mention = f"@{state.bot_user_name}"
     # Grouped in the order a rule runs — configs, then trigger, condition, what it
     # matches, timing, the message it sends, buttons, alerting, formatting — with
@@ -265,7 +267,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         for title, rows in command_groups
     )
     help_text = (
-        f"Hi! :wave: I am *{name}* :palm_up_hand::tophat: Here's what I can do:\n\n"
+        f"Hi! :wave: I am *{name}* `{version}` :palm_up_hand::tophat: Here's what I can do:\n\n"
         "*Show All Configurations:*\n"
         f"> Either use the command `{command}` or just `{mention}` me.\n"
         f"```{command} show config\n"
diff --git a/hutbot/state.py b/hutbot/state.py
index 554a90c..c35d652 100644
--- a/hutbot/state.py
+++ b/hutbot/state.py
@@ -12,11 +12,16 @@
 import asyncio
 import datetime
 
-from .constants import DEFAULT_BOT_NAME, DEFAULT_SLASH_COMMAND
+from . import __version__
+from .constants import DEFAULT_BOT_NAME, DEFAULT_SLASH_COMMAND, normalize_version
 
 # Slash command this instance listens on; set from HUTBOT_SLASH_COMMAND at startup.
 slash_command = DEFAULT_SLASH_COMMAND
 
+# Version shown in `help` / `news`; set from HUTBOT_VERSION (the deployed image
+# tag) at startup, falling back to the package version.
+version = normalize_version(__version__)
+
 # Name the bot uses for itself in user-facing text; set from HUTBOT_BOT_NAME at startup.
 bot_name = DEFAULT_BOT_NAME
 
@@ -66,7 +71,7 @@
 
 def reset() -> None:
     """Reset all shared state to its initial values (used by the test suite)."""
-    global _scheduler_last_check, bot_user_id, bot_user_name, opsgenie_configured, slash_command, bot_name, default_datetime_locale
+    global _scheduler_last_check, bot_user_id, bot_user_name, opsgenie_configured, slash_command, bot_name, default_datetime_locale, version
     channel_config.clear()
     scheduled_messages.clear()
     _scheduled_replies_cache.clear()
@@ -86,3 +91,4 @@ def reset() -> None:
     slash_command = DEFAULT_SLASH_COMMAND
     bot_name = DEFAULT_BOT_NAME
     default_datetime_locale = ""
+    version = normalize_version(__version__)
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index b659396..b57d579 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -359,3 +359,17 @@ async def test_show_config_marks_the_instance_default_locale():
         await show_config(app, channel, user, "")
 
     assert "Date/time locale    de_DE (instance default)" in mock_send_message.call_args.args[3].splitlines()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["help", "news"])
+async def test_help_and_news_name_the_running_version(command):
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.state.version', "v1.2.3"), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert "I am *Hutbot* `v1.2.3` :palm_up_hand::tophat:" in mock_send_message.call_args.args[3]
diff --git a/tests/test_deployment_validation.py b/tests/test_deployment_validation.py
index ee1c537..1eb8db2 100644
--- a/tests/test_deployment_validation.py
+++ b/tests/test_deployment_validation.py
@@ -88,3 +88,16 @@ def test_chart_omits_timezone_and_locale_by_default():
     assert result.returncode == 0, result.stderr
     assert "name: TZ" not in result.stdout
     assert "HUTBOT_DEFAULT_DATETIME_LOCALE" not in result.stdout
+
+
+def test_chart_passes_the_image_tag_as_the_bot_version():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3"),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "- name: HUTBOT_VERSION\n              value: \"v1.2.3\"" in result.stdout

From 2a414cb4025960b4569d1ccf563124feae266cfa Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 12 Aug 2026 10:13:51 +0200
Subject: [PATCH 28/42] feat(slack): add date/time template variables and bot
 handle resolution

Introduce `{{date}}`, `{{time}}`, and `{{datetime}}` template variables that
render the triggering message's timestamp or the current time for scheduled
and manual triggers. These variables support the same formatting, timezone,
and locale arguments as existing Opsgenie datetime variables.

Update bot handle resolution to fetch the profile display name via the Slack
API, ensuring correct @mention examples in help text across different app
configurations.

Add tests for the new templating features and bot handle fetching logic.
---
 README.md                      |  2 +-
 hutbot/__main__.py             |  6 ++-
 hutbot/constants.py            |  5 +++
 hutbot/datetimefmt.py          | 28 ++++++++++++++
 hutbot/slackcache.py           | 22 +++++++++++
 hutbot/templating.py           | 19 +++++++++-
 tests/_common.py               |  1 +
 tests/test_commands_setters.py | 21 +++++++++++
 tests/test_entrypoint.py       | 38 +++++++++++++++++++
 tests/test_templating.py       | 68 ++++++++++++++++++++++++++++++++++
 10 files changed, 205 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 608a21c..6831c7d 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 The hutbot is a simple Slack bot that monitors messages in a channel and automatically replies in a thread if no one reacts or responds to the message within a configurable time period (by default 30 minutes). The bot reminds channel members that a message has gone unanswered. Scheduled reminders are cancelled when someone replies in the thread or reacts in a way that does not match the config criteria that caused that reminder to be scheduled, or when the original message is deleted. Users can adjust both the waiting time and the reminder message directly within the channel, including `{{variable}}` placeholders in the reminder text.
 
-Reply messages support built-in placeholders such as `{{user}}`, `{{channel}}`, and `{{message_link}}`. If a channel config also has an Opsgenie schedule configured via `/hutbot [config] set opsgenie-schedule <name>`, Hutbot can resolve the current on-call person and expose:
+Reply messages support built-in placeholders such as `{{user}}`, `{{channel}}`, and `{{message_link}}`. `{{date}}`, `{{time}}`, and `{{datetime}}` render the triggering message's time — or the time the rule ran, for `schedule`/`manual` triggers and for `test`/`run` — using the config's date/time format, timezone, and locale, and take the same `fmt`/`tz`/`lc` arguments as the Opsgenie date/time variables below. `{{timestamp}}` is the raw Slack timestamp of the same instant. If a channel config also has an Opsgenie schedule configured via `/hutbot [config] set opsgenie-schedule <name>`, Hutbot can resolve the current on-call person and expose:
 
 - `{{opsgenie_schedule_name}}` for the configured schedule
 - `{{opsgenie_current_user}}` for a Slack `@mention`
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
index 372f376..87055b2 100644
--- a/hutbot/__main__.py
+++ b/hutbot/__main__.py
@@ -46,9 +46,11 @@ async def main() -> None:
         await persistence.load_configuration(app)
         auth = await app.client.auth_test()
         state.bot_user_id = auth["user_id"]
-        # The Slack handle differs per app (hutbot vs. hutbot_dev), so the help
+        # The Slack handle differs per app (Hutbot vs. Hutbot_DEV), so the help
         # text's `@mention` examples have to come from the workspace, not a constant.
-        state.bot_user_name = auth.get("user") or DEFAULT_BOT_NAME
+        # The profile display name is the handle people type; auth.test only knows
+        # the flattened username ("hutbotdev").
+        state.bot_user_name = await slackcache.fetch_bot_handle(app, state.bot_user_id) or auth.get("user") or DEFAULT_BOT_NAME
         await slackcache.update_user_cache(app)
         await persistence.load_replies_cache()
         await scheduling.restore_scheduled_replies(app, opsgenie_token)
diff --git a/hutbot/constants.py b/hutbot/constants.py
index 37eb306..2e61e2d 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -174,7 +174,12 @@ def normalize_slash_command(value: str) -> str:
     "opsgenie_next_user",
     *OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
 }
+# Formatted renderings of ``{{timestamp}}``: the triggering message's time, or the
+# time the rule ran when there is no message behind it. Like the OpsGenie date/time
+# variables they take `fmt`/`tz`/`lc` arguments.
+DATETIME_TEMPLATE_VARIABLES = {"date", "time", "datetime"}
 SUPPORTED_TEMPLATE_VARIABLES = {
+    *DATETIME_TEMPLATE_VARIABLES,
     "channel",
     "channel_name",
     "config",
diff --git a/hutbot/datetimefmt.py b/hutbot/datetimefmt.py
index 69bcc7c..4180c49 100644
--- a/hutbot/datetimefmt.py
+++ b/hutbot/datetimefmt.py
@@ -333,6 +333,16 @@ def parse_opsgenie_datetime(value: str) -> datetime.datetime | None:
     return parsed
 
 
+def parse_slack_timestamp(value: str) -> datetime.datetime | None:
+    """Slack message timestamps are epoch seconds, e.g. "1786453297.645799"."""
+    if not value:
+        return None
+    try:
+        return datetime.datetime.fromtimestamp(float(value), datetime.timezone.utc)
+    except (TypeError, ValueError, OSError, OverflowError):
+        return None
+
+
 def format_datetime_value(
     value: str,
     part: str = "datetime",
@@ -343,7 +353,17 @@ def format_datetime_value(
     parsed = parse_opsgenie_datetime(value)
     if not parsed:
         return UNKNOWN_ONCALL_PERIOD_PLACEHOLDER
+    return render_datetime(parsed, part, config, args, local_tz)
 
+
+def render_datetime(
+    parsed: datetime.datetime,
+    part: str = "datetime",
+    config: dict | None = None,
+    args: dict[str, str] | None = None,
+    local_tz: datetime.tzinfo | None = None,
+) -> str:
+    """Format an instant with the config's date/time format, timezone, and locale."""
     args = args or {}
     timezone = get_config_timezone(config, args.get("tz", ""), local_tz)
     local_time = parsed.astimezone(timezone)
@@ -364,6 +384,14 @@ def format_datetime_value(
     return localize_formatted_datetime(local_time.strftime(fmt), locale_name)
 
 
+def format_timestamp_value(value: str, part: str = "datetime", config: dict | None = None, args: dict[str, str] | None = None) -> str:
+    """Render a Slack message timestamp for `{{date}}` / `{{time}}` / `{{datetime}}`."""
+    parsed = parse_slack_timestamp(value)
+    if not parsed:
+        return ""
+    return render_datetime(parsed, part, config, args)
+
+
 def format_opsgenie_template_datetime(value: str, variable: str, config: dict | None = None, args: dict[str, str] | None = None) -> str:
     part = variable.rsplit("_", 1)[-1]
     return format_datetime_value(value, part, config, args)
diff --git a/hutbot/slackcache.py b/hutbot/slackcache.py
index b99a047..53a6c45 100644
--- a/hutbot/slackcache.py
+++ b/hutbot/slackcache.py
@@ -177,6 +177,28 @@ async def fetch_user_by_id(app: AsyncApp, id: str, channel: Channel | None = Non
     return user
 
 
+async def fetch_bot_handle(app: AsyncApp, bot_user_id: str) -> str:
+    """The handle people actually type to mention the bot, e.g. "Hutbot_DEV".
+
+    ``auth.test`` only reports the bot user's username, which Slack derives from
+    the app name by lowercasing it and dropping punctuation ("hutbotdev"). The
+    handle shown in the mention autocomplete is the profile display name.
+    """
+    if not bot_user_id:
+        return ""
+    try:
+        response = await app.client.users_info(user=bot_user_id)
+    except SlackApiError as e:
+        log_error(f"Failed to fetch the bot user `{bot_user_id}`:", e)
+        return ""
+    slack_user = response.get('user') or {}
+    profile = slack_user.get('profile') or {}
+    for candidate in (profile.get('display_name'), profile.get('display_name_normalized'), slack_user.get('name')):
+        if candidate and candidate.strip():
+            return candidate.strip()
+    return ""
+
+
 async def get_user_by_id(app: AsyncApp, id: str, channel: Channel | None = None) -> User:
     await update_user_cache(app)
     user = state.id_user_cache.get(id, None)
diff --git a/hutbot/templating.py b/hutbot/templating.py
index e14ea68..b29df53 100644
--- a/hutbot/templating.py
+++ b/hutbot/templating.py
@@ -1,10 +1,13 @@
 """Parsing and rendering of ``{{variable}}`` reply-message templates."""
 
+import datetime
+
 from slack_bolt.async_app import AsyncApp
 
 from . import datetimefmt
 from . import opsgenie
 from .constants import (
+    DATETIME_TEMPLATE_VARIABLES,
     OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
     SUPPORTED_TEMPLATE_VARIABLES,
     TEAM_UNKNOWN,
@@ -153,7 +156,7 @@ def validate_template_expressions(message: str) -> str:
         )
 
     for expr in expressions:
-        if expr.args and expr.variable not in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
+        if expr.args and expr.variable not in OPSGENIE_DATETIME_TEMPLATE_VARIABLES | DATETIME_TEMPLATE_VARIABLES:
             return f"template variable `{{{{{expr.variable}}}}}` does not support arguments"
         if "tz" in expr.args:
             try:
@@ -201,7 +204,9 @@ def render_reply_message_template(message: str, variables: dict[str, str], confi
             last_index = end
             continue
 
-        if expr.variable in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
+        if expr.variable in DATETIME_TEMPLATE_VARIABLES:
+            rendered.append(datetimefmt.format_timestamp_value(variables.get("__timestamp_raw", ""), expr.variable, config, expr.args))
+        elif expr.variable in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
             raw_value = variables.get(f"__{expr.variable}_raw", "")
             if raw_value or expr.args:
                 rendered.append(datetimefmt.format_opsgenie_template_datetime(raw_value, expr.variable, config, expr.args))
@@ -221,7 +226,17 @@ async def build_reply_template_variables(app: AsyncApp, opsgenie_token: str, cha
     if include_opsgenie:
         opsgenie_template_variables = await opsgenie.get_opsgenie_template_variables(app, opsgenie_token, config)
 
+    # `test`, `run`, and schedule/manual triggers have no message behind them, so
+    # there is no Slack timestamp to report. Stand in the current time instead of
+    # rendering the time variables empty.
+    ts = ts or f"{datetime.datetime.now(datetime.timezone.utc).timestamp():.6f}"
+
     return {
+        "date": datetimefmt.format_timestamp_value(ts, "date", config),
+        "time": datetimefmt.format_timestamp_value(ts, "time", config),
+        "datetime": datetimefmt.format_timestamp_value(ts, "datetime", config),
+        # The raw timestamp, so `{{date(tz=...)}}` and friends can re-render it.
+        "__timestamp_raw": ts,
         "channel": f"#{channel.name}",
         "channel_name": channel.name,
         "config": config_name,
diff --git a/tests/_common.py b/tests/_common.py
index 4581e60..62d8aa3 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -1,6 +1,7 @@
 """Shared imports, helpers, and hutbot module aliases for the test suite."""
 
 import os
+import re
 import json
 import base64
 import tempfile
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index fb7a790..47ee61b 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -353,3 +353,24 @@ async def test_set_work_hours_still_takes_two_times():
 
     assert channel.configs["default"]["hours"] == ["09:00", "17:00"]
     assert mock_send_message.call_args.args[3] == "*Work hours* set to `09:00` - `17:00` in configuration `default`"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["test", "run"])
+async def test_test_and_run_populate_the_time_variables(command):
+    import hutbot
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "R1"}
+    config = {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}} on {{date}}, ts {{timestamp}}"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={})), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C1", "ts": "R1"})) as post, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    rendered = mock_send_message.call_args.args[3] if command == "test" else post.await_args.args[2]
+    assert "at  on , ts \n" not in rendered
+    assert "ts {{timestamp}}" not in rendered
+    assert re.search(r"at \d{2}:\d{2} on \w{3}, \d{2} \w{3} \d{4}, ts \d+\.\d+", rendered), rendered
diff --git a/tests/test_entrypoint.py b/tests/test_entrypoint.py
index 41d8a9e..a5e9a31 100644
--- a/tests/test_entrypoint.py
+++ b/tests/test_entrypoint.py
@@ -6,3 +6,41 @@ def test_legacy_bot_entrypoint_delegates_to_package_main():
     from hutbot.__main__ import main
 
     assert bot.main is main
+
+
+import pytest
+from unittest.mock import AsyncMock, patch
+
+
+@pytest.mark.asyncio
+async def test_fetch_bot_handle_prefers_the_profile_display_name():
+    import hutbot
+    app = AsyncMock()
+    app.client.users_info.return_value = {
+        "user": {"name": "hutbotdev", "profile": {"display_name": "Hutbot_DEV", "display_name_normalized": "Hutbot_DEV"}}
+    }
+
+    assert await hutbot.slackcache.fetch_bot_handle(app, "UBOT") == "Hutbot_DEV"
+    app.client.users_info.assert_awaited_once_with(user="UBOT")
+
+
+@pytest.mark.asyncio
+async def test_fetch_bot_handle_falls_back_to_the_username():
+    import hutbot
+    app = AsyncMock()
+    app.client.users_info.return_value = {"user": {"name": "hutbotdev", "profile": {"display_name": "  "}}}
+
+    assert await hutbot.slackcache.fetch_bot_handle(app, "UBOT") == "hutbotdev"
+
+
+@pytest.mark.asyncio
+async def test_fetch_bot_handle_returns_empty_without_a_bot_user_or_on_error():
+    import hutbot
+    from slack_sdk.errors import SlackApiError
+    app = AsyncMock()
+
+    assert await hutbot.slackcache.fetch_bot_handle(app, "") == ""
+    app.client.users_info.assert_not_awaited()
+
+    app.client.users_info.side_effect = SlackApiError("nope", {"error": "user_not_found"})
+    assert await hutbot.slackcache.fetch_bot_handle(app, "UBOT") == ""
diff --git a/tests/test_templating.py b/tests/test_templating.py
index 1118b45..3469de0 100644
--- a/tests/test_templating.py
+++ b/tests/test_templating.py
@@ -123,3 +123,71 @@ async def test_validate_config_payload_rejects_unknown_template_variable():
 
     assert cfg is None
     assert "reply_message" in errors
+
+
+def test_render_date_time_and_datetime_from_the_message_timestamp():
+    import hutbot
+    config = {**DEFAULT_CONFIG.copy(), "date_format": "%d.%m.%Y", "time_format": "%H:%M", "datetime_timezone": "Europe/Berlin"}
+    variables = {"__timestamp_raw": "1786453297.645799"}
+
+    rendered = hutbot.templating.render_reply_message_template(
+        "{{date}} / {{time}} / {{datetime}}", variables, config,
+    )
+
+    assert rendered == "11.08.2026 / 15:01 / 11.08.2026 15:01"
+
+
+def test_date_time_variables_take_format_timezone_and_locale_arguments():
+    import hutbot
+    config = {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Europe/Berlin"}
+    variables = {"__timestamp_raw": "1786453297.645799"}
+
+    rendered = hutbot.templating.render_reply_message_template(
+        "{{datetime(tz='Asia/Tokyo')}} | {{date(lc='de_DE', fmt='%A, %d %B %Y')}} | {{time(fmt='15:04')}}",
+        variables,
+        config,
+    )
+
+    assert rendered == "Tue, 11 Aug 2026 22:01 | Dienstag, 11 August 2026 | 15:01"
+    assert hutbot.templating.validate_template_expressions("{{date(tz='Asia/Tokyo')}}") == ""
+    assert "does not support arguments" in hutbot.templating.validate_template_expressions("{{user(tz='Asia/Tokyo')}}")
+
+
+def test_date_time_variables_are_supported_and_listed():
+    import hutbot
+    assert hutbot.templating.validate_template_expressions("{{date}} {{time}} {{datetime}}") == ""
+    assert {"date", "time", "datetime"} <= hutbot.constants.SUPPORTED_TEMPLATE_VARIABLES
+
+
+@pytest.mark.asyncio
+async def test_build_template_variables_stands_in_now_without_a_message_timestamp():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={})
+    user = User("U1", "dave", "Dave", "T")
+
+    variables = await hutbot.templating.build_reply_template_variables(
+        app, "tok", channel, DEFAULT_CONFIG.copy(), "default", user, "", "", "",
+    )
+
+    assert variables["timestamp"]
+    assert float(variables["timestamp"]) > 0
+    assert variables["date"] and variables["time"] and variables["datetime"]
+    assert variables["__timestamp_raw"] == variables["timestamp"]
+
+
+@pytest.mark.asyncio
+async def test_build_template_variables_keeps_a_real_message_timestamp():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={})
+    user = User("U1", "dave", "Dave", "T")
+    config = {**DEFAULT_CONFIG.copy(), "date_format": "%d.%m.%Y", "datetime_timezone": "Europe/Berlin"}
+
+    variables = await hutbot.templating.build_reply_template_variables(
+        app, "tok", channel, config, "default", user, "hi", "1786453297.645799", "link",
+    )
+
+    assert variables["timestamp"] == "1786453297.645799"
+    assert variables["date"] == "11.08.2026"
+    assert variables["time"] == "15:01"

From 7bcdb88ccb948dcf700871c53801310e8cbeb6a0 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 12 Aug 2026 10:30:12 +0200
Subject: [PATCH 29/42] fix(messaging): split long Slack messages to avoid code
 fence truncation

Slack splits oversized messages arbitrarily, which can break code fences and
display incomplete output. This change introduces `pack_message_chunks` to
gently group message parts while keeping individual blocks (like config
sections or command table rows) intact.

Key changes:
- Enforce a 3800 character limit on outgoing messages.
- Split the `show config` command into multiple messages if it contains
several configurations, ensuring each config block remains whole.
- Split the help command's command table into chunks, labeling subsequent
parts as "(continued)".
- Update bot handle resolution to prioritize `real_name` for better
display names in mentions.
- Add `sent_messages` test helper to aggregate split messages for easier
assertions.
---
 hutbot/commands/info.py     | 10 +++--
 hutbot/messaging.py         | 47 +++++++++++++++++---
 hutbot/slackcache.py        | 12 +++++-
 tests/_common.py            |  9 ++++
 tests/test_commands_info.py | 85 ++++++++++++++++++++++++++++++-------
 5 files changed, 136 insertions(+), 27 deletions(-)

diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index c255e13..c41d2bf 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -156,6 +156,7 @@ def destination_lines(config: dict, action: str, trigger: str, forward_channel_i
         return [f"*Action* `{action}`, target {format_target(action_target)}"]
 
     message = f"This is the configuration for #{channel.name}:"
+    config_sections = []
     for config_name, config in sorted(channel.configs.items()):
         opsgenie_enabled = config.get('opsgenie')
         wait_time_minutes = config.get('wait_time') // 60
@@ -272,9 +273,12 @@ def _button_label(b):
             f">\n"
             f"> *Settings*:\n"
         )
-        message += (
-            f"\n\n*Configuration*: `{config_name}` ({enabled_label})\n"
+        config_sections.append(
+            f"*Configuration*: `{config_name}` ({enabled_label})\n"
             f"{quoted_block}"
             f"```\n{config_block}\n```"
         )
-    await messaging.send_message(app, channel, user, message, thread_ts)
+    # Slack splits an oversized message wherever the break lands, cutting the code
+    # fence in half, so a channel with several configs is sent as several messages.
+    for chunk in messaging.pack_message_chunks([message, *config_sections]):
+        await messaging.send_message(app, channel, user, chunk, thread_ts)
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 64daf8c..4c33ece 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -15,6 +15,31 @@
 from .textutil import log_debug
 
 
+# Slack cuts a message this long into several, wherever the break happens to fall —
+# mid code fence included. Anything longer has to be split by us, on our own lines.
+SLACK_MESSAGE_CHARACTER_LIMIT = 3800
+
+
+def pack_message_chunks(parts: list[str], separator: str = "\n\n", limit: int = SLACK_MESSAGE_CHARACTER_LIMIT) -> list[str]:
+    """Greedily group `parts` into messages no longer than `limit`.
+
+    A single part longer than the limit is kept whole — splitting it would break
+    whatever made it one part (a code block, one config's settings).
+    """
+    chunks: list[str] = []
+    current = ""
+    for part in parts:
+        candidate = f"{current}{separator}{part}" if current else part
+        if current and len(candidate) > limit:
+            chunks.append(current)
+            current = part
+        else:
+            current = candidate
+    if current:
+        chunks.append(current)
+    return chunks
+
+
 async def send_message(app: AsyncApp, channel: Channel, user: User, text: str, thread_ts: str = "") -> None:
     log_debug(channel, f"Attempting to send message to #{channel.name}, user @{user.name}: {text.replace(chr(10), '\\n')}")
     retries = 3
@@ -262,20 +287,28 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ]),
     ]
     command_width = max(len(command) for _, rows in command_groups for command, _ in rows)
-    command_usage = "\n\n".join(
+    group_blocks = [
         f"# {title}\n" + "\n".join(f"{command:<{command_width}}  {description}" for command, description in rows)
         for title, rows in command_groups
-    )
-    help_text = (
+    ]
+    intro = (
         f"Hi! :wave: I am *{name}* `{version}` :palm_up_hand::tophat: Here's what I can do:\n\n"
         "*Show All Configurations:*\n"
         f"> Either use the command `{command}` or just `{mention}` me.\n"
         f"```{command} show config\n"
         f"{mention} show config```\n"
-        f"Displays all configurations for `#{channel.name}`.\n\n"
-        "*Commands:*\n"
-        f"```\n{command_usage}\n```\n\n"
+        f"Displays all configurations for `#{channel.name}`."
+    )
+    outro = (
         "`[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)
+    # The command table alone is well past Slack's per-message limit, and Slack
+    # splits an oversized message wherever it happens to land — which cuts the code
+    # fence in half. Send it in chunks that each close their own fence.
+    command_messages = [
+        f"*Commands{'' if index == 0 else ' (continued)'}:*\n```\n{chunk}\n```"
+        for index, chunk in enumerate(pack_message_chunks(group_blocks, limit=SLACK_MESSAGE_CHARACTER_LIMIT - 200))
+    ]
+    for message in [intro, *command_messages, outro]:
+        await send_message(app, channel, user, message, thread_ts)
diff --git a/hutbot/slackcache.py b/hutbot/slackcache.py
index 53a6c45..3a79b94 100644
--- a/hutbot/slackcache.py
+++ b/hutbot/slackcache.py
@@ -193,7 +193,17 @@ async def fetch_bot_handle(app: AsyncApp, bot_user_id: str) -> str:
         return ""
     slack_user = response.get('user') or {}
     profile = slack_user.get('profile') or {}
-    for candidate in (profile.get('display_name'), profile.get('display_name_normalized'), slack_user.get('name')):
+    # Bot users usually have no display name; their `real_name` carries the app's
+    # display name ("Hutbot_DEV"), which is what the mention autocomplete offers.
+    # `name` is the flattened username and only a last resort.
+    candidates = (
+        profile.get('display_name'),
+        profile.get('display_name_normalized'),
+        slack_user.get('real_name'),
+        profile.get('real_name'),
+        slack_user.get('name'),
+    )
+    for candidate in candidates:
         if candidate and candidate.strip():
             return candidate.strip()
     return ""
diff --git a/tests/_common.py b/tests/_common.py
index 62d8aa3..a7c22a5 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -87,4 +87,13 @@ def _ui_app():
     return app
 
 
+def sent_messages(mock) -> str:
+    """Every text a patched `send_message` received, joined.
+
+    Long replies (help, `show config` for many configs) are split into several
+    messages, so assertions have to look at all of them.
+    """
+    return "\n".join(call.args[3] for call in mock.call_args_list)
+
+
 __all__ = [name for name in list(globals()) if not name.startswith('__')]
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index b57d579..bdb2c46 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -19,7 +19,7 @@ async def test_show_config():
     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]
+        sent_message = sent_messages(mock_send_message)
         assert "\n\n*Configuration*: `default` (enabled)" in sent_message
         assert "> *Trigger*: `message`\n>\n> *Reply message*:\n> Default message\n>\n> *Replied in* <#C123> (in thread)\n>\n> *Settings*:\n```" in sent_message
         assert "\nTrigger" not in sent_message
@@ -59,12 +59,12 @@ async def test_show_config_resolves_the_server_timezone_and_locale():
          patch('hutbot.messaging.send_message') as mock_send_message:
         await show_config(app, channel, user, "")
 
-    lines = mock_send_message.call_args.args[3].splitlines()
+    lines = sent_messages(mock_send_message).splitlines()
     assert any(line.startswith("Date/time timezone  Europe/Berlin (") and line.endswith(", server local time)") for line in lines)
     assert "Date/time locale    English names (server locale de_DE not applied)" in lines
     assert "Date/time timezone  Asia/Tokyo (JST, UTC+09:00)" in lines
     assert "Date/time locale    de_DE" in lines
-    assert "<server local>" not in mock_send_message.call_args.args[3]
+    assert "<server local>" not in sent_messages(mock_send_message)
 
 
 
@@ -86,7 +86,7 @@ async def test_show_config_displays_multiline_team_values():
     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]
+    sent_message = sent_messages(mock_send_message)
     assert (
         "Excluded teams      Cloud Hosting\n"
         "                    m-kubed (m³)\n"
@@ -112,7 +112,7 @@ async def test_process_command_mention_test_uses_trailing_text_as_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]
+    sent_message = sent_messages(mock_send_message)
     assert "Preview: hello world 1234.1 https://slack.test/message" in sent_message
     assert "`{{message}}`: hello world" in sent_message
     assert "`{{timestamp}}`: 1234.1" in sent_message
@@ -129,7 +129,7 @@ async def test_process_command_help_uses_compact_command_reference():
     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]
+    sent_message = sent_messages(mock_send_message)
     assert "*Show All Configurations:*" in sent_message
     assert "Either use the command `/hutbot` or just `@Hutbot` me." in sent_message
     assert "```/hutbot show config\n@Hutbot show config```" in sent_message
@@ -160,7 +160,7 @@ async def test_process_command_help_uses_configured_slash_command():
          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]
+    sent_message = sent_messages(mock_send_message)
     assert "Either use the command `/hutbot_dev` or just `@Hutbot` me." in sent_message
     assert "/hutbot_dev [config] set wait-time <minutes>" in sent_message
     assert "/hutbot " not in sent_message
@@ -178,7 +178,7 @@ async def test_process_command_help_uses_configured_bot_name():
          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]
+    sent_message = sent_messages(mock_send_message)
     assert "I am *Hutbot (DEV)*" in sent_message
     assert "or just `@hutbot_dev` me." in sent_message
     assert "@hutbot_dev show config```" in sent_message
@@ -217,7 +217,7 @@ async def test_show_config_displays_forward_channel():
     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]
+    sent_message = sent_messages(mock_send_message)
     assert "*Replied in* <#C123> (in thread)\n> *Forwarded to* <#CFWDCHAN>" in sent_message
 
 
@@ -231,7 +231,7 @@ async def test_show_config_omits_forward_line_without_forward_channel():
     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]
+    sent_message = sent_messages(mock_send_message)
     assert "*Replied in* <#C123> (in thread)" in sent_message
     assert "Forwarded to" not in sent_message
 
@@ -252,7 +252,7 @@ async def test_show_config_names_the_destination_per_action():
     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]
+    sent_message = sent_messages(mock_send_message)
     assert "*Posted in* <#CTARGET>" in sent_message
     assert "*Sent to* `d.grieser@mittwald.de` (direct message)" in sent_message
     assert "*Sent to* <!subteam^SGROUP> (group message)" in sent_message
@@ -275,7 +275,7 @@ async def test_show_config_displays_replies_enabled():
     with patch('hutbot.messaging.send_message') as mock_send:
         await show_config(app, channel, user)
 
-    sent_message = mock_send.call_args[0][3]
+    sent_message = sent_messages(mock_send)
     assert "\n\n*Configuration*: `default` (enabled)" in sent_message
 
 
@@ -289,7 +289,7 @@ async def test_show_config_displays_replies_disabled():
     with patch('hutbot.messaging.send_message') as mock_send:
         await show_config(app, channel, user)
 
-    sent_message = mock_send.call_args[0][3]
+    sent_message = sent_messages(mock_send)
     assert "\n\n*Configuration*: `default` (disabled)" in sent_message
 
 
@@ -343,7 +343,7 @@ async def test_show_config_explains_an_automatic_disable():
     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]
+    sent_message = sent_messages(mock_send_message)
     assert "*Configuration*: `removed` (disabled, because Hutbot was removed from this channel)" in sent_message
     assert "*Configuration*: `by-hand` (disabled)" in sent_message
 
@@ -358,7 +358,7 @@ async def test_show_config_marks_the_instance_default_locale():
          patch('hutbot.messaging.send_message') as mock_send_message:
         await show_config(app, channel, user, "")
 
-    assert "Date/time locale    de_DE (instance default)" in mock_send_message.call_args.args[3].splitlines()
+    assert "Date/time locale    de_DE (instance default)" in sent_messages(mock_send_message).splitlines()
 
 
 @pytest.mark.asyncio
@@ -372,4 +372,57 @@ async def test_help_and_news_name_the_running_version(command):
          patch('hutbot.messaging.send_message') as mock_send_message:
         await process_command(app, command, channel, user)
 
-    assert "I am *Hutbot* `v1.2.3` :palm_up_hand::tophat:" in mock_send_message.call_args.args[3]
+    assert "I am *Hutbot* `v1.2.3` :palm_up_hand::tophat:" in sent_messages(mock_send_message)
+
+
+@pytest.mark.asyncio
+async def test_help_is_split_into_messages_slack_will_not_cut_apart():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    texts = [call.args[3] for call in mock_send_message.call_args_list]
+    assert len(texts) > 1
+    for text in texts:
+        assert len(text) <= hutbot.messaging.SLACK_MESSAGE_CHARACTER_LIMIT, len(text)
+        # Every code fence a message opens, it also closes.
+        assert text.count("```") % 2 == 0, text
+    assert "*Commands:*" in texts[1]
+    assert "*Commands (continued):*" in texts[2]
+
+
+@pytest.mark.asyncio
+async def test_show_config_splits_many_configs_into_several_messages():
+    import hutbot
+    app = AsyncMock()
+    configs = {f"config-{index}": DEFAULT_CONFIG.copy() for index in range(8)}
+    channel = Channel(id="C1", name="general", configs=configs)
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    texts = [call.args[3] for call in mock_send_message.call_args_list]
+    assert len(texts) > 1
+    for text in texts:
+        assert len(text) <= hutbot.messaging.SLACK_MESSAGE_CHARACTER_LIMIT, len(text)
+        assert text.count("```") % 2 == 0, text
+    # No config is spread over two messages.
+    joined = sent_messages(mock_send_message)
+    for name in configs:
+        assert joined.count(f"*Configuration*: `{name}`") == 1
+
+
+def test_pack_message_chunks_keeps_an_oversized_part_whole():
+    import hutbot
+    parts = ["a" * 3000, "b" * 3000, "c" * 5000]
+
+    chunks = hutbot.messaging.pack_message_chunks(parts)
+
+    assert chunks == ["a" * 3000, "b" * 3000, "c" * 5000]
+    assert hutbot.messaging.pack_message_chunks(["x", "y"]) == ["x\n\ny"]
+    assert hutbot.messaging.pack_message_chunks([]) == []

From 2ea26ab08fd8123cb9bd3b220d71b3abdc30681e Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 12 Aug 2026 13:41:57 +0200
Subject: [PATCH 30/42] feat(commands): unify action and target into single
 command

Merge the separate `set target` and `set forward-channel` commands into
`set action <action> [<target>]`. This ensures a config always has a
valid destination for its chosen action, preventing runtime failures.
Legacy forwarding is removed in favor of the `post_channel` action.

- Require target when setting non-reply actions like `dm-user`,
`group-dm`, or `post-channel`.
- Remove `forward_channel` field and related commands.
- Update button specs to require an explicit action keyword.
- Add migration logic to warn about dropped legacy forward channels.
- Update help text, documentation, and tests accordingly.
---
 README.md                      |  18 ++--
 hutbot/actions.py              |  25 +++++-
 hutbot/buttonutil.py           |   9 +-
 hutbot/commands/dispatch.py    |   9 +-
 hutbot/commands/info.py        |  12 +--
 hutbot/commands/patterns.py    |   7 +-
 hutbot/commands/setters.py     | 114 +++++++++++-------------
 hutbot/constants.py            |  10 ++-
 hutbot/messaging.py            |   8 +-
 hutbot/persistence.py          |  11 ++-
 hutbot/scheduling.py           |  11 +--
 hutbot/webui_backend.py        |   5 --
 tests/_common.py               |   3 +-
 tests/test_actions.py          |   4 +-
 tests/test_buttons.py          |  30 +++++--
 tests/test_commands_info.py    |  51 -----------
 tests/test_commands_setters.py | 156 +++++++++++++++++++++++++++++++++
 tests/test_persistence.py      |  23 +++++
 tests/test_routing.py          |  92 -------------------
 tests/test_scheduling.py       |  61 -------------
 webui_static/app.js            |   3 -
 21 files changed, 327 insertions(+), 335 deletions(-)

diff --git a/README.md b/README.md
index 6831c7d..50c43ed 100644
--- a/README.md
+++ b/README.md
@@ -69,13 +69,15 @@ existing configs keep working unchanged.
     **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>`.
+- **Actions** (`/hutbot [config] set action <action> [<target>]`) decide what the rule does, using
+  `reply_message` (with the usual `{{variables}}`) as the body. The recipient is part of the same
+  command, so a config can never be left with an action that has nowhere to send.
+  - `set action reply` — post in the rule's channel. Takes no target.
+  - `set action dm-user <@user>` — DM a single user.
+  - `set action group-dm <@usergroup>` — open one group DM (mpim) with all members of a Slack user
+    group and post once (Slack caps a group DM at 8 members).
+  - `set action post-channel <#channel>` — post to another channel. Pick the channel from Slack's
+    autocomplete so it arrives as a link, or pass its `C…` id.
 
 - **Buttons** attach interactive buttons to the message a rule sends (including the classic
   unanswered-message reply). Each button is added incrementally with a typed action:
@@ -88,7 +90,6 @@ existing configs keep working unchanged.
   - `/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.
 
@@ -450,7 +451,6 @@ The name is used everywhere the instance identifies itself:
 | Surface           | With `HUTBOT_BOT_NAME='Hutbot (DEV)'`                       |
 | ----------------- | ----------------------------------------------------------- |
 | Help / news       | *Hi! I am **Hutbot (DEV)*** …                                 |
-| Forwarding notice | "… will now be forwarded here by Hutbot (DEV)"               |
 | Web UI            | Page title, wordmark and messages (served via `/api/meta`)   |
 | OpsGenie alert    | Tag `Hutbot (DEV)`, detail `bot: hutbot-dev`                  |
 
diff --git a/hutbot/actions.py b/hutbot/actions.py
index 2753292..acf0ab2 100644
--- a/hutbot/actions.py
+++ b/hutbot/actions.py
@@ -23,6 +23,8 @@
     ACTION_GROUP_DM,
     ACTION_POST_CHANNEL,
     ACTION_REPLY,
+    ACTIONS_REQUIRING_TARGET,
+    ACTION_TARGET_HINTS,
     CONDITION_NONE,
     CONDITION_OUTLOOK,
     OPSGENIE_TEMPLATE_VARIABLES,
@@ -127,7 +129,7 @@ async def action_group_dm(app: AsyncApp, channel: Channel, config: dict, text: s
 
 
 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 '')
+    target = (config.get('action_target') or '').strip()
     channel_id = targets.parse_channel_ref(target)
     if not channel_id:
         log_error(f"Action post_channel: invalid channel target '{target}'.")
@@ -135,11 +137,32 @@ async def action_post_channel(app: AsyncApp, channel: Channel, config: dict, tex
     return await messaging._post_message(app, channel_id, text, blocks)
 
 
+def missing_target_reason(config: dict) -> str:
+    """Why this config's action cannot run, or "" when it can.
+
+    Every action except `reply` sends somewhere else and needs a target; a config
+    that has none would only fail deep inside the action with an empty target.
+    """
+    action = config.get('action', ACTION_REPLY)
+    if action not in ACTIONS_REQUIRING_TARGET:
+        return ""
+    target = (config.get('action_target') or '').strip()
+    if not target:
+        return f"action `{action}` has no target"
+    if action == ACTION_POST_CHANNEL and not targets.parse_channel_ref(target):
+        return f"action `{action}` target `{target}` is not a channel"
+    return ""
+
+
 async def run_action(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None = None, _depth: int = 0) -> dict | None:
     if _depth > 5:
         log_warning(f"Action chain too deep at config '{config_name}'; aborting to avoid loops.")
         return None
     action = config.get('action', ACTION_REPLY)
+    reason = missing_target_reason(config)
+    if reason:
+        log_error(f"Config '{config_name}' in #{channel.name} cannot run: {reason}; set one with `set action {action.replace('_', '-')} {ACTION_TARGET_HINTS[action]}`.")
+        return None
     text = await render_action_text(app, opsgenie_token, channel, config, config_name, context)
     blocks = buttons.build_button_blocks(config, channel.id, config_name, text)
     log(f"Running action '{action}' for config '{config_name}' in #{channel.name}.")
diff --git a/hutbot/buttonutil.py b/hutbot/buttonutil.py
index 305e5a6..7998e1e 100644
--- a/hutbot/buttonutil.py
+++ b/hutbot/buttonutil.py
@@ -8,13 +8,8 @@
 
 
 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
+    """Return (action, value) for a button, defaulting a missing action to `config`."""
+    return button.get('action') or BUTTON_ACTION_CONFIG, button.get('value', '') or ''
 
 
 def _find_button_index(config: dict | None, label: str) -> int | None:
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index 5e2b105..fd98b43 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -82,11 +82,6 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         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)):
@@ -104,9 +99,7 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
     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)
+        await setters.set_action(app, channel, config_name, match.group("action"), match.group("target"), user, thread_ts)
     elif (match := patterns.ADD_BUTTON_PATTERN.match(command_text)):
         await setters.add_button(app, channel, config_name, match.group("label"), match.group("spec"), user, thread_ts)
     elif patterns.CLEAR_BUTTONS_PATTERN.match(command_text):
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index c41d2bf..153f265 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -136,19 +136,16 @@ def format_target(target: str) -> str:
             return f"<!subteam^{target}>"
         return f"`{target}`"
 
-    def destination_lines(config: dict, action: str, trigger: str, forward_channel_id: str) -> list[str]:
+    def destination_lines(config: dict, action: str, trigger: str) -> list[str]:
         """Where the message ends up, phrased per action instead of as raw fields."""
         action_target = config.get('action_target') or ''
         if action == ACTION_REPLY:
             # A reply threads on the triggering message; schedule/manual runs have
             # no message to thread on and land in the channel itself.
             thread = ' (in thread)' if trigger == TRIGGER_MESSAGE else ''
-            lines = [f"*Replied in* <#{channel.id}>{thread}"]
-            if forward_channel_id:
-                lines.append(f"*Forwarded to* <#{forward_channel_id}>")
-            return lines
+            return [f"*Replied in* <#{channel.id}>{thread}"]
         if action == ACTION_POST_CHANNEL:
-            return [f"*Posted in* {format_target(action_target or forward_channel_id)}"]
+            return [f"*Posted in* {format_target(action_target)}"]
         if action == ACTION_DM_USER:
             return [f"*Sent to* {format_target(action_target)} (direct message)"]
         if action == ACTION_GROUP_DM:
@@ -168,7 +165,6 @@ def destination_lines(config: dict, action: str, trigger: str, forward_channel_i
         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
@@ -257,7 +253,7 @@ def _button_label(b):
         )
         message_label = 'Reply message' if action == ACTION_REPLY else 'Message'
         reply_line = f"*{message_label}*:\n{reply_message}" if reply_message else f"*{message_label}*: <none>"
-        destinations = "\n".join(destination_lines(config, action, trigger, forward_channel_id))
+        destinations = "\n".join(destination_lines(config, action, trigger))
         if replies_enabled:
             enabled_label = 'enabled'
         elif config.get('disabled_reason') == DISABLED_REASON_REMOVED:
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index d18aae8..7fae2a0 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -39,8 +39,6 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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>.+)')
@@ -51,8 +49,9 @@ def create_command_pattern(command_regex: str) -> re.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>.+)')
+# The target belongs to the action, so both arrive in one command. `set` is
+# optional, like it is for `wait-time` and `message`.
+SET_ACTION_PATTERN = create_command_pattern(r'(set\s+)?action\s+(?P<action>\S+)(?:\s+(?P<target>.+))?$')
 ADD_BUTTON_PATTERN = create_command_pattern(r'add\s+button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
 CLEAR_BUTTONS_PATTERN = create_command_pattern(r'clear\s+buttons?')
 SET_BUTTON_TIMEOUT_TARGET_PATTERN = create_command_pattern(r'set\s+button[_ -]?timeout[_ -]?target\s+(?P<target>.+)')
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index c9954b6..ce804c9 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -13,8 +13,12 @@
 from .. import datetimefmt
 from .. import slackcache
 from .. import actions
+from .. import targets
 from ..buttonutil import _find_button_index
 from ..constants import (
+    ACTION_POST_CHANNEL,
+    ACTION_REPLY,
+    ACTION_TARGET_HINTS,
     ACTIONS,
     BUTTON_ACTION_CONFIG,
     BUTTON_ACTION_DELAY,
@@ -46,6 +50,13 @@ def _ensure_config(channel, config_name: str) -> dict:
     return channel.configs[config_name]
 
 
+def _set_action_hint(config_name: str, config: dict) -> str:
+    """The command that gives this config's action a usable target."""
+    action = config.get('action', ACTION_REPLY)
+    hint = ACTION_TARGET_HINTS.get(action, '<target>')
+    return f"`{state.slash_command} {config_name} set action {action.replace('_', '-')} {hint}`"
+
+
 async def set_bots(app: AsyncApp, channel, config_name: str, enabled: bool, user, thread_ts: str = "") -> None:
     if config_name not in channel.configs:
         channel.configs[config_name] = DEFAULT_CONFIG.copy()
@@ -91,46 +102,6 @@ async def set_work_hours(app: AsyncApp, channel, config_name: str, start: str, e
     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 {state.bot_name} :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()
@@ -424,25 +395,39 @@ async def set_condition_negate(app: AsyncApp, channel, config_name: str, enabled
     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:
+async def set_action(app: AsyncApp, channel, config_name: str, value: str, target: str, user, thread_ts: str = "") -> None:
+    """`set action <action> [<target>]` — the target is part of choosing the action.
+
+    Every action except `reply` sends somewhere else, so it is only a complete
+    instruction together with its recipient. Requiring both in one command means a
+    config can never be left in a state that fails when the rule fires.
+    """
     value = strip_quotes(value).strip().lower().replace('-', '_')
     if value not in ACTIONS:
         supported = ", ".join(f"`{a}`" for a in sorted(ACTIONS))
         await messaging.send_message(app, channel, user, f"Invalid *action*. Must be one of {supported}.", thread_ts)
         return
-    _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)
-
+    target = strip_quotes(target or "").strip()
 
-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)
+    if value == ACTION_REPLY:
+        if target:
+            await messaging.send_message(app, channel, user, f"Action `{ACTION_REPLY}` posts in this channel and takes no target.", thread_ts)
+            return
+    elif not target:
+        await messaging.send_message(app, channel, user, f"Action `{value}` needs a target: `{state.slash_command} {config_name} set action {value.replace('_', '-')} {ACTION_TARGET_HINTS[value]}`.", thread_ts)
         return
-    _ensure_config(channel, config_name)['action_target'] = target
+    elif value == ACTION_POST_CHANNEL and not targets.parse_channel_ref(target):
+        await messaging.send_message(app, channel, user, f"Invalid *target* `{target}` for action `{value}`. Pick the channel from Slack's autocomplete so it becomes a link, or pass its `C…` id.", thread_ts)
+        return
+
+    config = _ensure_config(channel, config_name)
+    config['action'] = value
+    config['action_target'] = target
     await persistence.save_configuration()
-    await messaging.send_message(app, channel, user, f"*Action target* set to `{target}` in configuration `{config_name}`.", thread_ts)
+    if target:
+        await messaging.send_message(app, channel, user, f"*Action* set to `{value}` sending to `{target}` in configuration `{config_name}`.", thread_ts)
+    else:
+        await messaging.send_message(app, channel, user, f"*Action* set to `{value}` in configuration `{config_name}`.", thread_ts)
 
 
 async def add_button(app: AsyncApp, channel, config_name: str, label: str, spec: str, user, thread_ts: str = "") -> None:
@@ -451,16 +436,15 @@ async def add_button(app: AsyncApp, channel, config_name: str, label: str, spec:
         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()
+    # spec is "<action> [arg]". The action keyword is required: without it a config
+    # named after one (`ack`, `message`, `delay`) could never be attached.
+    parts = spec.strip().split(None, 1)
+    action = parts[0].lower() if parts else ""
+    if action not in BUTTON_ACTIONS:
+        supported = ", ".join(f"`{a}`" for a in sorted(BUTTON_ACTIONS))
+        await messaging.send_message(app, channel, user, f"Invalid *button action* `{parts[0] if parts else ''}`. Must be one of {supported}.", thread_ts)
+        return
+    value = strip_quotes(parts[1]).strip() if len(parts) > 1 else ""
 
     if action in (BUTTON_ACTION_CONFIG, BUTTON_ACTION_MESSAGE) and not value:
         what = "a configuration name" if action == BUTTON_ACTION_CONFIG else "a message"
@@ -544,8 +528,14 @@ async def run_config_now(app: AsyncApp, opsgenie_token: str, channel, config_nam
     if not config:
         await messaging.send_message(app, channel, user, f"Configuration `{config_name}` not found.", thread_ts)
         return
+    reason = actions.missing_target_reason(config)
+    if reason:
+        await messaging.send_message(app, channel, user, f"Cannot run configuration `{config_name}`: {reason}. Set one with {_set_action_hint(config_name, config)}.", thread_ts)
+        return
     await messaging.send_message(app, channel, user, f"Running configuration `{config_name}` now…", thread_ts)
-    await actions.run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel.id, 'user': user})
+    posted = await actions.run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel.id, 'user': user})
+    if not posted:
+        await messaging.send_message(app, channel, user, f"Configuration `{config_name}` did not send anything. Check its action and target with `{state.slash_command} show config`.", thread_ts)
 
 
 async def add_excluded_team(app: AsyncApp, channel, config_name: str, team: str, user, thread_ts: str = "") -> None:
diff --git a/hutbot/constants.py b/hutbot/constants.py
index 2e61e2d..cda7604 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -37,6 +37,15 @@
 ACTION_POST_CHANNEL = "post_channel"
 ACTIONS = {ACTION_REPLY, ACTION_DM_USER, ACTION_GROUP_DM, ACTION_POST_CHANNEL}
 
+# Actions that go somewhere other than the channel the rule lives in, and what a
+# usable target looks like. `reply` is the only action that needs none.
+ACTION_TARGET_HINTS = {
+    ACTION_DM_USER: "<@user>",
+    ACTION_GROUP_DM: "@usergroup",
+    ACTION_POST_CHANNEL: "<#channel>",
+}
+ACTIONS_REQUIRING_TARGET = set(ACTION_TARGET_HINTS)
+
 BUTTON_ACTION_PREFIX = "hutbot_btn"
 
 # Marker written to a config's ``disabled_reason`` when the bot disabled it by
@@ -76,7 +85,6 @@
     "hours": [],
     "pattern": None,
     "pattern_case_sensitive": False,
-    "forward_channel": "",
     "enabled": True,
     # Why the bot disabled this config on its own; empty for a user-made change.
     "disabled_reason": "",
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 4c33ece..b249ad1 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -247,10 +247,10 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ]),
         ("Message and action", [
             (f"{command} [config] set message \"<reply message>\"", "Set reminder message."),
-            (f"{command} [config] set action <reply|dm-user|group-dm|post-channel>", "Set what the rule does."),
-            (f"{command} [config] set target <@user|@group|#channel>", "Set the action recipient."),
-            (f"{command} [config] set forward-channel <#channel>", "Forward replies to another channel."),
-            (f"{command} [config] clear forward-channel", "Remove the forward channel."),
+            (f"{command} [config] set action reply", "Reply in this channel (the default)."),
+            (f"{command} [config] set action post-channel <#channel>", "Post to another channel."),
+            (f"{command} [config] set action dm-user <@user>", "DM a single user."),
+            (f"{command} [config] set action group-dm <@usergroup>", "Open one group DM with a user group."),
         ]),
         ("Buttons", [
             (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
diff --git a/hutbot/persistence.py b/hutbot/persistence.py
index b41def1..1b0c655 100644
--- a/hutbot/persistence.py
+++ b/hutbot/persistence.py
@@ -39,7 +39,16 @@ async def migrate_and_apply_defaults(app: AsyncApp, config: dict) -> dict:
             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}.
+            # `forward_channel` was replaced by the `post_channel` action. Drop it
+            # instead of silently keeping a field nothing reads any more.
+            legacy_forward_channel = single_config.pop('forward_channel', '')
+            if legacy_forward_channel:
+                log_warning(
+                    f"Dropping the forward channel {legacy_forward_channel} of config '{config_name}' in channel {channel_id}. "
+                    f"To keep forwarding, add a second config with `set trigger message`, "
+                    f"`set action post-channel <#{legacy_forward_channel}>` and a message using {{{{message_link}}}}."
+                )
+            # Keep buttons to {label, action, value} and drop anything unusable.
             buttons = single_config.get('buttons')
             if isinstance(buttons, list):
                 normalized = []
diff --git a/hutbot/scheduling.py b/hutbot/scheduling.py
index 07c14f9..35dadf7 100644
--- a/hutbot/scheduling.py
+++ b/hutbot/scheduling.py
@@ -5,7 +5,6 @@
 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
 
@@ -13,7 +12,7 @@
 from . import slackcache
 from . import actions
 from . import persistence
-from .constants import ACTION_REPLY, SCHEDULER_INTERVAL, TRIGGER_SCHEDULE
+from .constants import SCHEDULER_INTERVAL, TRIGGER_SCHEDULE
 from .models import ScheduledReply
 
 try:
@@ -60,14 +59,6 @@ async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel, config: di
             'channel_id': channel.id,
             'permalink': permalink,
         })
-        reply_message = (posted or {}).get('text', '')
-        forward_channel_id = config.get('forward_channel')
-        if config.get('action', ACTION_REPLY) == ACTION_REPLY and 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.
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index afad530..6b8ea18 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -247,11 +247,6 @@ def get(key):
         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'))
diff --git a/tests/_common.py b/tests/_common.py
index a7c22a5..7297374 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -22,6 +22,7 @@
     ACTION_DM_USER,
     ACTION_GROUP_DM,
     ACTION_POST_CHANNEL,
+    ACTION_REPLY,
     DEFAULT_CONFIG,
     DISABLED_REASON_REMOVED,
     TRIGGER_SCHEDULE,
@@ -46,7 +47,7 @@
 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,
+    set_replies_enabled,
 )
 from hutbot.commands.info import get_team_of, show_config
 
diff --git a/tests/test_actions.py b/tests/test_actions.py
index 4429129..0a0c740 100644
--- a/tests/test_actions.py
+++ b/tests/test_actions.py
@@ -40,9 +40,9 @@ async def test_set_action_normalizes_dashes():
     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)
+        await process_command(app, "set action dm-user <@U999>", channel, user)
         assert channel.configs["default"]["action"] == "dm_user"
-        await process_command(app, "set action group-dm", channel, user)
+        await process_command(app, "set action group-dm @sre", channel, user)
         assert channel.configs["default"]["action"] == "group_dm"
 
 
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 372d9e2..5278c8c 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -9,8 +9,7 @@ async def test_add_button_copy_on_write_and_clear():
     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).
+        await process_command(app, 'add button "Approve" config approve-flow', channel, user)
         assert channel.configs["default"]["buttons"] == [{"label": "Approve", "action": "config", "value": "approve-flow"}]
         # DEFAULT_CONFIG's list must not have been mutated (copy-on-write).
         assert DEFAULT_CONFIG["buttons"] == default_buttons_before
@@ -42,12 +41,33 @@ async def test_add_button_typed_actions():
 
 
 @pytest.mark.asyncio
-async def test_migrate_normalizes_legacy_buttons():
+async def test_migrate_keeps_buttons_to_label_action_value():
     cfg = DEFAULT_CONFIG.copy()
-    cfg["buttons"] = [{"label": "Old", "target": "legacy-flow"}]
+    cfg["buttons"] = [
+        {"label": "Run", "action": "config", "value": "approve-flow", "stray": 1},
+        {"label": "Plain"},
+        "not-a-button",
+    ]
     config = {"C12345": {"default": cfg}}
     migrated = await migrate_and_apply_defaults(AsyncMock(), config)
-    assert migrated["C12345"]["default"]["buttons"] == [{"label": "Old", "action": "config", "value": "legacy-flow"}]
+    assert migrated["C12345"]["default"]["buttons"] == [
+        {"label": "Run", "action": "config", "value": "approve-flow"},
+        {"label": "Plain", "action": "config", "value": ""},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_add_button_requires_an_action_keyword():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "Approve" approve-flow', channel, user)
+
+    assert channel.configs["default"]["buttons"] == []
+    assert send.call_args.args[3] == (
+        "Invalid *button action* `approve-flow`. Must be one of `ack`, `config`, `delay`, `message`."
+    )
 
 
 
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index bdb2c46..106d351 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -186,57 +186,6 @@ async def test_process_command_help_uses_configured_bot_name():
     assert "@Hutbot" 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 = sent_messages(mock_send_message)
-    assert "*Replied in* <#C123> (in thread)\n> *Forwarded to* <#CFWDCHAN>" in sent_message
-
-
-
-@pytest.mark.asyncio
-async def test_show_config_omits_forward_line_without_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 = sent_messages(mock_send_message)
-    assert "*Replied in* <#C123> (in thread)" in sent_message
-    assert "Forwarded to" not in sent_message
-
-
-
 @pytest.mark.asyncio
 async def test_show_config_names_the_destination_per_action():
     app = AsyncMock()
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 47ee61b..6244fae 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -374,3 +374,159 @@ async def test_test_and_run_populate_the_time_variables(command):
     assert "at  on , ts \n" not in rendered
     assert "ts {{timestamp}}" not in rendered
     assert re.search(r"at \d{2}:\d{2} on \w{3}, \d{2} \w{3} \d{4}, ts \d+\.\d+", rendered), rendered
+
+
+@pytest.mark.asyncio
+async def test_set_action_requires_a_target_in_the_same_command():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set action post-channel", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "Action `post_channel` needs a target: `/hutbot default set action post-channel <#channel>`."
+    )
+    # Nothing was stored, so the config cannot end up in a state that fails when it runs.
+    assert config["action"] == ACTION_REPLY
+    assert config["action_target"] == ""
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command,action,target", [
+    ("set action post-channel <#CTARGET|targets>", ACTION_POST_CHANNEL, "<#CTARGET|targets>"),
+    ("set action dm-user <@U999>", ACTION_DM_USER, "<@U999>"),
+    ("set action group-dm @sre", ACTION_GROUP_DM, "@sre"),
+])
+async def test_set_action_stores_action_and_target_together(command, action, target):
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert config["action"] == action
+    assert config["action_target"] == target
+    assert mock_send_message.call_args.args[3] == (
+        f"*Action* set to `{action}` sending to `{target}` in configuration `default`."
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_action_reply_takes_no_target_and_clears_the_old_one():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL, "action_target": "<#CTARGET|targets>"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set action reply <#CTARGET|targets>", channel, user)
+        assert mock_send_message.call_args.args[3] == "Action `reply` posts in this channel and takes no target."
+        assert config["action"] == ACTION_POST_CHANNEL
+
+        await process_command(app, "set action reply", channel, user)
+
+    assert mock_send_message.call_args.args[3] == "*Action* set to `reply` in configuration `default`."
+    assert config["action"] == ACTION_REPLY
+    assert config["action_target"] == ""
+
+
+@pytest.mark.asyncio
+async def test_set_action_rejects_a_non_channel_target_for_post_channel():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set action post-channel @dave", channel, user)
+
+    assert "Invalid *target* `@dave` for action `post_channel`" in mock_send_message.call_args.args[3]
+    assert config["action"] == ACTION_REPLY
+    assert config["action_target"] == ""
+
+
+@pytest.mark.asyncio
+async def test_run_refuses_a_config_whose_action_has_no_target():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.messaging._post_message', new=AsyncMock()) as post, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "run", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "Cannot run configuration `default`: action `post_channel` has no target. "
+        "Set one with `/hutbot default set action post-channel <#channel>`."
+    )
+    post.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_run_action_refuses_instead_of_posting_with_an_empty_target():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+
+    with patch('hutbot.messaging._post_message', new=AsyncMock()) as post:
+        posted = await hutbot.actions.run_action(app, "tok", channel, config, "default", context={'channel_id': channel.id})
+
+    assert posted is None
+    post.assert_not_awaited()
+    assert hutbot.actions.missing_target_reason({**DEFAULT_CONFIG.copy()}) == ""
+    assert hutbot.actions.missing_target_reason({**config, "action_target": "not-a-channel"}) == (
+        "action `post_channel` target `not-a-channel` is not a channel"
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", [
+    "action post-channel <#CTARGET|targets>",
+    "set action post-channel <#CTARGET|targets>",
+])
+async def test_action_command_works_with_and_without_set(command):
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert config["action"] == ACTION_POST_CHANNEL
+    assert config["action_target"] == "<#CTARGET|targets>"
+    assert mock_send_message.call_args.args[3] == (
+        "*Action* set to `post_channel` sending to `<#CTARGET|targets>` in configuration `default`."
+    )
+
+
+@pytest.mark.asyncio
+async def test_bare_action_command_still_takes_a_config_name():
+    app = AsyncMock()
+    configs = {"logs": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "logs action dm-user <@U999>", channel, user)
+        assert configs["logs"]["action"] == ACTION_DM_USER
+        assert configs["logs"]["action_target"] == "<@U999>"
+
+        # `action` alone is not a command.
+        await process_command(app, "action", channel, user)
+
+    assert "Huh?" in mock_send_message.call_args.args[3]
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
index f7cd9b4..672fe93 100644
--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@@ -86,3 +86,26 @@ async def test_load_replies_cache_handles_missing_file():
         hutbot.state._scheduled_replies_cache.clear()
         await load_replies_cache()
         assert hutbot.state._scheduled_replies_cache == {}
+
+
+@pytest.mark.asyncio
+async def test_migration_drops_the_legacy_forward_channel():
+    app = AsyncMock()
+    config = {
+        "C123": {
+            "default": {**DEFAULT_CONFIG.copy(), "forward_channel": "CFWDCHAN"},
+            "clean": DEFAULT_CONFIG.copy(),
+        }
+    }
+
+    with patch('hutbot.persistence.log_warning') as mock_log_warning:
+        migrated = await migrate_and_apply_defaults(app, config)
+
+    assert "forward_channel" not in migrated["C123"]["default"]
+    assert "forward_channel" not in migrated["C123"]["clean"]
+    warning = mock_log_warning.call_args.args[0]
+    assert "Dropping the forward channel CFWDCHAN of config 'default' in channel C123" in warning
+    assert "set action post-channel <#CFWDCHAN>" in warning
+    assert "{{message_link}}" in warning
+    # Only the config that had one is reported.
+    assert mock_log_warning.call_count == 1
diff --git a/tests/test_routing.py b/tests/test_routing.py
index 9870581..241749f 100644
--- a/tests/test_routing.py
+++ b/tests/test_routing.py
@@ -206,98 +206,6 @@ async def test_thread_response_by_bot_cancels_only_configs_without_include_bots(
     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()
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
index 696cd69..ee82017 100644
--- a/tests/test_scheduling.py
+++ b/tests/test_scheduling.py
@@ -161,67 +161,6 @@ async def test_schedule_reply_removes_entry_from_cache():
     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
-@pytest.mark.parametrize("action", ["dm_user", "group_dm", "post_channel"])
-async def test_schedule_reply_does_not_legacy_forward_non_reply_actions(action):
-    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": "Private text",
-        "forward_channel": "CLEGACY",
-        "action": action,
-    }
-
-    with patch('hutbot.actions.run_action', new=AsyncMock(return_value={"text": "Private text"})), \
-         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
-        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_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()
diff --git a/webui_static/app.js b/webui_static/app.js
index 9b9d0ea..69466a7 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -374,9 +374,6 @@ function renderEditor(name) {
   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));
 

From fd07003a1c6508b57bea174a63cc2cc9b1aacaa7 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 12 Aug 2026 15:34:19 +0200
Subject: [PATCH 31/42] feat(scheduling): unify schedule timezone with
 date/time setting

Remove the dedicated `schedule_timezone` configuration option. Cron
schedules now fire using the config's `datetime_timezone`, falling back
o server local time if not set. Existing configurations are migrated:
if only a schedule timezone was defined, it is moved to the date/time
field; if both were defined and differ, the date/time timezone takes
precedence.
---
 README.md                   |  3 ++-
 hutbot/commands/dispatch.py |  2 --
 hutbot/commands/info.py     |  9 ++-------
 hutbot/commands/patterns.py |  1 -
 hutbot/commands/setters.py  | 13 -------------
 hutbot/constants.py         |  1 -
 hutbot/messaging.py         |  1 -
 hutbot/persistence.py       | 17 +++++++++++++++++
 hutbot/scheduling.py        | 20 ++++++--------------
 hutbot/webui_backend.py     | 10 ----------
 tests/test_commands_info.py |  3 ++-
 tests/test_persistence.py   | 26 ++++++++++++++++++++++++++
 tests/test_scheduling.py    | 28 ++++++++++++++++++++++++++++
 webui_static/app.js         |  4 ++--
 14 files changed, 85 insertions(+), 53 deletions(-)

diff --git a/README.md b/README.md
index 50c43ed..b964a68 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,8 @@ 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>`.
+    `0 9 * * 1-5`). It fires in the config's date/time timezone (see
+    `set datetime-format`), or server local time without one.
   - `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.
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index fd98b43..75d4d6f 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -86,8 +86,6 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         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)):
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 153f265..6d9f415 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -181,13 +181,8 @@ def destination_lines(config: dict, action: str, trigger: str) -> list[str]:
         groups: list[list[tuple]] = []
 
         if trigger == TRIGGER_SCHEDULE:
-            # Same fallback chain the scheduler uses: own timezone, then the
-            # date/time one, then the server's.
-            schedule_timezone = config.get('schedule_timezone') or config.get('datetime_timezone') or ''
-            groups.append([
-                ("Cron",              config.get('schedule_cron') or '<none>'),
-                ("Schedule timezone", datetimefmt.describe_timezone(schedule_timezone)),
-            ])
+            # The cron fires in the Date/time timezone below, so it is not repeated here.
+            groups.append([("Cron", config.get('schedule_cron') or '<none>')])
 
         condition = config.get('condition') or ''
         if condition:
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index 7fae2a0..70ae4e6 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -43,7 +43,6 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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>.+)')
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index ce804c9..be5c410 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -350,19 +350,6 @@ async def set_schedule_cron(app: AsyncApp, channel, config_name: str, cron_expr:
     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,
diff --git a/hutbot/constants.py b/hutbot/constants.py
index cda7604..17cd3c5 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -91,7 +91,6 @@
     # 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,
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index b249ad1..2e2124c 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -220,7 +220,6 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ("Trigger", [
             (f"{command} [config] set trigger <message|schedule|manual>", "Set how the rule starts."),
             (f"{command} [config] set cron <expr>", "Set the cron schedule, e.g. 0 9 * * 1-5."),
-            (f"{command} [config] set schedule-timezone <tz>", "Set the cron timezone (IANA name)."),
         ]),
         ("Condition", [
             (f"{command} [config] set condition <none|outlook>", "Gate a schedule on a condition."),
diff --git a/hutbot/persistence.py b/hutbot/persistence.py
index 1b0c655..6d85d4f 100644
--- a/hutbot/persistence.py
+++ b/hutbot/persistence.py
@@ -48,6 +48,23 @@ async def migrate_and_apply_defaults(app: AsyncApp, config: dict) -> dict:
                     f"To keep forwarding, add a second config with `set trigger message`, "
                     f"`set action post-channel <#{legacy_forward_channel}>` and a message using {{{{message_link}}}}."
                 )
+            # Crons now fire in the config's date/time timezone. Carry a separate
+            # schedule timezone over so the cron keeps its wall-clock time; if the
+            # two disagree, the date/time one wins and the cron shifts.
+            legacy_schedule_timezone = single_config.pop('schedule_timezone', '')
+            if legacy_schedule_timezone:
+                datetime_timezone = single_config.get('datetime_timezone') or ''
+                if not datetime_timezone:
+                    single_config['datetime_timezone'] = legacy_schedule_timezone
+                    log_warning(
+                        f"Config '{config_name}' in channel {channel_id}: moved the schedule timezone "
+                        f"{legacy_schedule_timezone} to the date/time timezone, which the cron now uses."
+                    )
+                elif datetime_timezone != legacy_schedule_timezone:
+                    log_warning(
+                        f"Config '{config_name}' in channel {channel_id}: dropping the schedule timezone "
+                        f"{legacy_schedule_timezone}; its cron now fires in {datetime_timezone}."
+                    )
             # Keep buttons to {label, action, value} and drop anything unusable.
             buttons = single_config.get('buttons')
             if isinstance(buttons, list):
diff --git a/hutbot/scheduling.py b/hutbot/scheduling.py
index 35dadf7..4bf03ec 100644
--- a/hutbot/scheduling.py
+++ b/hutbot/scheduling.py
@@ -2,13 +2,13 @@
 
 import asyncio
 import datetime
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from slack_bolt.async_app import AsyncApp
 
 from employee_list import log, log_error, log_warning
 
 from . import state
+from . import datetimefmt
 from . import slackcache
 from . import actions
 from . import persistence
@@ -72,20 +72,12 @@ async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel, config: di
         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()
+    # A cron fires in the config's date/time timezone (server local without one),
+    # the same timezone its work hours and date/time output use.
+    tz = datetimefmt.get_config_timezone(config)
+    base = last.astimezone(tz)
+    current = now.astimezone(tz)
     try:
         nxt = croniter(cron_expr, base).get_next(datetime.datetime)
     except (ValueError, KeyError) as e:
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 6b8ea18..2149844 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -181,16 +181,6 @@ def get(key):
     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`."
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 106d351..7161cba 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -208,7 +208,8 @@ async def test_show_config_names_the_destination_per_action():
     # No message to thread on for a schedule trigger.
     assert "*Replied in* <#C123>\n" in sent_message
     assert "Cron                0 9 * * 1-5" in sent_message
-    assert any(line.startswith("Schedule timezone   ") and "server local" in line for line in sent_message.splitlines())
+    # The cron uses the Date/time timezone, so it is not repeated as its own row.
+    assert "Schedule timezone" not in sent_message
     # Non-reply actions title their template "Message", not "Reply message".
     assert "*Message*:" in sent_message
     assert "Action target" not in sent_message
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
index 672fe93..508ee35 100644
--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@@ -109,3 +109,29 @@ async def test_migration_drops_the_legacy_forward_channel():
     assert "{{message_link}}" in warning
     # Only the config that had one is reported.
     assert mock_log_warning.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_migration_moves_a_schedule_timezone_into_the_datetime_timezone():
+    app = AsyncMock()
+    config = {
+        "C123": {
+            "own": {**DEFAULT_CONFIG.copy(), "schedule_timezone": "Asia/Tokyo"},
+            "both": {**DEFAULT_CONFIG.copy(), "schedule_timezone": "Asia/Tokyo", "datetime_timezone": "Europe/Berlin"},
+            "same": {**DEFAULT_CONFIG.copy(), "schedule_timezone": "Europe/Berlin", "datetime_timezone": "Europe/Berlin"},
+        }
+    }
+
+    with patch('hutbot.persistence.log_warning') as mock_log_warning:
+        migrated = await migrate_and_apply_defaults(app, config)
+
+    assert all("schedule_timezone" not in cfg for cfg in migrated["C123"].values())
+    # No date/time timezone of its own: the cron keeps its wall-clock time.
+    assert migrated["C123"]["own"]["datetime_timezone"] == "Asia/Tokyo"
+    # Both set: the date/time one wins and the shift is reported.
+    assert migrated["C123"]["both"]["datetime_timezone"] == "Europe/Berlin"
+    warnings = [call.args[0] for call in mock_log_warning.call_args_list]
+    assert any("moved the schedule timezone Asia/Tokyo" in w for w in warnings)
+    assert any("dropping the schedule timezone Asia/Tokyo; its cron now fires in Europe/Berlin" in w for w in warnings)
+    # Identical values are not worth a warning.
+    assert len(warnings) == 2
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
index ee82017..8a1e9c7 100644
--- a/tests/test_scheduling.py
+++ b/tests/test_scheduling.py
@@ -342,3 +342,31 @@ async def test_handle_channel_message_caches_the_wait_time_it_scheduled_with():
     for scheduled in list(hutbot.state.scheduled_messages.values()):
         scheduled.task.cancel()
     await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_cron_fires_in_the_configured_datetime_timezone():
+    import hutbot
+    # 09:00 in Tokyo is 00:00 UTC; a daily 9am cron is due at that instant for a
+    # Tokyo config and not for a Berlin one (where 9am is still 7 hours away).
+    last = datetime.datetime(2026, 4, 26, 23, 30, tzinfo=datetime.timezone.utc)
+    now = datetime.datetime(2026, 4, 27, 0, 5, tzinfo=datetime.timezone.utc)
+
+    tokyo = {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Asia/Tokyo"}
+    berlin = {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Europe/Berlin"}
+
+    assert hutbot.scheduling._cron_due("0 9 * * *", tokyo, last, now) is True
+    assert hutbot.scheduling._cron_due("0 9 * * *", berlin, last, now) is False
+
+
+@pytest.mark.asyncio
+async def test_cron_falls_back_to_server_local_time():
+    import hutbot
+    last = datetime.datetime(2026, 4, 26, 23, 30, tzinfo=datetime.timezone.utc)
+    now = datetime.datetime(2026, 4, 27, 0, 5, tzinfo=datetime.timezone.utc)
+    config = DEFAULT_CONFIG.copy()
+
+    with patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Asia/Tokyo")):
+        assert hutbot.scheduling._cron_due("0 9 * * *", config, last, now) is True
+    with patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Europe/Berlin")):
+        assert hutbot.scheduling._cron_due("0 9 * * *", config, last, now) is False
diff --git a/webui_static/app.js b/webui_static/app.js
index 69466a7..58a577f 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -350,8 +350,8 @@ function renderEditor(name) {
   }
   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") }),
+      field("Cron schedule", textInput("schedule_cron", { mono: true, placeholder: "0 9 * * 1-5" }),
+        { hint: "5-field cron, in the Date & time timezone below.", error: fieldErr("schedule_cron") }),
     ));
   }
   wrap.append(section("Status & trigger", null, ...triggerRows));

From 1328457fa44985c05696aa5e74bcc2047ff133e2 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Wed, 12 Aug 2026 16:02:35 +0200
Subject: [PATCH 32/42] feat(scheduling): merge cron expression into trigger
 configuration

Rename the `schedule` trigger to `cron` and integrate the cron expression directly into the trigger command. The cron expression is now mandatory for the `cron` trigger, preventing rules from being left in a state where they never fire. This simplifies the configuration model by removing the separate `set cron` command and consolidating schedule settings with the trigger definition.
---
 README.md                      | 19 +++++++------
 hutbot/commands/dispatch.py    |  4 +--
 hutbot/commands/info.py        | 13 +++++----
 hutbot/commands/patterns.py    |  4 +--
 hutbot/commands/setters.py     | 44 ++++++++++++++++++------------
 hutbot/constants.py            | 11 ++++----
 hutbot/messaging.py            |  6 ++--
 hutbot/scheduling.py           | 16 +++++------
 hutbot/webui_backend.py        | 10 +++----
 tests/_common.py               |  2 +-
 tests/test_commands_info.py    |  8 +++---
 tests/test_commands_setters.py | 50 ++++++++++++++++++++++++++++++++--
 tests/test_scheduling.py       | 20 +++-----------
 tests/test_webui_backend.py    | 10 +++----
 webui_static/app.js            | 18 ++++++------
 15 files changed, 139 insertions(+), 96 deletions(-)

diff --git a/README.md b/README.md
index b964a68..3173ebc 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 The hutbot is a simple Slack bot that monitors messages in a channel and automatically replies in a thread if no one reacts or responds to the message within a configurable time period (by default 30 minutes). The bot reminds channel members that a message has gone unanswered. Scheduled reminders are cancelled when someone replies in the thread or reacts in a way that does not match the config criteria that caused that reminder to be scheduled, or when the original message is deleted. Users can adjust both the waiting time and the reminder message directly within the channel, including `{{variable}}` placeholders in the reminder text.
 
-Reply messages support built-in placeholders such as `{{user}}`, `{{channel}}`, and `{{message_link}}`. `{{date}}`, `{{time}}`, and `{{datetime}}` render the triggering message's time — or the time the rule ran, for `schedule`/`manual` triggers and for `test`/`run` — using the config's date/time format, timezone, and locale, and take the same `fmt`/`tz`/`lc` arguments as the Opsgenie date/time variables below. `{{timestamp}}` is the raw Slack timestamp of the same instant. If a channel config also has an Opsgenie schedule configured via `/hutbot [config] set opsgenie-schedule <name>`, Hutbot can resolve the current on-call person and expose:
+Reply messages support built-in placeholders such as `{{user}}`, `{{channel}}`, and `{{message_link}}`. `{{date}}`, `{{time}}`, and `{{datetime}}` render the triggering message's time — or the time the rule ran, for `cron`/`manual` triggers and for `test`/`run` — using the config's date/time format, timezone, and locale, and take the same `fmt`/`tz`/`lc` arguments as the Opsgenie date/time variables below. `{{timestamp}}` is the raw Slack timestamp of the same instant. If a channel config also has an Opsgenie schedule configured via `/hutbot [config] set opsgenie-schedule <name>`, Hutbot can resolve the current on-call person and expose:
 
 - `{{opsgenie_schedule_name}}` for the configured schedule
 - `{{opsgenie_current_user}}` for a Slack `@mention`
@@ -57,14 +57,15 @@ Beyond the classic "reply if a message goes unanswered" behavior, each named con
 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`). It fires in the config's date/time timezone (see
-    `set datetime-format`), or server local time without one.
-  - `manual` — never fires on its own; used as the target of a button or a button timeout.
+- **Triggers** (`/hutbot [config] set trigger <trigger> [<cron expression>]`). The cron trigger
+  carries its expression, so a rule can never be left with a schedule that never fires.
+  - `set trigger message` — the classic behavior (matches channel messages by pattern/teams/hours).
+  - `set trigger cron "0 9 * * 1-5"` — fires on a 5-field cron schedule, in the config's date/time
+    timezone (see `set datetime-format`) or server local time without one. `schedule` and
+    `scheduled` are accepted as names for this trigger.
+  - `set trigger manual` — never fires on its own; used as the target of a button or a button timeout.
 
-- **Conditions** (`/hutbot [config] set condition <none|outlook>`) gate a `schedule` trigger.
+- **Conditions** (`/hutbot [config] set condition <none|outlook>`) gate a `cron` trigger.
   - `outlook` — matches Outlook calendar entries by `set outlook-subject <regex>` /
     `set outlook-body <regex>`. Use `enable negate` to fire when *no* matching entry exists.
     **Note:** the Outlook integration is currently a stub (events come from the
@@ -130,7 +131,7 @@ Use `/hutbot [config] run` to fire a configuration's action immediately (handy f
 ## Leaving and rejoining a channel
 
 Configurations outlive channel membership, so removing the bot from a channel would otherwise leave
-`schedule` rules firing (and pending reminders/escalations coming due) for a channel it can no longer
+`cron` rules firing (and pending reminders/escalations coming due) for a channel it can no longer
 post in. When Hutbot is removed from a channel (kicked, or `/remove`d):
 
 - every enabled configuration of that channel is disabled and marked as *disabled because Hutbot was
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index 75d4d6f..aadb846 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -83,9 +83,7 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
     elif (match := patterns.CLEAR_INCLUDED_TEAM_PATTERN.match(command_text)):
         await setters.clear_included_team(app, channel, config_name, user, thread_ts)
     elif (match := patterns.SET_TRIGGER_PATTERN.match(command_text)):
-        await setters.set_trigger(app, channel, config_name, match.group("trigger"), 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)
+        await setters.set_trigger(app, channel, config_name, match.group("trigger"), match.group("expression"), user, thread_ts)
     elif (match := patterns.SET_CONDITION_PATTERN.match(command_text)):
         await setters.set_condition(app, channel, config_name, match.group("condition"), user, thread_ts)
     elif (match := patterns.SET_OUTLOOK_SUBJECT_PATTERN.match(command_text)):
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 6d9f415..6e700f8 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -27,7 +27,7 @@
     ESCALATION_CONFIG,
     ID_PATTERN,
     TRIGGER_MESSAGE,
-    TRIGGER_SCHEDULE,
+    TRIGGER_CRON,
 )
 from ..textutil import log_debug
 
@@ -180,10 +180,6 @@ def destination_lines(config: dict, action: str, trigger: str) -> list[str]:
         # Each group becomes a blank-line-separated block in the code block.
         groups: list[list[tuple]] = []
 
-        if trigger == TRIGGER_SCHEDULE:
-            # The cron fires in the Date/time timezone below, so it is not repeated here.
-            groups.append([("Cron", config.get('schedule_cron') or '<none>')])
-
         condition = config.get('condition') or ''
         if condition:
             negate = ' (negated)' if config.get('condition_negate') else ''
@@ -255,8 +251,13 @@ def _button_label(b):
             enabled_label = f'disabled, because {state.bot_name} was removed from this channel'
         else:
             enabled_label = 'disabled'
+        trigger_line = f"*Trigger*: `{trigger}`"
+        if trigger == TRIGGER_CRON:
+            # The expression is part of the trigger, and it fires in the
+            # Date/time timezone printed with the settings below.
+            trigger_line += f" `{config.get('cron') or '<none>'}`"
         quoted_block = (
-            f"> *Trigger*: `{trigger}`\n"
+            f"> {trigger_line}\n"
             f">\n"
             f"> {reply_line.replace('\n', '\n> ')}\n"
             f">\n"
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index 70ae4e6..9d10c53 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -41,8 +41,8 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 DELETE_CONFIG_PATTERN = create_command_pattern(r'delete\s+config\s+(?P<name>.+)')
 ENABLE_REPLIES_PATTERN = create_command_pattern(r'enable$')
 DISABLE_REPLIES_PATTERN = create_command_pattern(r'disable$')
-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>.+)')
+# The cron expression belongs to the `cron` trigger, so both arrive together.
+SET_TRIGGER_PATTERN = create_command_pattern(r'set\s+trigger\s+(?P<trigger>\S+)(?:\s+(?P<expression>.+))?$')
 SET_CONDITION_PATTERN = create_command_pattern(r'set\s+condition\s+(?P<condition>.+)')
 SET_OUTLOOK_SUBJECT_PATTERN = create_command_pattern(r'set\s+outlook[_ -]?subject\s+(?P<pattern>.+)')
 SET_OUTLOOK_BODY_PATTERN = create_command_pattern(r'set\s+outlook[_ -]?body\s+(?P<pattern>.+)')
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index be5c410..a0cf440 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -33,7 +33,7 @@
     OPSGENIE_PRIORITIES,
     SUPPORTED_TEMPLATE_VARIABLES,
     TRIGGER_MESSAGE,
-    TRIGGER_SCHEDULE,
+    TRIGGER_CRON,
     TRIGGERS,
 )
 from ..textutil import log_debug, parse_quoted_tokens, strip_quotes
@@ -324,30 +324,40 @@ async def delete_config(app: AsyncApp, channel, config_name: str, user, thread_t
     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:
+async def set_trigger(app: AsyncApp, channel, config_name: str, value: str, expression: str, user, thread_ts: str = "") -> None:
+    """`set trigger <trigger> [<expression>]` — the cron trigger carries its cron.
+
+    A cron trigger without an expression never fires and the scheduler skips it
+    without a word, so the expression is part of choosing the trigger.
+    """
     value = strip_quotes(value).strip().lower()
-    value = {'msg': TRIGGER_MESSAGE, 'cron': TRIGGER_SCHEDULE, 'scheduled': TRIGGER_SCHEDULE}.get(value, value)
+    value = {'msg': TRIGGER_MESSAGE, 'schedule': TRIGGER_CRON, 'scheduled': TRIGGER_CRON}.get(value, value)
     if value not in TRIGGERS:
         supported = ", ".join(f"`{t}`" for t in sorted(TRIGGERS))
         await messaging.send_message(app, channel, user, f"Invalid *trigger*. Must be one of {supported}.", thread_ts)
         return
-    _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)
+    expression = strip_quotes(expression or "").strip()
 
-
-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)
+    if value == TRIGGER_CRON:
+        if not expression:
+            await messaging.send_message(app, channel, user, f"Trigger `{TRIGGER_CRON}` needs an expression: `{state.slash_command} {config_name} set trigger cron \"0 9 * * 1-5\"`.", thread_ts)
+            return
+        if croniter is not None and not croniter.is_valid(expression):
+            await messaging.send_message(app, channel, user, f"Invalid *cron* expression: `{expression}`. Use 5-field cron, e.g. `0 9 * * 1-5`.", thread_ts)
+            return
+    elif expression:
+        await messaging.send_message(app, channel, user, f"Trigger `{value}` takes no expression; only `{TRIGGER_CRON}` does.", thread_ts)
         return
-    _ensure_config(channel, config_name)['schedule_cron'] = cron_expr
+
+    config = _ensure_config(channel, config_name)
+    config['trigger'] = value
+    config['cron'] = expression
     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)
+    if value == TRIGGER_CRON:
+        note = "" if croniter is not None else " (not validated — `croniter` not installed)"
+        await messaging.send_message(app, channel, user, f"*Trigger* set to `{value}` running `{expression}` in configuration `{config_name}`{note}.", thread_ts)
+    else:
+        await messaging.send_message(app, channel, user, f"*Trigger* set to `{value}` in configuration `{config_name}`.", thread_ts)
 
 
 async def set_condition(app: AsyncApp, channel, config_name: str, value: str, user, thread_ts: str = "") -> None:
diff --git a/hutbot/constants.py b/hutbot/constants.py
index 17cd3c5..6af40b9 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -23,9 +23,9 @@
 OPSGENIE_PRIORITIES = {"P1", "P2", "P3", "P4", "P5"}
 
 TRIGGER_MESSAGE = "message"
-TRIGGER_SCHEDULE = "schedule"
+TRIGGER_CRON = "cron"
 TRIGGER_MANUAL = "manual"
-TRIGGERS = {TRIGGER_MESSAGE, TRIGGER_SCHEDULE, TRIGGER_MANUAL}
+TRIGGERS = {TRIGGER_MESSAGE, TRIGGER_CRON, TRIGGER_MANUAL}
 
 CONDITION_NONE = ""
 CONDITION_OUTLOOK = "outlook_calendar"
@@ -88,10 +88,11 @@
     "enabled": True,
     # Why the bot disabled this config on its own; empty for a user-made change.
     "disabled_reason": "",
-    # Trigger: how the rule starts. "message" keeps the classic behavior.
+    # Trigger: how the rule starts. "message" keeps the classic behavior; "cron"
+    # carries its expression in `cron`.
     "trigger": TRIGGER_MESSAGE,
-    "schedule_cron": "",
-    # Condition: optional gate evaluated when a schedule trigger fires.
+    "cron": "",
+    # Condition: optional gate evaluated when a cron trigger fires.
     "condition": CONDITION_NONE,
     "condition_negate": False,
     "outlook_subject_pattern": "",
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 2e2124c..77eb091 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -181,7 +181,7 @@ async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_
     update_text = (
         f"Hi! :wave: I am *{name}* `{version}` :palm_up_hand::tophat: Here's what's :new::\n\n"
         "> :robot_face: *Triggers, actions & buttons*\n>\n"
-        f"> Rules can now run on a `schedule` (cron), DM a user or group, post to a channel, and carry interactive buttons (with an auto-press default + timeout escalation). See `{command} help`.\n>\n"
+        f"> Rules can now run on a `cron` schedule, DM a user or group, post to a channel, and carry interactive buttons (with an auto-press default + timeout escalation). See `{command} help`.\n>\n"
         "> :calendar: *OpsGenie date/time template variables and defaults*\n>\n"
         f"> OpsGenie templates can now include current and next on-call start/end dates, times, and datetimes. Use `{command} [config] set datetime-format \"<date>\" \"<time>\" [<timezone> <locale>]` to set the defaults.\n>\n"
         "> :pencil: *Customize reply messages with `{{placeholders}}`*\n>\n"
@@ -218,8 +218,8 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} delete config <name>", "Delete a configuration."),
         ]),
         ("Trigger", [
-            (f"{command} [config] set trigger <message|schedule|manual>", "Set how the rule starts."),
-            (f"{command} [config] set cron <expr>", "Set the cron schedule, e.g. 0 9 * * 1-5."),
+            (f"{command} [config] set trigger <message|manual>", "Set how the rule starts."),
+            (f"{command} [config] set trigger cron \"<expr>\"", "Fire on a cron schedule, e.g. 0 9 * * 1-5."),
         ]),
         ("Condition", [
             (f"{command} [config] set condition <none|outlook>", "Gate a schedule on a condition."),
diff --git a/hutbot/scheduling.py b/hutbot/scheduling.py
index 4bf03ec..0662d04 100644
--- a/hutbot/scheduling.py
+++ b/hutbot/scheduling.py
@@ -1,4 +1,4 @@
-"""Scheduled replies (deferred message reminders) and the cron-trigger scheduler."""
+"""Deferred message reminders and the cron-trigger scheduler."""
 
 import asyncio
 import datetime
@@ -12,7 +12,7 @@
 from . import slackcache
 from . import actions
 from . import persistence
-from .constants import SCHEDULER_INTERVAL, TRIGGER_SCHEDULE
+from .constants import SCHEDULER_INTERVAL, TRIGGER_CRON
 from .models import ScheduledReply
 
 try:
@@ -106,27 +106,27 @@ async def scheduler_tick(app: AsyncApp, opsgenie_token: str) -> None:
     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:
+            if config.get('trigger') != TRIGGER_CRON:
                 continue
             if not config.get('enabled', True):
                 continue
-            cron_expr = config.get('schedule_cron') or ''
+            cron_expr = config.get('cron') or ''
             if not cron_expr:
                 continue
             if croniter is not None and not croniter.is_valid(cron_expr):
-                log_warning(f"Schedule '{config_name}' in channel {channel_id} has invalid cron '{cron_expr}'.")
+                log_warning(f"Cron config '{config_name}' in channel {channel_id} has an invalid expression '{cron_expr}'.")
                 continue
             if not _cron_due(cron_expr, config, last, now):
                 continue
             channel = await slackcache.get_channel_by_id(app, channel_id)
             if not await actions.evaluate_condition(app, config):
-                log(f"Schedule '{config_name}' in #{channel.name} fired but condition not met.")
+                log(f"Cron config '{config_name}' in #{channel.name} fired but condition not met.")
                 continue
-            log(f"Schedule '{config_name}' in #{channel.name} firing.")
+            log(f"Cron config '{config_name}' in #{channel.name} firing.")
             try:
                 await actions.run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel_id})
             except Exception as e:
-                log_error(f"Schedule '{config_name}' action failed:", e)
+                log_error(f"Cron config '{config_name}' action failed:", e)
 
 
 async def restore_scheduled_replies(app: AsyncApp, opsgenie_token: str) -> None:
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 2149844..04fc829 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -41,7 +41,7 @@
     SUPPORTED_TEMPLATE_VARIABLES,
     TEAM_UNKNOWN,
     TRIGGER_MESSAGE,
-    TRIGGER_SCHEDULE,
+    TRIGGER_CRON,
     TRIGGERS,
 )
 from .models import User
@@ -181,14 +181,14 @@ def get(key):
     else:
         cfg['datetime_locale'] = ""
 
-    cron_expr = str(get('schedule_cron') or "").strip()
+    cron_expr = str(get('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`."
+        errors['cron'] = "Invalid cron expression. Use 5 fields, e.g. `0 9 * * 1-5`."
     else:
-        cfg['schedule_cron'] = cron_expr
+        cfg['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)
+    trigger = {'msg': TRIGGER_MESSAGE, 'schedule': TRIGGER_CRON, 'scheduled': TRIGGER_CRON}.get(trigger, trigger)
     if trigger not in TRIGGERS:
         errors['trigger'] = "Trigger must be one of " + ", ".join(sorted(TRIGGERS)) + "."
     else:
diff --git a/tests/_common.py b/tests/_common.py
index 7297374..c24628d 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -25,7 +25,7 @@
     ACTION_REPLY,
     DEFAULT_CONFIG,
     DISABLED_REASON_REMOVED,
-    TRIGGER_SCHEDULE,
+    TRIGGER_CRON,
     bot_slug,
     normalize_slash_command,
 )
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 7161cba..4e3d3e8 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -193,7 +193,7 @@ async def test_show_config_names_the_destination_per_action():
         "post": {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL, "action_target": "<#CTARGET|targets>"},
         "dm": {**DEFAULT_CONFIG.copy(), "action": ACTION_DM_USER, "action_target": "d.grieser@mittwald.de"},
         "group": {**DEFAULT_CONFIG.copy(), "action": ACTION_GROUP_DM, "action_target": "SGROUP"},
-        "scheduled": {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_SCHEDULE, "schedule_cron": "0 9 * * 1-5"},
+        "scheduled": {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_CRON, "cron": "0 9 * * 1-5"},
     }
     channel = Channel(id="C123", name="general", configs=configs)
     user = User(id="U123", name="test", real_name="Test User", team="A")
@@ -207,9 +207,9 @@ async def test_show_config_names_the_destination_per_action():
     assert "*Sent to* <!subteam^SGROUP> (group message)" in sent_message
     # No message to thread on for a schedule trigger.
     assert "*Replied in* <#C123>\n" in sent_message
-    assert "Cron                0 9 * * 1-5" in sent_message
-    # The cron uses the Date/time timezone, so it is not repeated as its own row.
-    assert "Schedule timezone" not in sent_message
+    # The cron expression rides with the trigger, not as a settings row.
+    assert "> *Trigger*: `cron` `0 9 * * 1-5`" in sent_message
+    assert "\nCron " not in sent_message
     # Non-reply actions title their template "Message", not "Reply message".
     assert "*Message*:" in sent_message
     assert "Action target" not in sent_message
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 6244fae..16e367a 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -305,13 +305,57 @@ async def test_set_trigger_valid_and_invalid():
     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 cron \"0 9 * * 1-5\"", channel, user)
+        assert channel.configs["default"]["trigger"] == TRIGGER_CRON
+        assert channel.configs["default"]["cron"] == "0 9 * * 1-5"
+        # `schedule` still resolves to the cron trigger.
+        await process_command(app, "set trigger schedule \"0 8 * * *\"", channel, user)
+        assert channel.configs["default"]["cron"] == "0 8 * * *"
         await process_command(app, "set trigger bogus", channel, user)
-        assert channel.configs["default"]["trigger"] == "schedule"  # unchanged
+        assert channel.configs["default"]["trigger"] == TRIGGER_CRON  # unchanged
         assert "Invalid *trigger*" in send.call_args_list[-1].args[3]
 
 
+@pytest.mark.asyncio
+async def test_set_trigger_cron_requires_a_valid_expression():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set trigger cron", channel, user)
+        assert send.call_args.args[3] == (
+            'Trigger `cron` needs an expression: `/hutbot default set trigger cron "0 9 * * 1-5"`.'
+        )
+        await process_command(app, "set trigger cron not a cron", channel, user)
+        assert "Invalid *cron* expression: `not a cron`" in send.call_args.args[3]
+
+    # Neither attempt stored anything, so no rule sits there never firing.
+    assert config["trigger"] == "message"
+    assert config["cron"] == ""
+
+
+@pytest.mark.asyncio
+async def test_set_trigger_message_takes_no_expression_and_clears_the_cron():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_CRON, "cron": "0 9 * * 1-5"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set trigger message 0 9 * * 1-5", channel, user)
+        assert send.call_args.args[3] == "Trigger `message` takes no expression; only `cron` does."
+        assert config["cron"] == "0 9 * * 1-5"
+
+        await process_command(app, "set trigger message", channel, user)
+
+    assert send.call_args.args[3] == "*Trigger* set to `message` in configuration `default`."
+    assert config["cron"] == ""
+
+
 @pytest.mark.asyncio
 async def test_set_replies_enabled_clears_the_automatic_disable_reason():
     app = AsyncMock()
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
index 8a1e9c7..74d600d 100644
--- a/tests/test_scheduling.py
+++ b/tests/test_scheduling.py
@@ -161,18 +161,6 @@ async def test_schedule_reply_removes_entry_from_cache():
     assert key not in hutbot.state._scheduled_replies_cache
 
 
-@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 -----
@@ -181,8 +169,8 @@ async def test_set_schedule_cron_valid_and_invalid():
 async def test_scheduler_tick_fires_due_schedule_when_condition_met():
     app = AsyncMock()
     sched = DEFAULT_CONFIG.copy()
-    sched["trigger"] = "schedule"
-    sched["schedule_cron"] = "* * * * *"
+    sched["trigger"] = TRIGGER_CRON
+    sched["cron"] = "* * * * *"
     channel = _mk_channel({"sched": sched})
     hutbot.state._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
     with patch.dict('hutbot.state.channel_config', {"C12345": {"sched": sched}}, clear=True), \
@@ -200,8 +188,8 @@ async def test_scheduler_tick_fires_due_schedule_when_condition_met():
 async def test_scheduler_tick_skips_when_condition_not_met():
     app = AsyncMock()
     sched = DEFAULT_CONFIG.copy()
-    sched["trigger"] = "schedule"
-    sched["schedule_cron"] = "* * * * *"
+    sched["trigger"] = TRIGGER_CRON
+    sched["cron"] = "* * * * *"
     channel = _mk_channel({"sched": sched})
     hutbot.state._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
     with patch.dict('hutbot.state.channel_config', {"C12345": {"sched": sched}}, clear=True), \
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
index 50ade04..ab907b9 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -9,7 +9,7 @@ async def test_validate_config_payload_accepts_good_config():
     payload = {
         "enabled": True,
         "trigger": "schedule",
-        "schedule_cron": "0 9 * * 1-5",
+        "cron": "0 9 * * 1-5",
         "reply_message": "Hi {{user}} in {{channel}}",
         "action": "post-channel",
         "action_target": "C0123ABCD",
@@ -28,8 +28,8 @@ async def test_validate_config_payload_accepts_good_config():
 
     assert errors == {}
     assert cfg is not None
-    assert cfg["trigger"] == "schedule"
-    assert cfg["schedule_cron"] == "0 9 * * 1-5"
+    assert cfg["trigger"] == "cron"
+    assert cfg["cron"] == "0 9 * * 1-5"
     # action "post-channel" normalizes to "post_channel" with target preserved.
     assert cfg["action"] == "post_channel"
     assert cfg["action_target"] == "C0123ABCD"
@@ -59,7 +59,7 @@ async def test_validate_config_payload_collects_field_errors():
     payload = {
         "reply_message": "",
         "trigger": "bogus",
-        "schedule_cron": "nope",
+        "cron": "nope",
         "wait_time": 0,
         "datetime_timezone": "Mars/Phobos",
         "opsgenie_priority": "P9",
@@ -78,7 +78,7 @@ async def test_validate_config_payload_collects_field_errors():
     cfg, errors = await validate_config_payload(payload, app)
 
     assert cfg is None
-    for field in ("reply_message", "trigger", "schedule_cron", "wait_time",
+    for field in ("reply_message", "trigger", "cron", "wait_time",
                   "datetime_timezone", "opsgenie_priority", "included_teams",
                   "pattern", "hours", "action_target"):
         assert field in errors, f"expected an error for {field}, got {sorted(errors)}"
diff --git a/webui_static/app.js b/webui_static/app.js
index 58a577f..588c9f2 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -49,8 +49,8 @@ const state = {
 };
 
 // ---------- labels ----------
-const TRIGGER_LABEL = { message: "Message (classic)", schedule: "Schedule (cron)", manual: "Manual" };
-const TRIGGER_SHORT = { message: "message", schedule: "schedule", manual: "manual" };
+const TRIGGER_LABEL = { message: "Message (classic)", cron: "Cron schedule", manual: "Manual" };
+const TRIGGER_SHORT = { message: "message", cron: "cron", manual: "manual" };
 const ACTION_LABEL = { reply: "Reply in thread", dm_user: "Direct message", group_dm: "Group DM", post_channel: "Post to channel" };
 const ACTION_SHORT = { reply: "reply", dm_user: "dm", group_dm: "group dm", post_channel: "post" };
 const CONDITION_LABEL = { "": "None (always)", outlook_calendar: "Outlook calendar" };
@@ -236,7 +236,7 @@ function cardIdBlock(name, cfg) {
 }
 
 function pipelineFor(cfg) {
-  const condText = cfg.trigger === "schedule" && cfg.condition === "outlook_calendar"
+  const condText = cfg.trigger === "cron" && cfg.condition === "outlook_calendar"
     ? (cfg.condition_negate ? "no outlook" : "outlook") : "—";
   const chip = (kind, text, muted) => h("span", { class: "pipe-chip" + (muted ? " muted" : "") },
     h("span", { class: "pipe-kind", text: kind }), text);
@@ -348,16 +348,16 @@ function renderEditor(name) {
     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") {
+  if (cfg.trigger === "cron") {
     triggerRows.push(grid(
-      field("Cron schedule", textInput("schedule_cron", { mono: true, placeholder: "0 9 * * 1-5" }),
-        { hint: "5-field cron, in the Date & time timezone below.", error: fieldErr("schedule_cron") }),
+      field("Cron schedule", textInput("cron", { mono: true, placeholder: "0 9 * * 1-5" }),
+        { hint: "5-field cron, in the Date & time timezone below.", error: fieldErr("cron") }),
     ));
   }
   wrap.append(section("Status & trigger", null, ...triggerRows));
 
   // — Condition (schedule only) —
-  if (cfg.trigger === "schedule") {
+  if (cfg.trigger === "cron") {
     const condRows = [grid(field("Condition", selectInput("condition", state.meta.conditions, CONDITION_LABEL, structuralRefresh),
       { hint: "Gate the schedule on an Outlook calendar entry." }))];
     if (cfg.condition === "outlook_calendar") {
@@ -367,7 +367,7 @@ function renderEditor(name) {
       ));
       condRows.push(h("div", { class: "toggles-row" }, toggleInput("condition_negate", "Fire when no matching entry exists")));
     }
-    wrap.append(section("Condition", "schedule", ...condRows));
+    wrap.append(section("Condition", "cron", ...condRows));
   }
 
   // — Action —
@@ -407,7 +407,7 @@ function structuralRefreshLabelOnly() {
 
 function triggerHint(t) {
   if (t === "message") return "Watches channel messages and nudges if unanswered.";
-  if (t === "schedule") return "Fires on a cron schedule.";
+  if (t === "cron") return "Fires on a cron schedule.";
   return "Only runs when a button or another rule calls it.";
 }
 

From 1ad224f79a41bedc5b4ae4d528798ed26d91e70f Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 13 Aug 2026 11:03:08 +0200
Subject: [PATCH 33/42] feat(commands): add clear command for pattern and
 opsgenie-message

Introduce `clear pattern`, `clear default-button`, and `clear opsgenie-message` commands to reset configuration values to their defaults. This allows users to easily revert specific settings without manually re-entering other configurations.

Update help documentation to reflect new commands and clarify existing descriptions for conditions, datetime formats, and on-call lookups. Add tests to verify the new clearing functionality and ensure help output includes all documented commands.
---
 hutbot/commands/dispatch.py    |  2 ++
 hutbot/commands/patterns.py    |  1 +
 hutbot/commands/setters.py     |  8 ++++++++
 hutbot/messaging.py            |  9 ++++++---
 tests/test_commands_info.py    |  8 ++++++++
 tests/test_commands_setters.py | 35 ++++++++++++++++++++++++++++++++++
 6 files changed, 60 insertions(+), 3 deletions(-)

diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index aadb846..5d1b2c3 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -39,6 +39,8 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         await setters.set_opsgenie_message(app, channel, config_name, strip_quotes(match.group("message")), user, thread_ts)
     elif (match := patterns.SET_DATETIME_FORMAT_PATTERN.match(command_text)):
         await setters.set_datetime_format(app, channel, config_name, match.group("values"), user, thread_ts)
+    elif patterns.CLEAR_PATTERN_PATTERN.match(command_text):
+        await setters.clear_pattern(app, channel, config_name, user, thread_ts)
     elif (match := patterns.SET_PATTERN_PATTERN.match(command_text)):
         pattern = match.group("pattern")
         case_sensitive = match.group("case_sensitive")
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index 9d10c53..2d47bbe 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -18,6 +18,7 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 CLEAR_OPSGENIE_MESSAGE_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+opsgenie[_ -]?message')
 SET_OPSGENIE_MESSAGE_PATTERN = create_command_pattern(r'set\s+opsgenie[_ -]?message\s+(?P<message>.+)')
 SET_DATETIME_FORMAT_PATTERN = create_command_pattern(r'(set\s+)?(datetime[_ -]?format|date[_ -]?format|datefmt)\s+(?P<values>.+)')
+CLEAR_PATTERN_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+pattern')
 SET_PATTERN_PATTERN = create_command_pattern(r'set\s+pattern\s+(?P<pattern>"[^"]*"|\'[^\']*\'|[^\r\n\t\f\v\s"\']+)(?:\s+(?P<case_sensitive>true|false|1|0))?')
 ADD_EXCLUDED_TEAM_PATTERN = create_command_pattern(r'(add\s+)?excluded?([_ -]?teams?)?\s+(?P<team>.+)')
 CLEAR_EXCLUDED_TEAM_PATTERN = create_command_pattern(r'clear\s+excluded?([_ -]?teams?)?')
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index a0cf440..7e8b1c7 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -283,6 +283,14 @@ async def test_reply_message(app: AsyncApp, opsgenie_token: str, channel, config
     await messaging.send_message(app, channel, user, message, thread_ts)
 
 
+async def clear_pattern(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    config = _ensure_config(channel, config_name)
+    config['pattern'] = None
+    config['pattern_case_sensitive'] = False
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Pattern* cleared in configuration `{config_name}`; every message matches now.", thread_ts)
+
+
 async def set_pattern(app: AsyncApp, channel, config_name: str, pattern_str: str, case_sensitive_str: str | None, user, thread_ts: str = "") -> None:
     if config_name not in channel.configs:
         channel.configs[config_name] = DEFAULT_CONFIG.copy()
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 77eb091..81235d5 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -222,7 +222,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} [config] set trigger cron \"<expr>\"", "Fire on a cron schedule, e.g. 0 9 * * 1-5."),
         ]),
         ("Condition", [
-            (f"{command} [config] set condition <none|outlook>", "Gate a schedule on a condition."),
+            (f"{command} [config] set condition <none|outlook>", "Gate a cron trigger on a condition."),
             (f"{command} [config] set outlook-subject <regex>", "Match Outlook event subject (stub)."),
             (f"{command} [config] set outlook-body <regex>", "Match Outlook event body (stub)."),
             (f"{command} [config] enable negate", "Invert the condition (e.g. no matching event)."),
@@ -230,6 +230,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ]),
         ("What to react to", [
             (f"{command} [config] set pattern \"<regex>\" [0|1]", "Set message pattern; 1 means case sensitive."),
+            (f"{command} [config] clear pattern", "React to every message again."),
             (f"{command} [config] add included-team <team>", "Add an allowed team."),
             (f"{command} [config] clear included-teams", "Clear allowed teams."),
             (f"{command} [config] add excluded-team <team>", "Add an ignored team."),
@@ -260,6 +261,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} [config] set button-timeout <minutes>", "Escalate if no button is pressed in time."),
             (f"{command} [config] set button-timeout-target <config>", "Config to run on button timeout."),
             (f"{command} [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
+            (f"{command} [config] clear default-button", "Stop auto-pressing on timeout."),
         ]),
         ("OpsGenie", [
             (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
@@ -267,15 +269,16 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} [config] set opsgenie-schedule <name>", "Set the OpsGenie schedule name."),
             (f"{command} [config] set opsgenie-priority <P1-P5>", "Set the OpsGenie alert priority."),
             (f"{command} [config] set opsgenie-message <text>", "Template for the alert text (default: the message)."),
+            (f"{command} [config] clear opsgenie-message", "Back to alerting with the message itself."),
         ]),
         ("Date and time", [
-            (f"{command} [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Set date/time formats."),
+            (f"{command} [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Date/time output; <tz> also drives cron and work hours."),
         ]),
         ("Try it out and look things up", [
             (f"{command} [config] run", "Run this configuration's action now."),
             (f"{command} [config] test", "Preview configured reply."),
             (f"{mention} [config] test <message>", "Preview reply with <message> as {{message}}."),
-            (f"{command} [config] on-call [schedule]", "Show current on-call user."),
+            (f"{command} [config] on-call [opsgenie-schedule]", "Show current on-call user."),
             (f"{command} list teams", "List available teams."),
             (f"{command} list opsgenie-schedules", "List OpsGenie schedules."),
             (f"{command} team of <@user>", "Show a user's team."),
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 4e3d3e8..9406fbb 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -144,6 +144,14 @@ async def test_process_command_help_uses_compact_command_reference():
     assert "\n\n# Help\n/hutbot news" in sent_message
     assert sent_message.index("# Trigger") < sent_message.index("# When to react") < sent_message.index("# Buttons")
     assert "/hutbot [config] set work-hours all day" in sent_message
+    assert "/hutbot [config] set trigger cron \"<expr>\"" in sent_message
+    # Removed commands are gone from the reference.
+    for stale in ("set target", "set cron <", "set schedule-timezone", "forward-channel"):
+        assert stale not in sent_message, stale
+    # Every dispatched command is documented.
+    assert "/hutbot [config] clear opsgenie-message" in sent_message
+    assert "/hutbot [config] clear default-button" in sent_message
+    assert "/hutbot [config] clear pattern" in sent_message
     assert "@Hutbot [config] test <message>" in sent_message
     assert "Preview reply with <message> as {{message}}." in sent_message
     assert "*Enable OpsGenie Integration:*" not in sent_message
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 16e367a..2e044c8 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -574,3 +574,38 @@ async def test_bare_action_command_still_takes_a_config_name():
         await process_command(app, "action", channel, user)
 
     assert "Huh?" in mock_send_message.call_args.args[3]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["clear pattern", "unset pattern", "remove pattern"])
+async def test_clear_pattern_makes_every_message_match_again(command):
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "pattern": ".*alarm.*", "pattern_case_sensitive": True}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert config["pattern"] is None
+    # Case sensitivity is part of the pattern, so it goes back to the default too.
+    assert config["pattern_case_sensitive"] is False
+    assert mock_send_message.call_args.args[3] == (
+        "*Pattern* cleared in configuration `default`; every message matches now."
+    )
+
+
+@pytest.mark.asyncio
+async def test_clear_pattern_does_not_shadow_setting_one():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message'):
+        await process_command(app, 'set pattern ".*alarm.*" 1', channel, user)
+
+    assert config["pattern"] == ".*alarm.*"
+    assert config["pattern_case_sensitive"] is True

From 77aded1ec5812da5ed56e2b7de26ef4f95eae5b8 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 13 Aug 2026 11:29:44 +0200
Subject: [PATCH 34/42] fix(commands): allow optional 'set' keyword for setter
 commands

Update command patterns in `patterns.py` to make the leading word `set` optional for all setter commands. This allows users to run commands like `wait-time 5` or `trigger cron ...` without explicitly typing `set`.

Refactor `dispatch.py` to resolve ambiguity between config names and command words:
- Prioritize existing config names over command matching (e.g., `trigger message` uses the `trigger` config).
- Prevent reserved command words (like `set`, `enable`) from being used as config names.
- Add `RESERVED_CONFIG_NAMES` constant to define these protected words.
- Update help text to reflect the optional `set` keyword.

Add tests to verify that setter commands work with and without `set`, that existing configs take precedence in ambiguous cases, and that reserved words cannot create new configurations.
---
 hutbot/commands/dispatch.py    | 54 ++++++++++++++++-----
 hutbot/commands/patterns.py    | 26 ++++++-----
 hutbot/constants.py            |  6 +++
 hutbot/messaging.py            |  2 +-
 tests/test_commands_setters.py | 85 ++++++++++++++++++++++++++++++++++
 5 files changed, 149 insertions(+), 24 deletions(-)

diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index 5d1b2c3..cb9b268 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -1,5 +1,6 @@
 """Command dispatch: match a slash-command string and run the matching handler."""
 
+import re
 import traceback
 
 from slack_bolt.async_app import AsyncApp
@@ -9,7 +10,7 @@
 from .. import state
 from .. import messaging
 from .. import opsgenie
-from ..constants import CONFIG_NAME_PATTERN, DEFAULT_CONFIG_NAME
+from ..constants import CONFIG_NAME_PATTERN, DEFAULT_CONFIG_NAME, RESERVED_CONFIG_NAMES
 from ..textutil import log_debug, strip_quotes
 
 from . import patterns
@@ -130,6 +131,23 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
     return True
 
 
+def matches_a_command(command_text: str, allow_test_message: bool = False) -> bool:
+    """Whether `command_text` is a command in its own right.
+
+    Used to tell `<config> <command>` from a `<command>` whose first word happens
+    to look like a config name. Every regex in `patterns` is tried, so this cannot
+    drift out of step with what `parse_and_execute_command` accepts.
+    """
+    for name, pattern in vars(patterns).items():
+        if not name.endswith("_PATTERN") or not isinstance(pattern, re.Pattern):
+            continue
+        if name == "TEST_WITH_MESSAGE_PATTERN" and not allow_test_message:
+            continue
+        if pattern.match(command_text):
+            return True
+    return False
+
+
 async def process_command(app: AsyncApp, text: str, channel, user, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> None:
     try:
         await _process_command(app, text, channel, user, thread_ts, opsgenie_token, allow_test_message, command_ts)
@@ -148,21 +166,33 @@ async def _process_command(app: AsyncApp, text: str, channel, user, thread_ts: s
     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
+    async def run(command_text: str, config_name: str) -> bool:
+        return await parse_and_execute_command(app, command_text, channel, config_name, user, thread_ts, opsgenie_token, allow_test_message, command_ts)
 
-    # 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:])
+    parts = text.split(None, 1)
+    leading_word, remainder = (parts[0], parts[1]) if len(parts) > 1 else ("", "")
 
-        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)
+    # `<config> <command>` and `<command>` can both fit the same text — say a config
+    # named `trigger` and the command `trigger cron "…"`. An existing config wins
+    # that tie, because naming one is deliberate; otherwise the text is a command
+    # for the default config.
+    if remainder and leading_word in channel.configs and matches_a_command(remainder, allow_test_message):
+        if await run(remainder, leading_word):
             return
 
-        if await parse_and_execute_command(app, command_text, channel, config_name, user, thread_ts, opsgenie_token, allow_test_message, command_ts):
+    if await run(text, DEFAULT_CONFIG_NAME):
+        return
+
+    # Nothing matched as a command, so a leading word can only be a config name —
+    # including one that does not exist yet, which is how configs are created.
+    if remainder and matches_a_command(remainder, allow_test_message):
+        if leading_word.lower() in RESERVED_CONFIG_NAMES:
+            await messaging.send_message(app, channel, user, f"`{leading_word}` cannot be a configuration name; it starts a command. Check the syntax with `{state.slash_command} help`.", thread_ts)
+            return
+        if not CONFIG_NAME_PATTERN.match(leading_word):
+            await messaging.send_message(app, channel, user, f"Invalid config name: `{leading_word}`. Only characters `A-Z`, `a-z`, `0-9`, `.`, `:`, `/`, `-`, `_` are allowed.", thread_ts)
+            return
+        if await run(remainder, leading_word):
             return
 
     await messaging.send_message(app, channel, user, f"Huh? :thinking_face: Maybe type `{state.slash_command} help` for a list of commands.", thread_ts)
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index 2d47bbe..baf5473 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -7,19 +7,23 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
     return re.compile(f'^{command_regex}', re.IGNORECASE)
 
 
+# Every command that sets something takes an optional leading `set`, so
+# `set wait-time 5` and `wait-time 5` are the same command.
+
+
 HELP_PATTERN = re.compile(r'help', re.IGNORECASE)
 WHATSNEW_PATTERN = re.compile(r'news', re.IGNORECASE)
 TEST_PATTERN = re.compile(r'^test$', re.IGNORECASE)
 TEST_WITH_MESSAGE_PATTERN = re.compile(r'^test(?:\s+(?P<message>.*))?$', re.IGNORECASE)
 SET_WAIT_TIME_PATTERN = create_command_pattern(r'(set\s+)?wait([_ -]?time)?\s+(?P<wait_time>.+)')
 SET_REPLY_MESSAGE_PATTERN = create_command_pattern(r'(set\s+)?(message|reply)\s+(?P<message>.+)')
-SET_OPSGENIE_SCHEDULE_PATTERN = create_command_pattern(r'set\s+opsgenie[_ -]?schedule\s+(?P<schedule>.+)')
-SET_OPSGENIE_PRIORITY_PATTERN = create_command_pattern(r'set\s+opsgenie[_ -]?priority\s+(?P<priority>.+)')
+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_OPSGENIE_MESSAGE_PATTERN = create_command_pattern(r'(set\s+)?opsgenie[_ -]?message\s+(?P<message>.+)')
 SET_DATETIME_FORMAT_PATTERN = create_command_pattern(r'(set\s+)?(datetime[_ -]?format|date[_ -]?format|datefmt)\s+(?P<values>.+)')
 CLEAR_PATTERN_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+pattern')
-SET_PATTERN_PATTERN = create_command_pattern(r'set\s+pattern\s+(?P<pattern>"[^"]*"|\'[^\']*\'|[^\r\n\t\f\v\s"\']+)(?:\s+(?P<case_sensitive>true|false|1|0))?')
+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>.+)')
@@ -43,10 +47,10 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 ENABLE_REPLIES_PATTERN = create_command_pattern(r'enable$')
 DISABLE_REPLIES_PATTERN = create_command_pattern(r'disable$')
 # The cron expression belongs to the `cron` trigger, so both arrive together.
-SET_TRIGGER_PATTERN = create_command_pattern(r'set\s+trigger\s+(?P<trigger>\S+)(?:\s+(?P<expression>.+))?$')
-SET_CONDITION_PATTERN = create_command_pattern(r'set\s+condition\s+(?P<condition>.+)')
-SET_OUTLOOK_SUBJECT_PATTERN = create_command_pattern(r'set\s+outlook[_ -]?subject\s+(?P<pattern>.+)')
-SET_OUTLOOK_BODY_PATTERN = create_command_pattern(r'set\s+outlook[_ -]?body\s+(?P<pattern>.+)')
+SET_TRIGGER_PATTERN = create_command_pattern(r'(set\s+)?trigger\s+(?P<trigger>\S+)(?:\s+(?P<expression>.+))?$')
+SET_CONDITION_PATTERN = create_command_pattern(r'(set\s+)?condition\s+(?P<condition>.+)')
+SET_OUTLOOK_SUBJECT_PATTERN = create_command_pattern(r'(set\s+)?outlook[_ -]?subject\s+(?P<pattern>.+)')
+SET_OUTLOOK_BODY_PATTERN = create_command_pattern(r'(set\s+)?outlook[_ -]?body\s+(?P<pattern>.+)')
 ENABLE_CONDITION_NEGATE_PATTERN = create_command_pattern(r'enable\s+(condition[_ -]?)?negate')
 DISABLE_CONDITION_NEGATE_PATTERN = create_command_pattern(r'disable\s+(condition[_ -]?)?negate')
 # The target belongs to the action, so both arrive in one command. `set` is
@@ -54,8 +58,8 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 SET_ACTION_PATTERN = create_command_pattern(r'(set\s+)?action\s+(?P<action>\S+)(?:\s+(?P<target>.+))?$')
 ADD_BUTTON_PATTERN = create_command_pattern(r'add\s+button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
 CLEAR_BUTTONS_PATTERN = create_command_pattern(r'clear\s+buttons?')
-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>.+)')
+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>.+)')
+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/constants.py b/hutbot/constants.py
index 6af40b9..b144f0a 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -156,6 +156,12 @@ def normalize_slash_command(value: str) -> str:
 ID_PATTERN = re.compile(r'<([#@!][a-zA-Z0-9^]+)([|]([^>]*))?>')
 TIME_HOUR_PATTERN = re.compile(r"^[0-9]{1,2}$")
 CONFIG_NAME_PATTERN = re.compile(r"^[A-Za-z0-9-_\.:/]+$")
+# Words that start a command. A config may not be named after one, or
+# `set enable` would create a config called "set" instead of failing.
+RESERVED_CONFIG_NAMES = {
+    "set", "clear", "unset", "remove", "add", "enable", "disable",
+    "show", "delete", "list", "run", "fire", "test", "help", "news",
+}
 TEMPLATE_VARIABLE_NAME_PATTERN = re.compile(r'[a-z_][a-z0-9_]*')
 TEMPLATE_ARGUMENT_NAME_PATTERN = re.compile(r'[a-z_][a-z0-9_]*')
 TEMPLATE_ARGUMENT_ALIASES = {
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 81235d5..24bbcd5 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -302,7 +302,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         f"Displays all configurations for `#{channel.name}`."
     )
     outro = (
-        "`[config]` is optional; omitted commands use `default`.\n\n"
+        "`[config]` is optional; omitted commands use `default`. The word `set` is optional too.\n\n"
         f"Supported reply variables: {supported_template_variables}."
     )
     # The command table alone is well past Slack's per-message limit, and Slack
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 2e044c8..9716438 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -609,3 +609,88 @@ async def test_clear_pattern_does_not_shadow_setting_one():
 
     assert config["pattern"] == ".*alarm.*"
     assert config["pattern_case_sensitive"] is True
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command,field,value", [
+    ('trigger cron "0 9 * * 1-5"', "cron", "0 9 * * 1-5"),
+    ("condition outlook", "condition", "outlook_calendar"),
+    ('pattern ".*alarm.*"', "pattern", ".*alarm.*"),
+    ("opsgenie-schedule SRE", "opsgenie_schedule_name", "SRE"),
+    ("opsgenie-priority P2", "opsgenie_priority", "P2"),
+    ("opsgenie-message Alert!", "opsgenie_message", "Alert!"),
+    ("outlook-subject .*urlaub.*", "outlook_subject_pattern", ".*urlaub.*"),
+    ("outlook-body .*ooo.*", "outlook_body_pattern", ".*ooo.*"),
+    ("button-timeout 5", "button_timeout", 300),
+    ("button-timeout-target alarm", "button_timeout_target", "alarm"),
+    ('default-button "Yes"', "default_button", "Yes"),
+])
+async def test_every_setting_command_works_without_the_word_set(command, field, value):
+    app = AsyncMock()
+    user = User("U1", "dave", "Dave", "T")
+
+    for text in (command, f"set {command}"):
+        config = DEFAULT_CONFIG.copy()
+        channel = Channel(id="C1", name="davetest", configs={"default": config})
+        with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+             patch('hutbot.messaging.send_message'):
+            await process_command(app, text, channel, user)
+        assert config[field] == value, text
+
+
+@pytest.mark.asyncio
+async def test_an_existing_config_wins_an_ambiguous_first_word():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy(), "trigger": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        # Both readings fit: the `trigger` config's message, or the default config's
+        # trigger. The named config wins.
+        await process_command(app, "trigger message hello", channel, user)
+        assert configs["trigger"]["reply_message"] == "hello"
+        assert configs["default"]["reply_message"] == DEFAULT_CONFIG["reply_message"]
+
+        # `cron "…"` is not a command on its own, so this can only be the command.
+        await process_command(app, 'trigger cron "0 9 * * 1-5"', channel, user)
+
+    assert configs["default"]["trigger"] == TRIGGER_CRON
+    assert configs["trigger"]["trigger"] == "message"
+    assert "in configuration `default`" in mock_send_message.call_args.args[3]
+
+
+@pytest.mark.asyncio
+async def test_a_command_word_is_not_taken_as_a_config_name():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set enable", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "`set` cannot be a configuration name; it starts a command. Check the syntax with `/hutbot help`."
+    )
+    assert sorted(configs) == ["default"]
+
+
+@pytest.mark.asyncio
+async def test_a_typo_does_not_create_a_config():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "wiat-time 5", channel, user)
+        assert "Huh?" in mock_send_message.call_args.args[3]
+        # A real command behind a new name still creates it.
+        await process_command(app, "alarms wait-time 5", channel, user)
+
+    assert configs["alarms"]["wait_time"] == 300
+    assert sorted(configs) == ["alarms", "default"]

From 92aa49f21532dd9419fd4592d212481d204179ac Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 13 Aug 2026 12:51:18 +0200
Subject: [PATCH 35/42] refactor(buttons): unify button timeout and default
 into escalation setting

Replace the separate `button-timeout`, `button-timeout-target`, and
`default-button` commands with a single `set escalation <minutes> <kind>
<target>` command. This ensures a timer always has a defined action to
fire, preventing silent no-ops.

Key changes:
- Merge timeout duration and target into one atomic setting stored as
`escalation_timeout`, `escalation_kind`, and `escalation_target`.
- Button `message` and `ack` actions now support template rendering
(variables and @mentions) against the original message context.
- Update Web UI to reflect the new escalation structure.
- Remove deprecated commands and update tests accordingly.
---
 README.md                      |  21 +++--
 hutbot/actions.py              |   5 +
 hutbot/buttons.py              |  29 +++---
 hutbot/commands/dispatch.py    |  10 +-
 hutbot/commands/info.py        |  21 ++---
 hutbot/commands/patterns.py    |   7 +-
 hutbot/commands/setters.py     |  93 ++++++++++++-------
 hutbot/constants.py            |   8 +-
 hutbot/messaging.py            |  11 +--
 hutbot/webui_backend.py        |  44 +++++++--
 tests/_common.py               |   1 +
 tests/test_buttons.py          | 165 +++++++++++++++++++++++++++------
 tests/test_commands_info.py    |   9 +-
 tests/test_commands_setters.py |   4 +-
 tests/test_webui_backend.py    |  39 +++++++-
 webui_static/app.js            |  19 +++-
 16 files changed, 348 insertions(+), 138 deletions(-)

diff --git a/README.md b/README.md
index 3173ebc..2d42aaa 100644
--- a/README.md
+++ b/README.md
@@ -86,12 +86,17 @@ existing configs keep working unchanged.
   - `/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>" message <text>` — post `<text>` in the thread of the
+    buttoned message. Like a reply message, it may use `{{variables}}` and `@mentions` (both are
+    resolved against the *original* message when pressed). The same applies to an `ack` text.
   - `/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.
+  - `/hutbot [config] set escalation <minutes> button "<label>"` — if nobody presses within
+    `<minutes>`, auto-press that button (exactly as a human click would).
+  - `/hutbot [config] set escalation <minutes> config <config>` — …or run that config instead.
+  - `/hutbot [config] set escalation none` — never escalate; the buttons stay open until pressed.
+    The timeout and its target are one setting, so a timer can never exist with nothing to fire.
+    Pending escalations survive restarts.
   - A button/timeout that runs a config passes the **original message context** to it, so the target's
     templates and any OpsGenie alert reference the original message.
 
@@ -100,8 +105,7 @@ existing configs keep working unchanged.
   /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"
+  /hutbot helpcheck set escalation 5 button "Yes"
   ```
   Pressing *Yes* posts the help message; *No* dismisses it; if nobody clicks within 5 minutes, Hutbot
   auto-presses *Yes* and posts the help message.
@@ -109,14 +113,13 @@ existing configs keep working unchanged.
 - **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
+  from a button or the escalation — don't put OpsGenie on the question config itself (or it would
   alert as soon as the question is posted). Example:
   ```bash
   # question — no OpsGenie
   /hutbot incident set message Incident — on it?
   /hutbot incident add button "I've got it" ack
-  /hutbot incident set button-timeout 5
-  /hutbot incident set button-timeout-target page-oncall   # escalate if ignored
+  /hutbot incident set escalation 5 config page-oncall   # page if nobody acknowledges
   # alert config — OpsGenie on, runs only when escalated (or via a Yes-style button)
   /hutbot page-oncall set trigger manual
   /hutbot page-oncall enable opsgenie
diff --git a/hutbot/actions.py b/hutbot/actions.py
index acf0ab2..c1b7bc0 100644
--- a/hutbot/actions.py
+++ b/hutbot/actions.py
@@ -52,6 +52,11 @@ async def _render_template(app: AsyncApp, opsgenie_token: str, channel: Channel,
     return templating.render_reply_message_template(template, variables, config)
 
 
+async def render_template_text(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None, template: str) -> str:
+    """Render any template with a config's variables — a button's message, say."""
+    return await _render_template(app, opsgenie_token, channel, config, config_name, context, template)
+
+
 async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None) -> str:
     return await _render_template(app, opsgenie_token, channel, config, config_name, context, config.get('reply_message') or '')
 
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index 4ebad8d..95642e6 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -72,13 +72,15 @@ def build_button_blocks(config: dict, def_channel_id: str, config_name: str, tex
 
 
 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
+    """What a buttoned message escalates to if no button is pressed in time.
+
+    Stored as set: `set escalation` writes the kind and target together and
+    rejects a target it cannot resolve, so there is nothing to decide here.
+    """
+    kind = config.get('escalation_kind') or ESCALATION_NONE
+    target = config.get('escalation_target') or ''
+    if kind in (ESCALATION_BUTTON, ESCALATION_CONFIG) and target:
+        return kind, target
     return ESCALATION_NONE, ''
 
 
@@ -93,7 +95,7 @@ async def register_escalation(app: AsyncApp, opsgenie_token: str, posted_channel
         return
     context = context or {}
     user = context.get('user')
-    timeout = config.get('button_timeout') or 0
+    timeout = config.get('escalation_timeout') or 0
     kind, target = _escalation_kind(config)
     key = (posted_channel_id, message_ts)
     has_timer = timeout > 0 and kind != ESCALATION_NONE
@@ -145,7 +147,7 @@ async def _escalation_context(app: AsyncApp, entry: dict | None, posted_channel_
     }
 
 
-async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel, posted_channel_id: str, message_ts: str, button: dict, run_context: dict) -> None:
+async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel, posted_channel_id: str, message_ts: str, button: dict, run_context: dict, src_config: dict | None = None, src_config_name: str = '') -> None:
     """Run a button's action. Shared by a real press and an auto-press on timeout.
 
     `delay` is handled by the caller (it is only meaningful for a live press).
@@ -159,8 +161,11 @@ async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel, po
         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).
+        # The text is a template like a config's reply message, rendered against the
+        # original message with the defining config's date/time settings.
         if value:
-            await messaging._post_message(app, posted_channel_id, value, None, message_ts)
+            text = await actions.render_template_text(app, opsgenie_token, channel, src_config or {}, src_config_name, run_context, value)
+            await messaging._post_message(app, posted_channel_id, text, None, message_ts)
     else:
         log_warning(f"Unsupported button action '{action}' in #{channel.name}.")
 
@@ -182,7 +187,7 @@ async def _run_escalation(app: AsyncApp, opsgenie_token: str, entry: dict) -> No
             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 dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[idx], run_context, src_config, entry.get('config_name', ''))
         await _strip_buttons(app, posted_channel_id, message_ts, entry)
     elif kind == ESCALATION_CONFIG:
         target = entry.get('escalation_target', '')
@@ -376,5 +381,5 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
     # run is attributed to the *original* author (presser=None ⇒ orig.user_id), matching
     # the timeout-escalation path; the presser is only used for the log line above.
     run_context = await _escalation_context(app, entry, posted_channel_id, message_ts)
-    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[index], run_context)
+    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[index], run_context, src_config, src_config_name)
     await _strip_buttons(app, posted_channel_id, message_ts, entry)
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index cb9b268..b43e937 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -103,14 +103,8 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         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 (match := patterns.SET_ESCALATION_PATTERN.match(command_text)):
+        await setters.set_escalation(app, channel, config_name, match.group("minutes"), match.group("kind"), match.group("target"), user, thread_ts)
     elif patterns.RUN_PATTERN.match(command_text):
         await setters.run_config_now(app, opsgenie_token, channel, config_name, user, thread_ts)
     elif patterns.ENABLE_REPLIES_PATTERN.match(command_text):
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 6e700f8..568a504 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -24,7 +24,7 @@
     DEFAULT_TIME_FORMAT,
     DISABLED_REASON_REMOVED,
     ESCALATION_BUTTON,
-    ESCALATION_CONFIG,
+    ESCALATION_NONE,
     ID_PATTERN,
     TRIGGER_MESSAGE,
     TRIGGER_CRON,
@@ -209,18 +209,13 @@ def _button_label(b):
                 button_action, value = normalize_button(b)
                 return f"{b.get('label')} → {button_action}" + (f":{value}" if value else "")
             button_rows = [("Buttons", [_button_label(b) for b in config_buttons])]
-            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"
-                button_rows.append(("Button timeout", f"{button_timeout_minutes} minutes → {escalates_to}"))
-            if config.get('default_button'):
-                button_rows.append(("Default button", config.get('default_button')))
+            escalation_minutes = (config.get('escalation_timeout') or 0) // 60
+            kind, target = buttons._escalation_kind(config)
+            if escalation_minutes and kind != ESCALATION_NONE:
+                escalates_to = f"auto-press `{target}`" if kind == ESCALATION_BUTTON else f"run `{target}`"
+                button_rows.append(("Escalation", f"after {escalation_minutes} minutes, {escalates_to}"))
+            else:
+                button_rows.append(("Escalation", "none, buttons stay open until pressed"))
             groups.append(button_rows)
 
         groups.append([
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index baf5473..95cdb2f 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -58,8 +58,7 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 SET_ACTION_PATTERN = create_command_pattern(r'(set\s+)?action\s+(?P<action>\S+)(?:\s+(?P<target>.+))?$')
 ADD_BUTTON_PATTERN = create_command_pattern(r'add\s+button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
 CLEAR_BUTTONS_PATTERN = create_command_pattern(r'clear\s+buttons?')
-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>.+)')
+# `<minutes> <kind> <target>`: the timeout and what it escalates to are one setting.
+# A bare `none`/`off`/`0` clears all three.
+SET_ESCALATION_PATTERN = create_command_pattern(r'(set\s+)?escalation\s+(?P<minutes>\S+)(?:\s+(?P<kind>\S+)(?:\s+(?P<target>.+))?)?$')
 RUN_PATTERN = re.compile(r'^(run|fire)$', re.IGNORECASE)
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index 7e8b1c7..f5a165e 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -17,6 +17,10 @@
 from ..buttonutil import _find_button_index
 from ..constants import (
     ACTION_POST_CHANNEL,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ESCALATION_NONE,
+    BUTTON_ACTION_ACK,
     ACTION_REPLY,
     ACTION_TARGET_HINTS,
     ACTIONS,
@@ -455,6 +459,17 @@ async def add_button(app: AsyncApp, channel, config_name: str, label: str, spec:
         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 in (BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ACK) and value:
+        # A button's text is a template too, so it gets the same treatment as
+        # `set message`: @mentions resolved to ids, variables checked.
+        ok, mention_error, value = await messaging.process_mentions(app, value)
+        if not ok:
+            await messaging.send_message(app, channel, user, f"Invalid *button* message: {mention_error}.", thread_ts)
+            return
+        template_error = templating.validate_template_expressions(value)
+        if template_error:
+            await messaging.send_message(app, channel, user, f"Invalid *button* message: {template_error}", thread_ts)
+            return
     if action == BUTTON_ACTION_DELAY:
         try:
             minutes = int(value)
@@ -484,48 +499,64 @@ async def clear_buttons(app: AsyncApp, channel, config_name: str, user, thread_t
     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 set_escalation(app: AsyncApp, channel, config_name: str, minutes_str: str, kind: str | None, target: str | None, user, thread_ts: str = "") -> None:
+    """`set escalation <minutes> <button|config> <target>` — one setting, not three.
 
-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)
+    A timeout with nothing to escalate to silently does nothing, and a target with
+    no timeout never fires, so both halves are set together or not at all.
+    """
+    minutes_str = strip_quotes(minutes_str or "").strip().lower()
+    kind = strip_quotes(kind or "").strip().lower()
+    target = strip_quotes(target or "").strip()
+    usage = f'`{state.slash_command} {config_name} set escalation <minutes> <button "<label>"|config <name>>`, or `set escalation none`'
 
+    if minutes_str in ("none", "off", "no", "0"):
+        if kind or target:
+            await messaging.send_message(app, channel, user, f"`set escalation {minutes_str}` takes nothing else.", thread_ts)
+            return
+        config = _ensure_config(channel, config_name)
+        config['escalation_timeout'] = 0
+        config['escalation_kind'] = ESCALATION_NONE
+        config['escalation_target'] = ''
+        await persistence.save_configuration()
+        await messaging.send_message(app, channel, user, f"*Escalation* disabled in configuration `{config_name}`; buttons stay open until pressed.", thread_ts)
+        return
 
-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())
+        minutes = int(minutes_str)
     except ValueError:
-        await messaging.send_message(app, channel, user, "Invalid *button timeout*. Must be a number of minutes between 0 and 1440.", thread_ts)
+        await messaging.send_message(app, channel, user, f"Invalid *escalation*. Use {usage}.", 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)
+    if minutes < 1 or minutes > 1440:
+        await messaging.send_message(app, channel, user, "Invalid *escalation*. Minutes must be between 1 and 1440, or `none`.", thread_ts)
         return
-    _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 kind not in (ESCALATION_BUTTON, ESCALATION_CONFIG):
+        await messaging.send_message(app, channel, user, f"*Escalation* needs what to escalate to: {usage}.", thread_ts)
+        return
     if not target:
-        await messaging.send_message(app, channel, user, "Invalid *button timeout target*. Must reference a configuration name.", thread_ts)
+        what = "a button label" if kind == ESCALATION_BUTTON else "a configuration name"
+        await messaging.send_message(app, channel, user, f"*Escalation* `{kind}` needs {what}: {usage}.", thread_ts)
         return
-    _ensure_config(channel, config_name)['button_timeout_target'] = target
+
+    config = _ensure_config(channel, config_name)
+    warning = ""
+    if kind == ESCALATION_BUTTON:
+        # An unknown label would otherwise only surface as a warning at escalation time.
+        if _find_button_index(config, target) is None:
+            labels = ", ".join(f"`{b.get('label')}`" for b in (config.get('buttons') or [])) or "none yet"
+            await messaging.send_message(app, channel, user, f"No button labelled `{target}` in configuration `{config_name}` (buttons: {labels}).", thread_ts)
+            return
+    elif target not in channel.configs:
+        # A target config is often created afterwards, so this is only a warning.
+        warning = f" :warning: (configuration `{target}` does not exist yet)"
+
+    config['escalation_timeout'] = minutes * 60
+    config['escalation_kind'] = kind
+    config['escalation_target'] = target
     await persistence.save_configuration()
-    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)
+    does = f"auto-press `{target}`" if kind == ESCALATION_BUTTON else f"run `{target}`"
+    await messaging.send_message(app, channel, user, f"*Escalation* set: after `{minutes}` minutes without a press, {does} in configuration `{config_name}`{warning}.", thread_ts)
 
 
 async def run_config_now(app: AsyncApp, opsgenie_token: str, channel, config_name: str, user, thread_ts: str = "") -> None:
diff --git a/hutbot/constants.py b/hutbot/constants.py
index b144f0a..69f7e98 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -102,9 +102,11 @@
     "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
+    # Escalation: what happens when nobody presses a button in time. The timeout and
+    # its target are one setting, so a timer can never exist with nothing to fire.
+    "escalation_timeout": 0,           # seconds; 0 = never escalate
+    "escalation_kind": ESCALATION_NONE,  # "none" | "button" | "config"
+    "escalation_target": "",           # a button label, or a config name
 }
 
 CONFIG_FILE_NAME = os.environ.get('HUTBOT_CONFIG_FILE', 'bot.json')
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 24bbcd5..ba1d041 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -254,14 +254,13 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ]),
         ("Buttons", [
             (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
-            (f"{command} [config] add button \"<label>\" ack [text]", "Button acknowledges/dismisses (stops escalation)."),
-            (f"{command} [config] add button \"<label>\" message <text>", "Button posts a fixed message."),
+            (f"{command} [config] add button \"<label>\" ack [text]", "Button dismisses; [text] may use {{variables}}."),
+            (f"{command} [config] add button \"<label>\" message <text>", "Button posts <text>; may use {{variables}}."),
             (f"{command} [config] add button \"<label>\" delay <minutes>", "Button delays the escalation."),
             (f"{command} [config] clear buttons", "Remove all buttons."),
-            (f"{command} [config] set button-timeout <minutes>", "Escalate if no button is pressed in time."),
-            (f"{command} [config] set button-timeout-target <config>", "Config to run on button timeout."),
-            (f"{command} [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
-            (f"{command} [config] clear default-button", "Stop auto-pressing on timeout."),
+            (f"{command} [config] set escalation <minutes> button \"<label>\"", "Auto-press that button if nobody does in time."),
+            (f"{command} [config] set escalation <minutes> config <config>", "Run that config if nobody presses in time."),
+            (f"{command} [config] set escalation none", "Never escalate; buttons stay open."),
         ]),
         ("OpsGenie", [
             (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 04fc829..80931db 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -26,6 +26,10 @@
     ACTION_REPLY,
     ACTIONS,
     BUTTON_ACTION_CONFIG,
+    BUTTON_ACTION_ACK,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ESCALATION_NONE,
     BUTTON_ACTION_DELAY,
     BUTTON_ACTION_MESSAGE,
     BUTTON_ACTIONS,
@@ -87,7 +91,7 @@ async def validate_config_payload(payload: dict, app: AsyncApp, channel_id: str
     """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.
+    Values use the persisted shape: ``wait_time`` and ``escalation_timeout`` are in seconds.
     """
     if not isinstance(payload, dict):
         return None, {'_': "Expected a configuration object."}
@@ -113,16 +117,30 @@ def get(key):
         else:
             cfg['wait_time'] = wait_time
 
-    # button_timeout (stored as seconds; 0..1440 minutes, 0 = disabled)
+    # escalation_timeout (stored as seconds; 1..1440 minutes, 0 = never escalate) and
+    # what it escalates to. Both halves are validated together.
     try:
-        button_timeout = int(get('button_timeout'))
+        escalation_timeout = int(get('escalation_timeout'))
     except (TypeError, ValueError):
-        errors['button_timeout'] = "Button timeout must be a number."
+        errors['escalation_timeout'] = "Escalation 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."
+        escalation_kind = str(get('escalation_kind') or ESCALATION_NONE).strip().lower() or ESCALATION_NONE
+        escalation_target = str(get('escalation_target') or "").strip()
+        if escalation_timeout < 0 or escalation_timeout > 86400:
+            errors['escalation_timeout'] = "Escalation timeout must be between 0 and 1440 minutes."
+        elif escalation_kind not in (ESCALATION_NONE, ESCALATION_BUTTON, ESCALATION_CONFIG):
+            errors['escalation_kind'] = "Escalation must be none, button or config."
+        elif escalation_kind == ESCALATION_NONE or not escalation_timeout:
+            # Half a setting escalates nothing, so store it as switched off.
+            cfg['escalation_timeout'] = 0
+            cfg['escalation_kind'] = ESCALATION_NONE
+            cfg['escalation_target'] = ""
+        elif not escalation_target:
+            errors['escalation_target'] = "Pick a button label or a rule to escalate to."
         else:
-            cfg['button_timeout'] = button_timeout
+            cfg['escalation_timeout'] = escalation_timeout
+            cfg['escalation_kind'] = escalation_kind
+            cfg['escalation_target'] = escalation_target
 
     # reply_message — resolve @mentions and validate template variables
     reply_message = get('reply_message')
@@ -292,6 +310,16 @@ def get(key):
                 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 in (BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ACK) and value:
+                # Same treatment as reply_message: mentions resolved, variables checked.
+                ok, mention_error, value = await messaging.process_mentions(app, value)
+                if not ok:
+                    errors[f'buttons.{i}'] = f"Unknown user mention: {mention_error}."
+                    continue
+                template_error = templating.validate_template_expressions(value)
+                if template_error:
+                    errors[f'buttons.{i}'] = template_error
+                    continue
             if button_action == BUTTON_ACTION_DELAY:
                 try:
                     minutes = int(value)
@@ -306,8 +334,6 @@ def get(key):
     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
diff --git a/tests/_common.py b/tests/_common.py
index c24628d..1905e2b 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -25,6 +25,7 @@
     ACTION_REPLY,
     DEFAULT_CONFIG,
     DISABLED_REASON_REMOVED,
+    ESCALATION_NONE,
     TRIGGER_CRON,
     bot_slug,
     normalize_slash_command,
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 5278c8c..023785a 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -72,15 +72,46 @@ async def test_add_button_requires_an_action_keyword():
 
 
 @pytest.mark.asyncio
-async def test_set_button_timeout_minutes_to_seconds():
+async def test_set_escalation_stores_minutes_kind_and_target():
     app = AsyncMock()
     channel = _mk_channel()
     user = User("U1", "test", "Test User", "Testers")
-    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
-        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"
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set escalation 15 config escalate", channel, user)
+        cfg = channel.configs["default"]
+        assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (900, "config", "escalate")
+        assert "after `15` minutes without a press, run `escalate`" in send.call_args.args[3]
+
+        await process_command(app, 'add button "Yes" ack', channel, user)
+        await process_command(app, 'escalation 5 button "Yes"', channel, user)
+        assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (300, "button", "Yes")
+
+        await process_command(app, "set escalation none", channel, user)
+        assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+        assert "buttons stay open until pressed" in send.call_args.args[3]
+
+
+@pytest.mark.asyncio
+async def test_set_escalation_refuses_half_a_setting():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    cfg = channel.configs["default"]
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        # A timeout with nothing to escalate to used to be accepted and do nothing.
+        await process_command(app, "set escalation 5", channel, user)
+        assert "needs what to escalate to" in send.call_args.args[3]
+        # A button that does not exist would only fail at escalation time.
+        await process_command(app, 'set escalation 5 button "Nope"', channel, user)
+        assert "No button labelled `Nope`" in send.call_args.args[3]
+        await process_command(app, "set escalation 5 button", channel, user)
+        assert "needs a button label" in send.call_args.args[3]
+        await process_command(app, "set escalation 0 config escalate", channel, user)
+        assert "takes nothing else" in send.call_args.args[3]
+        await process_command(app, "set escalation 5000 config escalate", channel, user)
+        assert "between 1 and 1440" in send.call_args.args[3]
+
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
 
 
 
@@ -128,7 +159,7 @@ async def test_run_action_reply_posts_with_buttons():
     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
+    config["escalation_timeout"] = 0  # no timeout watch
     channel = _mk_channel({"src": config})
     with patch('hutbot.buttons.register_escalation', new=AsyncMock()) as reg:
         posted = await hutbot.actions.run_action(app, "token", channel, config, "src", context=None)
@@ -246,8 +277,9 @@ 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"
+    config["escalation_timeout"] = 3600
+    config["escalation_kind"] = "config"
+    config["escalation_target"] = "escalate"
     hutbot.state.pending_buttons.clear()
     with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
         await hutbot.buttons.register_escalation(app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
@@ -264,8 +296,9 @@ async def test_cancelled_timer_keeps_persisted_record_for_restart():
     app = AsyncMock()
     config = DEFAULT_CONFIG.copy()
     config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
-    config["button_timeout"] = 3600
-    config["button_timeout_target"] = "escalate"
+    config["escalation_timeout"] = 3600
+    config["escalation_kind"] = "config"
+    config["escalation_target"] = "escalate"
     key = ("C12345", "10.1")
 
     with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()) as flush:
@@ -370,7 +403,7 @@ async def test_register_escalation_keeps_record_with_orig():
     # record is still kept so button presses get the original message context.
     app = AsyncMock()
     cfg = DEFAULT_CONFIG.copy()
-    cfg["button_timeout"] = 0
+    cfg["escalation_timeout"] = 0
     cfg["buttons"] = [{"label": "Yes", "action": "config", "value": "flow"}]
     hutbot.state.pending_buttons.clear()
     with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
@@ -386,27 +419,34 @@ async def test_register_escalation_keeps_record_with_orig():
 # ----- Default button: auto-press on timeout -----
 
 @pytest.mark.asyncio
-async def test_set_default_button_command():
+async def test_the_old_three_commands_are_gone():
     app = AsyncMock()
     channel = _mk_channel()
     user = User("U1", "test", "Test User", "Testers")
-    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
-        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"] == ""
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        for gone in ('set default-button "Yes"', "clear default-button", "set button-timeout 5",
+                     "set button-timeout-target alarm"):
+            await process_command(app, gone, channel, user)
+            assert "Huh?" in send.call_args.args[3], gone
+    cfg = channel.configs["default"]
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
 
 
 
-def test_escalation_kind_prefers_default_button():
+def test_escalation_kind_reads_what_was_stored():
+    import hutbot
     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")
+    assert hutbot.buttons._escalation_kind(cfg) == (ESCALATION_NONE, "")
+
+    cfg["escalation_kind"], cfg["escalation_target"] = "button", "Yes"
+    assert hutbot.buttons._escalation_kind(cfg) == ("button", "Yes")
+
+    cfg["escalation_kind"], cfg["escalation_target"] = "config", "some-config"
+    assert hutbot.buttons._escalation_kind(cfg) == ("config", "some-config")
+
+    # Half a setting escalates nothing.
+    cfg["escalation_target"] = ""
+    assert hutbot.buttons._escalation_kind(cfg) == (ESCALATION_NONE, "")
 
 
 
@@ -442,8 +482,9 @@ async def test_delay_press_does_not_clobber_rescheduled_escalation():
     app = AsyncMock()
     config = DEFAULT_CONFIG.copy()
     config["buttons"] = [{"label": "Wait", "action": "delay", "value": "3"}]
-    config["button_timeout"] = 3600
-    config["button_timeout_target"] = "escalate"
+    config["escalation_timeout"] = 3600
+    config["escalation_kind"] = "config"
+    config["escalation_target"] = "escalate"
     key = ("C12345", "10.1")
     with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
         await hutbot.buttons.register_escalation(
@@ -557,3 +598,71 @@ async def test_cancel_channel_pending_buttons_without_matches_does_not_flush():
         assert await hutbot.buttons.cancel_channel_pending_buttons("C12345") == 0
         assert await hutbot.buttons.cancel_channel_pending_buttons("") == 0
     mock_flush.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_button_message_is_a_template_rendered_against_the_original_message():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "date_format": "%d.%m.%Y", "datetime_timezone": "Europe/Berlin"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    author = User("UAUTH", "author", "Ada Author", "Platform")
+    entry = {
+        'posted_channel_id': "C1", 'message_ts': "R1", 'def_channel_id': "C1", 'config_name': "default",
+        'orig': {'user_id': author.id, 'text': "the server is down", 'ts': "1786453297.645799", 'permalink': "https://slack.test/p1"},
+    }
+    button = {'label': "help", 'action': "message",
+              'value': "Help <@UAUTH> with {{message}} from {{date}} ({{user_name}}) — {{message_link}}"}
+
+    with patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=author)), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C1", "ts": "R2"})) as post:
+        run_context = await hutbot.buttons._escalation_context(app, entry, "C1", "R1")
+        await hutbot.buttons.dispatch_button_action(app, "tok", channel, "C1", "R1", button, run_context, config, "default")
+
+    assert post.await_args.args[2] == (
+        "Help <@UAUTH> with the server is down from 11.08.2026 (Ada Author) — https://slack.test/p1"
+    )
+    # Posted in the thread of the buttoned message.
+    assert post.await_args.args[4] == "R1"
+
+
+@pytest.mark.asyncio
+async def test_add_button_resolves_mentions_and_rejects_unknown_variables():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+    author = User("UAUTH", "author", "Ada Author", "Platform")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_user_by_name', new=AsyncMock(return_value=author)), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "help" message "Help @author with {{message}}"', channel, user)
+        assert config["buttons"] == [
+            {"label": "help", "action": "message", "value": "Help <@UAUTH> with {{message}}"}
+        ]
+
+        await process_command(app, 'add button "bad" message "{{nope}}"', channel, user)
+        assert "unsupported template variable(s) `{{nope}}`" in send.call_args.args[3]
+        # Nothing added for the rejected button.
+        assert len(config["buttons"]) == 1
+
+        # `ack` text gets the same treatment.
+        await process_command(app, 'add button "ok" ack "Thanks @author"', channel, user)
+        assert config["buttons"][1]["value"] == "Thanks <@UAUTH>"
+
+
+@pytest.mark.asyncio
+async def test_add_button_reports_an_unknown_mention():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_user_by_name', new=AsyncMock(return_value=User(None, "ghost", "", "T"))), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "help" message "Help @ghost"', channel, user)
+
+    assert send.call_args.args[3] == "Invalid *button* message: ghost not found."
+    assert config["buttons"] == []
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 9406fbb..c01bd82 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -146,11 +146,13 @@ async def test_process_command_help_uses_compact_command_reference():
     assert "/hutbot [config] set work-hours all day" in sent_message
     assert "/hutbot [config] set trigger cron \"<expr>\"" in sent_message
     # Removed commands are gone from the reference.
-    for stale in ("set target", "set cron <", "set schedule-timezone", "forward-channel"):
+    for stale in ("set target", "set cron <", "set schedule-timezone", "forward-channel",
+                  "button-timeout", "default-button"):
         assert stale not in sent_message, stale
     # Every dispatched command is documented.
     assert "/hutbot [config] clear opsgenie-message" in sent_message
-    assert "/hutbot [config] clear default-button" in sent_message
+    assert '/hutbot [config] set escalation <minutes> button "<label>"' in sent_message
+    assert "/hutbot [config] set escalation none" in sent_message
     assert "/hutbot [config] clear pattern" in sent_message
     assert "@Hutbot [config] test <message>" in sent_message
     assert "Preview reply with <message> as {{message}}." in sent_message
@@ -265,8 +267,7 @@ async def test_need_help_yes_no_workflow_end_to_end():
         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)
+        await process_command(app, 'set escalation 5 button "Yes"', ch, u)
         cfg = ch.configs["default"]
 
         # Fire the reply; an auto-press-Yes escalation is registered (no inline message yet).
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 9716438..4c94786 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -621,9 +621,7 @@ async def test_clear_pattern_does_not_shadow_setting_one():
     ("opsgenie-message Alert!", "opsgenie_message", "Alert!"),
     ("outlook-subject .*urlaub.*", "outlook_subject_pattern", ".*urlaub.*"),
     ("outlook-body .*ooo.*", "outlook_body_pattern", ".*ooo.*"),
-    ("button-timeout 5", "button_timeout", 300),
-    ("button-timeout-target alarm", "button_timeout_target", "alarm"),
-    ('default-button "Yes"', "default_button", "Yes"),
+    ("escalation 5 config alarm", "escalation_timeout", 300),
 ])
 async def test_every_setting_command_works_without_the_word_set(command, field, value):
     app = AsyncMock()
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
index ab907b9..e349751 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -17,7 +17,9 @@ async def test_validate_config_payload_accepts_good_config():
         "hours": ["09:00", "17:00"],
         "opsgenie_priority": "p2",
         "wait_time": 600,
-        "button_timeout": 300,
+        "escalation_timeout": 300,
+        "escalation_kind": "config",
+        "escalation_target": "alarm",
         "buttons": [
             {"label": "Snooze", "action": "delay", "value": "10"},
             {"label": "Note", "action": "message", "value": "Some message"},
@@ -40,9 +42,11 @@ async def test_validate_config_payload_accepts_good_config():
     assert cfg["hours"] == ["09:00", "17:00"]
     # priority lowercased input is uppercased.
     assert cfg["opsgenie_priority"] == "P2"
-    # wait_time/button_timeout stay in seconds.
+    # wait_time/escalation_timeout stay in seconds.
     assert cfg["wait_time"] == 600
-    assert cfg["button_timeout"] == 300
+    assert cfg["escalation_timeout"] == 300
+    assert cfg["escalation_kind"] == "config"
+    assert cfg["escalation_target"] == "alarm"
     assert cfg["buttons"] == [
         {"label": "Snooze", "action": "delay", "value": "10"},
         {"label": "Note", "action": "message", "value": "Some message"},
@@ -259,3 +263,32 @@ async def test_ui_apply_config_stale_save_cannot_undo_removal_disable(monkeypatc
     assert config["reply_message"] == "Updated in stale editor"
     assert config["enabled"] is False
     assert config["disabled_reason"] == DISABLED_REASON_REMOVED
+
+
+@pytest.mark.asyncio
+async def test_validate_config_payload_stores_escalation_as_one_setting():
+    _seed_user_caches()
+    app = _ui_app()
+    base = {
+        "reply_message": "Hi", "wait_time": 600, "trigger": "message", "action": "reply",
+        "buttons": [{"label": "Yes", "action": "ack", "value": ""}],
+    }
+
+    # Half a setting is stored as switched off, not as a timer with nothing to fire.
+    cfg, errors = await validate_config_payload({**base, "escalation_timeout": 300}, app)
+    assert errors == {}
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+
+    cfg, errors = await validate_config_payload(
+        {**base, "escalation_timeout": 0, "escalation_kind": "button", "escalation_target": "Yes"}, app)
+    assert errors == {}
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+
+    # A kind with a timeout but no target is an error, not a silent no-op.
+    cfg, errors = await validate_config_payload(
+        {**base, "escalation_timeout": 300, "escalation_kind": "config", "escalation_target": ""}, app)
+    assert errors == {"escalation_target": "Pick a button label or a rule to escalate to."}
+
+    cfg, errors = await validate_config_payload(
+        {**base, "escalation_timeout": 300, "escalation_kind": "nonsense", "escalation_target": "x"}, app)
+    assert errors == {"escalation_kind": "Escalation must be none, button or config."}
diff --git a/webui_static/app.js b/webui_static/app.js
index 588c9f2..9473856 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -55,6 +55,7 @@ const ACTION_LABEL = { reply: "Reply in thread", dm_user: "Direct message", grou
 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 ESCALATION_LABEL = { none: "Never escalate; buttons stay open", button: "Auto-press a button", config: "Run another rule" };
 const TARGET_HINT = { dm_user: "A @user (id, name, or email)", group_dm: "A @usergroup handle", post_channel: "A channel ID like C0123ABCD" };
 // Set by the bot itself when it is removed from a channel (see DISABLED_REASON_REMOVED).
 const DISABLED_REASON_LABEL = { removed_from_channel: "Disabled — the bot was removed from this channel" };
@@ -222,10 +223,10 @@ function renderCard(name) {
 function lampFor(cfg) {
   let cls = "lamp";
   if (!cfg.enabled) cls += " off";
-  else if (cfg.opsgenie || cfg.button_timeout > 0) cls += " escalating";
+  else if (cfg.opsgenie || cfg.escalation_timeout > 0) cls += " escalating";
   const title = !cfg.enabled
     ? (DISABLED_REASON_LABEL[cfg.disabled_reason] || "Disabled")
-    : (cfg.opsgenie || cfg.button_timeout > 0) ? "Active · can escalate" : "Active";
+    : (cfg.opsgenie || cfg.escalation_timeout > 0) ? "Active · can escalate" : "Active";
   return h("span", { class: cls, title, role: "img", "aria-label": title });
 }
 
@@ -521,11 +522,19 @@ function buttonsSection() {
 
   const add = h("button", { class: "add-row", type: "button", onclick: () => { cfg.buttons = buttons.concat([{ label: "", action: "message", value: "" }]); structuralRefresh(); } }, "+ Add button");
 
+  // Escalation is one setting: minutes + what to escalate to. Picking "Never" hides
+  // the rest, so the form cannot produce a timer with nothing to fire.
+  const escalationKinds = ["none", "button", "config"];
   const meta = grid(
-    field("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)." }),
+    field("If nobody presses", selectInput("escalation_kind", escalationKinds, ESCALATION_LABEL, structuralRefresh),
+      { hint: ESCALATION_LABEL[cfg.escalation_kind || "none"], error: fieldErr("escalation_kind") }),
   );
-  meta.append(field("…or run this rule on timeout", textInput("button_timeout_target", { mono: true }), { hint: "Another rule's name (optional)." }));
+  if (cfg.escalation_kind === "button" || cfg.escalation_kind === "config") {
+    meta.append(field("After (minutes)", minutesInput("escalation_timeout"), { error: fieldErr("escalation_timeout") }));
+    meta.append(field(cfg.escalation_kind === "button" ? "Button to press" : "Rule to run",
+      textInput("escalation_target", { mono: cfg.escalation_kind === "config" }),
+      { hint: cfg.escalation_kind === "button" ? "A button label above." : "Another rule's name.", error: fieldErr("escalation_target") }));
+  }
 
   return section("Buttons", null, rows, add, meta);
 }

From ead3347a6122a67bafe2e6146d5f0a12accdb432 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 13 Aug 2026 15:00:25 +0200
Subject: [PATCH 36/42] feat(config): replace `set escalation none` with `clear
 escalation`

Refactor the command for disabling escalations to use a dedicated
`clear escalation` command instead of the `set escalation none` syntax.
This improves clarity and consistency with other configuration commands.

- Update command patterns and dispatch logic to handle `clear/unset/remove
escalation`.
- Add `clear_escalation` setter function.
- Modify `set_escalation` to guide users toward the new command when
attempting to disable escalation.
- Update button delay logic to gracefully handle presses on messages
without active escalations, keeping buttons functional.
- Update documentation, help text, and tests to reflect the change.
---
 README.md                   |  6 +++--
 hutbot/buttons.py           | 10 +++++++-
 hutbot/commands/dispatch.py |  2 ++
 hutbot/commands/patterns.py |  2 +-
 hutbot/commands/setters.py  | 19 +++++++-------
 hutbot/messaging.py         |  2 +-
 tests/test_buttons.py       | 51 ++++++++++++++++++++++++++++++++++++-
 tests/test_commands_info.py |  2 +-
 8 files changed, 78 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index 2d42aaa..87cfceb 100644
--- a/README.md
+++ b/README.md
@@ -89,12 +89,14 @@ existing configs keep working unchanged.
   - `/hutbot [config] add button "<label>" message <text>` — post `<text>` in the thread of the
     buttoned message. Like a reply message, it may use `{{variables}}` and `@mentions` (both are
     resolved against the *original* message when pressed). The same applies to an `ack` text.
-  - `/hutbot [config] add button "<label>" delay <minutes>` — delay the escalation by N minutes.
+  - `/hutbot [config] add button "<label>" delay <minutes>` — push the escalation out by N minutes
+    and leave the buttons in place (the only button that does not consume the message). Pointless
+    without an escalation, and a press then says so.
   - `/hutbot [config] clear buttons`
   - `/hutbot [config] set escalation <minutes> button "<label>"` — if nobody presses within
     `<minutes>`, auto-press that button (exactly as a human click would).
   - `/hutbot [config] set escalation <minutes> config <config>` — …or run that config instead.
-  - `/hutbot [config] set escalation none` — never escalate; the buttons stay open until pressed.
+  - `/hutbot [config] clear escalation` — never escalate; the buttons stay open until pressed.
     The timeout and its target are one setting, so a timer can never exist with nothing to fire.
     Pending escalations survive restarts.
   - A button/timeout that runs a config passes the **original message context** to it, so the target's
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index 95642e6..6626260 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -271,8 +271,16 @@ async def reschedule_escalation(app: AsyncApp, opsgenie_token: str, posted_chann
     if not entry:
         log_warning(f"No pending escalation to delay for message {message_ts}.")
         return False
-    extra = minutes * 60
     record = {k: v for k, v in entry.items() if k != 'task'}
+    if record.get('escalation_kind', ESCALATION_NONE) == ESCALATION_NONE:
+        # Nothing to postpone. Put the record back (unchanged, no timer) so the
+        # other buttons on the message keep working.
+        log_warning(f"Nothing to delay for message {message_ts}: this config has no escalation.")
+        state.pending_buttons[key] = {'task': None, **record}
+        state._button_states_cache[key] = record
+        await persistence.flush_button_cache()
+        return False
+    extra = minutes * 60
     record['timeout'] = extra
     record['run_at'] = (datetime.datetime.now() + datetime.timedelta(seconds=extra)).isoformat()
     task = asyncio.create_task(_escalation_task(app, opsgenie_token, key, extra))
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index b43e937..21eb2a3 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -103,6 +103,8 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         await setters.add_button(app, channel, config_name, match.group("label"), match.group("spec"), user, thread_ts)
     elif patterns.CLEAR_BUTTONS_PATTERN.match(command_text):
         await setters.clear_buttons(app, channel, config_name, user, thread_ts)
+    elif patterns.CLEAR_ESCALATION_PATTERN.match(command_text):
+        await setters.clear_escalation(app, channel, config_name, user, thread_ts)
     elif (match := patterns.SET_ESCALATION_PATTERN.match(command_text)):
         await setters.set_escalation(app, channel, config_name, match.group("minutes"), match.group("kind"), match.group("target"), user, thread_ts)
     elif patterns.RUN_PATTERN.match(command_text):
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index 95cdb2f..55963d9 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -59,6 +59,6 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 ADD_BUTTON_PATTERN = create_command_pattern(r'add\s+button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
 CLEAR_BUTTONS_PATTERN = create_command_pattern(r'clear\s+buttons?')
 # `<minutes> <kind> <target>`: the timeout and what it escalates to are one setting.
-# A bare `none`/`off`/`0` clears all three.
+CLEAR_ESCALATION_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+escalation')
 SET_ESCALATION_PATTERN = create_command_pattern(r'(set\s+)?escalation\s+(?P<minutes>\S+)(?:\s+(?P<kind>\S+)(?:\s+(?P<target>.+))?)?$')
 RUN_PATTERN = re.compile(r'^(run|fire)$', re.IGNORECASE)
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index f5a165e..84a0644 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -499,6 +499,15 @@ async def clear_buttons(app: AsyncApp, channel, config_name: str, user, thread_t
     await messaging.send_message(app, channel, user, f"Cleared *buttons* in configuration `{config_name}`.", thread_ts)
 
 
+async def clear_escalation(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    config = _ensure_config(channel, config_name)
+    config['escalation_timeout'] = 0
+    config['escalation_kind'] = ESCALATION_NONE
+    config['escalation_target'] = ''
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Escalation* cleared in configuration `{config_name}`; buttons stay open until pressed.", thread_ts)
+
+
 async def set_escalation(app: AsyncApp, channel, config_name: str, minutes_str: str, kind: str | None, target: str | None, user, thread_ts: str = "") -> None:
     """`set escalation <minutes> <button|config> <target>` — one setting, not three.
 
@@ -511,15 +520,7 @@ async def set_escalation(app: AsyncApp, channel, config_name: str, minutes_str:
     usage = f'`{state.slash_command} {config_name} set escalation <minutes> <button "<label>"|config <name>>`, or `set escalation none`'
 
     if minutes_str in ("none", "off", "no", "0"):
-        if kind or target:
-            await messaging.send_message(app, channel, user, f"`set escalation {minutes_str}` takes nothing else.", thread_ts)
-            return
-        config = _ensure_config(channel, config_name)
-        config['escalation_timeout'] = 0
-        config['escalation_kind'] = ESCALATION_NONE
-        config['escalation_target'] = ''
-        await persistence.save_configuration()
-        await messaging.send_message(app, channel, user, f"*Escalation* disabled in configuration `{config_name}`; buttons stay open until pressed.", thread_ts)
+        await messaging.send_message(app, channel, user, f"To switch escalation off, use `{state.slash_command} {config_name} clear escalation`.", thread_ts)
         return
 
     try:
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index ba1d041..90daa07 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -260,7 +260,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} [config] clear buttons", "Remove all buttons."),
             (f"{command} [config] set escalation <minutes> button \"<label>\"", "Auto-press that button if nobody does in time."),
             (f"{command} [config] set escalation <minutes> config <config>", "Run that config if nobody presses in time."),
-            (f"{command} [config] set escalation none", "Never escalate; buttons stay open."),
+            (f"{command} [config] clear escalation", "Never escalate; buttons stay open."),
         ]),
         ("OpsGenie", [
             (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 023785a..8ab1391 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -86,7 +86,12 @@ async def test_set_escalation_stores_minutes_kind_and_target():
         await process_command(app, 'escalation 5 button "Yes"', channel, user)
         assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (300, "button", "Yes")
 
+        # `none` points at the clear command instead of doing it silently.
         await process_command(app, "set escalation none", channel, user)
+        assert "use `/hutbot default clear escalation`" in send.call_args.args[3]
+        assert cfg["escalation_timeout"] == 300
+
+        await process_command(app, "clear escalation", channel, user)
         assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
         assert "buttons stay open until pressed" in send.call_args.args[3]
 
@@ -107,7 +112,7 @@ async def test_set_escalation_refuses_half_a_setting():
         await process_command(app, "set escalation 5 button", channel, user)
         assert "needs a button label" in send.call_args.args[3]
         await process_command(app, "set escalation 0 config escalate", channel, user)
-        assert "takes nothing else" in send.call_args.args[3]
+        assert "clear escalation" in send.call_args.args[3]
         await process_command(app, "set escalation 5000 config escalate", channel, user)
         assert "between 1 and 1440" in send.call_args.args[3]
 
@@ -666,3 +671,47 @@ async def test_add_button_reports_an_unknown_mention():
 
     assert send.call_args.args[3] == "Invalid *button* message: ghost not found."
     assert config["buttons"] == []
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["clear escalation", "unset escalation", "remove escalation"])
+async def test_clear_escalation_switches_it_off(command):
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    config.update({"escalation_timeout": 300, "escalation_kind": "config", "escalation_target": "alarm"})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, command, channel, user)
+
+    assert (config["escalation_timeout"], config["escalation_kind"], config["escalation_target"]) == (0, ESCALATION_NONE, "")
+    assert send.call_args.args[3] == (
+        "*Escalation* cleared in configuration `default`; buttons stay open until pressed."
+    )
+
+
+@pytest.mark.asyncio
+async def test_delay_press_without_an_escalation_keeps_the_buttons_and_starts_no_timer():
+    import hutbot
+    app = AsyncMock()
+    channel = _mk_channel()
+    key = ("C12345", "R1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state._button_states_cache.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "posted_channel_id": "C12345", "message_ts": "R1",
+        "def_channel_id": "C12345", "config_name": "default",
+        "escalation_kind": ESCALATION_NONE, "escalation_target": "",
+        "buttons": [{"label": "Later", "action": "delay", "value": "10"}],
+        "orig": {"user_id": "U1", "text": "x", "ts": "9.9", "permalink": "p"},
+    }
+
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
+        delayed = await hutbot.buttons.reschedule_escalation(app, "tok", "C12345", "R1", 10)
+
+    assert delayed is False
+    entry = hutbot.state.pending_buttons[key]
+    # Record kept so the other buttons still resolve, but no timer was created.
+    assert entry["task"] is None
+    assert entry["escalation_kind"] == ESCALATION_NONE
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index c01bd82..1ed982d 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -152,7 +152,7 @@ async def test_process_command_help_uses_compact_command_reference():
     # Every dispatched command is documented.
     assert "/hutbot [config] clear opsgenie-message" in sent_message
     assert '/hutbot [config] set escalation <minutes> button "<label>"' in sent_message
-    assert "/hutbot [config] set escalation none" in sent_message
+    assert "/hutbot [config] clear escalation" in sent_message
     assert "/hutbot [config] clear pattern" in sent_message
     assert "@Hutbot [config] test <message>" in sent_message
     assert "Preview reply with <message> as {{message}}." in sent_message

From d973ede351e089bf6dca5afb9b44c9a7f4a3a168 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Thu, 13 Aug 2026 15:48:45 +0200
Subject: [PATCH 37/42] fix(commands): require escalation for delay buttons

Delay buttons now validate that an active escalation exists before being
added, preventing stranded buttons. Clearing an escalation now warns
users if any delay buttons remain in the configuration.

- Enforce escalation requirement in `add_button` command
- Add warning to `clear_escalation` when delay buttons are present
- Update documentation and help text
- Add tests for validation and warning behavior
---
 README.md                  |  4 ++--
 hutbot/commands/setters.py | 14 +++++++++++--
 hutbot/messaging.py        |  2 +-
 tests/test_buttons.py      | 41 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 56 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 87cfceb..6629071 100644
--- a/README.md
+++ b/README.md
@@ -90,8 +90,8 @@ existing configs keep working unchanged.
     buttoned message. Like a reply message, it may use `{{variables}}` and `@mentions` (both are
     resolved against the *original* message when pressed). The same applies to an `ack` text.
   - `/hutbot [config] add button "<label>" delay <minutes>` — push the escalation out by N minutes
-    and leave the buttons in place (the only button that does not consume the message). Pointless
-    without an escalation, and a press then says so.
+    and leave the buttons in place (the only button that does not consume the message). It needs an
+    escalation to postpone, so set one first; `clear escalation` warns if it strands such a button.
   - `/hutbot [config] clear buttons`
   - `/hutbot [config] set escalation <minutes> button "<label>"` — if nobody presses within
     `<minutes>`, auto-press that button (exactly as a human click would).
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index 84a0644..e4cf664 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -14,7 +14,7 @@
 from .. import slackcache
 from .. import actions
 from .. import targets
-from ..buttonutil import _find_button_index
+from ..buttonutil import _find_button_index, normalize_button
 from ..constants import (
     ACTION_POST_CHANNEL,
     ESCALATION_BUTTON,
@@ -471,6 +471,11 @@ async def add_button(app: AsyncApp, channel, config_name: str, label: str, spec:
             await messaging.send_message(app, channel, user, f"Invalid *button* message: {template_error}", thread_ts)
             return
     if action == BUTTON_ACTION_DELAY:
+        # A delay button postpones the escalation, so there has to be one to postpone.
+        existing = channel.configs.get(config_name) or {}
+        if not (existing.get('escalation_timeout') and (existing.get('escalation_kind') or ESCALATION_NONE) != ESCALATION_NONE):
+            await messaging.send_message(app, channel, user, f"A `delay` button needs an escalation to postpone. Set one first with `{state.slash_command} {config_name} set escalation <minutes> <button \"<label>\"|config <name>>`.", thread_ts)
+            return
         try:
             minutes = int(value)
         except ValueError:
@@ -505,7 +510,12 @@ async def clear_escalation(app: AsyncApp, channel, config_name: str, user, threa
     config['escalation_kind'] = ESCALATION_NONE
     config['escalation_target'] = ''
     await persistence.save_configuration()
-    await messaging.send_message(app, channel, user, f"*Escalation* cleared in configuration `{config_name}`; buttons stay open until pressed.", thread_ts)
+    delay_buttons = [b.get('label') for b in (config.get('buttons') or []) if normalize_button(b)[0] == BUTTON_ACTION_DELAY]
+    warning = ""
+    if delay_buttons:
+        labels = ", ".join(f"`{label}`" for label in delay_buttons)
+        warning = f" :warning: ({labels} now has nothing to postpone)"
+    await messaging.send_message(app, channel, user, f"*Escalation* cleared in configuration `{config_name}`; buttons stay open until pressed{warning}.", thread_ts)
 
 
 async def set_escalation(app: AsyncApp, channel, config_name: str, minutes_str: str, kind: str | None, target: str | None, user, thread_ts: str = "") -> None:
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index 90daa07..ae2f14c 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -256,7 +256,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
             (f"{command} [config] add button \"<label>\" ack [text]", "Button dismisses; [text] may use {{variables}}."),
             (f"{command} [config] add button \"<label>\" message <text>", "Button posts <text>; may use {{variables}}."),
-            (f"{command} [config] add button \"<label>\" delay <minutes>", "Button delays the escalation."),
+            (f"{command} [config] add button \"<label>\" delay <minutes>", "Button postpones the escalation; buttons stay."),
             (f"{command} [config] clear buttons", "Remove all buttons."),
             (f"{command} [config] set escalation <minutes> button \"<label>\"", "Auto-press that button if nobody does in time."),
             (f"{command} [config] set escalation <minutes> config <config>", "Run that config if nobody presses in time."),
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 8ab1391..69d0e59 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -26,6 +26,8 @@ async def test_add_button_typed_actions():
     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)
+        # A delay button needs something to postpone.
+        await process_command(app, "set escalation 5 config approve-flow", channel, user)
         await process_command(app, 'add button "Wait" delay 3', channel, user)
         await process_command(app, 'add button "Run" config approve-flow', channel, user)
     assert channel.configs["default"]["buttons"] == [
@@ -715,3 +717,42 @@ async def test_delay_press_without_an_escalation_keeps_the_buttons_and_starts_no
     # Record kept so the other buttons still resolve, but no timer was created.
     assert entry["task"] is None
     assert entry["escalation_kind"] == ESCALATION_NONE
+
+
+@pytest.mark.asyncio
+async def test_add_delay_button_requires_an_escalation():
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "Later" delay 10', channel, user)
+        assert send.call_args.args[3] == (
+            'A `delay` button needs an escalation to postpone. Set one first with '
+            '`/hutbot default set escalation <minutes> <button "<label>"|config <name>>`.'
+        )
+        assert config["buttons"] == []
+
+        await process_command(app, "set escalation 5 config alarm", channel, user)
+        await process_command(app, 'add button "Later" delay 10', channel, user)
+
+    assert config["buttons"] == [{"label": "Later", "action": "delay", "value": "10"}]
+
+
+@pytest.mark.asyncio
+async def test_clear_escalation_warns_about_a_stranded_delay_button():
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set escalation 5 config alarm", channel, user)
+        await process_command(app, 'add button "Later" delay 10', channel, user)
+        await process_command(app, "clear escalation", channel, user)
+
+    assert send.call_args.args[3] == (
+        "*Escalation* cleared in configuration `default`; buttons stay open until pressed "
+        ":warning: (`Later` now has nothing to postpone)."
+    )

From 6420d683c1b701beb039c552b279e9d2419c5516 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 14 Aug 2026 14:30:00 +0200
Subject: [PATCH 38/42] fix(routing): correctly identify app bot users as bots

Previously, messages sent by Slack apps through their bot user were treated
as human messages because the presence of a `user` ID was used to disqualify
the message from being bot-generated. This commit updates the routing logic
to check for `bot_id` and the new `is_bot` attribute on the User model.

The `User` namedtuple now includes an `is_bot` field (defaulting to False)
to maintain compatibility with existing code. The slackcache is updated to
populate this field based on the API response or `USLACKBOT` ID. Additionally,
employee mapping is skipped for bot users to avoid unnecessary lookups and
warnings.
---
 hutbot/models.py      |  3 +-
 hutbot/routing.py     |  7 ++--
 hutbot/slackcache.py  |  5 +--
 tests/_common.py      |  1 +
 tests/test_routing.py | 78 +++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 88 insertions(+), 6 deletions(-)

diff --git a/hutbot/models.py b/hutbot/models.py
index 04d635e..4dd687c 100644
--- a/hutbot/models.py
+++ b/hutbot/models.py
@@ -4,7 +4,8 @@
 from dataclasses import dataclass
 
 ScheduledReply = collections.namedtuple('ScheduledReply', ['task', 'user_id'])
-User = collections.namedtuple('User', ['id', 'name', 'real_name', 'team'])
+# `is_bot` defaults to False so the many four-field constructions stay valid.
+User = collections.namedtuple('User', ['id', 'name', 'real_name', 'team', 'is_bot'], defaults=(False,))
 Usergroup = collections.namedtuple('Usergroup', ['id', 'handle', 'name'])
 Channel = collections.namedtuple('Channel', ['id', 'name', 'configs'])
 OpsGeniePeriod = collections.namedtuple('OpsGeniePeriod', ['recipient_email', 'slack_user', 'start', 'end'])
diff --git a/hutbot/routing.py b/hutbot/routing.py
index 722b835..748df0a 100644
--- a/hutbot/routing.py
+++ b/hutbot/routing.py
@@ -53,13 +53,14 @@ async def route_message(app: AsyncApp, opsgenie_token: str, event: dict) -> None
         log(f"Ignoring message with subtype '{subtype}' for channel #{channel.name}.")
         return
 
-    actor_is_bot = False
+    # An app posting through its bot user sends both `user` and `bot_id`, so the
+    # presence of `user` says nothing about whether a human wrote this.
+    actor_is_bot = bool(bot_id) or subtype == 'bot_message'
     user = None
     if user_id:
         user = await slackcache.get_user_by_id(app, user_id)
-        actor_is_bot = user_id == 'USLACKBOT'
+        actor_is_bot = actor_is_bot or user_id == 'USLACKBOT' or bool(getattr(user, 'is_bot', False))
     elif bot_id and (thread_ts or any(c.get('include_bots', False) for c in channel.configs.values())):
-        actor_is_bot = True
         user = await slackcache.get_user_by_id(app, bot_id)
 
     if subtype == 'message_deleted' and previous_message:
diff --git a/hutbot/slackcache.py b/hutbot/slackcache.py
index 3a79b94..d8d876e 100644
--- a/hutbot/slackcache.py
+++ b/hutbot/slackcache.py
@@ -93,9 +93,10 @@ def build_user(user: dict, employees: dict, mappings: dict) -> tuple[str, User]:
     user_email_alias_normalized = normalize_user_name(user_email_alias)
     user_real_name = user.get('real_name', '').strip()
     user_real_name_normalized = normalize_real_name(user_real_name)
+    user_is_bot = bool(user.get('is_bot')) or user_id == 'USLACKBOT'
     user_team = TEAM_UNKNOWN
 
-    if len(employees) > 0:
+    if len(employees) > 0 and not user_is_bot:
         # Try different variations of the username to find a match in employees
         user_key_candidates = [
             user_name,
@@ -127,7 +128,7 @@ def build_user(user: dict, employees: dict, mappings: dict) -> tuple[str, User]:
         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)
+    return user_email, User(id=user_id, name=user_name, team=user_team, real_name=user_real_name, is_bot=user_is_bot)
 
 
 def cache_user(user_email: str, u: User) -> None:
diff --git a/tests/_common.py b/tests/_common.py
index 1905e2b..7032758 100644
--- a/tests/_common.py
+++ b/tests/_common.py
@@ -26,6 +26,7 @@
     DEFAULT_CONFIG,
     DISABLED_REASON_REMOVED,
     ESCALATION_NONE,
+    TEAM_UNKNOWN,
     TRIGGER_CRON,
     bot_slug,
     normalize_slash_command,
diff --git a/tests/test_routing.py b/tests/test_routing.py
index 241749f..62c762d 100644
--- a/tests/test_routing.py
+++ b/tests/test_routing.py
@@ -404,3 +404,81 @@ def register(fn):
         await handlers["member_joined_channel"]({"event": {"user": "UBOT", "channel": "C2"}}, None)
         mock_removed.assert_called_once_with(app, "C1")
         mock_added.assert_called_once_with(app, "C2")
+
+
+@pytest.mark.asyncio
+async def test_route_message_treats_an_app_bot_user_as_a_bot():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="davetest", configs={"default": DEFAULT_CONFIG.copy()})
+    # An app posting through its bot user sends `user` *and* `bot_id`, and users.info
+    # reports is_bot — none of which used to count as "a bot wrote this".
+    bot_user = User(id="U0A9NGY2U5B", name="mping", real_name="mPing", team=TEAM_UNKNOWN, is_bot=True)
+    event = {
+        "type": "message", "text": "mr-merged m3-helmfile", "ts": "1786709950.634419",
+        "user": bot_user.id, "bot_id": "B0A9NGY2U5B", "app_id": "A0A9",
+        "channel": channel.id, "channel_type": "channel",
+    }
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=bot_user)), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        hutbot.state.scheduled_messages.clear()
+        hutbot.state._scheduled_replies_cache.clear()
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_not_called()
+
+    # With include_bots the same message is handled.
+    channel.configs["default"]["include_bots"] = True
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=bot_user)), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_called_once()
+    for scheduled in list(hutbot.state.scheduled_messages.values()):
+        scheduled.task.cancel()
+
+
+@pytest.mark.asyncio
+async def test_route_message_treats_a_bot_user_without_bot_id_as_a_bot():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="davetest", configs={"default": DEFAULT_CONFIG.copy()})
+    bot_user = User(id="UBOTUSER", name="somebot", real_name="Some Bot", team=TEAM_UNKNOWN, is_bot=True)
+    event = {"type": "message", "text": "beep", "ts": "1234.1", "user": bot_user.id,
+             "channel": channel.id, "channel_type": "channel"}
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=bot_user)), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        hutbot.state.scheduled_messages.clear()
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_not_called()
+
+
+def test_build_user_marks_bots_and_skips_employee_mapping():
+    import hutbot
+    employees = {"d.grieser": {"fullname": "David Grieser", "group": "Platform"}}
+
+    with patch('hutbot.slackcache.log_warning') as mock_log_warning:
+        _, bot = hutbot.slackcache.build_user(
+            {"id": "U0A9NGY2U5B", "name": "mping", "is_bot": True, "real_name": "mPing"}, employees, {})
+        _, slackbot = hutbot.slackcache.build_user({"id": "USLACKBOT", "name": "slackbot"}, employees, {})
+        _, human = hutbot.slackcache.build_user(
+            {"id": "U1", "name": "nobody", "real_name": "No Body"}, employees, {})
+
+    assert bot.is_bot is True and bot.team == TEAM_UNKNOWN
+    assert slackbot.is_bot is True
+    assert human.is_bot is False
+    # Only the human is worth an employee-mapping warning.
+    assert mock_log_warning.call_count == 1
+    assert "@nobody" in mock_log_warning.call_args.args[0]

From 21cddef18ca5da87dd891fabeeae61a4a15476ab Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 14 Aug 2026 15:01:50 +0200
Subject: [PATCH 39/42] feat(commands): refine work hours and config display

- Replace `set work-hours all day` with a new `clear work-hours` command.
- Update help text and dispatch logic to support the new clearing syntax.
- Improve config display by hiding settings that do not apply to the current rule type (e.g., hiding patterns for cron rules, hiding date formats when no variables are used).
- Add footer note explaining filtered output in config display.
---
 README.md                      |   4 +-
 hutbot/commands/dispatch.py    |   9 ++-
 hutbot/commands/info.py        |  73 +++++++++++++++---------
 hutbot/commands/patterns.py    |   6 +-
 hutbot/commands/setters.py     |   9 +++
 hutbot/messaging.py            |   2 +-
 tests/test_commands_info.py    | 100 ++++++++++++++++++++++++++-------
 tests/test_commands_setters.py |  25 ++++++++-
 8 files changed, 169 insertions(+), 59 deletions(-)

diff --git a/README.md b/README.md
index 6629071..934cfff 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,9 @@ Opsgenie date/time variables support `fmt`/`format`, `tz`/`timezone`, and `lc`/`
 ```
 
 The `<timezone>` is also the timezone the config's work days and work hours are
-counted in. Without one, both fall back to the server's local time.
+counted in — `/hutbot [config] set work-hours 9:00 17:00`, `/hutbot [config] clear work-hours` to
+react at any hour, and `/hutbot [config] enable only-work-days` for Mon–Fri only. Without a
+timezone, all of them fall back to the server's local time.
 
 Instance-wide defaults for configs that set neither come from the deployment
 (`time.timezone` / `time.locale` in the Helm chart, `HUTBOT_TIMEZONE` /
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
index 21eb2a3..8944a02 100644
--- a/hutbot/commands/dispatch.py
+++ b/hutbot/commands/dispatch.py
@@ -58,12 +58,11 @@ async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, c
         await setters.set_only_work_days(app, channel, config_name, True, user, thread_ts)
     elif (match := patterns.DISABLE_ONLY_WORK_DAYS_PATTERN.match(command_text)):
         await setters.set_only_work_days(app, channel, config_name, False, user, thread_ts)
+    elif patterns.CLEAR_WORK_HOURS_PATTERN.match(command_text):
+        await setters.clear_work_hours(app, channel, config_name, user, thread_ts)
     elif (match := patterns.SET_WORK_HOURS_PATTERN.match(command_text)):
-        if match.group("all_day"):
-            start = end = "0:00"
-        else:
-            start = strip_quotes(match.group("start"))
-            end = strip_quotes(match.group("end"))
+        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)
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
index 568a504..3e511e4 100644
--- a/hutbot/commands/info.py
+++ b/hutbot/commands/info.py
@@ -13,10 +13,13 @@
 from .. import opsgenie
 from .. import buttons
 from .. import datetimefmt
+from .. import templating
 from ..buttonutil import normalize_button
 from .. import targets
 from ..constants import (
     ACTION_DM_USER,
+    DATETIME_TEMPLATE_VARIABLES,
+    OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
     ACTION_GROUP_DM,
     ACTION_POST_CHANNEL,
     ACTION_REPLY,
@@ -178,10 +181,19 @@ def destination_lines(config: dict, action: str, trigger: str) -> list[str]:
         # Settings are grouped by topic, in the order a rule runs: when it fires,
         # what gates it, what it matches, timing, buttons, alerting, formatting.
         # Each group becomes a blank-line-separated block in the code block.
+        #
+        # A group is printed only where it has an effect: message matching and the
+        # reminder delay mean nothing to a `cron`/`manual` rule, a condition gates
+        # only a cron, and the date/time settings matter only to something that
+        # renders a date. Printing them anyway invites configuring a field that is
+        # never read.
         groups: list[list[tuple]] = []
+        reacts_to_messages = trigger == TRIGGER_MESSAGE
+        template_variables = templating.find_template_variables(reply_message or '') | templating.find_template_variables(config.get('opsgenie_message') or '')
+        renders_datetime = bool(template_variables & (DATETIME_TEMPLATE_VARIABLES | OPSGENIE_DATETIME_TEMPLATE_VARIABLES))
 
         condition = config.get('condition') or ''
-        if condition:
+        if condition and trigger == TRIGGER_CRON:
             negate = ' (negated)' if config.get('condition_negate') else ''
             condition_rows = [("Condition", f"{condition}{negate}")]
             if config.get('outlook_subject_pattern'):
@@ -190,18 +202,19 @@ def destination_lines(config: dict, action: str, trigger: str) -> list[str]:
                 condition_rows.append(("Outlook body", config.get('outlook_body_pattern')))
             groups.append(condition_rows)
 
-        groups.append([
-            ("Pattern",        f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<none>'),
-            ("Included teams", included_teams),
-            ("Excluded teams", excluded_teams),
-            ("Include bots",   'enabled' if include_bots else 'disabled'),
-        ])
+        if reacts_to_messages:
+            groups.append([
+                ("Pattern",        f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<none>'),
+                ("Included teams", included_teams),
+                ("Excluded teams", excluded_teams),
+                ("Include bots",   'enabled' if include_bots else 'disabled'),
+            ])
 
-        groups.append([
-            ("Wait time",      f"{wait_time_minutes} minutes"),
-            ("Only work days", 'enabled' if only_work_days else 'disabled'),
-            ("Work hours",     f"{hours[0]} - {hours[1]}" if len(hours) == 2 else 'all day'),
-        ])
+            groups.append([
+                ("Wait time",      f"{wait_time_minutes} minutes"),
+                ("Only work days", 'enabled' if only_work_days else 'disabled'),
+                ("Work hours",     f"{hours[0]} - {hours[1]}" if len(hours) == 2 else 'any hour'),
+            ])
 
         config_buttons = config.get('buttons') or []
         if config_buttons:
@@ -218,19 +231,27 @@ def _button_label(b):
                 button_rows.append(("Escalation", "none, buttons stay open until pressed"))
             groups.append(button_rows)
 
-        groups.append([
-            ("OpsGenie",          ('enabled' if opsgenie_enabled else 'disabled') + ('' if state.opsgenie_configured else ' (not configured)')),
-            ("OpsGenie schedule", opsgenie_schedule_name or '<none>'),
-            ("OpsGenie priority", opsgenie_priority),
-            ("OpsGenie message",  config.get('opsgenie_message') or '<original message>'),
-        ])
+        opsgenie_rows = [("OpsGenie", ('enabled' if opsgenie_enabled else 'disabled') + ('' if state.opsgenie_configured else ' (not configured)'))]
+        if opsgenie_enabled:
+            opsgenie_rows += [
+                ("OpsGenie schedule", opsgenie_schedule_name or '<none>'),
+                ("OpsGenie priority", opsgenie_priority),
+                ("OpsGenie message",  config.get('opsgenie_message') or '<original message>'),
+            ]
+        groups.append(opsgenie_rows)
 
-        groups.append([
-            ("Date format",        date_format),
-            ("Time format",        time_format),
-            ("Date/time timezone", datetime_timezone),
-            ("Date/time locale",   datetime_locale),
-        ])
+        # The timezone also decides when a cron fires and when work hours are, so it
+        # is shown for those even when nothing renders a date.
+        timezone_matters = trigger == TRIGGER_CRON or (reacts_to_messages and (only_work_days or len(hours) == 2))
+        if renders_datetime:
+            groups.append([
+                ("Date format",        date_format),
+                ("Time format",        time_format),
+                ("Date/time timezone", datetime_timezone),
+                ("Date/time locale",   datetime_locale),
+            ])
+        elif timezone_matters:
+            groups.append([("Date/time timezone", datetime_timezone)])
 
         key_width = max(len(label) for group in groups for label, _ in group)
         config_block = "\n\n".join(
@@ -265,7 +286,9 @@ def _button_label(b):
             f"{quoted_block}"
             f"```\n{config_block}\n```"
         )
+    # Say that the print is filtered, so a missing row does not read as a lost setting.
+    footer = "_Only the settings that apply to each configuration are shown._"
     # Slack splits an oversized message wherever the break lands, cutting the code
     # fence in half, so a channel with several configs is sent as several messages.
-    for chunk in messaging.pack_message_chunks([message, *config_sections]):
+    for chunk in messaging.pack_message_chunks([message, *config_sections, footer]):
         await messaging.send_message(app, channel, user, chunk, thread_ts)
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index 55963d9..fbe653d 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -36,10 +36,8 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 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?')
-# `all day` is the spelled-out form of `0:00 0:00`, which is how "no restriction"
-# is stored. It has to come first in the alternation or `<start> <end>` would
-# swallow it as the two times "all" and "day".
-SET_WORK_HOURS_PATTERN = create_command_pattern(r'(set\s+)?(work[_ -]?)?hours\s+(?:(?P<all_day>all[_ -]?day)\s*$|(?P<start>.+)\s+(?P<end>.+))')
+CLEAR_WORK_HOURS_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+(work[_ -]?)?hours')
+SET_WORK_HOURS_PATTERN = create_command_pattern(r'(set\s+)?(work[_ -]?)?hours\s+(?P<start>.+)\s+(?P<end>.+)')
 ENABLE_ONLY_WORK_DAYS_PATTERN = create_command_pattern(r'enable\s+(only[_ -]?)?work[_ -]?days')
 DISABLE_ONLY_WORK_DAYS_PATTERN = create_command_pattern(r'disable\s+(only[_ -]?)?work[_ -]?days')
 SHOW_CONFIG_PATTERN = re.compile(r'^(show\s+)?config(uration)?$', re.IGNORECASE)
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index e4cf664..7a9a036 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -87,9 +87,18 @@ async def set_replies_enabled(app: AsyncApp, channel, config_name: str, enabled:
     await messaging.send_message(app, channel, user, f"Replies are now *{'enabled' if enabled else 'disabled'}* in configuration `{config_name}`.", thread_ts)
 
 
+async def clear_work_hours(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['hours'] = []
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Work hours* cleared in configuration `{config_name}`; messages are handled at any hour.", thread_ts)
+
+
 async def set_work_hours(app: AsyncApp, channel, config_name: str, start: str, end: str, user, thread_ts: str = "") -> None:
     if config_name not in channel.configs:
         channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    if f"{start} {end}".strip().lower().replace('-', ' ') == "all day":
+        await messaging.send_message(app, channel, user, f"To handle messages at any hour, use `{state.slash_command} {config_name} clear work-hours`.", thread_ts)
+        return
     start_time = datetimefmt.parse_time(start)
     end_time = datetimefmt.parse_time(end)
     if not start_time:
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index ae2f14c..ef26717 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -243,7 +243,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
             (f"{command} [config] enable only-work-days", "Respond only on work days."),
             (f"{command} [config] disable only-work-days", "Respond on all days."),
             (f"{command} [config] set work-hours <start> <end>", "Set active hours, e.g. 9:00 17:00."),
-            (f"{command} [config] set work-hours all day", "React at any hour (same as 0:00 0:00)."),
+            (f"{command} [config] clear work-hours", "React at any hour."),
         ]),
         ("Message and action", [
             (f"{command} [config] set message \"<reply message>\"", "Set reminder message."),
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 1ed982d..3d92cc6 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -6,7 +6,7 @@
 async def test_show_config():
     app = AsyncMock()
     configs = {
-        "alarms": {"pattern": ".*alarm.*", "wait_time": 300, "reply_message": "Alarm message"},
+        "alarms": {"pattern": ".*alarm.*", "wait_time": 300, "reply_message": "Alarm message", "opsgenie": True},
         "default": {"wait_time": 600, "reply_message": "Default message"}
     }
     for name, cfg in configs.items():
@@ -23,23 +23,21 @@ async def test_show_config():
         assert "\n\n*Configuration*: `default` (enabled)" in sent_message
         assert "> *Trigger*: `message`\n>\n> *Reply message*:\n> Default message\n>\n> *Replied in* <#C123> (in thread)\n>\n> *Settings*:\n```" in sent_message
         assert "\nTrigger" not in sent_message
+        # Details only where OpsGenie is on; the disabled config shows just the one row.
         assert "OpsGenie schedule" in sent_message
-        assert "OpsGenie priority   P4" in sent_message
+        assert "OpsGenie priority" in sent_message
+        assert any(line.startswith("OpsGenie ") and line.endswith("disabled (not configured)") for line in sent_message.splitlines())
         # Settings are grouped, each group separated by a blank line.
         assert (
-            "Wait time           10 minutes\n"
-            "Only work days      disabled\n"
-            "Work hours          all day\n"
-            "\n"
-            "OpsGenie            disabled"
+            "Wait time       10 minutes\n"
+            "Only work days  disabled\n"
+            "Work hours      any hour"
         ) in sent_message
-        assert "Date format         %a, %d %b %Y" in sent_message
-        assert "Time format         %H:%M" in sent_message
-        assert "Wait time           10 minutes" 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 "Wait time          5 minutes" in sent_message  # wider column: the OpsGenie rows
+        assert "Pattern            .*alarm.* (case-insensitive)" in sent_message
         assert "Alarm message" in sent_message
 
 
@@ -48,8 +46,9 @@ async def test_show_config():
 async def test_show_config_resolves_the_server_timezone_and_locale():
     app = AsyncMock()
     configs = {
-        "default": DEFAULT_CONFIG.copy(),
-        "tokyo": {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Asia/Tokyo", "datetime_locale": "de-DE"},
+        "default": {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}}"},
+        "tokyo": {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}}",
+                  "datetime_timezone": "Asia/Tokyo", "datetime_locale": "de-DE"},
     }
     channel = Channel(id="C123", name="general", configs=configs)
     user = User(id="U123", name="test", real_name="Test User", team="A")
@@ -87,11 +86,13 @@ async def test_show_config_displays_multiline_team_values():
         await show_config(app, channel, user, "")
 
     sent_message = sent_messages(mock_send_message)
+    first = next(line for line in sent_message.splitlines() if line.startswith("Excluded teams"))
+    indent = " " * (len(first) - len("Cloud Hosting"))
     assert (
-        "Excluded teams      Cloud Hosting\n"
-        "                    m-kubed (m³)\n"
-        "                    Systemarchitektur Infrastruktur/Technik\n"
-        "                    Site Reliability"
+        f"{first}\n"
+        f"{indent}m-kubed (m³)\n"
+        f"{indent}Systemarchitektur Infrastruktur/Technik\n"
+        f"{indent}Site Reliability"
     ) in sent_message
 
 
@@ -143,7 +144,7 @@ async def test_process_command_help_uses_compact_command_reference():
     assert "\n\n# OpsGenie\n" in sent_message
     assert "\n\n# Help\n/hutbot news" in sent_message
     assert sent_message.index("# Trigger") < sent_message.index("# When to react") < sent_message.index("# Buttons")
-    assert "/hutbot [config] set work-hours all day" in sent_message
+    assert "/hutbot [config] clear work-hours" in sent_message
     assert "/hutbot [config] set trigger cron \"<expr>\"" in sent_message
     # Removed commands are gone from the reference.
     for stale in ("set target", "set cron <", "set schedule-timezone", "forward-channel",
@@ -313,6 +314,7 @@ async def test_show_config_marks_the_instance_default_locale():
     channel = Channel(id="C123", name="general", configs={"default": DEFAULT_CONFIG.copy()})
     user = User(id="U123", name="test", real_name="Test User", team="A")
 
+    channel.configs["default"]["reply_message"] = "at {{time}}"
     with patch('hutbot.state.default_datetime_locale', "de_DE"), \
          patch('hutbot.messaging.send_message') as mock_send_message:
         await show_config(app, channel, user, "")
@@ -358,7 +360,7 @@ async def test_help_is_split_into_messages_slack_will_not_cut_apart():
 async def test_show_config_splits_many_configs_into_several_messages():
     import hutbot
     app = AsyncMock()
-    configs = {f"config-{index}": DEFAULT_CONFIG.copy() for index in range(8)}
+    configs = {f"config-{index}": {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}}"} for index in range(8)}
     channel = Channel(id="C1", name="general", configs=configs)
     user = User("U1", "test", "Test User", "Testers")
 
@@ -385,3 +387,61 @@ def test_pack_message_chunks_keeps_an_oversized_part_whole():
     assert chunks == ["a" * 3000, "b" * 3000, "c" * 5000]
     assert hutbot.messaging.pack_message_chunks(["x", "y"]) == ["x\n\ny"]
     assert hutbot.messaging.pack_message_chunks([]) == []
+
+
+@pytest.mark.asyncio
+async def test_show_config_hides_settings_that_do_not_apply():
+    app = AsyncMock()
+    configs = {
+        # manual: no matching, no reminder delay, no work hours, nothing renders a date
+        "post": {**DEFAULT_CONFIG.copy(), "trigger": "manual", "reply_message": ":x: pressed"},
+        # cron with a date in its message: condition + full date/time block
+        "standup": {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_CRON, "cron": "0 9 * * 1-5",
+                    "reply_message": "Standup at {{time}}", "condition": "outlook_calendar"},
+        # message trigger with work hours: timezone only, no formats
+        "watch": {**DEFAULT_CONFIG.copy(), "hours": ["9:00", "17:00"]},
+    }
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sections = {name: part for name, part in
+                ((p.split("`")[1], p) for p in sent_messages(mock_send_message).split("*Configuration*: ")[1:])}
+
+    manual = sections["post"]
+    for mute in ("Pattern", "Included teams", "Include bots", "Wait time", "Only work days",
+                 "Work hours", "Date format", "Date/time timezone", "Condition"):
+        assert mute not in manual, mute
+    assert "OpsGenie" in manual
+
+    cron = sections["standup"]
+    assert "Condition           outlook_calendar" in cron
+    assert "Date format" in cron and "Date/time locale" in cron
+    for mute in ("Pattern", "Wait time", "Work hours", "Include bots"):
+        assert mute not in cron, mute
+
+    watch = sections["watch"]
+    assert "Work hours          9:00 - 17:00" in watch
+    # Work hours are counted in that timezone, but nothing renders a date.
+    assert "Date/time timezone" in watch
+    assert "Date format" not in watch and "Date/time locale" not in watch
+
+    assert "_Only the settings that apply to each configuration are shown._" in sent_messages(mock_send_message)
+
+
+@pytest.mark.asyncio
+async def test_show_config_hides_a_condition_on_a_non_cron_trigger():
+    app = AsyncMock()
+    # A condition is only evaluated when a cron fires, so it is noise elsewhere.
+    config = {**DEFAULT_CONFIG.copy(), "condition": "outlook_calendar", "outlook_subject_pattern": ".*x.*"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = sent_messages(mock_send_message)
+    assert "Condition" not in sent_message
+    assert "Outlook subject" not in sent_message
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
index 4c94786..d07e593 100644
--- a/tests/test_commands_setters.py
+++ b/tests/test_commands_setters.py
@@ -371,8 +371,8 @@ async def test_set_replies_enabled_clears_the_automatic_disable_reason():
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("command", ["set work-hours all day", "set work hours all-day", "hours allday"])
-async def test_set_work_hours_accepts_all_day(command):
+@pytest.mark.parametrize("command", ["clear work-hours", "unset hours", "remove work hours"])
+async def test_clear_work_hours_reacts_at_any_hour(command):
     app = AsyncMock()
     channel = Channel(id="C1", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "hours": ["8:00", "16:00"]}})
     user = User("U1", "test", "Test User", "Testers")
@@ -382,7 +382,26 @@ async def test_set_work_hours_accepts_all_day(command):
         await process_command(app, command, channel, user)
 
     assert channel.configs["default"]["hours"] == []
-    assert mock_send_message.call_args.args[3] == "*Work hours* set to all day in configuration `default`"
+    assert mock_send_message.call_args.args[3] == (
+        "*Work hours* cleared in configuration `default`; messages are handled at any hour."
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_work_hours_all_day_points_at_the_clear_command():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "hours": ["8:00", "16:00"]}
+    channel = Channel(id="C1", name="general", configs={"default": config})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set work-hours all day", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "To handle messages at any hour, use `/hutbot default clear work-hours`."
+    )
+    assert config["hours"] == ["8:00", "16:00"]
 
 
 @pytest.mark.asyncio

From a73568a2b1aa51f918c7fbe06c9f4f0c6290d67f Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Fri, 14 Aug 2026 18:43:05 +0200
Subject: [PATCH 40/42] fix(buttons): remove message action, unify with ack,
 and add post-press notes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Merge `message` button action into `ack` to simplify interaction models.
Both actions now dismiss the escalation and optionally post text. Remove
the redundant `message` keyword and update command parsing to allow omitting
the leading `add`.

When buttons are removed after a press or timeout, append a note indicating
who handled the message and what happened (e.g., "🔘 `Ack` Dave Grieser").
Update templates, web UI, and tests to reflect these changes.
---
 README.md                   |  17 +++---
 hutbot/buttons.py           |  48 +++++++++++----
 hutbot/commands/patterns.py |   2 +-
 hutbot/commands/setters.py  |   8 +--
 hutbot/constants.py         |   7 ++-
 hutbot/messaging.py         |   5 +-
 hutbot/templating.py        |   2 +-
 hutbot/webui_backend.py     |   8 +--
 tests/test_buttons.py       | 118 +++++++++++++++++++++++++++++++++---
 tests/test_commands_info.py |   2 +-
 tests/test_webui_backend.py |   4 +-
 webui_static/app.js         |   9 ++-
 12 files changed, 175 insertions(+), 55 deletions(-)

diff --git a/README.md b/README.md
index 934cfff..1fc01d2 100644
--- a/README.md
+++ b/README.md
@@ -84,13 +84,13 @@ existing configs keep working unchanged.
     autocomplete so it arrives as a link, or pass its `C…` id.
 
 - **Buttons** attach interactive buttons to the message a rule sends (including the classic
-  unanswered-message reply). Each button is added incrementally with a typed action:
+  unanswered-message reply). Each button is added incrementally with a typed action (the leading
+  `add`, like `set` elsewhere, is optional):
   - `/hutbot [config] add button "<label>" config <config>` — run another config (a `manual` rule).
-  - `/hutbot [config] add button "<label>" ack [text]` — acknowledge/dismiss: stop the escalation and
-    optionally post `text`.
-  - `/hutbot [config] add button "<label>" message <text>` — post `<text>` in the thread of the
-    buttoned message. Like a reply message, it may use `{{variables}}` and `@mentions` (both are
-    resolved against the *original* message when pressed). The same applies to an `ack` text.
+  - `/hutbot [config] add button "<label>" ack [text]` — mark the message handled: stop any
+    escalation, remove the buttons, and post `[text]` in the thread when given. Like a reply message,
+    the text may use `{{variables}}` and `@mentions`, both resolved against the *original* message
+    when pressed.
   - `/hutbot [config] add button "<label>" delay <minutes>` — push the escalation out by N minutes
     and leave the buttons in place (the only button that does not consume the message). It needs an
     escalation to postpone, so set one first; `clear escalation` warns if it strands such a button.
@@ -103,11 +103,14 @@ existing configs keep working unchanged.
     Pending escalations survive restarts.
   - A button/timeout that runs a config passes the **original message context** to it, so the target's
     templates and any OpsGenie alert reference the original message.
+  - Once a message is handled, its buttons are removed and replaced by a one-line note of what
+    happened: 🔘 *`I've got it` Dave Grieser*, 🔘 *`Page` Dave Grieser* ▶️ *`alarm`* for a press, and
+    ⏰ *`1m`* or ⏰ *`5m`* ▶️ *`alarm`* when the escalation acted instead.
 
 - **"Need help?" example** — a question that defaults to "Yes" if ignored:
   ```bash
   /hutbot helpcheck set message Need help?
-  /hutbot helpcheck add button "Yes" message "Here's the help doc: …"
+  /hutbot helpcheck add button "Yes" ack "Here's the help doc: …"
   /hutbot helpcheck add button "No" ack
   /hutbot helpcheck set escalation 5 button "Yes"
   ```
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index 6626260..27cff60 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -19,7 +19,6 @@
     BUTTON_ACTION_ACK,
     BUTTON_ACTION_CONFIG,
     BUTTON_ACTION_DELAY,
-    BUTTON_ACTION_MESSAGE,
     BUTTON_ACTION_PREFIX,
     ESCALATION_BUTTON,
     ESCALATION_CONFIG,
@@ -159,10 +158,10 @@ async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel, po
             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).
-        # The text is a template like a config's reply message, rendered against the
-        # original message with the defining config's date/time settings.
+    elif action == BUTTON_ACTION_ACK:
+        # Dismissing posts the ack text when there is one. The text is a template
+        # like a config's reply message, rendered against the original message with
+        # the defining config's date/time settings.
         if value:
             text = await actions.render_template_text(app, opsgenie_token, channel, src_config or {}, src_config_name, run_context, value)
             await messaging._post_message(app, posted_channel_id, text, None, message_ts)
@@ -188,14 +187,14 @@ async def _run_escalation(app: AsyncApp, opsgenie_token: str, entry: dict) -> No
         buttons = snapshot if snapshot is not None else (src_config or {}).get('buttons') or []
         log(f"No button pressed on message {message_ts}: auto-pressing '{entry.get('escalation_target')}' in #{channel.name}.")
         await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[idx], run_context, src_config, entry.get('config_name', ''))
-        await _strip_buttons(app, posted_channel_id, message_ts, entry)
+        await _strip_buttons(app, posted_channel_id, message_ts, entry, _timeout_note(entry.get('timeout', 0), _ran_config(buttons[idx])))
     elif kind == ESCALATION_CONFIG:
         target = entry.get('escalation_target', '')
         target_config = channel.configs.get(target)
         if target_config:
             log(f"Escalating message {message_ts}: running '{target}' in #{channel.name}.")
             await actions.run_action(app, opsgenie_token, channel, target_config, target, context=run_context)
-            await _strip_buttons(app, posted_channel_id, message_ts, entry)
+            await _strip_buttons(app, posted_channel_id, message_ts, entry, _timeout_note(entry.get('timeout', 0), target))
         else:
             log_warning(f"Escalation target '{target}' not found in #{channel.name}.")
 
@@ -316,18 +315,43 @@ async def restore_pending_buttons(app: AsyncApp, opsgenie_token: str) -> None:
     log(f"Restored {restored} pending button escalations.")
 
 
-async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str, entry: dict | None) -> None:
+def _ran_config(button: dict) -> str:
+    """The config a button runs, if it runs one."""
+    action, value = normalize_button(button)
+    return value if action == BUTTON_ACTION_CONFIG and value else ""
+
+
+def _ran_suffix(ran: str) -> str:
+    """`▶️ \u0060config\u0060`, with the emoji outside the italics."""
+    return f" ▶️ _`{ran}`_" if ran else ""
+
+
+def _press_note(button: dict, presser: User | None) -> str:
+    """What the message says in place of its buttons after somebody pressed one."""
+    who = (presser.real_name or presser.name or '?') if presser else 'Someone'
+    return f"🔘 _`{button.get('label') or '?'}` {who}_{_ran_suffix(_ran_config(button))}"
+
+
+def _timeout_note(timeout: float, ran: str = "") -> str:
+    """…and what it says when the escalation acted instead of a person."""
+    return f"⏰ _`{int((timeout or 0) // 60)}m`_{_ran_suffix(ran)}"
+
+
+async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str, entry: dict | None, note: str = "") -> None:
     """Remove the interactive buttons from a handled message so a stale later click
-    can't fire an action against a since-edited config. Best-effort."""
+    can't fire an action against a since-edited config, leaving a note of what was
+    done in their place (already formatted by `_press_note`/`_timeout_note`).
+    Best-effort."""
     posted_text = (entry or {}).get('posted_text')
     if not posted_text or not posted_channel_id or not message_ts:
         return
+    text = f"{posted_text}\n\n{note}" if note else posted_text
     try:
         await app.client.chat_update(
             channel=posted_channel_id,
             ts=message_ts,
-            text=posted_text,
-            blocks=_section_blocks(posted_text),
+            text=text,
+            blocks=_section_blocks(text),
         )
     except SlackApiError as e:
         log_warning(f"Failed to remove buttons from message {message_ts} in {posted_channel_id}:", e)
@@ -390,4 +414,4 @@ async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, ac
     # the timeout-escalation path; the presser is only used for the log line above.
     run_context = await _escalation_context(app, entry, posted_channel_id, message_ts)
     await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[index], run_context, src_config, src_config_name)
-    await _strip_buttons(app, posted_channel_id, message_ts, entry)
+    await _strip_buttons(app, posted_channel_id, message_ts, entry, _press_note(buttons[index], presser))
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
index fbe653d..c1a5b6a 100644
--- a/hutbot/commands/patterns.py
+++ b/hutbot/commands/patterns.py
@@ -54,7 +54,7 @@ def create_command_pattern(command_regex: str) -> re.Pattern:
 # The target belongs to the action, so both arrive in one command. `set` is
 # optional, like it is for `wait-time` and `message`.
 SET_ACTION_PATTERN = create_command_pattern(r'(set\s+)?action\s+(?P<action>\S+)(?:\s+(?P<target>.+))?$')
-ADD_BUTTON_PATTERN = create_command_pattern(r'add\s+button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
+ADD_BUTTON_PATTERN = create_command_pattern(r'(add\s+)?button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
 CLEAR_BUTTONS_PATTERN = create_command_pattern(r'clear\s+buttons?')
 # `<minutes> <kind> <target>`: the timeout and what it escalates to are one setting.
 CLEAR_ESCALATION_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+escalation')
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
index 7a9a036..92a49d5 100644
--- a/hutbot/commands/setters.py
+++ b/hutbot/commands/setters.py
@@ -26,7 +26,6 @@
     ACTIONS,
     BUTTON_ACTION_CONFIG,
     BUTTON_ACTION_DELAY,
-    BUTTON_ACTION_MESSAGE,
     BUTTON_ACTIONS,
     CONDITION_NONE,
     CONDITION_OUTLOOK,
@@ -464,11 +463,10 @@ async def add_button(app: AsyncApp, channel, config_name: str, label: str, spec:
         return
     value = strip_quotes(parts[1]).strip() if len(parts) > 1 else ""
 
-    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)
+    if action == BUTTON_ACTION_CONFIG and not value:
+        await messaging.send_message(app, channel, user, f"Invalid *button*. `{action}` needs a configuration name.", thread_ts)
         return
-    if action in (BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ACK) and value:
+    if action == BUTTON_ACTION_ACK and value:
         # A button's text is a template too, so it gets the same treatment as
         # `set message`: @mentions resolved to ids, variables checked.
         ok, mention_error, value = await messaging.process_mentions(app, value)
diff --git a/hutbot/constants.py b/hutbot/constants.py
index 69f7e98..0dda1b2 100644
--- a/hutbot/constants.py
+++ b/hutbot/constants.py
@@ -56,10 +56,11 @@
 
 # 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
+# Acknowledge/dismiss: cancels a pending escalation, and posts its text if it has
+# one. Posting and dismissing were two keywords for one behavior; this is it.
+BUTTON_ACTION_ACK = "ack"
 BUTTON_ACTION_DELAY = "delay"      # delay the pending escalation by N minutes
-BUTTON_ACTIONS = {BUTTON_ACTION_CONFIG, BUTTON_ACTION_ACK, BUTTON_ACTION_MESSAGE, BUTTON_ACTION_DELAY}
+BUTTON_ACTIONS = {BUTTON_ACTION_CONFIG, BUTTON_ACTION_ACK, BUTTON_ACTION_DELAY}
 
 # What a buttoned message escalates to if no button is pressed within the timeout.
 ESCALATION_NONE = "none"
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
index ef26717..774bc8e 100644
--- a/hutbot/messaging.py
+++ b/hutbot/messaging.py
@@ -254,8 +254,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         ]),
         ("Buttons", [
             (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
-            (f"{command} [config] add button \"<label>\" ack [text]", "Button dismisses; [text] may use {{variables}}."),
-            (f"{command} [config] add button \"<label>\" message <text>", "Button posts <text>; may use {{variables}}."),
+            (f"{command} [config] add button \"<label>\" ack [text]", "Button marks it handled, posting [text] if given."),
             (f"{command} [config] add button \"<label>\" delay <minutes>", "Button postpones the escalation; buttons stay."),
             (f"{command} [config] clear buttons", "Remove all buttons."),
             (f"{command} [config] set escalation <minutes> button \"<label>\"", "Auto-press that button if nobody does in time."),
@@ -301,7 +300,7 @@ async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_
         f"Displays all configurations for `#{channel.name}`."
     )
     outro = (
-        "`[config]` is optional; omitted commands use `default`. The word `set` is optional too.\n\n"
+        "`[config]` is optional; omitted commands use `default`. The leading `set`/`add` is optional too.\n\n"
         f"Supported reply variables: {supported_template_variables}."
     )
     # The command table alone is well past Slack's per-message limit, and Slack
diff --git a/hutbot/templating.py b/hutbot/templating.py
index b29df53..2bf67e6 100644
--- a/hutbot/templating.py
+++ b/hutbot/templating.py
@@ -221,7 +221,7 @@ def render_reply_message_template(message: str, variables: dict[str, str], confi
 
 
 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')
+    wait_time = config.get('wait_time') or 0
     opsgenie_template_variables = {}
     if include_opsgenie:
         opsgenie_template_variables = await opsgenie.get_opsgenie_template_variables(app, opsgenie_token, config)
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
index 80931db..c5bf482 100644
--- a/hutbot/webui_backend.py
+++ b/hutbot/webui_backend.py
@@ -31,7 +31,6 @@
     ESCALATION_CONFIG,
     ESCALATION_NONE,
     BUTTON_ACTION_DELAY,
-    BUTTON_ACTION_MESSAGE,
     BUTTON_ACTIONS,
     CONDITION_NONE,
     CONDITION_OUTLOOK,
@@ -306,11 +305,10 @@ def get(key):
             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}."
+            if button_action == BUTTON_ACTION_CONFIG and not value:
+                errors[f'buttons.{i}'] = "`config` button needs a configuration name."
                 continue
-            if button_action in (BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ACK) and value:
+            if button_action == BUTTON_ACTION_ACK and value:
                 # Same treatment as reply_message: mentions resolved, variables checked.
                 ok, mention_error, value = await messaging.process_mentions(app, value)
                 if not ok:
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 69d0e59..9f1e11d 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -25,14 +25,14 @@ async def test_add_button_typed_actions():
     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 "FAQ" ack "See the wiki"', channel, user)
         # A delay button needs something to postpone.
         await process_command(app, "set escalation 5 config approve-flow", channel, user)
         await process_command(app, 'add button "Wait" delay 3', channel, user)
         await process_command(app, 'add button "Run" config approve-flow', channel, user)
     assert channel.configs["default"]["buttons"] == [
         {"label": "Ack", "action": "ack", "value": "Got it"},
-        {"label": "FAQ", "action": "message", "value": "See the wiki"},
+        {"label": "FAQ", "action": "ack", "value": "See the wiki"},
         {"label": "Wait", "action": "delay", "value": "3"},
         {"label": "Run", "action": "config", "value": "approve-flow"},
     ]
@@ -68,7 +68,7 @@ async def test_add_button_requires_an_action_keyword():
 
     assert channel.configs["default"]["buttons"] == []
     assert send.call_args.args[3] == (
-        "Invalid *button action* `approve-flow`. Must be one of `ack`, `config`, `delay`, `message`."
+        "Invalid *button action* `approve-flow`. Must be one of `ack`, `config`, `delay`."
     )
 
 
@@ -462,7 +462,7 @@ 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": "Yes", "action": "ack", "value": "Here is the help"},
         {"label": "No", "action": "ack", "value": ""},
     ]
     channel = _mk_channel({"src": src})
@@ -561,7 +561,8 @@ async def test_button_resolves_from_snapshot_and_strips_after_press():
     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?"
+    # The buttons are replaced by a note saying who took the message.
+    assert kw["ts"] == "10.1" and kw["text"] == "Approve?\n\n🔘 _`Ack` Bob_"
 
 
 @pytest.mark.asyncio
@@ -618,7 +619,7 @@ async def test_button_message_is_a_template_rendered_against_the_original_messag
         'posted_channel_id': "C1", 'message_ts': "R1", 'def_channel_id': "C1", 'config_name': "default",
         'orig': {'user_id': author.id, 'text': "the server is down", 'ts': "1786453297.645799", 'permalink': "https://slack.test/p1"},
     }
-    button = {'label': "help", 'action': "message",
+    button = {'label': "help", 'action': "ack",
               'value': "Help <@UAUTH> with {{message}} from {{date}} ({{user_name}}) — {{message_link}}"}
 
     with patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=author)), \
@@ -644,12 +645,12 @@ async def test_add_button_resolves_mentions_and_rejects_unknown_variables():
     with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
          patch('hutbot.slackcache.get_user_by_name', new=AsyncMock(return_value=author)), \
          patch('hutbot.messaging.send_message') as send:
-        await process_command(app, 'add button "help" message "Help @author with {{message}}"', channel, user)
+        await process_command(app, 'add button "help" ack "Help @author with {{message}}"', channel, user)
         assert config["buttons"] == [
-            {"label": "help", "action": "message", "value": "Help <@UAUTH> with {{message}}"}
+            {"label": "help", "action": "ack", "value": "Help <@UAUTH> with {{message}}"}
         ]
 
-        await process_command(app, 'add button "bad" message "{{nope}}"', channel, user)
+        await process_command(app, 'add button "bad" ack "{{nope}}"', channel, user)
         assert "unsupported template variable(s) `{{nope}}`" in send.call_args.args[3]
         # Nothing added for the rejected button.
         assert len(config["buttons"]) == 1
@@ -669,7 +670,7 @@ async def test_add_button_reports_an_unknown_mention():
     with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
          patch('hutbot.slackcache.get_user_by_name', new=AsyncMock(return_value=User(None, "ghost", "", "T"))), \
          patch('hutbot.messaging.send_message') as send:
-        await process_command(app, 'add button "help" message "Help @ghost"', channel, user)
+        await process_command(app, 'add button "help" ack "Help @ghost"', channel, user)
 
     assert send.call_args.args[3] == "Invalid *button* message: ghost not found."
     assert config["buttons"] == []
@@ -756,3 +757,100 @@ async def test_clear_escalation_warns_about_a_stranded_delay_button():
         "*Escalation* cleared in configuration `default`; buttons stay open until pressed "
         ":warning: (`Later` now has nothing to postpone)."
     )
+
+
+@pytest.mark.asyncio
+async def test_add_is_optional_for_button_commands():
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'button "Yes" ack "Got it"', channel, user)
+        await process_command(app, 'add button "FAQ" ack "See the wiki"', channel, user)
+        # A label alone is not a command.
+        await process_command(app, "button", channel, user)
+        assert "Huh?" in send.call_args.args[3]
+
+    assert config["buttons"] == [
+        {"label": "Yes", "action": "ack", "value": "Got it"},
+        {"label": "FAQ", "action": "ack", "value": "See the wiki"},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_a_config_named_button_still_gets_its_own_commands():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy(), "button": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        # `wait-time 5` is a command, so the leading word is the config.
+        await process_command(app, "button wait-time 5", channel, user)
+        # `"Yes" ack` is not, so this adds a button to `default`.
+        await process_command(app, 'button "Yes" ack', channel, user)
+
+    assert configs["button"]["wait_time"] == 300
+    assert configs["button"]["buttons"] == []
+    assert [b["label"] for b in configs["default"]["buttons"]] == ["Yes"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("button,expected", [
+    ({"label": "I've got it", "action": "ack", "value": "On it"}, "🔘 _`I've got it` Dave Grieser_"),
+    ({"label": "No", "action": "ack", "value": ""}, "🔘 _`No` Dave Grieser_"),
+    ({"label": "Page", "action": "config", "value": "alarm"}, "🔘 _`Page` Dave Grieser_ ▶️ _`alarm`_"),
+])
+async def test_a_press_leaves_a_note_in_place_of_the_buttons(button, expected):
+    import hutbot
+    app = AsyncMock()
+    channel = _mk_channel({"default": DEFAULT_CONFIG.copy(), "alarm": DEFAULT_CONFIG.copy()})
+    dave = User("U1", "dave", "Dave Grieser", "T")
+    key = ("C12345", "R1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "orig": {}, "posted_text": "Incident — on it?",
+        "posted_channel_id": "C12345", "message_ts": "R1", "def_channel_id": "C12345",
+        "config_name": "default", "buttons": [button],
+    }
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "R1"}, "user": {"id": "U1"}}
+    action = {"value": json.dumps({"channel": "C12345", "config": "default", "index": 0})}
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=dave)), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C12345", "ts": "R2"})), \
+         patch('hutbot.actions.run_action', new=AsyncMock()):
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+
+    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n{expected}"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("escalation,expected", [
+    ({"escalation_kind": "button", "escalation_target": "I've got it", "timeout": 60}, "⏰ _`1m`_"),
+    ({"escalation_kind": "config", "escalation_target": "alarm", "timeout": 300}, "⏰ _`5m`_ ▶️ _`alarm`_"),
+])
+async def test_an_escalation_leaves_a_note_in_place_of_the_buttons(escalation, expected):
+    import hutbot
+    app = AsyncMock()
+    channel = _mk_channel({"default": DEFAULT_CONFIG.copy(), "alarm": DEFAULT_CONFIG.copy()})
+    key = ("C12345", "R1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "orig": {}, "posted_text": "Incident — on it?",
+        "posted_channel_id": "C12345", "message_ts": "R1", "def_channel_id": "C12345",
+        "config_name": "default", "buttons": [{"label": "I've got it", "action": "ack", "value": "On it"}],
+        **escalation,
+    }
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U1", "dave", "Dave", "T"))), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C12345", "ts": "R2"})), \
+         patch('hutbot.actions.run_action', new=AsyncMock()):
+        await hutbot.buttons._escalation_task(app, "token", key, 0)
+
+    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n{expected}"
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
index 3d92cc6..31a704d 100644
--- a/tests/test_commands_info.py
+++ b/tests/test_commands_info.py
@@ -266,7 +266,7 @@ async def test_need_help_yes_no_workflow_end_to_end():
     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 "Yes" ack "Here is the help doc"', ch, u)
         await process_command(app, 'add button "No" ack', ch, u)
         await process_command(app, 'set escalation 5 button "Yes"', ch, u)
         cfg = ch.configs["default"]
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
index e349751..9dd023a 100644
--- a/tests/test_webui_backend.py
+++ b/tests/test_webui_backend.py
@@ -22,7 +22,7 @@ async def test_validate_config_payload_accepts_good_config():
         "escalation_target": "alarm",
         "buttons": [
             {"label": "Snooze", "action": "delay", "value": "10"},
-            {"label": "Note", "action": "message", "value": "Some message"},
+            {"label": "Note", "action": "ack", "value": "Some message"},
         ],
     }
 
@@ -49,7 +49,7 @@ async def test_validate_config_payload_accepts_good_config():
     assert cfg["escalation_target"] == "alarm"
     assert cfg["buttons"] == [
         {"label": "Snooze", "action": "delay", "value": "10"},
-        {"label": "Note", "action": "message", "value": "Some message"},
+        {"label": "Note", "action": "ack", "value": "Some message"},
     ]
     # the Slack client is never touched when caches are seeded and there are no @mentions.
     app.client.users_list.assert_not_called()
diff --git a/webui_static/app.js b/webui_static/app.js
index 9473856..916da5b 100644
--- a/webui_static/app.js
+++ b/webui_static/app.js
@@ -54,7 +54,7 @@ const TRIGGER_SHORT = { message: "message", cron: "cron", manual: "manual" };
 const ACTION_LABEL = { reply: "Reply in thread", dm_user: "Direct message", group_dm: "Group DM", post_channel: "Post to channel" };
 const ACTION_SHORT = { reply: "reply", dm_user: "dm", group_dm: "group dm", post_channel: "post" };
 const CONDITION_LABEL = { "": "None (always)", outlook_calendar: "Outlook calendar" };
-const BTN_ACTION_LABEL = { config: "Run rule", ack: "Acknowledge", message: "Post message", delay: "Delay timer" };
+const BTN_ACTION_LABEL = { config: "Run rule", ack: "Acknowledge / post text", delay: "Delay timer" };
 const ESCALATION_LABEL = { none: "Never escalate; buttons stay open", button: "Auto-press a button", config: "Run another rule" };
 const TARGET_HINT = { dm_user: "A @user (id, name, or email)", group_dm: "A @usergroup handle", post_channel: "A channel ID like C0123ABCD" };
 // Set by the bot itself when it is removed from a channel (see DISABLED_REASON_REMOVED).
@@ -520,7 +520,7 @@ function buttonsSection() {
   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 add = h("button", { class: "add-row", type: "button", onclick: () => { cfg.buttons = buttons.concat([{ label: "", action: "ack", value: "" }]); structuralRefresh(); } }, "+ Add button");
 
   // Escalation is one setting: minutes + what to escalate to. Picking "Never" hides
   // the rest, so the form cannot produce a timer with nothing to fire.
@@ -545,10 +545,9 @@ function buttonRow(btn, i) {
   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 });
+  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 });
+  else valueControl = h("input", { type: "text", value: btn.value || "", placeholder: "Optional message to post", oninput: onValue });
   const remove = h("div", { class: "drop" }, h("button", { class: "icon-btn", type: "button", title: "Remove button", "aria-label": "Remove button", onclick: () => { draft().buttons.splice(i, 1); structuralRefresh(); } }, "×"));
   const row = h("div", { class: "btn-row" }, labelI, actionSel, valueControl, remove);
   if (fieldErr(`buttons.${i}`)) { row.classList.add("has-error"); row.append(h("div", { class: "err row-err", text: fieldErr(`buttons.${i}`) })); }

From 956b8b10ff47b8fdb2a02cdfc6efe9c7ecf9d85f Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Sat, 15 Aug 2026 07:08:33 +0200
Subject: [PATCH 41/42] style(buttons): update button note formatting and
 emojis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Replace button icons (🔘, ⏰) with alternative symbols (▣, ⌛︎)
- Change config/code formatting from backticks to square brackets
- Update `▶️` arrow to `▶︎` for config actions
- Adjust markdown styling to wrap notes in italics
- Update corresponding tests and documentation to match new format
---
 README.md             |  4 ++--
 hutbot/buttons.py     |  8 ++++----
 tests/test_buttons.py | 12 ++++++------
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 1fc01d2..2074273 100644
--- a/README.md
+++ b/README.md
@@ -104,8 +104,8 @@ existing configs keep working unchanged.
   - A button/timeout that runs a config passes the **original message context** to it, so the target's
     templates and any OpsGenie alert reference the original message.
   - Once a message is handled, its buttons are removed and replaced by a one-line note of what
-    happened: 🔘 *`I've got it` Dave Grieser*, 🔘 *`Page` Dave Grieser* ▶️ *`alarm`* for a press, and
-    ⏰ *`1m`* or ⏰ *`5m`* ▶️ *`alarm`* when the escalation acted instead.
+    happened: *▣ [I've got it] Dave Grieser* or *▣ [Page] Dave Grieser ▶︎ [alarm]* for a press, and
+    *⌛︎ [1m]* or *⌛︎ [5m] ▶︎ [alarm]* when the escalation acted instead.
 
 - **"Need help?" example** — a question that defaults to "Yes" if ignored:
   ```bash
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index 27cff60..c9036f6 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -322,19 +322,19 @@ def _ran_config(button: dict) -> str:
 
 
 def _ran_suffix(ran: str) -> str:
-    """`▶️ \u0060config\u0060`, with the emoji outside the italics."""
-    return f" ▶️ _`{ran}`_" if ran else ""
+    """The config a press or a timeout ran, if any."""
+    return f" ▶︎ [{ran}]" if ran else ""
 
 
 def _press_note(button: dict, presser: User | None) -> str:
     """What the message says in place of its buttons after somebody pressed one."""
     who = (presser.real_name or presser.name or '?') if presser else 'Someone'
-    return f"🔘 _`{button.get('label') or '?'}` {who}_{_ran_suffix(_ran_config(button))}"
+    return f"_▣ [{button.get('label') or '?'}] {who}{_ran_suffix(_ran_config(button))}_"
 
 
 def _timeout_note(timeout: float, ran: str = "") -> str:
     """…and what it says when the escalation acted instead of a person."""
-    return f"⏰ _`{int((timeout or 0) // 60)}m`_{_ran_suffix(ran)}"
+    return f"_⌛︎ [{int((timeout or 0) // 60)}m]{_ran_suffix(ran)}_"
 
 
 async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str, entry: dict | None, note: str = "") -> None:
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index 9f1e11d..a02101e 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -562,7 +562,7 @@ async def test_button_resolves_from_snapshot_and_strips_after_press():
     app.client.chat_update.assert_awaited_once()               # buttons stripped
     kw = app.client.chat_update.await_args.kwargs
     # The buttons are replaced by a note saying who took the message.
-    assert kw["ts"] == "10.1" and kw["text"] == "Approve?\n\n🔘 _`Ack` Bob_"
+    assert kw["ts"] == "10.1" and kw["text"] == "Approve?\n\n_▣ [Ack] Bob_"
 
 
 @pytest.mark.asyncio
@@ -799,9 +799,9 @@ async def test_a_config_named_button_still_gets_its_own_commands():
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("button,expected", [
-    ({"label": "I've got it", "action": "ack", "value": "On it"}, "🔘 _`I've got it` Dave Grieser_"),
-    ({"label": "No", "action": "ack", "value": ""}, "🔘 _`No` Dave Grieser_"),
-    ({"label": "Page", "action": "config", "value": "alarm"}, "🔘 _`Page` Dave Grieser_ ▶️ _`alarm`_"),
+    ({"label": "I've got it", "action": "ack", "value": "On it"}, "_▣ [I've got it] Dave Grieser_"),
+    ({"label": "No", "action": "ack", "value": ""}, "_▣ [No] Dave Grieser_"),
+    ({"label": "Page", "action": "config", "value": "alarm"}, "_▣ [Page] Dave Grieser ▶︎ [alarm]_"),
 ])
 async def test_a_press_leaves_a_note_in_place_of_the_buttons(button, expected):
     import hutbot
@@ -830,8 +830,8 @@ async def test_a_press_leaves_a_note_in_place_of_the_buttons(button, expected):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("escalation,expected", [
-    ({"escalation_kind": "button", "escalation_target": "I've got it", "timeout": 60}, "⏰ _`1m`_"),
-    ({"escalation_kind": "config", "escalation_target": "alarm", "timeout": 300}, "⏰ _`5m`_ ▶️ _`alarm`_"),
+    ({"escalation_kind": "button", "escalation_target": "I've got it", "timeout": 60}, "_⌛︎ [1m]_"),
+    ({"escalation_kind": "config", "escalation_target": "alarm", "timeout": 300}, "_⌛︎ [5m] ▶︎ [alarm]_"),
 ])
 async def test_an_escalation_leaves_a_note_in_place_of_the_buttons(escalation, expected):
     import hutbot

From 3b8e74ef782de20a54f5b089feb0cc58a98e47b7 Mon Sep 17 00:00:00 2001
From: David Grieser <d.grieser@mittwald.de>
Date: Sat, 15 Aug 2026 07:22:12 +0200
Subject: [PATCH 42/42] fix(buttons): update button note format and separator

- Change press/timeout notes to place the user name before the action label (e.g., "Dave: [Ack]" instead of "[Ack] Dave").
- Remove square brackets around timeout durations and config names in notes.
- Add a horizontal rule separator between the original message and the action note for better visual distinction.
- Update tests to reflect the new formatting and separator.
---
 README.md             |  4 ++--
 hutbot/buttons.py     |  9 +++++----
 tests/test_buttons.py | 16 ++++++++--------
 3 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 2074273..d5ef24a 100644
--- a/README.md
+++ b/README.md
@@ -104,8 +104,8 @@ existing configs keep working unchanged.
   - A button/timeout that runs a config passes the **original message context** to it, so the target's
     templates and any OpsGenie alert reference the original message.
   - Once a message is handled, its buttons are removed and replaced by a one-line note of what
-    happened: *▣ [I've got it] Dave Grieser* or *▣ [Page] Dave Grieser ▶︎ [alarm]* for a press, and
-    *⌛︎ [1m]* or *⌛︎ [5m] ▶︎ [alarm]* when the escalation acted instead.
+    happened: *Dave Grieser: [I've got it]* or *Dave Grieser: [Page] ▶︎ alarm* for a press, and
+    *⌛︎ 1m* or *⌛︎ 5m ▶︎ alarm* when the escalation acted instead.
 
 - **"Need help?" example** — a question that defaults to "Yes" if ignored:
   ```bash
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
index c9036f6..bfdab4d 100644
--- a/hutbot/buttons.py
+++ b/hutbot/buttons.py
@@ -323,18 +323,18 @@ def _ran_config(button: dict) -> str:
 
 def _ran_suffix(ran: str) -> str:
     """The config a press or a timeout ran, if any."""
-    return f" ▶︎ [{ran}]" if ran else ""
+    return f" ▶︎ {ran}" if ran else ""
 
 
 def _press_note(button: dict, presser: User | None) -> str:
     """What the message says in place of its buttons after somebody pressed one."""
     who = (presser.real_name or presser.name or '?') if presser else 'Someone'
-    return f"_▣ [{button.get('label') or '?'}] {who}{_ran_suffix(_ran_config(button))}_"
+    return f"_{who}: [{button.get('label') or '?'}]{_ran_suffix(_ran_config(button))}_"
 
 
 def _timeout_note(timeout: float, ran: str = "") -> str:
     """…and what it says when the escalation acted instead of a person."""
-    return f"_⌛︎ [{int((timeout or 0) // 60)}m]{_ran_suffix(ran)}_"
+    return f"_⌛︎ {int((timeout or 0) // 60)}m{_ran_suffix(ran)}_"
 
 
 async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str, entry: dict | None, note: str = "") -> None:
@@ -345,7 +345,8 @@ async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str,
     posted_text = (entry or {}).get('posted_text')
     if not posted_text or not posted_channel_id or not message_ts:
         return
-    text = f"{posted_text}\n\n{note}" if note else posted_text
+    # A plain rule separates the note from the message it belongs to.
+    text = f"{posted_text}\n\n---\n{note}" if note else posted_text
     try:
         await app.client.chat_update(
             channel=posted_channel_id,
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
index a02101e..189db69 100644
--- a/tests/test_buttons.py
+++ b/tests/test_buttons.py
@@ -562,7 +562,7 @@ async def test_button_resolves_from_snapshot_and_strips_after_press():
     app.client.chat_update.assert_awaited_once()               # buttons stripped
     kw = app.client.chat_update.await_args.kwargs
     # The buttons are replaced by a note saying who took the message.
-    assert kw["ts"] == "10.1" and kw["text"] == "Approve?\n\n_▣ [Ack] Bob_"
+    assert kw["ts"] == "10.1" and kw["text"] == "Approve?\n\n---\n_Bob: [Ack]_"
 
 
 @pytest.mark.asyncio
@@ -799,9 +799,9 @@ async def test_a_config_named_button_still_gets_its_own_commands():
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("button,expected", [
-    ({"label": "I've got it", "action": "ack", "value": "On it"}, "_▣ [I've got it] Dave Grieser_"),
-    ({"label": "No", "action": "ack", "value": ""}, "_▣ [No] Dave Grieser_"),
-    ({"label": "Page", "action": "config", "value": "alarm"}, "_▣ [Page] Dave Grieser ▶︎ [alarm]_"),
+    ({"label": "I've got it", "action": "ack", "value": "On it"}, "_Dave Grieser: [I've got it]_"),
+    ({"label": "No", "action": "ack", "value": ""}, "_Dave Grieser: [No]_"),
+    ({"label": "Page", "action": "config", "value": "alarm"}, "_Dave Grieser: [Page] ▶︎ alarm_"),
 ])
 async def test_a_press_leaves_a_note_in_place_of_the_buttons(button, expected):
     import hutbot
@@ -825,13 +825,13 @@ async def test_a_press_leaves_a_note_in_place_of_the_buttons(button, expected):
          patch('hutbot.actions.run_action', new=AsyncMock()):
         await hutbot.buttons.handle_button_press(app, "token", body, action)
 
-    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n{expected}"
+    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n---\n{expected}"
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("escalation,expected", [
-    ({"escalation_kind": "button", "escalation_target": "I've got it", "timeout": 60}, "_⌛︎ [1m]_"),
-    ({"escalation_kind": "config", "escalation_target": "alarm", "timeout": 300}, "_⌛︎ [5m] ▶︎ [alarm]_"),
+    ({"escalation_kind": "button", "escalation_target": "I've got it", "timeout": 60}, "_⌛︎ 1m_"),
+    ({"escalation_kind": "config", "escalation_target": "alarm", "timeout": 300}, "_⌛︎ 5m ▶︎ alarm_"),
 ])
 async def test_an_escalation_leaves_a_note_in_place_of_the_buttons(escalation, expected):
     import hutbot
@@ -853,4 +853,4 @@ async def test_an_escalation_leaves_a_note_in_place_of_the_buttons(escalation, e
          patch('hutbot.actions.run_action', new=AsyncMock()):
         await hutbot.buttons._escalation_task(app, "token", key, 0)
 
-    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n{expected}"
+    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n---\n{expected}"