@mnemom/mnemom 0.17.25 → 0.17.27

package/dist/lib/slack-route.d.ts

@@ -14,6 +14,22 @@
  *   3. PLAIN HANDLE — `@pv2-lead …` typed as text routes to that session when it
  *      is a known live session (plain text is not a Slack mention, so it is only
  *      honoured for names we recognise, to avoid routing stray `@words`).
+ *   4. ALIAS — an operator-registered handle (`mnemom agent slack alias <handle>
+ *      <session>`) routes to that session whether or not it is live right now:
+ *      the inbox is a file and the session's listener resumes from its saved
+ *      offset, so the message waits for it. The hit carries `for: <handle>`, so a
+ *      session fronting for several handles can tell which one was addressed.
+ *
+ * STICKY THREADS: once a message is routed to a session by (2)-(4), the router
+ * records that routing like a post, so later replies in the same thread reach the
+ * same session under (1) without re-addressing it (bounded by a TTL in
+ * lib/slack-state.ts). The record keeps the ADDRESS that was used, and every read
+ * re-resolves it (reresolveRoutes), so a thread follows a restarted or replaced
+ * session instead of the one that happened to answer first.
+ *
+ * Aliases (4) and sticky threads are each OFF unless the operator turns them on
+ * (launcher `slack_aliases` / `slack_sticky_threads`); off, routing is exactly
+ * (1)-(3) as before.
  *
  * The app's own posts (bot_id set) are never routed — sessions do not hear
  * themselves or each other through the router.
@@ -33,15 +49,23 @@ export interface SlackMessageEvent {
         permalink?: string;
     }>;
 }
-/** One post a session made: `ts` in `channel`, plus the thread it was in (if any). */
+/**
+ * One post a session made: `ts` in `channel`, plus the thread it was in (if any).
+ * A sticky-thread route record has the same shape, with `for` set when the message
+ * reached the session through an alias handle.
+ */
 export interface PostRecord {
     session: string;
     channel: string;
     ts: string;
     thread_ts?: string;
+    for?: string;
 }
-/** channel → thread root ts → sessions that posted in that thread. */
-export type ThreadIndex = Map<string, Map<string, Set<string>>>;
+/**
+ * channel → thread root ts → sessions that posted (or were routed) in that thread,
+ * each with the alias handle it was reached as (undefined for a plain post).
+ */
+export type ThreadIndex = Map<string, Map<string, Map<string, string | undefined>>>;
 export declare function buildThreadIndex(posts: Iterable<PostRecord>): ThreadIndex;
 /** Normalise a session name for comparison (same shape the launcher emits). */
 export declare function normSession(raw: string): string;
@@ -51,19 +75,58 @@ export declare function normSession(raw: string): string;
  * `agent-user-mnemom-design-helper`. Ambiguous or unknown → undefined.
  */
 export declare function resolveLiveSession(name: string, live: Map<string, string>): string | undefined;
+/** A session a message is routed to, and the alias handle it was addressed by (if any). */
+export interface RouteHit {
+    session: string;
+    for?: string;
+    /** The normalised name the message used to reach it (a handle or a session name). */
+    addr?: string;
+}
+/** Normalise an alias handle (the same shape as a session name; `@` and case dropped). */
+export declare function normHandle(raw: string): string;
+/**
+ * What `name` addresses: an exact live session, else a registered alias (live or
+ * not — see ALIAS above), else the ONE live session whose name ends in `-<name>`.
+ * An alias outranks a suffix match because an operator registered it on purpose.
+ */
+export declare function resolveAddress(name: string, live: Map<string, string>, aliases?: Map<string, string>): RouteHit | undefined;
+/** A sticky-thread route as stored: a post-shaped record plus the address it was made by. */
+export interface StickyRoute extends PostRecord {
+    addr?: string;
+}
 /**
- * The sessions `ev` is addressed to. `liveSessions` are the names with a running
- * listener; `botUserId` is the app's bot user (from auth.test). Returns [] for
- * events that address no one (or that the app itself posted).
+ * Re-resolve stored sticky routes against who is live and which aliases exist NOW,
+ * so a thread follows the session currently behind the address rather than the one
+ * it reached when the route was recorded:
+ *   - the stored address resolves (live session, alias, unique live suffix) → route
+ *     to that session, with the handle it resolved as;
+ *   - it does not, and the route was made through an alias → drop it (the handle was
+ *     removed: the operator stopped routing it);
+ *   - it does not, and it was a plain session address → keep the recorded session
+ *     (nothing newer answers to that name).
+ * A record with no stored address falls back to its alias handle.
  */
