diff --git a/CLAUDE.md b/CLAUDE.md
index ba8b906..655a735 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -37,6 +37,7 @@ title-bar controls). The rules that matter most:
 - Verify against the guide's testing section and resilience checklist. Mocks
   for the existing upstreams: `node tools/prodcom-mock.js` (ProdCom) and
   `node band-lineup-display/tmp/pp-mock.js 1599` (ProPresenter).
+  `node tools/slack-mock.js 24716` (Slack; run ProdDash with `SLACK_API_BASE=http://127.0.0.1:24716/api`).
 
 ## Reference code (read-only forks — don't develop these here)
 
diff --git a/docs/MODULE-GUIDE.md b/docs/MODULE-GUIDE.md
index 7593f1a..71969b5 100644
--- a/docs/MODULE-GUIDE.md
+++ b/docs/MODULE-GUIDE.md
@@ -104,7 +104,7 @@ the app); its settings are kept for a later reinstall.
 Both schemas map field names to specs:
 
 ```
-{ "type": "string" | "number" | "boolean" | "switch" | "select" | "color" | "password" | "endpoint",
+{ "type": "string" | "text" | "number" | "boolean" | "switch" | "select" | "color" | "password" | "endpoint",
   "label": "Shown next to the field",
   "default": <value>,
   "group": "Section heading",                         // optional; see below
@@ -125,6 +125,9 @@ shown or enabled, off means hidden or disabled, and the label shouldn't say
 so twice.
 `color` renders a swatch picker and stores a `#rrggbb` string (give it a hex
 default; the tile applies it as a CSS custom property — see `pco-plan`).