-export declare function routeMessage(ev: SlackMessageEvent, ctx: {
+export declare function reresolveRoutes(routes: Iterable<StickyRoute>, live: Iterable<string>, aliases: Map<string, string>): PostRecord[];
+export interface RouteContext {
     botUserId: string;
     liveSessions: Iterable<string>;
     threads: ThreadIndex;
-}): string[];
+    /** normalised handle → session (from `mnemom agent slack alias`). */
+    aliases?: Map<string, string>;
+}
+/**
+ * The sessions `ev` is addressed to, each with the alias handle it was reached
+ * as. `liveSessions` are the names with a running listener; `botUserId` is the
+ * app's bot user (from auth.test). Returns [] for events that address no one (or
+ * that the app itself posted). A session hit both as an alias and otherwise keeps
+ * the alias handle.
+ */
+export declare function routeHits(ev: SlackMessageEvent, ctx: RouteContext): RouteHit[];
+/** The session names `ev` is addressed to (routeHits without the handles). */
+export declare function routeMessage(ev: SlackMessageEvent, ctx: RouteContext): string[];
 /**
  * The text a session receives: the app mention, and a live session name right
  * after it, are stripped so the model reads the instruction, not the routing.
  * A word after the mention that is NOT a live session is kept (it is content).
  */
-export declare function stripAddressing(text: string, botUserId: string, liveSessions: Iterable<string>): string;
+export declare function stripAddressing(text: string, botUserId: string, liveSessions: Iterable<string>, aliases?: Map<string, string>): string;

package/dist/lib/slack-route.js

@@ -14,6 +14,22 @@
  *   3. PLAIN HANDLE — `@pv2-lead …` typed as text routes to that session when it
  *      is a known live session (plain text is not a Slack mention, so it is only
  *      honoured for names we recognise, to avoid routing stray `@words`).
+ *   4. ALIAS — an operator-registered handle (`mnemom agent slack alias <handle>
+ *      <session>`) routes to that session whether or not it is live right now:
+ *      the inbox is a file and the session's listener resumes from its saved
+ *      offset, so the message waits for it. The hit carries `for: <handle>`, so a
+ *      session fronting for several handles can tell which one was addressed.
+ *
+ * STICKY THREADS: once a message is routed to a session by (2)-(4), the router
+ * records that routing like a post, so later replies in the same thread reach the
+ * same session under (1) without re-addressing it (bounded by a TTL in
+ * lib/slack-state.ts). The record keeps the ADDRESS that was used, and every read
+ * re-resolves it (reresolveRoutes), so a thread follows a restarted or replaced
+ * session instead of the one that happened to answer first.
+ *
+ * Aliases (4) and sticky threads are each OFF unless the operator turns them on
+ * (launcher `slack_aliases` / `slack_sticky_threads`); off, routing is exactly
+ * (1)-(3) as before.
  *
  * The app's own posts (bot_id set) are never routed — sessions do not hear
  * themselves or each other through the router.
@@ -30,8 +46,10 @@ export function buildThreadIndex(posts) {
         for (const root of new Set([p.ts, p.thread_ts].filter(Boolean))) {
             let sessions = byRoot.get(root);
             if (!sessions)
-                byRoot.set(root, (sessions = new Set()));
-            sessions.add(p.session);
+                byRoot.set(root, (sessions = new Map()));
+            // A plain post never erases the handle an earlier route recorded.
+            if (!sessions.has(p.session) || p.for)
+                sessions.set(p.session, p.for);
         }
     }
     return idx;
@@ -59,12 +77,71 @@ export function resolveLiveSession(name, live) {
     const hits = [...live.keys()].filter((k) => k.endsWith(`-${n}`));
     return hits.length === 1 ? live.get(hits[0]) : undefined;
 }
+/** Normalise an alias handle (the same shape as a session name; `@` and case dropped). */
+export function normHandle(raw) {
+    return normSession(raw.replace(/^@+/, ""));
+}
 /**
- * The sessions `ev` is addressed to. `liveSessions` are the names with a running
- * listener; `botUserId` is the app's bot user (from auth.test). Returns [] for
- * events that address no one (or that the app itself posted).
+ * What `name` addresses: an exact live session, else a registered alias (live or
+ * not — see ALIAS above), else the ONE live session whose name ends in `-<name>`.
+ * An alias outranks a suffix match because an operator registered it on purpose.
  */
-export function routeMessage(ev, ctx) {
+export function resolveAddress(name, live, aliases = new Map()) {
+    // An empty name matches nothing: live and alias keys are never empty, and
+    // resolveLiveSession refuses an empty suffix.
+    const n = normSession(name);
+    const exact = live.get(n);
+    if (exact)
+        return { session: exact, addr: n };
+    const alias = aliases.get(n);
+    if (alias)
+        return { session: alias, for: n, addr: n };
+    const hit = resolveLiveSession(n, live);
+    return hit ? { session: hit, addr: n } : undefined;
+}
+/**
+ * Re-resolve stored sticky routes against who is live and which aliases exist NOW,
+ * so a thread follows the session currently behind the address rather than the one
+ * it reached when the route was recorded:
+ *   - the stored address resolves (live session, alias, unique live suffix) → route
+ *     to that session, with the handle it resolved as;
+ *   - it does not, and the route was made through an alias → drop it (the handle was
+ *     removed: the operator stopped routing it);
+ *   - it does not, and it was a plain session address → keep the recorded session
+ *     (nothing newer answers to that name).
+ * A record with no stored address falls back to its alias handle.
+ */
+export function reresolveRoutes(routes, live, aliases) {
+    const liveMap = new Map();
+    for (const s of live)
+        liveMap.set(normSession(s), s);
+    const out = [];
+    for (const r of routes) {
+        const base = {
+            session: r.session,
+            channel: r.channel,
+            ts: r.ts,
+            ...(r.thread_ts ? { thread_ts: r.thread_ts } : {}),
+        };
+        const addr = r.addr ?? r.for;
+        const now = addr ? resolveAddress(addr, liveMap, aliases) : undefined;
+        if (now)
+            out.push({ ...base, session: now.session, ...(now.for ? { for: now.for } : {}) });
+        else if (r.for)
+            continue;
+        else
+            out.push(base);
+    }
+    return out;
+}
+/**
+ * The sessions `ev` is addressed to, each with the alias handle it was reached
+ * as. `liveSessions` are the names with a running listener; `botUserId` is the
+ * app's bot user (from auth.test). Returns [] for events that address no one (or
+ * that the app itself posted). A session hit both as an alias and otherwise keeps
+ * the alias handle.
+ */
+export function routeHits(ev, ctx) {
     if (ev.bot_id || !ev.user || !ev.channel || !ev.ts)
         return [];
     if (ev.subtype && ev.subtype !== "thread_broadcast" && ev.subtype !== "file_share")
@@ -72,43 +149,55 @@ export function routeMessage(ev, ctx) {
     const live = new Map();
     for (const s of ctx.liveSessions)
         live.set(normSession(s), s);
-    const out = new Set();
+    const aliases = ctx.aliases ?? new Map();
+    const out = new Map();
+    const add = (h) => {
+        if (!h)
+            return;
+        const prev = out.get(h.session);
+        // An alias hit outranks a plain one for the same session; otherwise first wins.
+        if (!prev || (h.for && !prev.for))
+            out.set(h.session, h);
+    };
     const text = ev.text ?? "";
-    // 1. thread reply
+    // 1. thread reply (posts + sticky routes)
     if (ev.thread_ts && ev.thread_ts !== ev.ts) {
-        for (const s of ctx.threads.get(ev.channel)?.get(ev.thread_ts) ?? [])
-            out.add(s);
+        for (const [s, f] of ctx.threads.get(ev.channel)?.get(ev.thread_ts) ?? []) {
+            add({ session: s, ...(f ? { for: f } : {}) });
+        }
     }
     // 2. <@BOT> name…
     const mention = `<@${ctx.botUserId}>`;
     let at = text.indexOf(mention);
     while (at !== -1) {
         const after = text.slice(at + mention.length).match(/^[\s,:]*@?([A-Za-z0-9][A-Za-z0-9-]*)/);
-        if (after) {
-            const hit = resolveLiveSession(after[1], live);
-            if (hit)
-                out.add(hit);
-        }
+        if (after)
+            add(resolveAddress(after[1], live, aliases));
         at = text.indexOf(mention, at + mention.length);
     }
-    // 3. plain @handle for a known live session
-    for (const m of text.matchAll(HANDLE_RE)) {
-        const hit = resolveLiveSession(m[1], live);
-        if (hit)
-            out.add(hit);
-    }
-    return [...out];
+    // 3./4. plain @handle for a known live session or a registered alias
+    for (const m of text.matchAll(HANDLE_RE))
+        add(resolveAddress(m[1], live, aliases));
+    return [...out.values()].map(({ session, for: f, addr }) => ({
+        session,
+        ...(f ? { for: f } : {}),
+        ...(addr ? { addr } : {}),
+    }));
+}
+/** The session names `ev` is addressed to (routeHits without the handles). */
+export function routeMessage(ev, ctx) {
+    return routeHits(ev, ctx).map((h) => h.session);
 }
 /**
  * The text a session receives: the app mention, and a live session name right
  * after it, are stripped so the model reads the instruction, not the routing.
  * A word after the mention that is NOT a live session is kept (it is content).
  */
-export function stripAddressing(text, botUserId, liveSessions) {
+export function stripAddressing(text, botUserId, liveSessions, aliases = new Map()) {
     const live = new Map([...liveSessions].map((s) => [normSession(s), s]));
     const re = new RegExp(`<@${botUserId}>[\\s,:]*(?:@?([A-Za-z0-9][A-Za-z0-9-]*)[\\s,:]*)?`, "g");
     return text
-        .replace(re, (_whole, name) => name && !resolveLiveSession(name, live) ? `${name} ` : "")
+        .replace(re, (_whole, name) => name && !resolveAddress(name, live, aliases) ? `${name} ` : "")
         .replace(/[ \t]{2,}/g, " ")
         .trim();
 }

package/dist/lib/slack-router.d.ts

@@ -6,10 +6,29 @@
  * connection per session would silently drop messages). For every channel
  * message it asks lib/slack-route.ts who is addressed and appends the message to
  * each addressed session's inbox (lib/slack-state.ts); each session's listener
- * delivers from there. The router never writes to a session, never runs a tool,
- * and holds no state beyond an in-memory user-name cache.
+ * delivers from there. A routing made by address (mention, handle, alias) is
+ * recorded so later replies in that thread stick to the same session. The router
+ * never writes to a session, never runs a tool, and holds no state beyond an
+ * in-memory user-name cache.
  */
 import { type FetchLike } from "./slack.js";
+/** How often the router settles held messages (delivered / expired). */
+export declare const PENDING_SWEEP_MS = 30000;
+/**
+ * Settle the held messages (see settlePending) and tell the sender of each expired
+ * one, in its thread, that it was not delivered. Best effort: a failed post is
+ * logged, never retried (the message is already dropped from the queue).
+ */
+export declare function sweepPending(opts: {
+    botToken: string;
+    fetchImpl?: FetchLike;
+    log?: (line: string) => void;
+    now?: number;
+}): Promise<{
+    delivered: number;
+    expired: number;
+    held: number;
+}>;
 /** The running router's pid, or null. */
 export declare function routerPid(): number | null;
 /**
@@ -23,6 +42,22 @@ export declare function runRouter(opts: {
     appToken: string;
     /** Slack member ids allowed to reach a session; everyone else is dropped. */
     allow: string[];
+    /**
+     * Route `mnemom agent slack alias` handles, and hold a message for a session that
+     * is not listening (tell the sender it is waiting; report it undelivered after
+     * PENDING_TTL_MS). Off (the default): aliases are ignored and routing is unchanged.
+     */
+    aliases?: boolean;
+    /**
+     * A thread a session was addressed in keeps routing replies to it, re-resolved to
+     * whoever answers to that address now. Off (the default): only threads a session
+     * posted in route replies.
+     */
+    stickyThreads?: boolean;
+    /** How often to settle held messages (default PENDING_SWEEP_MS). */
+    sweepMs?: number;
+    /** Aborting stops the held-message sweep (tests; the CLI router runs until killed). */
+    signal?: AbortSignal;
     log?: (line: string) => void;
     fetchImpl?: FetchLike;
 }): Promise<never>;