+`text` is a multi-line string — a `<textarea>` in the admin page, stored with
+its newlines; one item per line is the convention (the `slack` module's quick
+replies). Admin config only.
 
 `group` gathers consecutive fields under a labeled subsection in the admin
 page, so a module with several distinct concerns (e.g. a ProPresenter
diff --git a/modules/slack/client.js b/modules/slack/client.js
new file mode 100644
index 0000000..761e243
--- /dev/null
+++ b/modules/slack/client.js
@@ -0,0 +1,765 @@
+/* Slack — client part.
+
+   Three tiles from one module (moduleApi.variant picks): the channel
+   transcript, a PIN-gated free-text sender and a PIN-gated grid of preset
+   replies. Everything lives inside the tile's root; all traffic goes through
+   the module's server routes (the token and the PIN never reach a browser).
+   Nothing here uses innerHTML with data — every string from Slack lands in
+   a text node. */
+
+/* ── shared helpers ─────────────────────────────────────────────────── */
+
+function el(tag, cls, text) {
+  const node = document.createElement(tag);
+  if (cls) node.className = cls;
+  if (text !== undefined) node.textContent = text;
+  return node;
+}
+
+function fmtTime(ms) {
+  const d = new Date(ms);
+  return isNaN(d) ? '' : d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
+}
+
+/* Inline marks the server left in the text: ```code``` `code` *bold*
+   _italic_ ~strike~. Openers must not sit inside a word (snake_case_names
+   and 5 * 3 * 2 stay as they are). Built with DOM nodes, so any character
+   in a message is safe. */
+const MARK_RE = /(```[\s\S]*?```|`[^`\n]+`|(?<![\w*])\*(?!\s)[^*\n]*?(?<!\s)\*(?![\w*])|(?<![\w_])_(?!\s)[^_\n]*?(?<!\s)_(?![\w_])|(?<![\w~])~(?!\s)[^~\n]*?(?<!\s)~(?![\w~]))/g;
+
+function renderRich(container, text, depth = 0) {
+  container.textContent = '';
+  const s = String(text || '');
+  let last = 0;
+  if (depth < 3) {
+    for (const m of s.matchAll(MARK_RE)) {
+      if (m.index > last) container.appendChild(document.createTextNode(s.slice(last, m.index)));
+      const tok = m[0];
+      let node;
+      if (tok.startsWith('```')) {
+        node = el('span', 'sl-code sl-block', tok.slice(3, -3).replace(/^\n+|\n+$/g, ''));
+      } else if (tok.startsWith('`')) {
+        node = el('code', 'sl-code', tok.slice(1, -1));
+      } else {
+        node = el(tok.startsWith('*') ? 'b' : tok.startsWith('_') ? 'i' : 's');
+        renderRich(node, tok.slice(1, -1), depth + 1);
+      }
+      container.appendChild(node);
+      last = m.index + tok.length;
+    }
+  }
+  if (last < s.length) container.appendChild(document.createTextNode(s.slice(last)));
+}
+
+function textSizePx(moduleApi, fallback = 14) {
+  return Math.min(48, Math.max(10, Number(moduleApi.instanceSettings.textSize) || fallback));
+}
+
+async function readJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return {};
+  }
+}
+
+const LOCK_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="5" y="11" width="14" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></svg>';
+const JUMP_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 4v11"/><path d="m7 10 5 5 5-5"/><path d="M5 20h14"/></svg>';
+const BACK_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 6H8l-5 6 5 6h13a1 1 0 0 0 1-1V7a1 1 0 0 0-1-1z"/><path d="m18 9-6 6M12 9l6 6"/></svg>';
+const CHECK_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m5 12 5 5L20 7"/></svg>';
+
+/* ── the factory ────────────────────────────────────────────────────── */
+
+export default function create({ root, moduleApi }) {
+  const view = String(moduleApi.variant || moduleApi.instanceSettings.view || 'transcript');
+  if (view === 'send' || view === 'quick') return createSendTile({ root, moduleApi, mode: view });
+  return createTranscriptTile({ root, moduleApi });
+}
+
+/* ── transcript ─────────────────────────────────────────────────────── */
+
+function createTranscriptTile({ root, moduleApi }) {
+  const entries = new Map(); // ts -> { el, sig, ... }
+  let pinnedToLatest = true;
+  let painted = false;
+  let stream = null;
+  let stopped = false;
+
+  root.innerHTML = `
+    <div class="sl-wrap sl-transcript">
+      <div class="sl-banner" hidden></div>
+      <div class="sl-stream">
+        <div class="sl-empty">Connecting to Slack…</div>
+        <div class="sl-entries"></div>
+      </div>
+      <button class="sl-jump" hidden>↓ New messages</button>
+    </div>`;
+  const wrap = root.querySelector('.sl-wrap');
+  const banner = root.querySelector('.sl-banner');
+  const streamEl = root.querySelector('.sl-stream');
+  const entriesEl = root.querySelector('.sl-entries');
+  const emptyEl = root.querySelector('.sl-empty');
+  const jumpBtn = root.querySelector('.sl-jump');
+
+  /* title-bar controls */
+  function bumpTextSize(delta) {
+    moduleApi.saveInstanceSettings({ textSize: Math.min(48, Math.max(10, textSizePx(moduleApi) + delta)) });
+    applyInstanceSettings();
+  }
+  moduleApi.header.addButton({ label: 'A−', title: 'Smaller text', onClick: () => bumpTextSize(-1) });
+  moduleApi.header.addButton({ label: 'A+', title: 'Larger text', onClick: () => bumpTextSize(1) });
+  moduleApi.header.addButton({
+    icon: JUMP_SVG,
+    title: 'Jump to latest',
+    onClick() {
+      pinnedToLatest = true;
+      jumpBtn.hidden = true;
+      scrollToLatest();
+    },
+  });
+
+  function applyInstanceSettings() {
+    const s = moduleApi.instanceSettings;
+    wrap.style.setProperty('--sl-size', textSizePx(moduleApi) + 'px');
+    wrap.classList.toggle('show-times', s.showTimes !== false);
+    wrap.classList.toggle('show-names', s.showNames !== false);
+    wrap.classList.toggle('show-system', s.showSystem !== false);
+    if (pinnedToLatest) scrollToLatest();
+  }
+  applyInstanceSettings();
+
+  /* scrolling */
+  streamEl.addEventListener('scroll', () => {
+    const near = streamEl.scrollHeight - streamEl.scrollTop - streamEl.clientHeight < 60;
+    pinnedToLatest = near;
+    if (near) jumpBtn.hidden = true;
+  });
+  jumpBtn.addEventListener('click', () => {
+    pinnedToLatest = true;
+    jumpBtn.hidden = true;
+    scrollToLatest();
+  });
+  function scrollToLatest() {
+    streamEl.scrollTop = streamEl.scrollHeight;
+  }
+
+  /* entries */
+  function buildMeta(m) {
+    const meta = el('div', 'sl-meta');
+    meta.append(el('span', 'sl-name', m.name || ''), el('span', 'sl-time', fmtTime(m.time)));
+    return meta;
+  }
+
+  function buildLine(m) {
+    // A message or a thread reply: name + time, then the text.
+    const line = el('div', m.parent ? 'sl-reply' : 'sl-msg');
+    line.classList.toggle('sl-me', Boolean(m.me));
+    line.classList.toggle('sl-bot', Boolean(m.bot));
+    line.appendChild(buildMeta(m));
+    const text = el('div', 'sl-text');
+    renderRich(text, m.text);
+    if (m.edited) text.appendChild(el('span', 'sl-edited', ' (edited)'));
+    line.appendChild(text);
+    return line;
+  }
+
+  function buildEntry(m) {
+    const node = el('div', 'sl-entry');
+    node.dataset.ts = m.ts;
+    return { el: node, sig: '' };
+  }
+
+  function fillEntry(entry, m) {
+    const sig = JSON.stringify(m);
+    if (sig === entry.sig) return;
+    entry.sig = sig;
+    const node = entry.el;
+    node.textContent = '';
+    node.classList.toggle('sl-system', Boolean(m.system));
+    node.classList.toggle('sl-me', Boolean(m.me));
+    if (m.system) {
+      const line = el('div', 'sl-sysline');
+      line.append(el('span', 'sl-time', fmtTime(m.time)), el('span', 'sl-systext', m.text || ''));
+      node.appendChild(line);
+      return;
+    }
+    node.appendChild(buildLine(m));
+    if (Array.isArray(m.replies)) {
+      if (m.replies.length) {
+        const list = el('div', 'sl-replies');
+        for (const r of m.replies) list.appendChild(buildLine(r));
+        node.appendChild(list);
+      }
+    } else if (m.replyCount > 0) {
+      node.appendChild(el('div', 'sl-replycount', `${m.replyCount} ${m.replyCount === 1 ? 'reply' : 'replies'}`));
+    }
+  }
+
+  function renderMessages(list) {
+    const seen = new Set();
+    let prev = null;
+    let added = 0;
+    for (const m of list) {
+      if (!m || !m.ts) continue;
+      seen.add(m.ts);
+      let entry = entries.get(m.ts);
+      if (!entry) {
+        entry = buildEntry(m);
+        entries.set(m.ts, entry);
+        if (painted) entry.el.classList.add('sl-new');
+        added += 1;
+      }
+      fillEntry(entry, m);
+      const node = entry.el;
+      // Keep DOM order equal to list order without re-inserting settled nodes
+      // (a move would replay the fade-in).
+      if (prev ? node.previousElementSibling !== prev : node !== entriesEl.firstElementChild) {
+        if (prev) prev.after(node);
+        else entriesEl.prepend(node);
+      }
+      prev = node;
+    }
+    for (const [ts, entry] of entries) {
+      if (seen.has(ts)) continue;
+      entry.el.remove();
+      entries.delete(ts);
+    }
+    if (pinnedToLatest) scrollToLatest();
+    else if (added) jumpBtn.hidden = false;
+  }
+
+  function applyState(s) {
+    if (stopped || !s || typeof s !== 'object') return;
+    const st = s.status || {};
+    const chan = s.channel?.name ? '#' + s.channel.name : '';
+    const who = s.identity?.name ? ` as ${s.identity.name}` : '';
+    renderMessages(Array.isArray(s.messages) ? s.messages : []);
+    const hasEntries = entries.size > 0;
+    if (st.state === 'ok') {
+      moduleApi.setStatus('ok', `Live — ${chan}${who}`);
+      banner.hidden = true;
+    } else {
+      moduleApi.setStatus(st.state === 'error' ? 'error' : 'connecting', st.message || 'Connecting to Slack…');
+      // With messages on screen the problem rides in a banner; with none,
+      // the empty state says it, once.
+      banner.textContent = st.message || 'Connecting to Slack…';
+      banner.classList.toggle('is-error', st.state === 'error');
+      banner.hidden = !hasEntries;
+    }
+    emptyEl.hidden = hasEntries;
+    if (!hasEntries) {
+      emptyEl.textContent = st.state !== 'ok'
+        ? (st.message || 'Connecting to Slack…')
+        : chan ? `No messages yet in ${chan}` : 'No channel chosen — pick one in Admin → Slack';
+      emptyEl.classList.toggle('is-error', st.state === 'error');
+    }
+    painted = true;
+  }
+
+  async function loadState() {
+    try {
+      const res = await moduleApi.fetch('/state');
+      if (!res.ok) throw new Error(String(res.status));
+      applyState(await res.json());
+    } catch {
+      /* the stream's next frame paints; the error handler reports the outage */
+    }
+  }
+
+  function connect() {
+    stream = moduleApi.sse('/stream', {
+      open() {
+        // Tiles share one stream; a late joiner missed its first frame, and a
+        // reconnect may have missed changes — a snapshot covers both.
+        loadState();
+      },
+      error() {
+        moduleApi.setStatus('error', 'ProdDash Slack module unreachable — reconnecting…');
+        banner.textContent = 'ProdDash Slack module unreachable — reconnecting…';
+        banner.classList.add('is-error');
+        banner.hidden = entries.size === 0;
+        if (!entries.size) {
+          emptyEl.textContent = 'ProdDash Slack module unreachable — reconnecting…';
+          emptyEl.classList.add('is-error');
+        }
+      },
+      events: {
+        state(e) {
+          try {
+            applyState(JSON.parse(e.data));
+          } catch { /* a bad frame is skipped */ }
+        },
+      },
+    });
+  }
+
+  return {
+    start() {
+      moduleApi.setStatus('connecting', 'Connecting to Slack…');
+      connect();
+    },
+    stop() {
+      stopped = true;
+      stream?.close();
+      root.innerHTML = ''; // header controls are removed by the shell
+    },
+    onResize() {
+      if (pinnedToLatest) scrollToLatest();
+    },
+  };
+}
+
+/* ── send + quick replies ───────────────────────────────────────────── */
+
+function createSendTile({ root, moduleApi, mode }) {
+  let token = '';          // the unlock token — memory only; a remount shows the pad again
+  let expiresAt = 0;
+  let state = null;        // latest snapshot: sending flags, identity, channel, status
+  let stream = null;
+  let ticker = null;
+  let stopped = false;
+  let busy = false;
+  let pinBuf = '';
+  let gateNote = '';       // one line under the pad ("Locked after inactivity")
+  let gateError = '';      // the server's refusal ("Wrong PIN", "locked for 30 s")
+  let gateKind = '';       // what the gate currently shows, to avoid needless rebuilds
+  let presets = null;
+
+  root.innerHTML = `
+    <div class="sl-wrap sl-send" tabindex="0">
+      <div class="sl-gate"></div>
+      <div class="sl-compose" hidden></div>
+    </div>`;
+  const wrap = root.querySelector('.sl-wrap');
+  const gate = root.querySelector('.sl-gate');
+  const compose = root.querySelector('.sl-compose');
+
+  const lockBtn = moduleApi.header.addButton({ icon: LOCK_SVG, title: 'Lock now', onClick: () => lock('Locked') });
+  lockBtn.style.display = 'none';
+
+  function applyInstanceSettings() {
+    wrap.style.setProperty('--sl-size', textSizePx(moduleApi) + 'px');
+  }
+  applyInstanceSettings();
+
+  function sendingLine() {
+    const who = state?.sendingAs || '…';
+    const chan = state?.channel?.name ? '#' + state.channel.name : 'no channel';
+    return `Sending as ${who} → ${chan}`;
+  }
+
+  function authHeaders(extra = {}) {
+    return { Authorization: `Bearer ${token}`, ...extra };
+  }
+
+  /* ── the gate: a PIN pad, or the reason there isn't one ── */
+  function renderGate() {
+    compose.hidden = true;
+    gate.hidden = false;
+    lockBtn.style.display = 'none';
+    let kind;
+    if (!state) kind = 'connecting';
+    else if (!state.sending?.enabled) kind = 'off';
+    else if (!state.sending?.pinSet) kind = 'nopin';
+    else kind = 'pad';
+    if (kind !== gateKind) {
+      gateKind = kind;
+      gate.textContent = '';
+      if (kind === 'pad') gate.appendChild(buildPad());
+      else {
+        const note = el('div', 'sl-note');
+        note.textContent = kind === 'connecting' ? 'Connecting to ProdDash…'
+          : kind === 'off' ? 'Sending is off — turn it on in Admin → Slack → Sending'
+            : 'Set a PIN in Admin → Slack → Sending';
+        gate.appendChild(note);
+      }
+    }
+    if (kind === 'pad') refreshPad();
+  }
+
+  let padEls = null;
+  function buildPad() {
+    const pad = el('div', 'sl-pad');
+    const head = el('div', 'sl-pad-head');
+    head.append(el('b', '', 'Enter PIN'), el('span', 'sl-pad-sub'));
+    const dots = el('div', 'sl-dots');
+    for (let i = 0; i < 8; i += 1) dots.appendChild(el('span', 'sl-dot'));
+    const keys = el('div', 'sl-keys');
+    const key = (label, cls, onClick, html) => {
+      const b = el('button', 'sl-key' + (cls ? ' ' + cls : ''));
+      b.type = 'button';
+      if (html) b.innerHTML = html; // our own SVG constants only
+      else b.textContent = label;
+      b.addEventListener('click', (e) => {
+        e.preventDefault();
+        onClick();
+        wrap.focus({ preventScroll: true });
+      });
+      return b;
+    };
+    for (const d of ['1', '2', '3', '4', '5', '6', '7', '8', '9']) keys.appendChild(key(d, '', () => pressDigit(d)));
+    const back = key('⌫', 'sl-key-back', () => { pinBuf = pinBuf.slice(0, -1); gateError = ''; refreshPad(); }, BACK_SVG);
+    back.title = 'Backspace';
+    keys.appendChild(back);
+    keys.appendChild(key('0', '', () => pressDigit('0')));
+    const ok = key('Unlock', 'sl-key-ok', submitPin, CHECK_SVG);
+    ok.title = 'Unlock';
+    keys.appendChild(ok);
+    const msg = el('div', 'sl-pad-msg');
+    pad.append(head, dots, keys, msg);
+    padEls = { pad, sub: head.lastChild, dots, msg, ok };
+    return pad;
+  }
+
+  function refreshPad() {
+    if (!padEls) return;
+    padEls.sub.textContent = ` · ${sendingLine().replace(/^Sending/, 'sending')}`;
+    const n = Math.min(8, pinBuf.length);
+    [...padEls.dots.children].forEach((d, i) => {
+      d.classList.toggle('on', i < n);
+      // Show as many slots as could still be typed: 4 minimum, up to 8.
+      d.hidden = i >= Math.max(4, n + (n < 8 ? 1 : 0));
+    });
+    padEls.ok.disabled = pinBuf.length < 4 || busy;
+    padEls.msg.textContent = gateError || gateNote;
+    padEls.msg.classList.toggle('is-error', Boolean(gateError));
+  }
+
+  function pressDigit(d) {
+    if (busy || pinBuf.length >= 8) return;
+    pinBuf += d;
+    gateError = '';
+    refreshPad();
+    if (pinBuf.length === 8) submitPin();
+  }
+
+  function shake(message) {
+    gateError = message;
+    gateNote = '';
+    pinBuf = '';
+    refreshPad();
+    if (!padEls) return;
+    padEls.pad.classList.remove('sl-shake');
+    // restart the animation
+    void padEls.pad.offsetWidth;
+    padEls.pad.classList.add('sl-shake');
+  }
+
+  async function submitPin() {
+    if (busy || pinBuf.length < 4) return;
+    busy = true;
+    refreshPad();
+    try {
+      const res = await moduleApi.fetch('/unlock', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ pin: pinBuf }),
+      });
+      const body = await readJson(res);
+      if (!res.ok || !body.token) {
+        shake(body.error || `Could not unlock (HTTP ${res.status})`);
+        return;
+      }
+      token = String(body.token);
+      expiresAt = Number(body.expiresAt) || Date.now() + 10 * 60000;
+      pinBuf = '';
+      gateError = '';
+      gateNote = '';
+      await showCompose();
+    } catch {
+      shake('ProdDash unreachable — try again');
+    } finally {
+      busy = false;
+      refreshPad();
+    }
+  }
+
+  wrap.addEventListener('keydown', (e) => {
+    if (!gate.hidden && gateKind === 'pad') {
+      if (/^[0-9]$/.test(e.key)) { e.preventDefault(); pressDigit(e.key); }
+      else if (e.key === 'Backspace') { e.preventDefault(); pinBuf = pinBuf.slice(0, -1); gateError = ''; refreshPad(); }
+      else if (e.key === 'Enter') { e.preventDefault(); submitPin(); }
+      else if (e.key === 'Escape') { pinBuf = ''; gateError = ''; refreshPad(); }
+    }
+  });
+
+  /* ── unlocked: compose or the preset grid ── */
+  let composeEls = null;
+  function buildCompose() {
+    compose.textContent = '';
+    const head = el('div', 'sl-compose-head');
+    const line = el('span', 'sl-sending', sendingLine());
+    const lockLink = el('button', 'sl-lock-link', 'Lock');
+    lockLink.type = 'button';
+    lockLink.title = 'Lock now';
+    lockLink.addEventListener('click', () => lock('Locked'));
+    head.append(line, lockLink);
+    compose.appendChild(head);
+
+    const foot = el('div', 'sl-compose-foot');
+    const msg = el('div', 'sl-msg');
+    const countdown = el('span', 'sl-countdown');
+    countdown.hidden = true;
+    let input = null;
+    let sendBtn = null;
+    let grid = null;
+
+    if (mode === 'send') {
+      input = el('textarea', 'sl-input');
+      input.rows = 3;
+      input.placeholder = state?.channel?.name ? `Message #${state.channel.name}…` : 'Message…';
+      input.spellcheck = true;
+      input.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+          e.preventDefault();
+          sendText();
+        }
+      });
+      compose.appendChild(input);
+      sendBtn = el('button', 'sl-sendbtn', 'Send');
+      sendBtn.type = 'button';
+      sendBtn.addEventListener('click', sendText);
+      foot.append(msg, countdown, sendBtn);
+    } else {
+      grid = el('div', 'sl-grid');
+      compose.appendChild(grid);
+      foot.append(msg, countdown);
+    }
+    compose.appendChild(foot);
+    composeEls = { line, msg, countdown, input, sendBtn, grid };
+  }
+
+  async function showCompose() {
+    buildCompose();
+    gate.hidden = true;
+    compose.hidden = false;
+    lockBtn.style.display = '';
+    moduleApi.setStatus(statusState(), `${statusMessage()} · unlocked`);
+    if (mode === 'quick') await loadPresets();
+    else composeEls.input?.focus();
+    tickLock();
+  }
+
+  function flash(text) {
+    if (!composeEls) return;
+    composeEls.msg.textContent = text;
+    composeEls.msg.className = 'sl-msg is-flash';
+    clearTimeout(flash.timer);
+    flash.timer = setTimeout(() => {
+      if (composeEls && composeEls.msg.textContent === text) {
+        composeEls.msg.textContent = '';
+        composeEls.msg.className = 'sl-msg';
+      }
+    }, 1800);
+  }
+
+  function showError(text) {
+    if (!composeEls) return;
+    clearTimeout(flash.timer);
+    composeEls.msg.textContent = text;
+    composeEls.msg.className = 'sl-msg is-error';
+  }
+
+  async function sendText() {
+    if (busy || !composeEls?.input) return;
+    const text = composeEls.input.value.trim();
+    if (!text) return;
+    busy = true;
+    composeEls.sendBtn.disabled = true;
+    try {
+      const res = await moduleApi.fetch('/send', {
+        method: 'POST',
+        headers: authHeaders({ 'Content-Type': 'application/json' }),
+        body: JSON.stringify({ text }),
+      });
+      const body = await readJson(res);
+      if (res.status === 401) return void lock(body.error || 'Locked — enter the PIN', true);
+      if (!res.ok) return void showError(body.error || `Send failed (HTTP ${res.status})`);
+      composeEls.input.value = '';
+      if (body.expiresAt) expiresAt = Number(body.expiresAt);
+      flash('Sent ✓');
+    } catch {
+      showError('ProdDash unreachable — not sent');
+    } finally {
+      busy = false;
+      if (composeEls?.sendBtn) {
+        composeEls.sendBtn.disabled = false;
+        composeEls.input?.focus();
+      }
+    }
+  }
+
+  async function loadPresets() {
+    if (!composeEls?.grid) return;
+    composeEls.grid.textContent = '';
+    composeEls.grid.appendChild(el('div', 'sl-note', 'Loading…'));
+    try {
+      const res = await moduleApi.fetch('/quick', { headers: authHeaders() });
+      const body = await readJson(res);
+      if (res.status === 401) return void lock(body.error || 'Locked — enter the PIN', true);
+      if (!res.ok) throw new Error(body.error || `HTTP ${res.status}`);
+      presets = Array.isArray(body.presets) ? body.presets : [];
+      if (body.expiresAt) expiresAt = Number(body.expiresAt);
+      renderPresets();
+    } catch (err) {
+      composeEls.grid.textContent = '';
+      const note = el('div', 'sl-note is-error', `Could not load quick replies — ${err.message}`);
+      composeEls.grid.appendChild(note);
+    }
+  }
+
+  function renderPresets() {
+    if (!composeEls?.grid) return;
+    const grid = composeEls.grid;
+    grid.textContent = '';
+    if (!presets.length) {
+      grid.appendChild(el('div', 'sl-note', 'No quick replies yet — add some in Admin → Slack → Sending'));
+      return;
+    }
+    for (const p of presets) {
+      const b = el('button', 'sl-quick');
+      b.type = 'button';
+      b.appendChild(el('span', 'sl-quick-label', p.label));
+      if (p.channel) b.appendChild(el('span', 'sl-quick-chan', `→ ${p.channel}`));
+      b.addEventListener('click', () => sendQuick(p.index, b));
+      grid.appendChild(b);
+    }
+  }
+
+  async function sendQuick(index, btn) {
+    if (busy) return;
+    busy = true;
+    btn.disabled = true;
+    btn.classList.add('is-busy');
+    try {
+      const res = await moduleApi.fetch('/quick', {
+        method: 'POST',
+        headers: authHeaders({ 'Content-Type': 'application/json' }),
+        body: JSON.stringify({ index }),
+      });
+      const body = await readJson(res);
+      if (res.status === 401) return void lock(body.error || 'Locked — enter the PIN', true);
+      if (!res.ok) return void showError(body.error || `Send failed (HTTP ${res.status})`);
+      if (body.expiresAt) expiresAt = Number(body.expiresAt);
+      if (composeEls) {
+        composeEls.msg.textContent = '';
+        composeEls.msg.className = 'sl-msg';
+      }
+      btn.classList.remove('is-busy');
+      btn.classList.add('is-sent');
+      const label = btn.querySelector('.sl-quick-label');
+      const original = label.textContent;
+      label.textContent = 'Sent ✓';
+      setTimeout(() => {
+        if (!btn.isConnected) return;
+        label.textContent = original;
+        btn.classList.remove('is-sent');
+      }, 1000);
+    } catch {
+      showError('ProdDash unreachable — not sent');
+    } finally {
+      busy = false;
+      btn.disabled = false;
+      btn.classList.remove('is-busy');
+    }
+  }
+
+  /* ── locking ── */
+  function lock(note, fromServer = false) {
+    const had = token;
+    token = '';
+    expiresAt = 0;
+    pinBuf = '';
+    presets = null;
+    composeEls = null;
+    compose.textContent = '';
+    if (had && !fromServer) {
+      moduleApi.fetch('/lock', { method: 'POST', headers: { Authorization: `Bearer ${had}` } }).catch(() => {});
+    }
+    gateNote = note || '';
+    gateError = '';
+    gateKind = ''; // rebuild the pad fresh
+    padEls = null;
+    renderGate();
+    moduleApi.setStatus(statusState(), `${statusMessage()} · locked`);
+  }
+
+  function tickLock() {
+    if (!token) return;
+    const left = expiresAt - Date.now();
+    if (left <= 0) return void lock('Locked after inactivity');
+    if (composeEls) {
+      const cd = composeEls.countdown;
+      if (left < 60000) {
+        const s = Math.ceil(left / 1000);
+        cd.textContent = `Locks in 0:${String(s).padStart(2, '0')}`;
+        cd.hidden = false;
+      } else cd.hidden = true;
+    }
+  }
+
+  /* ── server state ── */
+  function statusState() {
+    const st = state?.status?.state;
+    return st === 'ok' || st === 'connecting' || st === 'error' ? st : 'connecting';
+  }
+  function statusMessage() {
+    return state?.status?.message || 'Connecting to Slack…';
+  }
+
+  function applyState(s) {
+    if (stopped || !s || typeof s !== 'object') return;
+    state = s;
+    moduleApi.setStatus(statusState(), `${statusMessage()} · ${token ? 'unlocked' : 'locked'}`);
+    if (token) {
+      // Sending switched off or the PIN removed while unlocked: the server
+      // will refuse the next send; say so now instead of on failure.
+      if (!s.sending?.enabled || !s.sending?.pinSet) return void lock('');
+      if (composeEls) {
+        composeEls.line.textContent = sendingLine();
+        if (composeEls.input && s.channel?.name) composeEls.input.placeholder = `Message #${s.channel.name}…`;
+      }
+    } else renderGate();
+  }
+
+  async function loadState() {
+    try {
+      const res = await moduleApi.fetch('/state');
+      if (!res.ok) throw new Error(String(res.status));
+      applyState(await res.json());
+    } catch { /* the stream paints */ }
+  }
+
+  function connect() {
+    stream = moduleApi.sse('/stream', {
+      open() { loadState(); },
+      error() {
+        moduleApi.setStatus('error', 'ProdDash Slack module unreachable — reconnecting…');
+      },
+      events: {
+        state(e) {
+          try {
+            applyState(JSON.parse(e.data));
+          } catch { /* skip a bad frame */ }
+        },
+      },
+    });
+  }
+
+  return {
+    start() {
+      moduleApi.setStatus('connecting', 'Connecting to Slack…');
+      renderGate();
+      connect();
+      ticker = setInterval(tickLock, 1000);
+    },
+    stop() {
+      stopped = true;
+      clearInterval(ticker);
+      clearTimeout(flash.timer);
+      stream?.close();
+      token = ''; // the unlock dies with the tile
+      root.innerHTML = '';
+    },
+  };
+}
diff --git a/modules/slack/module.json b/modules/slack/module.json
new file mode 100644
index 0000000..3b82a58
--- /dev/null
+++ b/modules/slack/module.json
@@ -0,0 +1,100 @@
+{
+  "id": "slack",
+  "name": "Slack",
+  "version": "1.0.0",
+  "proddash": ">=1.4.0",
+  "description": "A Slack channel's live transcript, plus PIN-protected sending as this location",
+  "client": "client.js",
+  "server": "server.js",
+  "style": "style.css",
+  "minSize": { "w": 2, "h": 2 },
+  "defaultSize": { "w": 4, "h": 4 },
+  "configGroups": {
+    "Slack account": {
+      "collapsed": "whenSet",
+      "help": "Create a Slack app in the workspace (api.slack.com/apps → Create New App → From scratch) and, under OAuth & Permissions → User Token Scopes, add channels:history, channels:read, groups:history, groups:read, chat:write and users:read (users:read.email is not needed). Sign in to Slack as this location's account — the one named for the campus — open the app's OAuth & Permissions page and press Install to Workspace (or Reinstall to Workspace), then copy the User OAuth Token (xoxp-…) it shows and paste it here: messages from this machine are then literally from the location. A bot token (xoxb-…) works too; it posts as the app, with \"Send as\" naming the location."
+    },
+    "Sending": {
+      "toggle": "sendEnabled",
+      "help": "Messages leave this machine only from a Send or Quick replies tile, and only after the PIN is entered on that tile — every tile asks again after Auto-lock minutes without a send. Sending stays refused until a 4–8 digit PIN is set here. Quick replies are one per line, Label | Message, with an optional | #channel-name to send that one somewhere other than the transcript channel."
+    }
+  },
+  "configSchema": {
+    "token": {
+      "type": "password",
+      "label": "Token",
+      "default": "",
+      "group": "Slack account",
+      "help": "The location account's User OAuth Token (xoxp-…, recommended) or a Bot User OAuth Token (xoxb-…)."
+    },
+    "sendAs": {
+      "type": "string",
+      "label": "Send as",
+      "default": "",
+      "group": "Slack account",
+      "help": "Only used with a bot token — a user token always sends as its own account; needs the chat:write.customize scope."
+    },
+    "channel": {
+      "type": "select",
+      "label": "Channel",
+      "default": "",
+      "group": "Channel",
+      "optionsRoute": "/channels",
+      "help": "The channel the transcript shows and messages go to by default. Only channels the account has joined are listed — join one in Slack first."
+    },
+    "pollSeconds": {
+      "type": "number",
+      "label": "Refresh interval (s)",
+      "default": 2,
+      "group": "Transcript",
+      "help": "How often the channel is re-read (1 s at the fastest)."
+    },
+    "historyCount": {
+      "type": "number",
+      "label": "Messages kept",
+      "default": 40,
+      "group": "Transcript"
+    },
+    "includeReplies": {
+      "type": "switch",
+      "label": "Thread replies",
+      "default": false,
+      "group": "Transcript"
+    },
+    "sendEnabled": {
+      "type": "switch",
+      "label": "Sending",
+      "default": false,
+      "group": "Sending"
+    },
+    "pin": {
+      "type": "password",
+      "label": "PIN",
+      "default": "",
+      "group": "Sending",
+      "help": "4–8 digits; asked every time a send tile opens."
+    },
+    "pinIdleMinutes": {
+      "type": "number",
+      "label": "Auto-lock (min)",
+      "default": 10,
+      "group": "Sending"
+    },
+    "quickReplies": {
+      "type": "text",
+      "label": "Quick replies",
+      "default": "",
+      "group": "Sending",
+      "help": "One per line: Label | Message. Add | #channel-name to send one somewhere else."
+    }
+  },
+  "instanceGroups": {
+    "Transcript": { "collapsed": false }
+  },
+  "instanceSchema": {
+    "textSize": { "type": "number", "label": "Text size (px)", "default": 14 },
+    "showTimes": { "type": "switch", "label": "Timestamps", "default": true, "group": "Transcript" },
+    "showNames": { "type": "switch", "label": "Names", "default": true, "group": "Transcript" },
+    "showSystem": { "type": "switch", "label": "System lines", "default": true, "group": "Transcript" }
+  }
+}
diff --git a/modules/slack/server.js b/modules/slack/server.js
new file mode 100644
index 0000000..854c3b0
--- /dev/null
+++ b/modules/slack/server.js
@@ -0,0 +1,1007 @@
+'use strict';
+
+/**
+ * Slack — server part.
+ *
+ * One Slack Web API connection per ProdDash machine — the campus's shared
+ * location account (a user token), or a bot — polled for the configured
+ * channel's recent history and fanned out to every tile over SSE, plus
+ * PIN-gated sending from this machine so a message reads as coming from the
+ * location. Browsers never talk to Slack; the token and the PIN stay here.
+ *
+ *   GET  /state      snapshot: identity, channel, messages, sending state
+ *   GET  /stream     SSE `state` events (change-detected, heartbeated)
+ *   GET  /channels   admin select options — the channels the account is in
+ *   POST /unlock     { pin } → { token, expiresAt }   (constant-time, lockout)
+ *   POST /lock       Bearer → forget that unlock token
+ *   GET  /quick      Bearer → preset labels + indexes (never the message text)
+ *   POST /send       Bearer, { text, channel? } → chat.postMessage
+ *   POST /quick      Bearer, { index } → post that preset
+ *
+ * SLACK_API_BASE=http://127.0.0.1:24716/api points the module at
+ * tools/slack-mock.js for development.
+ */
+
+const crypto = require('crypto');
+
+const DEFAULT_API_BASE = 'https://slack.com/api';
+const API_BASE = String(process.env.SLACK_API_BASE || DEFAULT_API_BASE).replace(/\/+$/, '');
+
+/** Abort a hung Slack request well before the poll cadence stacks up. */
+const REQUEST_TIMEOUT_MS = 10000;
+/** SSE comment ping cadence — keeps idle connections alive through sleepy Wi-Fi. */
+const HEARTBEAT_MS = 15000;
+/** Fastest allowed history poll; the admin default is 2 s. */
+const MIN_POLL_S = 1;
+/** With no tile watching, poll this slowly instead — the API budget is shared with sends. */
+const IDLE_POLL_S = 15;
+/** …once nothing has asked for /state or /stream for this long. */
+const IDLE_AFTER_MS = 30000;
+const HISTORY_MIN = 5;
+const HISTORY_MAX = 200;
+/** Thread fetches per poll (oldest parent first) — keeps a busy channel inside Tier 3. */
+const THREAD_FETCHES_PER_POLL = 3;
+const THREAD_REPLIES_LIMIT = 50;
+const USER_LOOKUPS_PER_POLL = 15;
+const USER_TTL_MS = 60 * 60 * 1000;
+const CHANNEL_LIST_TTL_MS = 10 * 60 * 1000;
+const RETRY_NETWORK_MS = 10000;
+/** A bad token or an unreadable channel: nothing we do fixes it, so re-check slowly. */
+const RETRY_CONFIG_MS = 60000;
+/** "Join it in Slack" — someone may just have. */
+const RETRY_MEMBERSHIP_MS = 30000;
+const PIN_RE = /^\d{4,8}$/;
+const PIN_MAX_WRONG = 5;
+const PIN_LOCKOUT_MS = 30000;
+const SEND_MIN_INTERVAL_MS = 1000;
+const MAX_TEXT_CHARS = 4000;
+const BODY_LIMIT_BYTES = 64 * 1024;
+const DEFAULT_ICON = ':satellite_antenna:';
+const UNLOCK_SWEEP_MS = 30000;
+
+/** Set by init(), read by routes() and tiles() — all rebuilt together on remount. */
+let current = null;
+
+/* ── Slack Web API ──────────────────────────────────────────────────── */
+
+class SlackError extends Error {
+  constructor(code, extra = {}) {
+    super(code);
+    this.code = code;
+    Object.assign(this, extra);
+  }
+}
+
+/** Call one Web API method. Form-encoded by default; chat.postMessage takes JSON. */
+async function slackCall(token, method, params = {}, { json = false } = {}) {
+  const headers = { Authorization: `Bearer ${token}`, Accept: 'application/json' };
+  let body;
+  if (json) {
+    headers['Content-Type'] = 'application/json; charset=utf-8';
+    body = JSON.stringify(params);
+  } else {
+    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    const form = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined && v !== null && v !== '') form.set(k, String(v));
+    }
+    body = form.toString();
+  }
+  let response;
+  try {
+    response = await fetch(`${API_BASE}/${method}`, {
+      method: 'POST',
+      headers,
+      body,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+  } catch (err) {
+    throw new SlackError('network', { network: true, detail: err?.message || String(err) });
+  }
+  if (response.status === 429) {
+    const retryAfter = Math.max(1, Math.trunc(Number(response.headers.get('retry-after'))) || 5);
+    throw new SlackError('ratelimited', { retryAfter, status: 429 });
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new SlackError('bad_response', { status: response.status });
+  }
+  if (!response.ok || !data || data.ok !== true) {
+    const meta = data?.response_metadata;
+    throw new SlackError(String(data?.error || `http_${response.status}`), {
+      status: response.status,
+      needed: data?.needed ? String(data.needed) : '',
+      detail: Array.isArray(meta?.messages) ? meta.messages.join('; ') : '',
+    });
+  }
+  return data;
+}
+
+/** A Slack error as a sentence a tech can act on. */
+function describeError(err, ctx = {}) {
+  const who = ctx.name || 'The Slack account';
+  const chan = ctx.channel ? `#${ctx.channel}` : 'the channel';
+  switch (err?.code) {
+    case 'network': return `Slack unreachable: ${err.detail}`;
+    case 'ratelimited': return `Slack is rate-limiting — try again in ${err.retryAfter} s`;
+    case 'invalid_auth': return 'Slack rejected the token (invalid_auth) — paste a current User OAuth Token in Admin → Slack';
+    case 'not_authed': return 'No token reached Slack (not_authed) — paste the User OAuth Token in Admin → Slack';
+    case 'token_revoked': return 'The token was revoked (token_revoked) — Reinstall to Workspace in the Slack app and paste the new token';
+    case 'token_expired': return 'The token expired (token_expired) — Reinstall to Workspace in the Slack app and paste the new token';
+    case 'account_inactive': return 'The Slack account behind the token is deactivated (account_inactive)';
+    case 'missing_scope': return `The token is missing the ${err.needed || 'required'} scope (missing_scope) — add it under OAuth & Permissions, reinstall, paste the new token`;
+    case 'not_in_channel': return `${who} isn't a member of ${chan} — join it in Slack`;
+    case 'channel_not_found': return 'Channel not found (channel_not_found) — pick it again in Admin → Slack → Channel';
+    case 'is_archived': return `${chan} is archived (is_archived)`;
+    case 'msg_too_long': return 'Message too long for Slack (msg_too_long)';
+    case 'no_text': return 'Nothing to send (no_text)';
+    case 'restricted_action': return `Posting in ${chan} is restricted by a workspace admin (restricted_action)`;
+    case 'bad_response': return `Slack answered with something that isn't JSON (HTTP ${err.status})`;
+    default: return `Slack error: ${err?.code || err?.message || err}${err?.detail ? ` — ${err.detail}` : ''}`;
+  }
+}
+
+/** Errors that no amount of retrying fixes — config has to change. */
+function isConfigError(err) {
+  return ['invalid_auth', 'not_authed', 'token_revoked', 'token_expired', 'account_inactive', 'missing_scope', 'channel_not_found'].includes(err?.code);
+}
+
+/* ── mrkdwn → plain text with a few inline marks ────────────────────── */
+
+const EMOJI = {
+  '+1': '👍', thumbsup: '👍', '-1': '👎', thumbsdown: '👎', white_check_mark: '✅', heavy_check_mark: '✔️',
+  x: '❌', pray: '🙏', tada: '🎉', fire: '🔥', eyes: '👀', heart: '❤️', clap: '👏', warning: '⚠️',
+  rotating_light: '🚨', smile: '😄', grinning: '😀', joy: '😂', sweat_smile: '😅', thinking_face: '🤔',
+  wave: '👋', ok_hand: '👌', raised_hands: '🙌', bell: '🔔', microphone: '🎤', musical_note: '🎵',
+  video_camera: '📹', tv: '📺', church: '⛪', zap: '⚡', 100: '💯', point_right: '👉', muscle: '💪',
+  slightly_smiling_face: '🙂', raised_hand: '✋', satellite_antenna: '📡',
+};
+
+function unescapeSlack(s) {
+  return s.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+}
+
+/**
+ * Slack mrkdwn → plain text. Mentions, channel links, broadcasts and URLs are
+ * spelled out; *bold* _italic_ ~strike~ `code` markers are kept for the
+ * client to style; :shortcodes: in the small map become the emoji.
+ */
+function renderMrkdwn(raw, lookupUser, lookupChannel) {
+  let text = String(raw || '');
+  text = text.replace(/<([^<>]+)>/g, (m, inner) => {
+    if (inner.startsWith('@')) {
+      const [id, label] = inner.slice(1).split('|');
+      return '@' + (label || lookupUser(id) || id);
+    }
+    if (inner.startsWith('#')) {
+      const [id, label] = inner.slice(1).split('|');
+      return '#' + (label || lookupChannel(id) || id);
+    }
+    if (inner.startsWith('!')) {
+      const [cmd, label] = inner.slice(1).split('|');
+      if (cmd.startsWith('subteam^')) return label ? (label.startsWith('@') ? label : '@' + label) : '@group';
+      if (cmd.startsWith('date^')) {
+        const secs = Number(cmd.split('^')[1]);
+        return label || (secs ? new Date(secs * 1000).toLocaleString() : 'date');
+      }
+      return '@' + (label || cmd);
+    }
+    const [url, label] = inner.split('|');
+    if (label && label !== url) return `${label} (${url})`;
+    return url.replace(/^mailto:/, '');
+  });
+  text = unescapeSlack(text);
+  text = text.replace(/:([a-z0-9_+-]+):/g, (m, code) => EMOJI[code] || m);
+  return text;
+}
+
+/** Text from a blocks-only message (section / context / rich_text). */
+function textFromBlocks(blocks) {
+  const out = [];
+  const walk = (node) => {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) return void node.forEach(walk);
+    if (typeof node.text === 'string' && (node.type === 'text' || node.type === 'mrkdwn' || node.type === 'plain_text')) {
+      out.push(node.text);
+      return;
+    }
+    if (node.type === 'link') return void out.push(node.text || node.url || '');
+    if (node.type === 'emoji' && node.name) return void out.push(`:${node.name}:`);
+    if (node.type === 'user' && node.user_id) return void out.push(`<@${node.user_id}>`);
+    if (node.type === 'channel' && node.channel_id) return void out.push(`<#${node.channel_id}>`);
+    if (node.type === 'broadcast' && node.range) return void out.push(`<!${node.range}>`);
+    for (const key of ['text', 'elements', 'fields', 'title']) if (node[key]) walk(node[key]);
+  };
+  walk(blocks);
+  return out.join(' ').replace(/\s+\n/g, '\n').trim();
+}
+
+/* ── small helpers ──────────────────────────────────────────────────── */
+
+function sendJson(res, code, body) {
+  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
+  res.end(JSON.stringify(body));
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    let size = 0;
+    req.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > BODY_LIMIT_BYTES) {
+        reject(new Error('Request body too large.'));
+        req.destroy();
+        return;
+      }
+      data += chunk;
+    });
+    req.on('end', () => {
+      if (!data.trim()) return resolve({});
+      try {
+        const body = JSON.parse(data);
+        resolve(body && typeof body === 'object' ? body : {});
+      } catch {
+        reject(new Error('Malformed JSON.'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+/** Route handlers are async — the shell only catches synchronous throws. */
+function guard(fn) {
+  return (req, res) => {
+    Promise.resolve()
+      .then(() => fn(req, res))
+      .catch((err) => {
+        if (!res.headersSent) sendJson(res, 500, { error: err?.message || String(err) });
+        else try { res.end(); } catch { /* gone */ }
+      });
+  };
+}
+
+function bearer(req) {
+  const m = /^Bearer\s+([A-Za-z0-9]+)\s*$/.exec(String(req.headers.authorization || ''));
+  return m ? m[1] : '';
+}
+
+function clientIp(req) {
+  return String(req.socket?.remoteAddress || '');
+}
+
+/** Constant-time PIN compare (lengths are folded in after the timing-safe step). */
+function pinMatches(given, expected) {
+  const a = Buffer.alloc(16);
+  const b = Buffer.alloc(16);
+  a.write(String(given).slice(0, 16));
+  b.write(String(expected).slice(0, 16));
+  const same = crypto.timingSafeEqual(a, b);
+  return same && given.length === expected.length;
+}
+
+/**
+ * "Label | Message | #channel" per line. A line with no "|" is both its label
+ * and its message; the channel (optional) is a name the account can see.
+ */
+function parseQuickReplies(text) {
+  const out = [];
+  for (const rawLine of String(text || '').split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const parts = line.split('|').map((p) => p.trim());
+    const label = parts[0];
+    const message = parts.length > 1 && parts[1] ? parts[1] : label;
+    const channel = parts.length > 2 ? parts[2].replace(/^#/, '') : '';
+    if (!label || !message) continue;
+    out.push({ label, message, channel });
+  }
+  return out;
+}
+
+const SYSTEM_SUBTYPES = new Set([
+  'channel_join', 'channel_leave', 'channel_topic', 'channel_purpose', 'channel_name',
+  'channel_archive', 'channel_unarchive', 'group_join', 'group_leave', 'group_topic',
+  'group_purpose', 'group_name', 'pinned_item', 'unpinned_item', 'bot_add', 'bot_remove',
+  'sh_room_created', 'reminder_add', 'huddle_thread',
+]);
+
+/* ── the module ─────────────────────────────────────────────────────── */
+
+module.exports = {
+  init({ config, log }) {
+    /* ── config ── */
+    const token = String(config.token || '').trim();
+    const sendAs = String(config.sendAs || '').trim();
+    const channelId = String(config.channel || '').trim();
+    const pollMs = Math.max(MIN_POLL_S, Number(config.pollSeconds) || 2) * 1000;
+    const historyCount = Math.min(HISTORY_MAX, Math.max(HISTORY_MIN, Math.trunc(Number(config.historyCount)) || 40));
+    const includeReplies = Boolean(config.includeReplies);
+    const sendEnabled = Boolean(config.sendEnabled);
+    const pin = String(config.pin || '').trim();
+    const pinOk = PIN_RE.test(pin);
+    const idleMs = Math.min(240, Math.max(1, Number(config.pinIdleMinutes) || 10)) * 60 * 1000;
+    const quickReplies = parseQuickReplies(config.quickReplies);
+
+    /* ── state (all inside this closure so a re-init starts clean) ── */
+    let stopped = false;
+    let identity = null;        // { kind: 'user'|'bot', name, handle, userId, team, botId }
+    let authError = '';
+    let channel = null;         // { id, name, isMember, isPrivate }
+    let channelError = '';
+    let pollError = '';
+    let lastPollAt = 0;
+    let rawWindow = [];         // conversations.history messages, as Slack sent them (newest first)
+    const threads = new Map();  // parent ts -> { latestReply, replyCount, replies: [raw…] }
+    const users = new Map();    // user id -> { name, at }
+    const pendingUsers = new Set();
+    const channelNames = new Map(); // channel id -> name (from list/info calls)
+    let channelList = { at: 0, channels: [] };
+    let channelListPromise = null;
+    let snapshotCache = null;
+    let lastSig = '';
+    let lastInterest = Date.now();
+    let pollTimer = null;
+    let polling = false;
+    let pollAgain = false;
+    let currentIntervalMs = pollMs;
+    const streams = new Set();
+    const unlocks = new Map();     // token -> { expiresAt, lastSendAt, ip }
+    const pinAttempts = new Map(); // ip -> { count, lockedUntil }
+
+    /* ── names ── */
+    function lookupUser(id) {
+      if (!id) return '';
+      const hit = users.get(id);
+      if (hit && Date.now() - hit.at < USER_TTL_MS) return hit.name;
+      pendingUsers.add(id);
+      return hit ? hit.name : '';
+    }
+
+    function lookupChannel(id) {
+      return channelNames.get(id) || '';
+    }
+
+    async function resolveUsers() {
+      const ids = [...pendingUsers].slice(0, USER_LOOKUPS_PER_POLL);
+      if (!ids.length) return false;
+      let changed = false;
+      await Promise.all(ids.map(async (id) => {
+        pendingUsers.delete(id);
+        try {
+          const data = await slackCall(token, 'users.info', { user: id });
+          const u = data.user || {};
+          const name = String(u.profile?.display_name || u.real_name || u.profile?.real_name || u.name || id);
+          users.set(id, { name, at: Date.now() });
+          changed = true;
+        } catch (err) {
+          // Unknown or deactivated: remember the raw id for a while so we
+          // don't ask again every poll. Rate limits and outages retry.
+          if (err.code !== 'network' && err.code !== 'ratelimited') users.set(id, { name: id, at: Date.now() });
+        }
+      }));
+      return changed;
+    }
+
+    /* ── channel list (admin options, #name → id, <#C…> rendering) ── */
+    async function loadChannelList(force = false) {
+      if (!force && Date.now() - channelList.at < CHANNEL_LIST_TTL_MS) return channelList.channels;
+      if (channelListPromise) return channelListPromise;
+      channelListPromise = (async () => {
+        const all = [];
+        let cursor = '';
+        for (let page = 0; page < 10; page += 1) {
+          const data = await slackCall(token, 'conversations.list', {
+            types: 'public_channel,private_channel',
+            exclude_archived: 'true',
+            limit: 200,
+            cursor: cursor || undefined,
+          });
+          for (const c of data.channels || []) {
+            if (!c?.id) continue;
+            channelNames.set(String(c.id), String(c.name || ''));
+            all.push({ id: String(c.id), name: String(c.name || ''), isMember: Boolean(c.is_member), isPrivate: Boolean(c.is_private) });
+          }
+          cursor = String(data.response_metadata?.next_cursor || '');
+          if (!cursor) break;
+        }
+        all.sort((a, b) => a.name.localeCompare(b.name));
+        channelList = { at: Date.now(), channels: all };
+        return all;
+      })();
+      try {
+        return await channelListPromise;
+      } finally {
+        channelListPromise = null;
+      }
+    }
+
+    /** "#name" or a channel id → the channel id, or '' when the account can't see it. */
+    async function resolveChannel(ref) {
+      const s = String(ref || '').trim();
+      if (!s) return channelId;
+      if (/^[CG][A-Z0-9]{6,}$/.test(s)) return s;
+      const name = s.replace(/^#/, '').toLowerCase();
+      let list = await loadChannelList();
+      let hit = list.find((c) => c.name.toLowerCase() === name);
+      if (!hit) {
+        list = await loadChannelList(true);
+        hit = list.find((c) => c.name.toLowerCase() === name);
+      }
+      return hit ? hit.id : '';
+    }
+
+    /* ── normalisation ── */
+    function nameFor(m) {
+      if (m.subtype === 'bot_message' && m.username) return String(m.username);
+      if (m.user) {
+        const n = lookupUser(String(m.user));
+        if (n) return n;
+      }
+      if (m.bot_profile?.name) return String(m.bot_profile.name);
+      if (m.username) return String(m.username);
+      return String(m.user || m.bot_id || 'unknown');
+    }
+
+    function textFor(m) {
+      let text = renderMrkdwn(m.text, lookupUser, lookupChannel).trim();
+      if (!text && Array.isArray(m.attachments)) {
+        text = m.attachments
+          .map((a) => renderMrkdwn(a?.fallback || a?.text || a?.title || '', lookupUser, lookupChannel).trim())
+          .filter(Boolean)
+          .join('\n');
+      }
+      if (!text && Array.isArray(m.blocks)) text = renderMrkdwn(textFromBlocks(m.blocks), lookupUser, lookupChannel);
+      if (Array.isArray(m.files) && m.files.length) {
+        const files = m.files.map((f) => `[file: ${f?.title || f?.name || 'file'}]`).join(' ');
+        text = text ? `${text}\n${files}` : files;
+      }
+      return text;
+    }
+
+    function normalize(m, parentTs = '') {
+      if (!m || typeof m !== 'object' || !m.ts) return null;
+      if (m.subtype === 'tombstone') return null;
+      const name = nameFor(m);
+      const system = SYSTEM_SUBTYPES.has(m.subtype || '');
+      let text = textFor(m);
+      if (m.subtype === 'channel_join' || m.subtype === 'group_join') text = `${name} joined ${channel ? '#' + channel.name : 'the channel'}`;
+      else if (m.subtype === 'channel_leave' || m.subtype === 'group_leave') text = `${name} left ${channel ? '#' + channel.name : 'the channel'}`;
+      const out = {
+        id: String(m.ts),
+        ts: String(m.ts),
+        time: Math.round(Number(m.ts) * 1000) || Date.now(),
+        name,
+        text,
+        edited: Boolean(m.edited),
+        system,
+        subtype: String(m.subtype || ''),
+        bot: Boolean(m.bot_id) || m.subtype === 'bot_message',
+        me: Boolean(identity && m.user && m.user === identity.userId),
+      };
+      if (parentTs) out.parent = parentTs;
+      else {
+        out.replyCount = Math.max(0, Math.trunc(Number(m.reply_count)) || 0);
+        if (includeReplies && out.replyCount) {
+          const t = threads.get(out.ts);
+          out.replies = t ? t.replies.map((r) => normalize(r, out.ts)).filter(Boolean) : [];
+        }
+      }
+      return out;
+    }
+
+    function identityLabel() {
+      if (!identity) return '';
+      if (identity.kind === 'bot') return sendAs ? `${identity.name} (bot) as "${sendAs}"` : `${identity.name} (bot)`;
+      return identity.name;
+    }
+
+    function sendingAs() {
+      if (!identity) return '';
+      return identity.kind === 'bot' && sendAs ? sendAs : identity.name;
+    }
+
+    function health() {
+      if (!token) return { status: 'error', message: 'No Slack token — paste the location account’s User OAuth Token in Admin → Slack' };
+      if (authError) return { status: 'error', message: authError };
+      if (!identity) return { status: 'connecting', message: 'Checking the Slack token…' };
+      const who = identityLabel();
+      if (!channelId) return { status: 'error', message: `${who} · pick a channel in Admin → Slack → Channel` };
+      if (channelError) return { status: 'error', message: `${who} · ${channelError}` };
+      if (!channel) return { status: 'connecting', message: `${who} · looking up the channel…` };
+      const sending = !sendEnabled ? 'sending off' : !pinOk ? 'sending on — set a 4–8 digit PIN' : 'sending on';
+      if (pollError) return { status: 'error', message: `${who} · #${channel.name} · ${pollError}` };
+      if (!lastPollAt) return { status: 'connecting', message: `${who} · #${channel.name} · first read…` };
+      const age = Date.now() - lastPollAt;
+      if (age > 3 * currentIntervalMs + 5000) {
+        return { status: 'connecting', message: `${who} · #${channel.name} · last read ${Math.round(age / 1000)} s ago` };
+      }
+      return { status: 'ok', message: `${who} · #${channel.name} · ${sending}` };
+    }
+
+    function snapshot() {
+      if (snapshotCache) return snapshotCache;
+      const messages = rawWindow
+        .map((m) => normalize(m))
+        .filter(Boolean)
+        .sort((a, b) => Number(a.ts) - Number(b.ts));
+      const h = health();
+      snapshotCache = {
+        identity: identity
+          ? { kind: identity.kind, name: identity.name, team: identity.team, sendAs: identity.kind === 'bot' ? sendAs : '' }
+          : null,
+        sendingAs: sendingAs(),
+        channel: channel ? { id: channel.id, name: channel.name, isMember: channel.isMember } : (channelId ? { id: channelId, name: lookupChannel(channelId), isMember: null } : null),
+        messages,
+        includeReplies,
+        historyCount,
+        sending: { enabled: sendEnabled, pinSet: pinOk, idleMinutes: idleMs / 60000 },
+        status: { state: h.status, message: h.message, lastPollAt },
+        apiBase: API_BASE,
+      };
+      return snapshotCache;
+    }
+
+    function invalidate() {
+      snapshotCache = null;
+    }
+
+    /** Broadcast the snapshot when anything a tile shows has changed. */
+    function broadcastIfChanged() {
+      invalidate();
+      const snap = snapshot();
+      const { lastPollAt: _ignored, ...statusSig } = snap.status;
+      const sig = JSON.stringify({ ...snap, status: statusSig });
+      if (sig === lastSig) return;
+      lastSig = sig;
+      if (!streams.size) return;
+      const payload = `event: state\ndata: ${JSON.stringify(snap)}\n\n`;
+      for (const res of streams) {
+        try {
+          res.write(payload);
+        } catch {
+          streams.delete(res);
+        }
+      }
+    }
+
+    /* ── the poll loop: token → channel → history (+ threads, names) ── */
+    function schedule(ms) {
+      if (stopped) return;
+      clearTimeout(pollTimer);
+      currentIntervalMs = ms;
+      pollTimer = setTimeout(tick, ms);
+      pollTimer.unref?.();
+    }
+
+    function pollSoon() {
+      if (stopped) return;
+      if (polling) {
+        pollAgain = true;
+        return;
+      }
+      clearTimeout(pollTimer);
+      pollTimer = setTimeout(tick, 250);
+      pollTimer.unref?.();
+    }
+
+    function watched() {
+      return streams.size > 0 || Date.now() - lastInterest < IDLE_AFTER_MS;
+    }
+
+    async function checkAuth() {
+      const data = await slackCall(token, 'auth.test', {});
+      const userId = String(data.user_id || '');
+      const id = {
+        kind: data.bot_id ? 'bot' : 'user',
+        name: String(data.user || 'Slack'),
+        handle: String(data.user || ''),
+        userId,
+        team: String(data.team || ''),
+        botId: data.bot_id ? String(data.bot_id) : '',
+      };
+      // The handle is "apollo.beach"; the display name is "Apollo Beach".
+      if (userId) {
+        try {
+          const u = await slackCall(token, 'users.info', { user: userId });
+          const name = String(u.user?.profile?.display_name || u.user?.real_name || u.user?.profile?.real_name || '').trim();
+          if (name) id.name = name;
+          users.set(userId, { name: id.name, at: Date.now() });
+        } catch { /* the handle will do */ }
+      }
+      identity = id;
+      authError = '';
+      log(`token belongs to ${identityLabel()} (${id.team || 'team unknown'})${id.kind === 'bot' && !sendAs ? ' — messages will read as the app; set "Send as" to name the location' : ''}`);
+    }
+
+    async function checkChannel() {
+      const data = await slackCall(token, 'conversations.info', { channel: channelId });
+      const c = data.channel || {};
+      channel = {
+        id: String(c.id || channelId),
+        name: String(c.name || c.name_normalized || channelId),
+        isMember: c.is_member !== false,
+        isPrivate: Boolean(c.is_private),
+      };
+      channelNames.set(channel.id, channel.name);
+      channelError = '';
+      if (!channel.isMember) {
+        channelError = `${identity?.name || 'The account'} isn't a member of #${channel.name} — join it in Slack`;
+        throw new SlackError('not_in_channel');
+      }
+    }
+
+    async function readHistory() {
+      const data = await slackCall(token, 'conversations.history', { channel: channelId, limit: historyCount });
+      const messages = Array.isArray(data.messages) ? data.messages.filter((m) => m && m.ts) : [];
+      rawWindow = messages;
+      lastPollAt = Date.now();
+      pollError = '';
+
+      // Threads: parents in the window whose reply set changed since we
+      // last read it — oldest first, a few per poll.
+      const inWindow = new Set(messages.map((m) => String(m.ts)));
+      for (const ts of [...threads.keys()]) if (!inWindow.has(ts)) threads.delete(ts);
+      if (includeReplies) {
+        const stale = messages
+          .filter((m) => Number(m.reply_count) > 0)
+          .filter((m) => {
+            const t = threads.get(String(m.ts));
+            return !t || t.latestReply !== String(m.latest_reply || '') || t.replyCount !== Number(m.reply_count);
+          })
+          .sort((a, b) => Number(a.ts) - Number(b.ts))
+          .slice(0, THREAD_FETCHES_PER_POLL);
+        for (const parent of stale) {
+          try {
+            const rep = await slackCall(token, 'conversations.replies', { channel: channelId, ts: parent.ts, limit: THREAD_REPLIES_LIMIT });
+            const replies = (rep.messages || []).filter((r) => r && r.ts && String(r.ts) !== String(parent.ts));
+            threads.set(String(parent.ts), { latestReply: String(parent.latest_reply || ''), replyCount: Number(parent.reply_count), replies });
+          } catch (err) {
+            if (err.code === 'ratelimited') throw err;
+            log(`thread ${parent.ts}: ${describeError(err, { name: identity?.name, channel: channel?.name })}`);
+          }
+        }
+      }
+    }
+
+    async function tick() {
+      if (stopped || polling) return;
+      polling = true;
+      pollAgain = false;
+      let next = watched() ? pollMs : Math.max(pollMs, IDLE_POLL_S * 1000);
+      try {
+        if (!identity) await checkAuth();
+        if (!channelId) {
+          next = RETRY_CONFIG_MS;
+        } else {
+          if (!channel || channelError) await checkChannel();
+          await readHistory();
+          await resolveUsers();
+        }
+      } catch (err) {
+        const ctx = { name: identity?.name, channel: channel?.name };
+        const text = describeError(err, ctx);
+        if (!identity) {
+          authError = text;
+          next = isConfigError(err) ? RETRY_CONFIG_MS : RETRY_NETWORK_MS;
+        } else if (!channel || channelError) {
+          if (!channelError) channelError = text;
+          next = err.code === 'not_in_channel' ? RETRY_MEMBERSHIP_MS : isConfigError(err) ? RETRY_CONFIG_MS : RETRY_NETWORK_MS;
+        } else {
+          pollError = text;
+          if (err.code === 'not_in_channel') {
+            channel.isMember = false;
+            channelError = text;
+            next = RETRY_MEMBERSHIP_MS;
+          } else next = isConfigError(err) ? RETRY_CONFIG_MS : Math.max(pollMs, RETRY_NETWORK_MS);
+        }
+        if (err.code === 'ratelimited') next = err.retryAfter * 1000;
+        log(text);
+      } finally {
+        polling = false;
+        broadcastIfChanged();
+        if (pollAgain) pollSoon();
+        else schedule(next);
+      }
+    }
+
+    /* ── unlock tokens ── */
+    function sweepUnlocks() {
+      const now = Date.now();
+      for (const [t, u] of unlocks) if (u.expiresAt <= now) unlocks.delete(t);
+      for (const [ip, a] of pinAttempts) if (a.lockedUntil && a.lockedUntil <= now && !a.count) pinAttempts.delete(ip);
+    }
+
+    /** The unlock behind a request, or null (the client re-asks for the PIN). */
+    function unlockFor(req) {
+      const t = bearer(req);
+      const u = t ? unlocks.get(t) : null;
+      if (!u) return null;
+      if (u.expiresAt <= Date.now()) {
+        unlocks.delete(t);
+        return null;
+      }
+      return { token: t, ...u };
+    }
+
+    /** Everything a send needs before Slack is asked; answers the response itself when refusing. */
+    function sendGate(req, res) {
+      if (!sendEnabled) {
+        sendJson(res, 403, { error: 'Sending is off — turn it on in Admin → Slack → Sending', code: 'sending_off' });
+        return null;
+      }
+      if (!pinOk) {
+        sendJson(res, 403, { error: 'Set a PIN in Admin → Slack → Sending', code: 'no_pin' });
+        return null;
+      }
+      const u = unlockFor(req);
+      if (!u) {
+        sendJson(res, 401, { error: 'Locked — enter the PIN', code: 'locked' });
+        return null;
+      }
+      return u;
+    }
+
+    async function postMessage(targetChannelId, text) {
+      const params = { channel: targetChannelId, text };
+      if (identity?.kind === 'bot' && sendAs) {
+        params.username = sendAs;
+        params.icon_emoji = DEFAULT_ICON;
+      }
+      return slackCall(token, 'chat.postMessage', params, { json: true });
+    }
+
+    /** Post on behalf of an unlock; answers the response. */
+    async function deliver(req, res, unlock, { text, channelRef, what }) {
+      const now = Date.now();
+      if (now - unlock.lastSendAt < SEND_MIN_INTERVAL_MS) {
+        return sendJson(res, 429, { error: 'One message per second — try again', code: 'too_fast' });
+      }
+      unlocks.get(unlock.token).lastSendAt = now;
+      if (!identity || authError) {
+        return sendJson(res, 502, { error: authError || 'Slack token not checked yet — try again in a moment' });
+      }
+      let target = channelId;
+      if (channelRef) {
+        try {
+          target = await resolveChannel(channelRef);
+        } catch (err) {
+          return sendJson(res, 502, { error: describeError(err, { name: identity.name, channel: channel?.name }) });
+        }
+        if (!target) return sendJson(res, 400, { error: `No channel named #${String(channelRef).replace(/^#/, '')} that ${identity.name} can see` });
+      }
+      if (!target) return sendJson(res, 400, { error: 'No channel — pick one in Admin → Slack → Channel' });
+      const targetName = lookupChannel(target) || target;
+      try {
+        const data = await postMessage(target, text);
+        const u = unlocks.get(unlock.token);
+        if (u) u.expiresAt = Date.now() + idleMs;
+        const preview = text.replace(/\s+/g, ' ').slice(0, 60);
+        log(`${what} → #${targetName} as ${sendingAs()}: "${preview}${text.length > 60 ? '…' : ''}"`);
+        if (target === channelId) pollSoon();
+        return sendJson(res, 200, {
+          ok: true,
+          ts: String(data.ts || ''),
+          channel: `#${targetName}`,
+          sendingAs: sendingAs(),
+          expiresAt: u ? u.expiresAt : unlock.expiresAt,
+        });
+      } catch (err) {
+        const message = describeError(err, { name: sendingAs() || identity.name, channel: targetName });
+        log(`${what} to #${targetName} failed: ${message}`);
+        return sendJson(res, err.code === 'ratelimited' ? 429 : 502, { error: message, code: err.code || 'slack_error' });
+      }
+    }
+
+    /* ── go ── */
+    const heartbeat = setInterval(() => {
+      for (const res of streams) {
+        try {
+          res.write(': ping\n\n');
+        } catch {
+          streams.delete(res);
+        }
+      }
+    }, HEARTBEAT_MS);
+    heartbeat.unref?.();
+    const sweeper = setInterval(sweepUnlocks, UNLOCK_SWEEP_MS);
+    sweeper.unref?.();
+
+    if (!token) log('no Slack token configured — paste one in /admin');
+    else {
+      if (sendEnabled && !pinOk) log('sending is on but no valid PIN (4–8 digits) is set — send tiles stay locked');
+      schedule(50);
+    }
+
+    current = {
+      streams,
+      snapshot,
+      health,
+      quickReplies,
+      sendGate,
+      deliver,
+      unlockFor,
+      touch() { lastInterest = Date.now(); },
+      wake() {
+        lastInterest = Date.now();
+        if (identity && channel && Date.now() - lastPollAt > pollMs) pollSoon();
+      },
+      loadChannelList,
+      channelId,
+      pinOk,
+      sendEnabled,
+      identityName: () => identity?.name || '',
+      channelName: () => channel?.name || '',
+      unlock(req, res, given) {
+        if (!sendEnabled) return sendJson(res, 403, { error: 'Sending is off — turn it on in Admin → Slack → Sending', code: 'sending_off' });
+        if (!pinOk) return sendJson(res, 403, { error: 'Set a PIN in Admin → Slack → Sending', code: 'no_pin' });
+        const ip = clientIp(req);
+        const now = Date.now();
+        let a = pinAttempts.get(ip);
+        if (a && a.lockedUntil > now) {
+          const secs = Math.ceil((a.lockedUntil - now) / 1000);
+          return sendJson(res, 429, { error: `Too many wrong PINs — locked for ${secs} s`, code: 'lockout', retryAfter: secs });
+        }
+        if (a && a.lockedUntil && a.lockedUntil <= now) a = null; // lockout served — clean slate
+        const str = String(given ?? '');
+        if (!PIN_RE.test(str) || !pinMatches(str, pin)) {
+          const count = (a ? a.count : 0) + 1;
+          if (count >= PIN_MAX_WRONG) {
+            pinAttempts.set(ip, { count: 0, lockedUntil: now + PIN_LOCKOUT_MS });
+            log(`wrong PIN ×${PIN_MAX_WRONG} from ${ip} — locked for ${PIN_LOCKOUT_MS / 1000} s`);
+            return sendJson(res, 429, { error: `Wrong PIN — locked for ${PIN_LOCKOUT_MS / 1000} s`, code: 'lockout', retryAfter: PIN_LOCKOUT_MS / 1000 });
+          }
+          pinAttempts.set(ip, { count, lockedUntil: 0 });
+          return sendJson(res, 401, { error: 'Wrong PIN', code: 'wrong_pin', triesLeft: PIN_MAX_WRONG - count });
+        }
+        pinAttempts.delete(ip);
+        const t = crypto.randomBytes(32).toString('hex');
+        const expiresAt = now + idleMs;
+        unlocks.set(t, { expiresAt, lastSendAt: 0, ip });
+        log(`unlocked from ${ip} (auto-lock after ${idleMs / 60000} min idle)`);
+        return sendJson(res, 200, { token: t, expiresAt, idleMs, sendingAs: sendingAs(), channel: channel ? `#${channel.name}` : '' });
+      },
+      lock(req, res) {
+        const t = bearer(req);
+        if (t) unlocks.delete(t);
+        return sendJson(res, 200, { ok: true });
+      },
+    };
+
+    return {
+      stop() {
+        stopped = true;
+        clearTimeout(pollTimer);
+        clearInterval(heartbeat);
+        clearInterval(sweeper);
+        unlocks.clear(); // an admin Apply locks every send tile
+        for (const res of streams) {
+          try { res.end(); } catch { /* already gone */ }
+        }
+        streams.clear();
+        if (current && current.streams === streams) current = null;
+      },
+      health,
+    };
+  },
+
+  tiles() {
+    const snap = current ? current.snapshot() : null;
+    const chan = snap?.channel?.name ? `#${snap.channel.name}` : 'the configured channel';
+    const who = snap?.sendingAs ? ` as ${snap.sendingAs}` : '';
+    return [
+      { id: 'transcript', name: 'Transcript', description: `Live transcript of ${chan}`, defaultSize: { w: 4, h: 4 }, minSize: { w: 2, h: 2 }, settings: { view: 'transcript' } },
+      { id: 'send', name: 'Send message', description: `PIN-protected message to ${chan}${who}`, defaultSize: { w: 3, h: 3 }, minSize: { w: 2, h: 2 }, settings: { view: 'send' } },
+      { id: 'quick', name: 'Quick replies', description: `PIN-protected preset buttons${who}`, defaultSize: { w: 3, h: 2 }, minSize: { w: 2, h: 1 }, settings: { view: 'quick' } },
+    ];
+  },
+
+  routes() {
+    const unmounted = (res) => sendJson(res, 503, { error: 'Slack module is restarting — try again' });
+
+    return {
+      'GET /state': (req, res) => {
+        if (!current) return unmounted(res);
+        current.wake();
+        sendJson(res, 200, current.snapshot());
+      },
+
+      'GET /stream': (req, res) => {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream; charset=utf-8',
+          'Cache-Control': 'no-cache, no-transform',
+          Connection: 'keep-alive',
+          'X-Accel-Buffering': 'no',
+        });
+        res.write('retry: 3000\n\n');
+        if (!current) {
+          res.write(`event: state\ndata: ${JSON.stringify({ messages: [], status: { state: 'connecting', message: 'Slack module is restarting…' } })}\n\n`);
+          return void res.end();
+        }
+        res.write(`event: state\ndata: ${JSON.stringify(current.snapshot())}\n\n`);
+        // A viewer that stops reading (locked tablet, sleeping laptop) must
+        // not queue frames forever; keepalive probes make the OS notice.
+        try { req.socket.setKeepAlive(true, 15000); } catch { /* gone */ }
+        current.streams.add(res);
+        current.wake();
+        req.on('close', () => current && current.streams.delete(res));
+      },
+
+      // The admin "Channel" select: channels the account is a member of.
+      'GET /channels': guard(async (req, res) => {
+        if (!current) return unmounted(res);
+        try {
+          const list = await current.loadChannelList(true);
+          const options = list
+            .filter((c) => c.isMember)
+            .map((c) => ({ value: c.id, label: `#${c.name}${c.isPrivate ? ' (private)' : ''}` }));
+          sendJson(res, 200, { options });
+        } catch (err) {
+          // 200 with no options: the admin page keeps the saved value selectable.
+          sendJson(res, 200, { options: [], error: describeError(err, { name: current.identityName() }) });
+        }
+      }),
+
+      'POST /unlock': guard(async (req, res) => {
+        if (!current) return unmounted(res);
+        let body;
+        try {
+          body = await readJson(req);
+        } catch (err) {
+          return sendJson(res, 400, { error: err.message });
+        }
+        current.unlock(req, res, body.pin);
+      }),
+
+      'POST /lock': (req, res) => {
+        if (!current) return unmounted(res);
+        current.lock(req, res);
+      },
+
+      // Labels and indexes only — the message text never leaves the server.
+      'GET /quick': (req, res) => {
+        if (!current) return unmounted(res);
+        const unlock = current.sendGate(req, res);
+        if (!unlock) return;
+        sendJson(res, 200, {
+          presets: current.quickReplies.map((q, index) => ({ index, label: q.label, channel: q.channel ? `#${q.channel}` : '' })),
+          expiresAt: unlock.expiresAt,
+        });
+      },
+
+      'POST /send': guard(async (req, res) => {
+        if (!current) return unmounted(res);
+        const unlock = current.sendGate(req, res);
+        if (!unlock) return;
+        let body;
+        try {
+          body = await readJson(req);
+        } catch (err) {
+          return sendJson(res, 400, { error: err.message });
+        }
+        const text = String(body.text ?? '').replace(/\r\n/g, '\n').trim();
+        if (!text) return sendJson(res, 400, { error: 'Nothing to send' });
+        if (text.length > MAX_TEXT_CHARS) return sendJson(res, 400, { error: `Too long — ${MAX_TEXT_CHARS} characters at most` });
+        await current.deliver(req, res, unlock, { text, channelRef: body.channel ? String(body.channel) : '', what: 'sent' });
+      }),
+
+      'POST /quick': guard(async (req, res) => {
+        if (!current) return unmounted(res);
+        const unlock = current.sendGate(req, res);
+        if (!unlock) return;
+        let body;
+        try {
+          body = await readJson(req);
+        } catch (err) {
+          return sendJson(res, 400, { error: err.message });
+        }
+        const index = Math.trunc(Number(body.index));
+        const preset = Number.isInteger(index) ? current.quickReplies[index] : null;
+        if (!preset) return sendJson(res, 404, { error: 'No such quick reply — the list may have changed in Admin' });
+        await current.deliver(req, res, unlock, { text: preset.message, channelRef: preset.channel, what: `quick reply "${preset.label}"` });
+      }),
+    };
+  },
+};
diff --git a/modules/slack/style.css b/modules/slack/style.css
new file mode 100644
index 0000000..aa61b0d
--- /dev/null
+++ b/modules/slack/style.css
@@ -0,0 +1,424 @@
+/* Slack module — scoped to its tiles, shell variables only.
+   --sl-size (per tile, from the Text size setting) drives every font size. */
+
+[data-module="slack"] .sl-wrap {
+  --sl-size: 14px;
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  container-type: size;
+  font-size: var(--sl-size);
+  color: var(--text);
+}
+[data-module="slack"] .sl-wrap:focus { outline: none; }
+[data-module="slack"] [hidden] { display: none !important; }
+
+/* ── degraded banner (transcript) ── */
+
+[data-module="slack"] .sl-banner {
+  flex: none;
+  padding: 4px 10px;
+  font-size: 0.8em;
+  color: var(--warn);
+  background: color-mix(in srgb, var(--warn) 12%, transparent);
+  border-bottom: 1px solid color-mix(in srgb, var(--warn) 35%, var(--border));
+}
+[data-module="slack"] .sl-banner.is-error {
+  color: var(--danger);
+  background: color-mix(in srgb, var(--danger) 12%, transparent);
+  border-bottom-color: color-mix(in srgb, var(--danger) 35%, var(--border));
+}
+
+/* ── transcript stream ── */
+
+[data-module="slack"] .sl-stream {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 6px 10px 10px;
+  overscroll-behavior: contain;
+}
+
+[data-module="slack"] .sl-empty {
+  color: var(--muted);
+  font-size: 0.9em;
+  text-align: center;
+  padding: 14% 10px 0;
+  line-height: 1.45;
+}
+[data-module="slack"] .sl-empty.is-error { color: var(--danger); }
+
+[data-module="slack"] .sl-entry {
+  padding: 4px 6px;
+  border-radius: 8px;
+  line-height: 1.4;
+}
+[data-module="slack"] .sl-entry:hover { background: var(--bg); }
+[data-module="slack"] .sl-entry.sl-new { animation: sl-fade-in 0.25s ease-out; }
+@keyframes sl-fade-in {
+  from { opacity: 0; transform: translateY(4px); }
+  to   { opacity: 1; transform: none; }
+}
+
+/* a message from this machine's own account */
+[data-module="slack"] .sl-entry.sl-me {
+  box-shadow: inset 3px 0 0 color-mix(in srgb, var(--accent) 55%, transparent);
+}
+
+[data-module="slack"] .sl-meta {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  min-width: 0;
+  margin-bottom: 1px;
+}
+[data-module="slack"] .sl-name {
+  font-weight: 700;
+  font-size: 0.86em;
+  color: var(--accent);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+[data-module="slack"] .sl-bot .sl-name { color: var(--muted); }
+[data-module="slack"] .sl-time {
+  flex: none;
+  font-size: 0.72em;
+  color: var(--muted);
+  font-variant-numeric: tabular-nums;
+}
+[data-module="slack"] .sl-wrap:not(.show-times) .sl-time { display: none; }
+[data-module="slack"] .sl-wrap:not(.show-names) .sl-msg > .sl-meta,
+[data-module="slack"] .sl-wrap:not(.show-names) .sl-reply > .sl-meta { display: none; }
+[data-module="slack"] .sl-wrap.show-times:not(.show-names) .sl-msg > .sl-meta,
+[data-module="slack"] .sl-wrap.show-times:not(.show-names) .sl-reply > .sl-meta { display: flex; }
+[data-module="slack"] .sl-wrap.show-times:not(.show-names) .sl-name { display: none; }
+[data-module="slack"] .sl-wrap:not(.show-system) .sl-entry.sl-system { display: none; }
+
+[data-module="slack"] .sl-text {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  color: var(--text);
+}
+[data-module="slack"] .sl-text b { font-weight: 700; }
+[data-module="slack"] .sl-text i { font-style: italic; }
+[data-module="slack"] .sl-text s { color: var(--muted); }
+[data-module="slack"] .sl-code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 0.9em;
+  padding: 0 4px;
+  border-radius: 4px;
+  background: color-mix(in srgb, var(--text) 8%, transparent);
+  border: 1px solid var(--border);
+}
+[data-module="slack"] .sl-code.sl-block {
+  display: block;
+  padding: 4px 8px;
+  margin: 3px 0;
+  white-space: pre-wrap;
+}
+[data-module="slack"] .sl-edited {
+  font-size: 0.75em;
+  color: var(--muted);
+  white-space: nowrap;
+}
+
+/* thread replies nest under their parent; without them, a muted count */
+[data-module="slack"] .sl-replies {
+  margin: 4px 0 0 10px;
+  padding-left: 10px;
+  border-left: 2px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+[data-module="slack"] .sl-reply { font-size: 0.92em; }
+[data-module="slack"] .sl-replycount {
+  margin-top: 2px;
+  font-size: 0.75em;
+  color: var(--muted);
+}
+
+/* system lines: joins, leaves, topic changes */
+[data-module="slack"] .sl-sysline {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  font-size: 0.82em;
+  color: var(--muted);
+  font-style: italic;
+}
+[data-module="slack"] .sl-sysline .sl-time { font-style: normal; }
+
+[data-module="slack"] .sl-jump {
+  position: absolute;
+  left: 50%;
+  bottom: 10px;
+  transform: translateX(-50%);
+  padding: 5px 12px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  background: var(--accent);
+  color: var(--accent-text);
+  font: inherit;
+  font-size: 0.8em;
+  font-weight: 700;
+  cursor: pointer;
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.35);
+}
+
+/* ── send / quick replies: the gate ── */
+
+[data-module="slack"] .sl-gate,
+[data-module="slack"] .sl-compose {
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  padding: 6px 10px;
+  overflow: auto;
+}
+
+[data-module="slack"] .sl-note {
+  margin: auto;
+  padding: 10px;
+  text-align: center;
+  color: var(--muted);
+  font-size: 0.9em;
+  line-height: 1.45;
+}
+[data-module="slack"] .sl-note.is-error { color: var(--danger); }
+
+/* The pad never shrinks below its content (min-height stays `auto` on it
+   and on the key grid) — a shrunken grid would spill its rows under the
+   message line, which then swallows the taps. A tile too short for it
+   scrolls instead (.sl-gate has overflow: auto). */
+[data-module="slack"] .sl-pad {
+  flex: 1 1 auto;
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  max-width: 340px;
+  width: 100%;
+  margin: 0 auto;
+}
+[data-module="slack"] .sl-pad.sl-shake { animation: sl-shake 0.4s ease; }
+@keyframes sl-shake {
+  10%, 90% { transform: translateX(-2px); }
+  20%, 80% { transform: translateX(3px); }
+  30%, 50%, 70% { transform: translateX(-5px); }
+  40%, 60% { transform: translateX(5px); }
+}
+
+/* one line: "Enter PIN · sending as Apollo Beach → #production" */
+[data-module="slack"] .sl-pad-head {
+  flex: none;
+  text-align: center;
+  font-size: 0.8em;
+  color: var(--muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+[data-module="slack"] .sl-pad-head b { font-weight: 700; color: var(--text); }
+
+[data-module="slack"] .sl-dots {
+  flex: none;
+  display: flex;
+  justify-content: center;
+  gap: 8px;
+  height: 14px;
+}
+[data-module="slack"] .sl-dot {
+  width: 11px;
+  height: 11px;
+  border-radius: 50%;
+  border: 2px solid var(--muted);
+  transition: background 0.12s, border-color 0.12s;
+}
+[data-module="slack"] .sl-dot.on { background: var(--accent); border-color: var(--accent); }
+
+[data-module="slack"] .sl-keys {
+  flex: 1 1 auto;
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  grid-template-rows: repeat(4, minmax(24px, 1fr));
+  gap: 5px;
+}
+[data-module="slack"] .sl-key {
+  min-width: 0;
+  min-height: 24px;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: color-mix(in srgb, var(--text) 5%, var(--panel));
+  color: var(--text);
+  font: inherit;
+  font-size: clamp(13px, 9cqh, 26px);
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+  transition: background 0.1s;
+}
+[data-module="slack"] .sl-key:hover { background: var(--border); }
+[data-module="slack"] .sl-key:active { background: color-mix(in srgb, var(--accent) 30%, var(--panel)); }
+[data-module="slack"] .sl-key svg { width: 1.1em; height: 1.1em; }
+[data-module="slack"] .sl-key-back { color: var(--muted); }
+[data-module="slack"] .sl-key-ok { background: var(--accent); color: var(--accent-text); border-color: transparent; }
+[data-module="slack"] .sl-key-ok:hover { background: color-mix(in srgb, var(--accent) 85%, var(--text)); }
+[data-module="slack"] .sl-key-ok:disabled {
+  background: color-mix(in srgb, var(--accent) 25%, var(--panel));
+  color: var(--muted);
+  cursor: default;
+}
+
+[data-module="slack"] .sl-pad-msg {
+  flex: none;
+  min-height: 1.1em;
+  text-align: center;
+  font-size: 0.78em;
+  line-height: 1.1;
+  color: var(--muted);
+}
+[data-module="slack"] .sl-pad-msg.is-error { color: var(--danger); font-weight: 600; }
+
+/* ── send / quick replies: unlocked ── */
+
+[data-module="slack"] .sl-compose { gap: 6px; }
+
+[data-module="slack"] .sl-compose-head {
+  flex: none;
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+  font-size: 0.8em;
+  color: var(--muted);
+}
+[data-module="slack"] .sl-sending {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+[data-module="slack"] .sl-lock-link {
+  flex: none;
+  padding: 1px 8px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  background: none;
+  color: var(--muted);
+  font: inherit;
+  font-size: 0.9em;
+  cursor: pointer;
+}
+[data-module="slack"] .sl-lock-link:hover { color: var(--text); background: var(--border); }
+
+[data-module="slack"] .sl-input {
+  flex: 1;
+  min-height: 2.6em;
+  width: 100%;
+  resize: none;
+  padding: 7px 9px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--bg);
+  color: var(--text);
+  font: inherit;
+  line-height: 1.4;
+}
+[data-module="slack"] .sl-input:focus { outline: none; border-color: var(--accent); }
+
+[data-module="slack"] .sl-compose-foot {
+  flex: none;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 1.6em;
+}
+[data-module="slack"] .sl-msg {
+  flex: 1;
+  min-width: 0;
+  font-size: 0.8em;
+  color: var(--muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+[data-module="slack"] .sl-msg.is-flash { color: var(--accent); font-weight: 700; }
+[data-module="slack"] .sl-msg.is-error { color: var(--danger); white-space: normal; font-weight: 600; }
+[data-module="slack"] .sl-countdown {
+  flex: none;
+  font-size: 0.75em;
+  color: var(--warn);
+  font-variant-numeric: tabular-nums;
+}
+[data-module="slack"] .sl-sendbtn {
+  flex: none;
+  padding: 6px 16px;
+  border: none;
+  border-radius: 8px;
+  background: var(--accent);
+  color: var(--accent-text);
+  font: inherit;
+  font-weight: 700;
+  cursor: pointer;
+}
+[data-module="slack"] .sl-sendbtn:hover { background: color-mix(in srgb, var(--accent) 85%, var(--text)); }
+[data-module="slack"] .sl-sendbtn:disabled { opacity: 0.6; cursor: default; }
+
+/* the preset grid: big targets, labels wrap */
+[data-module="slack"] .sl-grid {
+  flex: 1;
+  min-height: 0;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(min(150px, 100%), 1fr));
+  grid-auto-rows: minmax(44px, auto);
+  gap: 6px;
+  align-content: start;
+  overflow-y: auto;
+}
+[data-module="slack"] .sl-grid .sl-note { grid-column: 1 / -1; }
+[data-module="slack"] .sl-quick {
+  min-width: 0;
+  min-height: 44px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 2px;
+  padding: 6px 10px;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: color-mix(in srgb, var(--accent) 12%, var(--panel));
+  color: var(--text);
+  font: inherit;
+  font-weight: 600;
+  line-height: 1.25;
+  text-align: center;
+  cursor: pointer;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+  transition: background 0.1s;
+}
+[data-module="slack"] .sl-quick:hover { background: color-mix(in srgb, var(--accent) 22%, var(--panel)); }
+[data-module="slack"] .sl-quick:active { background: color-mix(in srgb, var(--accent) 40%, var(--panel)); }
+[data-module="slack"] .sl-quick.is-busy { opacity: 0.7; }
+[data-module="slack"] .sl-quick.is-sent {
+  background: var(--accent);
+  border-color: transparent;
+  color: var(--accent-text);
+}
+[data-module="slack"] .sl-quick-label { overflow-wrap: anywhere; }
+[data-module="slack"] .sl-quick-chan {
+  font-size: 0.72em;
+  font-weight: 500;
+  color: var(--muted);
+}
+[data-module="slack"] .sl-quick.is-sent .sl-quick-chan { color: inherit; }
diff --git a/public/admin/admin.css b/public/admin/admin.css
index e895423..157d0fb 100644
--- a/public/admin/admin.css
+++ b/public/admin/admin.css
@@ -135,6 +135,22 @@ body { overflow: auto; }
 .module-form { margin-top: 12px; border-top: 1px solid var(--border); padding-top: 12px; }
 .module-form .field { max-width: 420px; }
 
+/* a multi-line string (manifest type `text`): the same box as the other
+   inputs (those rules live in the shell's style.css), a few lines tall */
+.field textarea {
+  padding: 7px 9px;
+  font-size: 13px;
+  font-family: inherit;
+  line-height: 1.4;
+  color: var(--text);
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 7px;
+  resize: vertical;
+  min-height: 72px;
+}
+.field textarea:focus { outline: none; border-color: var(--accent); }
+
 /* endpoint fields: every module's upstream is entered the same way */
 .field .endpoint-row { display: flex; align-items: center; gap: 7px; }
 .endpoint-row .ep-host { flex: 1; min-width: 0; }
diff --git a/public/admin/admin.js b/public/admin/admin.js
index ff771cc..17dd44e 100644
--- a/public/admin/admin.js
+++ b/public/admin/admin.js
@@ -239,6 +239,17 @@ function fieldFor(key, spec, value, passwordSet, moduleId) {
     input.value = hex(value, hex(spec?.default, '#2ee59a'));
     field.append(span, input);
     read = () => input.value;
+  } else if (type === 'text') {
+    // A multi-line string — one item per line by convention (a list of
+    // presets, say). Stored as-is, newlines included.
+    const span = document.createElement('span');
+    span.textContent = label;
+    const textarea = document.createElement('textarea');
+    textarea.rows = 5;
+    textarea.spellcheck = false;
+    textarea.value = value === undefined || value === null ? '' : String(value);
+    field.append(span, textarea);
+    read = () => textarea.value;
   } else {
     const span = document.createElement('span');
     span.textContent = label;
diff --git a/tools/slack-mock.js b/tools/slack-mock.js
new file mode 100644
index 0000000..07c3908
--- /dev/null
+++ b/tools/slack-mock.js
@@ -0,0 +1,309 @@
+/**
+ * Mock Slack Web API for developing the slack module without a workspace.
+ *
+ *   node tools/slack-mock.js [port]                       (default 24716)
+ *   SLACK_API_BASE=http://127.0.0.1:24716/api node server.js
+ *
+ * Then, in /admin → Slack, paste any token that starts with xoxp- (a user
+ * token: auth.test answers as the location account "Apollo Beach") or xoxb-
+ * (a bot token: bot_id set, user "proddash"); anything else is invalid_auth.
+ * Two more tokens exercise the error paths: xoxp-revoked → token_revoked,
+ * xoxp-noscope → missing_scope (needed channels:history) on history reads.
+ *
+ * Methods, all under /api/<method>, POST form or JSON (GET works too):
+ *   auth.test               identity for the token (see above)
+ *   conversations.list      #production, #ops, #campus-leads (private) as
+ *                           member; #announcements not a member; paginated
+ *   conversations.info      one channel, with is_member
+ *   conversations.history   newest-first window (limit); not_in_channel for
+ *                           #announcements
+ *   conversations.replies   a thread's parent + replies
+ *   users.info              display names for the seeded users
+ *   chat.postMessage        appends to the channel (echoes `username` for
+ *                           bots as a bot_message); text containing "!429"
+ *                           answers HTTP 429 with Retry-After: 3
+ *
+ * #production is seeded with mrkdwn, mentions, a link, a thread, a bot
+ * attachment and a file; it gains a new fake message every ~8 s, edits one
+ * every ~25 s, deletes one every ~40 s and adds a thread reply every ~30 s.
+ * Every request is logged.
+ */
+'use strict';
+
+const http = require('http');
+
+const PORT = Number.parseInt(process.argv[2] || '24716', 10);
+
+/* ── data ───────────────────────────────────────────────────────────── */
+
+const USERS = {
+  U001: { name: 'apollo.beach', real_name: 'Apollo Beach', display_name: 'Apollo Beach' },
+  U002: { name: 'michael', real_name: 'Michael McGary', display_name: 'Michael' },
+  U003: { name: 'sarah.lee', real_name: 'Sarah Lee', display_name: 'Sarah' },
+  U004: { name: 'north.attleboro', real_name: 'North Attleboro', display_name: 'North Attleboro' },
+  U005: { name: 'dan.k', real_name: 'Dan Kowalski', display_name: 'Dan K' },
+  UBOT: { name: 'proddash', real_name: 'ProdDash', display_name: '', is_bot: true },
+};
+
+const CHANNELS = [
+  { id: 'C001', name: 'production', is_private: false, is_member: true },
+  { id: 'C002', name: 'ops', is_private: false, is_member: true },
+  { id: 'G001', name: 'campus-leads', is_private: true, is_member: true },
+  { id: 'C003', name: 'announcements', is_private: false, is_member: false },
+];
+
+let tsCounter = 0;
+function ts(offsetMs = 0) {
+  tsCounter += 1;
+  return `${Math.floor((Date.now() + offsetMs) / 1000)}.${String(tsCounter).padStart(6, '0')}`;
+}
+
+/** channel id -> messages (ascending); replies live inside their parent. */
+const history = new Map();
+for (const c of CHANNELS) history.set(c.id, []);
+
+function push(channelId, msg) {
+  const list = history.get(channelId);
+  const m = { type: 'message', ts: msg.ts || ts(), ...msg };
+  list.push(m);
+  if (list.length > 400) list.splice(0, list.length - 400);
+  return m;
+}
+
+function seed() {
+  const min = 60000;
+  const at = (minsAgo) => ts(-minsAgo * min);
+  push('C001', { ts: at(58), user: 'U003', subtype: 'channel_join', text: '<@U003> has joined the channel' });
+  push('C001', { ts: at(55), user: 'U002', text: 'Morning all — doors at 9:15, first service 10:00. Run of show is in <#C002|ops>.' });
+  push('C001', { ts: at(50), user: 'U001', text: 'Apollo Beach is up. Stream key checked, ProPresenter online :white_check_mark:' });
+  push('C001', { ts: at(47), user: 'U004', text: 'North Attleboro here — we have *no audio* on the sermon feed yet, working on it' });
+  push('C001', { ts: at(44), user: 'U002', text: '<@U004> try the Dante patch — `Sermon Feed L/R` should be on 31/32. _Ping me if not._' });
+  const parent = push('C001', { ts: at(40), user: 'U003', text: 'Countdown video is the new one this week, right? ~old one~ &lt;-- not this', reply_count: 2, latest_reply: '' });
+  parent.replies = [
+    { type: 'message', ts: at(39), user: 'U002', text: 'Yes — "Countdown 5 min (Sept)" in the media bin', thread_ts: parent.ts },
+    { type: 'message', ts: at(38), user: 'U003', text: 'Got it :+1:', thread_ts: parent.ts },
+  ];
+  parent.latest_reply = parent.replies[1].ts;
+  push('C001', {
+    ts: at(35), subtype: 'bot_message', bot_id: 'B002', username: 'Planning Center', text: '',
+    attachments: [{ fallback: 'Plan updated: Sunday Service — Sept 14 (2 items changed)', title: 'Plan updated', text: 'Sunday Service — Sept 14 (2 items changed)' }],
+  });
+  push('C001', { ts: at(30), user: 'U005', text: 'Lower thirds for the announcements: <https://waterschurch.org/plan|this week’s plan>', files: [{ id: 'F001', name: 'lower-thirds-0914.png', title: 'lower-thirds-0914.png' }] });
+  push('C001', { ts: at(25), user: 'U004', text: 'Audio fixed — Dante patch was it. Thanks <@U002> :pray:', edited: { user: 'U004', ts: at(24) } });
+  push('C001', { ts: at(20), user: 'U002', text: '<!here> 10 minutes to doors. Campuses, post "ready" when your pre-service loop is running.' });
+  push('C001', { ts: at(15), user: 'U001', text: 'Apollo Beach ready' });
+  push('C001', { ts: at(14), user: 'U004', text: 'North Attleboro ready' });
+
+  push('C002', { ts: at(120), user: 'U002', text: 'Run of show for Sept 14 is pinned. Changes go here, not in DMs.' });
+  push('C002', { ts: at(90), user: 'U005', text: 'Bumper video is 0:42 this week, not 0:30 — adjust your timers.' });
+  push('G001', { ts: at(200), user: 'U002', text: 'Leads: budget call moved to Tuesday 2pm.' });
+  push('C003', { ts: at(300), user: 'U002', text: 'Staff meeting notes are in the drive.' });
+}
+seed();
+
+const CHATTER = [
+  { user: 'U003', text: 'Walk-in music is a touch loud at the back, can we come down 2 dB?' },
+  { user: 'U002', text: 'Cue 4 is the *baptism video* — heads up, it has its own audio' },
+  { user: 'U005', text: 'Livestream is live, 38 viewers already :tada:' },
+  { user: 'U004', text: 'North Attleboro: pastor is running about 3 min long today' },
+  { user: 'U002', text: 'Copy. Apollo Beach, hold your bumper until you hear from us' },
+  { user: 'U003', text: 'Lyrics slide 3 of "Living Hope" has a typo — fixing for second service' },
+  { user: 'U005', text: 'Stream bitrate dipped for a sec, back to normal now' },
+  { user: 'U002', text: 'Offering moment is *after* the sermon this week, not before' },
+  { user: 'U004', text: 'Anyone else seeing the ProPresenter stage display lag?' },
+  { user: 'U003', text: 'Kids check-in is slammed, could use one more volunteer at the desk' },
+  { user: 'U002', text: 'Great first service everyone :clap: reset in 15' },
+];
+let chatterIx = 0;
+
+function tickNew() {
+  const line = CHATTER[chatterIx % CHATTER.length];
+  chatterIx += 1;
+  const m = push('C001', { user: line.user, text: line.text });
+  console.log(`[slack-mock] + new message ${m.ts} from ${line.user}`);
+}
+
+function tickEdit() {
+  const list = history.get('C001');
+  const recent = list.slice(-8).filter((m) => m.user && !m.subtype && !m.edited);
+  if (!recent.length) return;
+  const m = recent[Math.floor(Math.random() * recent.length)];
+  m.text += ' — fixed';
+  m.edited = { user: m.user, ts: ts() };
+  console.log(`[slack-mock] ~ edited ${m.ts}`);
+}
+
+function tickDelete() {
+  const list = history.get('C001');
+  const candidates = list.slice(-10, -2).filter((m) => m.user && !m.subtype && !m.reply_count);
+  if (!candidates.length) return;
+  const victim = candidates[Math.floor(Math.random() * candidates.length)];
+  list.splice(list.indexOf(victim), 1);
+  console.log(`[slack-mock] - deleted ${victim.ts}`);
+}
+
+function tickReply() {
+  const list = history.get('C001');
+  const parent = list.find((m) => m.reply_count);
+  if (!parent) return;
+  const reply = { type: 'message', ts: ts(), user: ['U002', 'U003', 'U005'][parent.replies.length % 3], text: `Thread reply ${parent.replies.length + 1} :eyes:`, thread_ts: parent.ts };
+  parent.replies.push(reply);
+  parent.reply_count = parent.replies.length;
+  parent.latest_reply = reply.ts;
+  console.log(`[slack-mock] ↳ reply on ${parent.ts} (${parent.reply_count} total)`);
+}
+
+setInterval(tickNew, 8000).unref();
+setInterval(tickEdit, 25000).unref();
+setInterval(tickDelete, 40000).unref();
+setInterval(tickReply, 30000).unref();
+
+/* ── plumbing ───────────────────────────────────────────────────────── */
+
+function send(res, status, body, headers = {}) {
+  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store', ...headers });
+  res.end(JSON.stringify(body));
+}
+
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = '';
+    req.on('data', (c) => { data += c; });
+    req.on('end', () => resolve(data));
+    req.on('error', () => resolve(''));
+  });
+}
+
+function parseParams(req, url, raw) {
+  const params = Object.fromEntries(url.searchParams.entries());
+  const ctype = String(req.headers['content-type'] || '');
+  if (raw) {
+    if (ctype.includes('application/json')) {
+      try { Object.assign(params, JSON.parse(raw)); } catch { /* ignore */ }
+    } else {
+      for (const [k, v] of new URLSearchParams(raw)) params[k] = v;
+    }
+  }
+  return params;
+}
+
+function tokenOf(req, params) {
+  const m = /^Bearer\s+(\S+)/.exec(String(req.headers.authorization || ''));
+  return m ? m[1] : String(params.token || '');
+}
+
+function identity(token) {
+  if (token === 'xoxp-revoked') return { error: 'token_revoked' };
+  if (/^xoxp-/.test(token)) return { ok: true, url: 'https://waters.slack.com/', team: 'Waters Church', user: 'apollo.beach', team_id: 'T001', user_id: 'U001', noscope: token === 'xoxp-noscope' };
+  if (/^xoxb-/.test(token)) return { ok: true, url: 'https://waters.slack.com/', team: 'Waters Church', user: 'proddash', team_id: 'T001', user_id: 'UBOT', bot_id: 'B001' };
+  return { error: 'invalid_auth' };
+}
+
+function channelRecord(c) {
+  return { id: c.id, name: c.name, name_normalized: c.name, is_channel: !c.is_private, is_group: c.is_private, is_private: c.is_private, is_member: c.is_member, is_archived: false, num_members: 12 };
+}
+
+function publicMessage(m) {
+  const { replies, ...rest } = m;
+  return rest;
+}
+
+function findChannel(ref) {
+  const s = String(ref || '');
+  return CHANNELS.find((c) => c.id === s || c.name === s.replace(/^#/, ''));
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, `http://127.0.0.1:${PORT}`);
+  const raw = req.method === 'POST' ? await readBody(req) : '';
+  const params = parseParams(req, url, raw);
+  const method = url.pathname.replace(/^\/api\//, '');
+  const summary = Object.entries(params).filter(([k]) => k !== 'token').map(([k, v]) => `${k}=${String(v).slice(0, 40)}`).join(' ');
+  console.log(`[slack-mock] ${req.method} ${url.pathname} ${summary}`);
+
+  if (!url.pathname.startsWith('/api/')) return send(res, 404, { ok: false, error: 'unknown_method' });
+
+  const token = tokenOf(req, params);
+  const who = identity(token);
+  if (!who.ok) return send(res, 200, { ok: false, error: who.error });
+
+  switch (method) {
+    case 'auth.test': {
+      const { noscope, ...rest } = who;
+      return send(res, 200, rest);
+    }
+
+    case 'users.info': {
+      const u = USERS[String(params.user)];
+      if (!u) return send(res, 200, { ok: false, error: 'user_not_found' });
+      return send(res, 200, { ok: true, user: { id: params.user, name: u.name, real_name: u.real_name, is_bot: Boolean(u.is_bot), profile: { display_name: u.display_name, real_name: u.real_name } } });
+    }
+
+    case 'conversations.list': {
+      const types = String(params.types || 'public_channel').split(',');
+      let list = CHANNELS.filter((c) => (c.is_private ? types.includes('private_channel') : types.includes('public_channel')));
+      if (who.bot_id) list = list.filter((c) => c.is_member); // a bot sees only what it's in
+      const limit = Math.max(1, Math.min(1000, Number(params.limit) || 100));
+      const start = params.cursor ? Number(Buffer.from(String(params.cursor), 'base64').toString()) || 0 : 0;
+      const page = list.slice(start, start + limit);
+      const next = start + limit < list.length ? Buffer.from(String(start + limit)).toString('base64') : '';
+      return send(res, 200, { ok: true, channels: page.map(channelRecord), response_metadata: { next_cursor: next } });
+    }
+
+    case 'conversations.info': {
+      const c = findChannel(params.channel);
+      if (!c) return send(res, 200, { ok: false, error: 'channel_not_found' });
+      return send(res, 200, { ok: true, channel: channelRecord(c) });
+    }
+
+    case 'conversations.history': {
+      const c = findChannel(params.channel);
+      if (!c) return send(res, 200, { ok: false, error: 'channel_not_found' });
+      if (who.noscope) return send(res, 200, { ok: false, error: 'missing_scope', needed: 'channels:history', provided: 'channels:read,chat:write' });
+      if (!c.is_member) return send(res, 200, { ok: false, error: 'not_in_channel' });
+      const limit = Math.max(1, Math.min(1000, Number(params.limit) || 100));
+      const list = history.get(c.id);
+      const window = list.slice(-limit).reverse().map(publicMessage);
+      return send(res, 200, { ok: true, messages: window, has_more: list.length > limit, pin_count: 0 });
+    }
+
+    case 'conversations.replies': {
+      const c = findChannel(params.channel);
+      if (!c) return send(res, 200, { ok: false, error: 'channel_not_found' });
+      if (!c.is_member) return send(res, 200, { ok: false, error: 'not_in_channel' });
+      const parent = history.get(c.id).find((m) => m.ts === String(params.ts));
+      if (!parent) return send(res, 200, { ok: false, error: 'thread_not_found' });
+      const limit = Math.max(1, Math.min(1000, Number(params.limit) || 100));
+      return send(res, 200, { ok: true, messages: [publicMessage(parent), ...(parent.replies || []).slice(0, limit - 1)], has_more: false });
+    }
+
+    case 'chat.postMessage': {
+      const c = findChannel(params.channel);
+      if (!c) return send(res, 200, { ok: false, error: 'channel_not_found' });
+      if (!c.is_member) return send(res, 200, { ok: false, error: 'not_in_channel' });
+      const text = String(params.text || '');
+      if (!text.trim()) return send(res, 200, { ok: false, error: 'no_text' });
+      if (text.includes('!429')) return send(res, 429, { ok: false, error: 'ratelimited' }, { 'Retry-After': '3' });
+      let m;
+      if (who.bot_id && params.username) {
+        m = push(c.id, { subtype: 'bot_message', bot_id: who.bot_id, username: String(params.username), icons: params.icon_emoji ? { emoji: String(params.icon_emoji) } : undefined, text });
+      } else if (who.bot_id) {
+        m = push(c.id, { user: who.user_id, bot_id: who.bot_id, bot_profile: { id: who.bot_id, name: 'ProdDash' }, text });
+      } else {
+        m = push(c.id, { user: who.user_id, text });
+      }
+      if (params.thread_ts) m.thread_ts = String(params.thread_ts);
+      console.log(`[slack-mock] ✉ posted to #${c.name} as ${params.username || who.user}: ${text.slice(0, 60)}`);
+      return send(res, 200, { ok: true, channel: c.id, ts: m.ts, message: publicMessage(m) });
+    }
+
+    default:
+      return send(res, 200, { ok: false, error: 'unknown_method' });
+  }
+});
+
+server.listen(PORT, '127.0.0.1', () => {
+  console.log(`[slack-mock] Slack Web API mock on http://127.0.0.1:${PORT}/api`);
+  console.log('[slack-mock] tokens: xoxp-anything (user "Apollo Beach"), xoxb-anything (bot), xoxp-revoked, xoxp-noscope');
+  console.log('[slack-mock] run ProdDash with: SLACK_API_BASE=http://127.0.0.1:%d/api node server.js', PORT);
+});