package/dist/lib/slack-router.js

@@ -6,15 +6,37 @@
  * connection per session would silently drop messages). For every channel
  * message it asks lib/slack-route.ts who is addressed and appends the message to
  * each addressed session's inbox (lib/slack-state.ts); each session's listener
- * delivers from there. The router never writes to a session, never runs a tool,
- * and holds no state beyond an in-memory user-name cache.
+ * delivers from there. A routing made by address (mention, handle, alias) is
+ * recorded so later replies in that thread stick to the same session. The router
+ * never writes to a session, never runs a tool, and holds no state beyond an
+ * in-memory user-name cache.
  */
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { fetchThread, formatThread, messageBody, slackCall, } from "./slack.js";
-import { buildThreadIndex, routeMessage, stripAddressing, } from "./slack-route.js";
-import { appendInbox, liveSessions, readPosts, slackDir } from "./slack-state.js";
+import { buildThreadIndex, normSession, routeHits, stripAddressing, } from "./slack-route.js";
+import { appendInbox, inboxSize, listAliases, liveSessions, PENDING_TTL_MS, readAliases, readPosts, readThreadRecords, recordPending, recordRoute, settlePending, slackDir, } from "./slack-state.js";
+/** How often the router settles held messages (delivered / expired). */
+export const PENDING_SWEEP_MS = 30_000;
+const ttlText = () => `${Math.round(PENDING_TTL_MS / 60_000)} min`;
+/**
+ * Settle the held messages (see settlePending) and tell the sender of each expired
+ * one, in its thread, that it was not delivered. Best effort: a failed post is
+ * logged, never retried (the message is already dropped from the queue).
+ */
+export async function sweepPending(opts) {
+    const r = settlePending(opts.now ?? Date.now());
+    for (const p of r.expired) {
+        const res = await slackCall("chat.postMessage", opts.botToken, {
+            channel: p.channel,
+            thread_ts: p.thread_ts,
+            text: `<@${p.user}> not delivered: \`${p.session}\` did not pick this up within ${ttlText()}. Send it again once that session is running, or address another one.`,
+        }, opts.fetchImpl ?? fetch).catch((e) => ({ ok: false, error: e instanceof Error ? e.message : String(e) }));
+        opts.log?.(`undelivered ${p.channel}/${p.ts} → ${p.session}${res.ok ? "" : ` (notice failed: ${String(res.error)})`}`);
+    }
+    return { delivered: r.delivered.length, expired: r.expired.length, held: r.held.length };
+}
 const routerPidFile = () => join(slackDir(), "router.pid");
 function pidAlive(pid) {
     try {
@@ -53,6 +75,8 @@ export function ensureRouter(argv = [process.execPath, process.argv[1] ?? "mnemo
 }
 /** Run the router until the process is killed. Reconnects on disconnect. */
 export async function runRouter(opts) {
+    const aliasesOn = opts.aliases === true;
+    const stickyOn = opts.stickyThreads === true;
     // Lines carry Slack-supplied values (channel, handles, disconnect reason);
     // strip CR/LF so a crafted message cannot forge extra log lines.
     const log = opts.log ?? ((l) => console.error(`[slack-router] ${l.replace(/\n|\r/g, "")}`));
@@ -69,6 +93,14 @@ export async function runRouter(opts) {
         throw new Error(`a router is already running (pid ${other}).`);
     mkdirSync(slackDir(), { recursive: true, mode: 0o700 });
     writeFileSync(routerPidFile(), String(process.pid), { mode: 0o600 });
+    log(`aliases ${aliasesOn ? "on" : "off"}, sticky threads ${stickyOn ? "on" : "off"}`);
+    if (aliasesOn) {
+        const sweep = setInterval(() => {
+            sweepPending({ botToken: opts.botToken, fetchImpl, log }).catch((e) => log(`pending sweep failed: ${e instanceof Error ? e.message : e}`));
+        }, opts.sweepMs ?? PENDING_SWEEP_MS);
+        sweep.unref();
+        opts.signal?.addEventListener("abort", () => clearInterval(sweep));
+    }
     const names = new Map();
     const userName = async (id) => {
         if (names.has(id))
@@ -99,12 +131,14 @@ export async function runRouter(opts) {
         if (!ev.user || !opts.allow.includes(ev.user))
             return;
         const live = liveSessions();
-        const threads = buildThreadIndex(readPosts());
-        const targets = routeMessage(ev, { botUserId, liveSessions: live, threads });
-        if (!targets.length) {
+        const aliases = aliasesOn ? readAliases() : new Map();
+        const threads = buildThreadIndex(stickyOn ? readThreadRecords(Date.now(), { live, aliases }) : readPosts());
+        const hits = routeHits(ev, { botUserId, liveSessions: live, threads, aliases });
+        if (!hits.length) {
             if (ev.text?.includes(`<@${botUserId}>`) && !ev.bot_id) {
-                const hint = live.length
-                    ? `No live session matched. Address one as \`@<app> <session>: …\` — live now: ${live.map((s) => `\`${s}\``).join(", ")}.`
+                const handles = aliasesOn ? listAliases().map((a) => `\`@${a.handle}\``) : [];
+                const hint = live.length || handles.length
+                    ? `No live session matched. Address one as \`@<app> <session>: …\` — live now: ${live.length ? live.map((s) => `\`${s}\``).join(", ") : "none"}${handles.length ? `; handles: ${handles.join(", ")}` : ""}.`
                     : "No agent session is listening right now.";
                 // Ephemeral: only the sender sees the hint, so a mistyped address never
                 // leaves a permanent post in the thread for everyone else.
@@ -119,7 +153,7 @@ export async function runRouter(opts) {
         const user_name = await userName(user);
         const text = messageBody({
             ts,
-            text: stripAddressing(ev.text ?? "", botUserId, live),
+            text: stripAddressing(ev.text ?? "", botUserId, live, aliases),
             files: ev.files,
         });
         // A thread reply carries the thread so far: "review this" means nothing
@@ -143,12 +177,24 @@ export async function runRouter(opts) {
                 log(`thread context unavailable for ${channel}/${ev.thread_ts}: ${e instanceof Error ? e.message : e}`);
             }
         }
-        for (const session of targets) {
+        const mentioned = (ev.text ?? "").includes(`<@${botUserId}>`);
+        // Which sessions THIS message addresses (as opposed to inherits from the thread).
+        const addressed = new Map(routeHits({ ...ev, thread_ts: undefined }, { botUserId, liveSessions: live, threads, aliases }).map((h) => [h.session, h]));
+        const liveNow = new Set(live.map(normSession));
+        const waitingFor = [];
+        for (const { session, for: handle } of hits) {
+            // Not listening: hold it (aliases on) so it is delivered when the session
+            // reads its inbox, or reported undelivered — never left unread in silence.
+            const held = aliasesOn && !liveNow.has(normSession(session));
+            const at = new Date().toISOString();
+            const start = held ? inboxSize(session) : 0;
             const via = [];
             if (inThread?.has(session))
                 via.push("thread");
-            if ((ev.text ?? "").includes(`<@${botUserId}>`))
+            if (mentioned)
                 via.push("mention");
+            if (addressed.get(session)?.for)
+                via.push("alias");
             if (!via.length)
                 via.push("handle");
             appendInbox(session, {
@@ -159,9 +205,48 @@ export async function runRouter(opts) {
                 user_name,
                 text,
                 via,
+                ...(handle ? { for: handle } : {}),
                 ...(context ? { context } : {}),
+                ...(held ? { queued_at: at } : {}),
             });
-            log(`routed ${ev.channel}/${ev.ts} → ${session} (${via.join("+")})`);
+            if (held) {
+                recordPending({
+                    session,
+                    channel,
+                    ts,
+                    thread_ts: ev.thread_ts ?? ts,
+                    user,
+                    start,
+                    end: inboxSize(session),
+                    at,
+                });
+                waitingFor.push(session);
+            }
+            // Addressed here (not merely inherited from the thread) → the thread sticks.
+            // The address is kept so later replies re-resolve it (see reresolveRoutes).
+            const addr = addressed.get(session)?.addr;
+            if (stickyOn && addressed.has(session) && !inThread?.has(session)) {
+                recordRoute({
+                    session,
+                    channel,
+                    ts,
+                    thread_ts: ev.thread_ts,
+                    ...(handle ? { for: handle } : {}),
+                    ...(addr ? { addr } : {}),
+                    at,
+                });
+            }
+            log(`routed ${ev.channel}/${ev.ts} → ${session} (${via.join("+")}${handle ? ` for @${handle}` : ""}${held ? ", held" : ""})`);
+        }
+        if (waitingFor.length) {
+            // Ephemeral: the sender is looking now; the durable answer is the
+            // not-delivered reply sweepPending posts if the session never reads it.
+            await slackCall("chat.postEphemeral", opts.botToken, {
+                channel,
+                user,
+                thread_ts: ev.thread_ts ?? ts,
+                text: `Waiting for ${waitingFor.map((s) => `\`${s}\``).join(", ")}: not listening right now. It gets this when it next reads Slack; if it has not within ${ttlText()}, I will reply here that it was not delivered.`,
+            }, fetchImpl).catch(() => undefined);
         }
     };
     for (;;) {