@stratusagent/channel-slack 0.12.5 → 0.13.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
-import { lstat, mkdir, open, readdir, readFile, realpath } from 'node:fs/promises';
+import { lstat, mkdir, open, readdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { filePathsOf, isLatestTurn, latestTurnReply, MAX_IDEMPOTENCY_KEY_LENGTH, turnFailureFor, turnFilesFor, turnReplyFor, CONVERSATION_METADATA_KEY, SENDER_TRUST_METADATA_KEY, sessionWriteTrust, imageDimensions, isImageAttachmentMediaType, IMAGE_ATTACHMENT_MAX_BYTES, IMAGE_ATTACHMENT_MAX_DIMENSION, IMAGE_ATTACHMENTS_MAX_TOTAL_BYTES, escapeControlCharacters, RunAbortedError, leastTrusted, sessionTrustOf, SESSION_TRUST_METADATA_KEY, } from '@stratusagent/core';
@@ -27,6 +27,17 @@ const THREAD_ADDRESSEE_CAPACITY = 2000;
  * same message, and the addressee record answers for every message after.
  */
 const COLD_VERDICT_CAPACITY = 256;
+/**
+ * How many of one person's mentions one thread remembers (card 541). Only
+ * has to span the lag between two sockets, like `THREAD_HANDOVER_DEPTH`.
+ */
+const SENDER_ADDRESSEE_DEPTH = 8;
+/**
+ * How many people one thread remembers an addressee for. Past this the
+ * least recently heard is forgotten, and their next untagged reply goes to
+ * the thread's owner, as after a restart.
+ */
+const THREAD_SENDER_CAPACITY = 64;
 /**
  * How many claims on one thread it remembers.
  *
@@ -44,6 +55,17 @@ const COLD_VERDICT_CAPACITY = 256;
  * socket stays behind for all of them.
  */
 const THREAD_HANDOVER_DEPTH = 32;
+/**
+ * How far past this host's clock at `start()` claims count as seen live
+ * (card 562). Slack stamps messages by its own clock, so a host clock
+ * behind Slack's would date a message sent just before the restart as
+ * after it, and a read stopping there would look complete. Reads for
+ * messages in this first stretch are treated as stopping short, which
+ * costs a thread read or two, never a wrong placement.
+ */
+const LIVE_FROM_MARGIN_MS = 60_000;
+/** `liveFrom` while `start()` runs: later than any message. */
+const NOT_LIVE_YET = '9999999999.999999';
 /**
  * How many agent mentions one thread admits in a row before a person has
  * to speak there again (card 513): enough for a question, an answer and a
@@ -69,17 +91,6 @@ const toolStatus = (toolName) => `is running ${toolName}…`;
  * approval wait — is exactly the one whose status must not vanish.
  */
 const STATUS_REFRESH_MS = 60_000;
-/**
- * How long an agent that judges stays attentive after it last answered a
- * message that addressed it: this many messages, or this many minutes,
- * whichever ends first. Judging costs
- * a model call per message, and two people talking for an hour is a
- * hundred of them for one "no" — so attention decays the way a person's
- * does. Outside the window a message is overheard for free, and a mention
- * re-arms it, which is what a mention has always meant.
- */
-const ATTENTION_MESSAGES = 8;
-const ATTENTION_MS = 15 * 60 * 1000;
 /**
  * A 5 MB image over a slow link is seconds, not minutes. Past this the
  * downloads are abandoned and the turn runs with the attachments named as
@@ -114,6 +125,33 @@ const EARLIER_CHANNEL_LIMIT = 20;
 const EARLIER_CHANNEL_READ = 100;
 /** The most pages read to find them: 1,000 messages. */
 const EARLIER_CHANNEL_PAGES = 10;
+/** What a person who wrote during a restart is told, when it was kept. */
+export const RESTARTING_REPLY_TEXT = "I'm restarting right now. I'll answer this as soon as I'm back.";
+/** The same, for a daemon that is stopping rather than restarting. */
+export const STOPPING_REPLY_TEXT = "I'm shutting down right now. I'll answer this when I'm started again.";
+/**
+ * How old a kept message may be and still be answered at start: a daemon
+ * stopped for a week does not wake up to answer last week's questions.
+ */
+const PENDING_INTAKE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/**
+ * How long the start-up replay waits on Slack to read one kept message
+ * back. Past it, that message (and any kept after it in its conversation)
+ * is left for the next start rather than answered late; see `replayHolds`.
+ */
+const REPLAY_READ_MAX_MS = 10_000;
+/** The most messages kept at once; past it, a new one is refused, not kept. */
+const PENDING_INTAKE_MAX = 200;
+const isPendingIntake = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const entry = value;
+    const optionalString = (field) => field === undefined || typeof field === 'string';
+    return typeof entry.agentId === 'string' && typeof entry.team === 'string' && typeof entry.channel === 'string'
+        && typeof entry.ts === 'string' && typeof entry.user === 'string' && typeof entry.keptAt === 'number'
+        && optionalString(entry.threadTs) && optionalString(entry.channelType);
+};
 // Lazy (and CJS-interoperable) so tests with injected fakes never load the
 // real SDK stack.
 const requireModule = createRequire(import.meta.url);
@@ -1046,19 +1084,19 @@ class ReplyRenderer {
             // that would take the next turn's status down with it.
             await this.statusChain;
         }
-        return this.outcome(published, landed || this.edited || this.uploaded || stranded);
+        return this.outcome(published, landed || this.edited || this.uploaded || stranded, !published);
     }
     placeText(ts) {
         if (ts !== undefined && (this.textAt === undefined || ts > this.textAt)) {
             this.textAt = ts;
         }
     }
-    outcome(published, spoke) {
+    outcome(published, spoke, refused = false) {
         const spokeAt = [this.textAt, this.uploadedAt]
             .filter((ts) => ts !== undefined)
             .sort()
             .at(-1);
-        return { published, spoke, ...(spoke && spokeAt !== undefined ? { spokeAt } : {}) };
+        return { published, spoke, ...(spoke && spokeAt !== undefined ? { spokeAt } : {}), ...(refused ? { refused: true } : {}) };
     }
     /**
      * Take back the placeholder a turn nobody asked for opened and then had
@@ -2188,6 +2226,13 @@ const compareSlackTs = (left, right) => {
     }
     return Math.sign(Number(leftMicros.padEnd(6, '0').slice(0, 6)) - Number(rightMicros.padEnd(6, '0').slice(0, 6)));
 };
+/** What a Slack stop aborts a turn with, followed by the stopper's user id. */
+const SLACK_STOP_REASON = 'Stopped from Slack by ';
+/**
+ * Who stopped a turn, read back from the error it failed with: the gateway
+ * fails an aborted turn with the abort's reason verbatim.
+ */
+const slackStopper = (error) => error?.startsWith(SLACK_STOP_REASON) ? error.slice(SLACK_STOP_REASON.length) || undefined : undefined;
 export const createSlackChannelAdapter = (options) => {
     const log = options.log ?? (() => { });
     const warn = options.warn ?? (() => { });
@@ -2283,6 +2328,26 @@ export const createSlackChannelAdapter = (options) => {
      * corrects it.
      */
     const threadAddressee = new Map();
+    /**
+     * Per thread whose record has been cut in the middle (`trimHandovers`),
+     * the first claim kept after the cut. Who held the thread between its
+     * first claim and that one is no longer known here (card 559): a message
+     * from then is left to the sessions and a thread read, rather than
+     * placed by the first claim, or the latest take, that outlived the cut.
+     * Goes with the thread's record.
+     */
+    const threadTrimmedUntil = new Map();
+    /**
+     * Per thread the record was warmed from a thread read (#369), the last
+     * message a read covered. A read stops at the message it places, so one
+     * for a message from before this process started (delivered late, or a
+     * replay after a restart) leaves out every take between that message and
+     * the start (card 562). `liveFrom` is when every socket was up, plus a
+     * margin for clock skew: claims since were seen live. Goes with the
+     * thread's record.
+     */
+    const threadReadUntil = new Map();
+    let liveFrom;
     /**
      * Threads whose owner this process can name (card 508): `true` for one
      * whose first message it saw, so the first claim in `threadAddressee` is
@@ -2293,6 +2358,67 @@ export const createSlackChannelAdapter = (options) => {
      * the addressee map; a lost entry costs a lookup.
      */
     const threadOrigins = new Map();
+    /**
+     * Per thread, the agent each person last addressed by name, and when
+     * (card 541). An untagged reply from that person is that agent's —
+     * `@Bea your turn`, then `and?`, is Bea's — ahead of the thread's owner,
+     * who keeps every reply from someone who has not addressed anyone else.
+     * Recorded by every socket from the message itself, before any refusal,
+     * as a handover is, so the sockets agree. Bounded like the addressee map;
+     * a lost entry, or a restart, falls back to the owner.
+     */
+    const senderAddressees = new Map();
+    const rememberSenderAddressee = (key, sender, agentId, ts) => {
+        const senders = senderAddressees.get(key) ?? new Map();
+        // Kept in timestamp order, so a socket that is behind can still find the
+        // mention that preceded the reply it is only now reaching. A late
+        // delivery of an older mention slots in where it belongs.
+        const history = (senders.get(sender) ?? []).filter((entry) => entry.ts !== ts);
+        let at = history.length;
+        while (at > 0 && history[at - 1].ts > ts) {
+            at -= 1;
+        }
+        history.splice(at, 0, { agentId, ts });
+        if (history.length > SENDER_ADDRESSEE_DEPTH) {
+            history.splice(0, history.length - SENDER_ADDRESSEE_DEPTH);
+        }
+        // Most recently heard sender last, so the first key is the one to drop.
+        senders.delete(sender);
+        senders.set(sender, history);
+        if (senders.size > THREAD_SENDER_CAPACITY) {
+            const oldest = senders.keys().next();
+            if (!oldest.done) {
+                senders.delete(oldest.value);
+            }
+        }
+        senderAddressees.delete(key);
+        senderAddressees.set(key, senders);
+        if (senderAddressees.size > THREAD_ADDRESSEE_CAPACITY) {
+            const oldest = senderAddressees.keys().next();
+            if (!oldest.done) {
+                senderAddressees.delete(oldest.value);
+            }
+        }
+    };
+    /**
+     * The agent `sender` last addressed in thread `key` before `ts`, if this
+     * process saw it. A reply older than every mention still remembered for
+     * that sender has nothing to go on, and falls back to the owner.
+     */
+    const senderAddresseeAt = (key, sender, ts) => {
+        const history = senderAddressees.get(key)?.get(sender);
+        if (!history) {
+            return undefined;
+        }
+        for (let i = history.length - 1; i >= 0; i -= 1) {
+            if (history[i].ts < ts) {
+                return history[i].agentId;
+            }
+        }
+        return undefined;
+    };
+    /** Whose an untagged reply from `sender` at `ts` is: who they last addressed, else the owner. */
+    const replyTargetAt = (key, sender, ts) => senderAddresseeAt(key, sender, ts) ?? ownerAt(key, ts);
     /**
      * One cold verdict per message — see `followUpWinner`. Bounded, because
      * an entry outlives its own resolution on purpose; an entry that has not
@@ -2361,6 +2487,332 @@ export const createSlackChannelAdapter = (options) => {
         inflight.add(settled);
         void settled.finally(() => inflight.delete(settled));
     };
+    /**
+     * The kept messages (see `pendingIntakePath`), read and written one change
+     * at a time so two refusals landing together cannot drop each other.
+     */
+    const pendingIntakePath = options.pendingIntakePath;
+    let pendingChain = Promise.resolve();
+    const readPending = async (file) => {
+        let raw;
+        try {
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                return parsed.filter(isPendingIntake);
+            }
+        }
+        catch {
+            // Named below, and replaced by the next write.
+        }
+        warn(`slack: ${file} is not a list of kept messages; ignoring it`);
+        return [];
+    };
+    const changePending = (change) => {
+        const file = pendingIntakePath;
+        if (file === undefined) {
+            return Promise.reject(new Error('no pendingIntakePath'));
+        }
+        const run = pendingChain.then(async () => {
+            const before = await readPending(file);
+            const { entries, result } = change(before);
+            if (entries.length === 0) {
+                await rm(file, { force: true });
+            }
+            else {
+                // Whole or not at all: a crash mid-write must not leave half a list
+                // that the next start reads as no list.
+                const temporary = `${file}.${process.pid}.tmp`;
+                await writeFile(temporary, `${JSON.stringify(entries, null, 2)}\n`, { mode: 0o600 });
+                await rename(temporary, file);
+            }
+            return result;
+        });
+        pendingChain = run.catch(() => undefined);
+        return run;
+    };
+    const pendingKey = (entry) => `${entry.agentId}:${entry.team}:${entry.channel}:${entry.ts}`;
+    /**
+     * Kept messages being replayed, by `pendingKey`. A replayed message comes
+     * off the list only once its answer is confirmed (`answered`): an answer
+     * or failure Slack took, a turn that chose to say nothing, or the
+     * start-up recovery's own report of it reaching the thread. Every other
+     * way a handler can end leaves it kept, so a path that forgets to say
+     * how it went keeps the message rather than losing it. A message kept
+     * again by a restart during the replay (`rekept`) stays kept too. The
+     * next start hands it over again, and the gateway repeats the finished
+     * turn, so the answer is posted from the session rather than run again.
+     * `dispatched` and `refused` only choose the warning.
+     */
+    const replaying = new Map();
+    /** Notes a reply outcome against the kept message it answers, if that one is being replayed. */
+    const noteReplayOutcome = (connection, channel, ts, outcome) => {
+        const replay = replaying.get(pendingKey({ agentId: connection.config.agentId, team: connection.teamId, channel, ts }));
+        if (replay !== undefined) {
+            if (outcome.refused === true) {
+                replay.refused = true;
+            }
+            else {
+                replay.answered = true;
+            }
+        }
+        return outcome;
+    };
+    /** Confirms that a replayed message was answered by a report posted ahead of its own renderer. */
+    const noteReplayAnsweredAhead = (connection, channel, ts) => {
+        const replay = replaying.get(pendingKey({ agentId: connection.config.agentId, team: connection.teamId, channel, ts }));
+        if (replay !== undefined) {
+            replay.answered = true;
+        }
+    };
+    /**
+     * Live intake for a conversation (agent and channel) that has kept
+     * messages waits here until each of them has taken its place on its
+     * session's chain or been left for the next start, so a kept message is
+     * never answered after one sent later in the same conversation. Other
+     * conversations are not held. There is no timeout on the hold itself:
+     * the bound is on each read (`REPLAY_READ_MAX_MS`), and a read that
+     * outlasts it gives up its message for this run, which releases the hold.
+     */
+    const replayHolds = new Map();
+    const holdKey = (agentId, channel) => `${agentId}:${channel}`;
+    /**
+     * Whether `connection` is the one to replay `entry` through: the same
+     * agent in the workspace it was kept from. Channel and user ids belong to
+     * a workspace, so an agent whose credentials moved to another one leaves
+     * the entry kept (and its day-old expiry) rather than reading or answering
+     * whatever has that id there.
+     */
+    const keptFor = (connection, entry) => connection.config.agentId === entry.agentId && connection.teamId === entry.team;
+    const holdConversation = (key) => {
+        if (replayHolds.has(key)) {
+            return;
+        }
+        let release = () => { };
+        const held = new Promise((resolve) => {
+            release = () => {
+                replayHolds.delete(key);
+                resolve();
+            };
+        });
+        replayHolds.set(key, { held, release });
+    };
+    const releaseConversation = (key) => replayHolds.get(key)?.release();
+    /** Aborted by `stop()`, which ends a replay still reading kept messages back. */
+    let replayStopping;
+    const releaseAllConversations = () => {
+        for (const { release } of [...replayHolds.values()]) {
+            release();
+        }
+    };
+    /** Keeps a refused message for the next start; resolves with whether it was kept. */
+    const keepForNextStart = async (entry) => {
+        if (pendingIntakePath === undefined) {
+            return false;
+        }
+        try {
+            // Every kept message was told it will be answered, so a full list
+            // never evicts one of them: it makes room only from messages too old
+            // to be answered at start anyway, and otherwise refuses this one, which
+            // then gets the plain refusal and no promise.
+            const { full, expired } = await changePending((entries) => {
+                const key = pendingKey(entry);
+                let others = entries.filter((existing) => pendingKey(existing) !== key);
+                let expired = [];
+                if (others.length >= PENDING_INTAKE_MAX) {
+                    const cutoff = now() - PENDING_INTAKE_MAX_AGE_MS;
+                    expired = others.filter((existing) => existing.keptAt < cutoff);
+                    others = others.filter((existing) => existing.keptAt >= cutoff);
+                }
+                if (others.length >= PENDING_INTAKE_MAX) {
+                    return { entries, result: { full: true, expired: [] } };
+                }
+                return { entries: [...others, entry], result: { full: false, expired } };
+            });
+            for (const dropped of expired) {
+                log(`slack: ${dropped.agentId} dropped ${dropped.ts} in ${dropped.channel} kept from a restart: older than a day`);
+            }
+            if (full) {
+                warn(`slack: could not keep ${entry.ts} in ${entry.channel} for after the restart: ${PENDING_INTAKE_MAX} messages are already kept`);
+                return false;
+            }
+            const replay = replaying.get(pendingKey(entry));
+            if (replay !== undefined) {
+                replay.rekept = true;
+            }
+            return true;
+        }
+        catch (error) {
+            warn(`slack: could not keep ${entry.ts} in ${entry.channel} for after the restart: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    };
+    /** The kept message itself, as Slack has it now; `undefined` when it is gone. */
+    const fetchKept = async (connection, entry) => {
+        const { history, replies } = connection.web.conversations;
+        const inThread = entry.threadTs !== undefined && entry.threadTs !== entry.ts;
+        const range = { channel: entry.channel, oldest: entry.ts, latest: entry.ts, inclusive: true };
+        const page = inThread
+            ? await replies?.call(connection.web.conversations, { ...range, ts: entry.threadTs, limit: 2 })
+            : await history?.call(connection.web.conversations, { ...range, limit: 1 });
+        if (page === undefined) {
+            throw new Error('this Slack client cannot read conversations');
+        }
+        return page.messages?.find((message) => message.ts === entry.ts);
+    };
+    /** One kept message read back with a bound; `timedOut` when Slack took longer than that. */
+    const fetchKeptWithin = async (connection, entry) => {
+        let timer;
+        const late = new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ timedOut: true }), REPLAY_READ_MAX_MS);
+        });
+        try {
+            return await Promise.race([
+                fetchKept(connection, entry).then((message) => (message !== undefined ? { message } : {})),
+                late,
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    /**
+     * What the last daemon kept, handled as if it had just arrived: through
+     * admission, the thread rules, and a dispatch keyed as the original
+     * delivery would have been, so a message the gateway already ran is a
+     * repeat there and not a second turn. That makes handing one over twice
+     * safe and losing one not, so each comes off the list only once its
+     * handler has reached the gateway and settled: a crash, or a failure
+     * before the dispatch (the reply could not be started), leaves it for the
+     * next start, and one kept again by a restart during the replay stays
+     * kept. A message deleted since is dropped.
+     *
+     * Each conversation is replayed in ts order while its live intake is held
+     * (`replayHolds`), and released once its kept messages are handed over.
+     * A read that fails or outlasts `REPLAY_READ_MAX_MS` leaves that message,
+     * and the ones kept after it in the conversation, for the next start:
+     * handing a later one over first, or the slow one over after live
+     * messages were let in, would answer them out of order.
+     */
+    const replayKept = async (kept, onEvent, stopping) => {
+        if (pendingIntakePath === undefined || kept.length === 0) {
+            return;
+        }
+        const cutoff = now() - PENDING_INTAKE_MAX_AGE_MS;
+        const expired = kept.filter((entry) => entry.keptAt < cutoff);
+        for (const entry of expired) {
+            log(`slack: ${entry.agentId} dropped ${entry.ts} in ${entry.channel} kept from a restart: older than a day`);
+        }
+        // Not waited on before the reads: the list's writes are serialized, so
+        // this one lands ahead of any the replay makes, and the reads start
+        // inside start() (a stop right after it still sees each conversation's
+        // first one through).
+        const old = new Set(expired.map(pendingKey));
+        const droppingExpired = expired.length > 0
+            ? changePending((entries) => ({ entries: entries.filter((entry) => !old.has(pendingKey(entry))), result: undefined }))
+                .catch((error) => warn(`slack: could not drop the day-old messages kept from a restart; the next start drops them: ${error instanceof Error ? error.message : String(error)}`))
+            : Promise.resolve();
+        const conversations = new Map();
+        for (const entry of kept.filter((candidate) => candidate.keptAt >= cutoff)) {
+            const elsewhere = connections.find((connection) => connection.config.agentId === entry.agentId && !keptFor(connection, entry));
+            if (elsewhere !== undefined) {
+                warn(`slack: ${entry.agentId} kept ${entry.ts} in ${entry.channel} from workspace ${entry.team}, but is now connected to ${elsewhere.teamId}; keeping it for a start in that workspace`);
+                continue;
+            }
+            const key = holdKey(entry.agentId, entry.channel);
+            conversations.set(key, [...(conversations.get(key) ?? []), entry]);
+        }
+        const handovers = [];
+        const replayConversation = async (key, entries) => {
+            try {
+                entries.sort((a, b) => compareSlackTs(a.ts, b.ts));
+                const agentId = entries[0].agentId;
+                const connection = connections.find((candidate) => keptFor(candidate, entries[0]));
+                const handle = onEvent.get(agentId);
+                if (connection === undefined || handle === undefined) {
+                    return;
+                }
+                for (const [index, entry] of entries.entries()) {
+                    // A stop ends the replay at the next message: what it has not read
+                    // yet stays kept for the next start, so the stop waits on at most
+                    // the one bounded read in progress per conversation, not a chain
+                    // of them.
+                    if (stopping.aborted) {
+                        log(`slack: ${agentId} stopping; leaving ${entries.length - index} kept message(s) in ${entry.channel} for the next start`);
+                        return;
+                    }
+                    let read;
+                    try {
+                        read = await fetchKeptWithin(connection, entry);
+                    }
+                    catch (error) {
+                        warn(`slack: could not read ${entry.ts} in ${entry.channel} kept from the last restart; keeping it and ${entries.length - index - 1} after it for the next start: ${error instanceof Error ? error.message : String(error)}`);
+                        return;
+                    }
+                    if (read.timedOut === true) {
+                        warn(`slack: reading ${entry.ts} in ${entry.channel} kept from the last restart took over ${REPLAY_READ_MAX_MS / 1000}s; keeping it and ${entries.length - index - 1} after it for the next start`);
+                        return;
+                    }
+                    const message = read.message;
+                    if (message === undefined) {
+                        const gone = pendingKey(entry);
+                        await changePending((current) => ({ entries: current.filter((kept) => pendingKey(kept) !== gone), result: undefined }));
+                        log(`slack: ${entry.agentId} dropped ${entry.ts} in ${entry.channel} kept from a restart: no longer in Slack`);
+                        continue;
+                    }
+                    log(`slack: ${entry.agentId} replaying ${entry.ts} in ${entry.channel}, sent during the last restart`);
+                    const event = {
+                        ...message,
+                        type: 'message',
+                        channel: entry.channel,
+                        ts: entry.ts,
+                        ...(entry.threadTs !== undefined ? { thread_ts: entry.threadTs } : {}),
+                        ...(entry.channelType !== undefined ? { channel_type: entry.channelType } : {}),
+                    };
+                    const replayKey = pendingKey(entry);
+                    const replay = { dispatched: false, rekept: false, refused: false, answered: false };
+                    replaying.set(replayKey, replay);
+                    // Not waited on: the handler claims its place on its session's
+                    // chain synchronously, as a live delivery does, so the next kept
+                    // message (and, after the last, the held live ones) queue behind it.
+                    const handled = handle({ ack: async () => { }, body: { team_id: entry.team }, event });
+                    handovers.push(handled.catch(() => undefined).then(async () => {
+                        replaying.delete(replayKey);
+                        if (replay.rekept) {
+                            return;
+                        }
+                        if (!replay.dispatched) {
+                            warn(`slack: ${entry.agentId} could not hand ${entry.ts} in ${entry.channel} kept from a restart to the gateway; keeping it for the next start`);
+                            return;
+                        }
+                        if (replay.refused) {
+                            warn(`slack: ${entry.agentId} could not post the answer to ${entry.ts} in ${entry.channel} kept from a restart; keeping it for the next start`);
+                            return;
+                        }
+                        if (!replay.answered) {
+                            warn(`slack: ${entry.agentId} has no confirmed answer to ${entry.ts} in ${entry.channel} kept from a restart; keeping it for the next start`);
+                            return;
+                        }
+                        await changePending((current) => ({ entries: current.filter((kept) => pendingKey(kept) !== replayKey), result: undefined }));
+                    }));
+                }
+            }
+            finally {
+                releaseConversation(key);
+            }
+        };
+        await Promise.all([...conversations].map(([key, entries]) => replayConversation(key, entries)));
+        await Promise.all(handovers);
+        await droppingExpired;
+    };
     const alreadySeen = (key) => {
         if (seenEvents.has(key)) {
             return true;
@@ -2813,69 +3265,6 @@ export const createSlackChannelAdapter = (options) => {
      * nothing, which is every soul written before there was a choice.
      */
     const listensOf = (agentId) => gatewayRef?.agents().find((agent) => agent.id === agentId)?.listens ?? 'thread';
-    /**
-     * Whether an agent that judges is still paying attention to a thread:
-     * within `ATTENTION_MESSAGES` and `ATTENTION_MS` of when it last
-     * answered a message that addressed it, both read from the session
-     * rather than remembered here, so a restart forgets nothing. Anchored
-     * to an addressed answer and not to any reply: a reply the agent chose
-     * to give on a turn nobody asked for does not re-arm it, or a talkative
-     * judge would keep itself attentive for good and cost a call per message
-     * — the self-extension the spec declined. An agent never addressed in
-     * the thread is not attentive: it was mentioned and its first turn has
-     * not answered yet, or answered with nothing. Measured against the
-     * message's own timestamp, not the clock, so a delivery that ran late is
-     * judged as of when it was said. Bounded below as well as above: a
-     * message said before the answer the window starts from is outside it
-     * — Slack redelivers events a restarted daemon has no memory of, and a
-     * negative age would otherwise pass the minutes bound however old the
-     * message, on a turn the agent's answer already came after.
-     */
-    const attentive = (routing, messageTs, pending) => {
-        if (routing.lastAnsweredAt === undefined) {
-            return false;
-        }
-        const answeredAt = Date.parse(routing.lastAnsweredAt);
-        const saidAt = Number(messageTs) * 1000;
-        if (Number.isNaN(answeredAt) || Number.isNaN(saidAt) || saidAt < answeredAt || saidAt - answeredAt > ATTENTION_MS) {
-            return false;
-        }
-        return (routing.heardSinceAnswered ?? 0) + pending < ATTENTION_MESSAGES;
-    };
-    /**
-     * Messages this adapter has dispatched to a session that the session
-     * does not hold yet. The store counts what it holds, and a burst of
-     * messages typed inside one second would each read the same count and
-     * each be judged — the bound the window exists to give, blown by exactly
-     * the thread that needs it. The renderer queue already knows: a renderer
-     * is queued at dispatch and its turn starts (`turnStarted`) only once
-     * the runner has saved the message — the same moment the store's count
-     * takes it over — so the two never count one message twice.
-     */
-    const pendingFor = (sessionId) => (renderers.get(sessionId) ?? []).filter((renderer) => !renderer.turnStarted).length
-        + (pendingObserves.get(sessionId) ?? 0);
-    /**
-     * Overhears placed on the gateway's chain and not yet written, per
-     * session: the other kind of message the store does not hold yet. An
-     * observe queued behind a running turn is heard only when the turn ends,
-     * and a burst of messages to a colleague would otherwise count toward
-     * nothing until then. Counted from placement to settlement.
-     */
-    const pendingObserves = new Map();
-    const placeObserve = (sessionId, observed) => {
-        pendingObserves.set(sessionId, (pendingObserves.get(sessionId) ?? 0) + 1);
-        const release = () => {
-            const left = (pendingObserves.get(sessionId) ?? 1) - 1;
-            if (left > 0) {
-                pendingObserves.set(sessionId, left);
-            }
-            else {
-                pendingObserves.delete(sessionId);
-            }
-        };
-        void observed.then(release, release);
-        return observed;
-    };
     /**
      * Run `work` after everything already queued for this session's intake,
      * and hold the next link until it settles. The link is claimed
@@ -2997,7 +3386,7 @@ export const createSlackChannelAdapter = (options) => {
                     // whoever installed it.
                     const author = await displayNameFor(hearer, speaker.botUserId);
                     const observed = gateway.observe?.({ sessionId, agentId: hearer.config.agentId, message: `${author}: ${text}`, metadata: { ...metadata, [SENDER_TRUST_METADATA_KEY]: trust } });
-                    return { observed: observed === undefined ? undefined : placeObserve(sessionId, observed) };
+                    return { observed };
                 });
                 await observed;
             }
@@ -3061,7 +3450,7 @@ export const createSlackChannelAdapter = (options) => {
             }
             const author = await displayNameFor(connection, connection.botUserId);
             const observed = gateway.observe?.({ sessionId, agentId, message: `${author} (your own post, sent from another session): ${text}`, metadata });
-            return { observed: observed === undefined ? undefined : placeObserve(sessionId, observed) };
+            return { observed };
         });
         // Tracked, so stop() drains it: a restart right after a report must not
         // close the stores while the thread's session is still to hear it.
@@ -3161,6 +3550,55 @@ export const createSlackChannelAdapter = (options) => {
             },
         };
     };
+    /**
+     * Channel or DM, as this agent's app sees a conversation, for the
+     * operator's standing channel authorization (`approvals.channels`), which
+     * covers channels only. Asked of Slack (`conversations.info`), never read
+     * off the id: a `G…` id is a private channel or a group DM depending on
+     * its age. A definite answer is kept, since a conversation never turns
+     * from one into the other; a failed lookup is not, and reads as unknown,
+     * so the call asks.
+     */
+    const conversationKinds = new Map();
+    const CONVERSATION_KIND_CACHE_LIMIT = 1000;
+    const conversationKindFor = async (agentId, conversation) => {
+        const id = conversation.trim();
+        const connection = connectionFor(agentId);
+        if (!id || !connection) {
+            return undefined;
+        }
+        const key = `${agentId}:${botIdentities.get(agentId)?.teamId ?? ''}:${id}`;
+        const known = conversationKinds.get(key);
+        if (known !== undefined) {
+            return known;
+        }
+        let info;
+        try {
+            info = (await connection.web.conversations.info({ channel: id })).channel;
+        }
+        catch {
+            return undefined;
+        }
+        if (!info?.id) {
+            return undefined;
+        }
+        // A DM flag wins. Otherwise a channel only when Slack says so, by a
+        // channel flag or by stating it is not a DM: a reply with none of
+        // them is no proof of a channel.
+        const kind = info.is_im === true || info.is_mpim === true
+            ? 'direct'
+            : info.is_channel === true || info.is_group === true || (info.is_im === false && info.is_mpim === false) ? 'channel' : undefined;
+        if (kind !== undefined) {
+            if (conversationKinds.size >= CONVERSATION_KIND_CACHE_LIMIT) {
+                const oldest = conversationKinds.keys().next().value;
+                if (oldest !== undefined) {
+                    conversationKinds.delete(oldest);
+                }
+            }
+            conversationKinds.set(key, kind);
+        }
+        return kind;
+    };
     /**
      * The read side of the same boundary `resolveOutbound` draws: a channel
      * the agent's own app is a member of, public or private. DMs and group
@@ -3334,8 +3772,21 @@ export const createSlackChannelAdapter = (options) => {
         const sameChannel = metadata.channel === 'slack' && typeof metadata.slackChannel === 'string'
             ? metadata.slackChannel
             : undefined;
-        const channel = sameChannel ?? connection.config.approvalChannel;
-        const thread = sameChannel && typeof metadata.slackThread === 'string' ? metadata.slackThread : undefined;
+        // A scheduled firing has no conversation of its own. With no approval
+        // channel configured it used to be denied at its first gated call, seen
+        // only in the daemon log (card 218). Its schedule's destination is a
+        // conversation a person approved as where it speaks, and only approvers
+        // can answer there, so that is where it is asked. A configured approval
+        // channel still wins: the operator chose it for exactly this. Another
+        // channel's destination is not a Slack conversation id.
+        const scheduled = event.scheduleDestination?.channel.trim().toLowerCase() === 'slack'
+            ? event.scheduleDestination
+            : undefined;
+        const viaSchedule = !sameChannel && !connection.config.approvalChannel ? scheduled : undefined;
+        const channel = sameChannel ?? connection.config.approvalChannel ?? viaSchedule?.to;
+        const thread = sameChannel
+            ? (typeof metadata.slackThread === 'string' ? metadata.slackThread : undefined)
+            : viaSchedule?.thread;
         // Undeliverable, not decided: nobody was asked, so filing this next to
         // the denials somebody actually made would make the audit record lie
         // about which is which.
@@ -3600,6 +4051,11 @@ export const createSlackChannelAdapter = (options) => {
         return landed;
     };
     const reportUnrenderedFailure = async (event, behind, files) => {
+        // A turn no renderer here was showing (card 501) that a Slack stop
+        // aborted fails with the stop's own reason, so who stopped it is read
+        // from the failure itself rather than from a note an outcome may never
+        // come to clear.
+        const stoppedBy = slackStopper(event.error);
         const gateway = gatewayRef;
         if (!gateway?.sessionRouting) {
             return NOTHING_REPORTED;
@@ -3627,7 +4083,10 @@ export const createSlackChannelAdapter = (options) => {
         }
         const channel = metadata.slackChannel;
         const thread = typeof metadata.slackThread === 'string' ? metadata.slackThread : undefined;
-        if (routing.unaddressed === true && routing.reply === undefined) {
+        if (stoppedBy === undefined && routing.unaddressed === true && routing.reply === undefined) {
+            // A stop is someone asking, so a stopped turn always says who
+            // stopped it, judged or not.
+            //
             // A turn nobody asked for that said nothing before it broke — the
             // daemon died inside it, and the next start failed it with no
             // renderer here to keep quiet for it. The same rule as the lazy
@@ -3648,7 +4107,7 @@ export const createSlackChannelAdapter = (options) => {
             return { said: true, landed: await uploadUnrenderedFiles(connection, channel, thread, files) };
         }
         let landed = [];
-        const said = await postAheadOf(behind, connection, channel, thread, messageChunks(`Something went wrong: ${event.error}`), async () => {
+        const said = await postAheadOf(behind, connection, channel, thread, messageChunks(stoppedBy === undefined ? `Something went wrong: ${event.error}` : `Stopped by <@${stoppedBy}>.`), async () => {
             landed = await uploadUnrenderedFiles(connection, channel, thread, files);
         });
         return { said, landed };
@@ -4077,7 +4536,7 @@ export const createSlackChannelAdapter = (options) => {
      * Dropping that one would hand the thread back to its owner after enough
      * mentions of a third agent, while the judge that took it still answers.
      */
-    const trimHandovers = (handovers) => {
+    const trimHandovers = (key, handovers) => {
         if (handovers.length <= THREAD_HANDOVER_DEPTH) {
             return handovers;
         }
@@ -4093,6 +4552,13 @@ export const createSlackChannelAdapter = (options) => {
         // The kept take sits on top of the full recent tail, one past the depth,
         // so `holderAt` still sees every recent claim it saw before.
         const tail = handovers.slice(tailFrom);
+        // The cut only ever moves later: a claim inserted into the gap since
+        // is dropped again, and the gap it fell in stays unknown.
+        const until = tail[0].ts;
+        const before = threadTrimmedUntil.get(key);
+        if (before === undefined || before < until) {
+            threadTrimmedUntil.set(key, until);
+        }
         return latestTake > 0 && latestTake < tailFrom
             ? [first, handovers[latestTake], ...tail]
             : [first, ...tail];
@@ -4124,7 +4590,7 @@ export const createSlackChannelAdapter = (options) => {
      * Slack timestamps compare as strings: `seconds.microseconds`, both
      * parts fixed width, so lexicographic order is chronological order.
      */
-    const rememberAddressee = (key, agentId, ts, takes = false) => {
+    const rememberAddressee = (key, agentId, ts, takes = false, cold = false) => {
         const handovers = threadAddressee.get(key) ?? [];
         let at = handovers.length;
         while (at > 0 && handovers[at - 1].ts > ts) {
@@ -4135,17 +4601,23 @@ export const createSlackChannelAdapter = (options) => {
             if (takes) {
                 before.takes = true;
             }
+            // Seen live as well: no longer only a reconstruction.
+            if (!cold) {
+                delete before.cold;
+            }
             return;
         }
-        handovers.splice(at, 0, takes ? { agentId, ts, takes } : { agentId, ts });
+        handovers.splice(at, 0, { agentId, ts, ...(takes ? { takes } : {}), ...(cold ? { cold } : {}) });
         // Re-inserted rather than mutated in place: a Map iterates in insertion
         // order, which is what makes the first key the one to evict.
         threadAddressee.delete(key);
-        threadAddressee.set(key, trimHandovers(handovers));
+        threadAddressee.set(key, trimHandovers(key, handovers));
         if (threadAddressee.size > THREAD_ADDRESSEE_CAPACITY) {
             const oldest = threadAddressee.keys().next();
             if (!oldest.done) {
                 threadAddressee.delete(oldest.value);
+                threadTrimmedUntil.delete(oldest.value);
+                threadReadUntil.delete(oldest.value);
                 // The owner goes with the record of who took the thread since: an
                 // owner kept alone would stand in for a judge's takeover it no
                 // longer knows of, where the thread read would see it.
@@ -4158,15 +4630,69 @@ export const createSlackChannelAdapter = (options) => {
      * handover at or before it. Undefined when this process has no handover
      * that old, which sends the question to the sessions.
      */
+    /**
+     * Whose a stop at `ts` is, from the live record: who was asked last as
+     * of `ts` (`holderAt`). Undefined when the record cannot say, either
+     * because this process has seen nobody asked here by `ts`, or because the
+     * newest entry by then was rebuilt from a thread read (card 508): a
+     * mention since would not be among them. The stop is then left to a
+     * fresh read of the thread, never sent to the owner on a guess.
+     */
+    const stopHolderAt = (key, ts) => holderAt(key, ts);
+    /** Whether the record of thread `key` lost who held it at `ts` to a cut. */
+    const inTrimmedGap = (key, handovers, ts) => {
+        const until = threadTrimmedUntil.get(key);
+        const first = handovers[0];
+        return until !== undefined && first !== undefined && first.ts < ts && ts < until;
+    };
+    /**
+     * Records that a thread read of `key` covered every message before `ts`.
+     * Bounded on its own, since a read that found nobody's post leaves an
+     * owner and no record (Codex 4321103567). A thread whose mark is evicted
+     * loses its record and owner with it, so it is read afresh instead of
+     * placed from claims the read may have stopped short of.
+     */
+    const noteReadUntil = (key, ts) => {
+        const until = threadReadUntil.get(key);
+        threadReadUntil.delete(key);
+        threadReadUntil.set(key, until !== undefined && compareSlackTs(ts, until) < 0 ? until : ts);
+        if (threadReadUntil.size > THREAD_ADDRESSEE_CAPACITY) {
+            const oldest = threadReadUntil.keys().next();
+            if (!oldest.done) {
+                threadReadUntil.delete(oldest.value);
+                threadAddressee.delete(oldest.value);
+                threadTrimmedUntil.delete(oldest.value);
+                threadOrigins.delete(oldest.value);
+            }
+        }
+    };
+    /**
+     * Where the record of thread `key` stops knowing every take, for a
+     * message at `ts` after what a thread read covered (card 562): a claim
+     * older than the returned point may have been taken from since, unseen.
+     * Undefined when the record is complete as far as `ts`.
+     */
+    const unreadBefore = (key, ts) => {
+        const until = threadReadUntil.get(key);
+        return until !== undefined && liveFrom !== undefined && compareSlackTs(until, liveFrom) < 0 && compareSlackTs(ts, until) > 0
+            ? liveFrom
+            : undefined;
+    };
     const holderAt = (key, ts) => {
         const handovers = threadAddressee.get(key);
-        if (!handovers) {
+        if (!handovers || inTrimmedGap(key, handovers, ts)) {
             return undefined;
         }
+        // The newest entry at or before `ts` answers, and only if this process
+        // saw it live. A claim rebuilt from a thread read is a post; who was
+        // asked since may be a mention it cannot see, so it leaves the question
+        // to a fresh read. And it is newer than every live entry before it, so
+        // skipping it for one of those would answer with a claim it superseded.
+        const unread = unreadBefore(key, ts);
         for (let index = handovers.length - 1; index >= 0; index -= 1) {
             const handover = handovers[index];
             if (handover && handover.ts <= ts) {
-                return handover.agentId;
+                return handover.cold === true || (unread !== undefined && compareSlackTs(handover.ts, unread) < 0) ? undefined : handover.agentId;
             }
         }
         return undefined;
@@ -4188,13 +4714,19 @@ export const createSlackChannelAdapter = (options) => {
     const ownerAt = (key, ts) => {
         const origin = threadOrigins.get(key);
         const handovers = threadAddressee.get(key) ?? [];
+        if (inTrimmedGap(key, handovers, ts)) {
+            return undefined;
+        }
+        // A take from before the stretch the read left out may have been
+        // superseded there: the question goes to a fresh read (card 562).
+        const unread = unreadBefore(key, ts);
         for (let index = handovers.length - 1; index >= 0; index -= 1) {
             const handover = handovers[index];
             if (handover && handover.ts <= ts && (handover.takes === true || (index === 0 && typeof origin !== 'string'))) {
-                return handover.agentId;
+                return unread !== undefined && compareSlackTs(handover.ts, unread) < 0 ? undefined : handover.agentId;
             }
         }
-        return typeof origin === 'string' ? origin : undefined;
+        return typeof origin === 'string' && unread === undefined ? origin : undefined;
     };
     /**
      * The agent the thread `key` belongs to, whoever holds it now: the owner
@@ -4402,7 +4934,7 @@ export const createSlackChannelAdapter = (options) => {
                     const own = message.user === undefined ? undefined : byBotUser.get(message.user);
                     if (own !== undefined) {
                         place(own, at);
-                        posts.push({ agentId: own, at, asked: asked.has(own) });
+                        posts.push({ agentId: own, at, ts: message.ts, asked: asked.has(own) });
                         // An agent here naming a colleague that answers its mentions
                         // asks it, as `admitAgentMention` has it live, so the answer is
                         // not a judge speaking unasked.
@@ -4692,13 +5224,38 @@ export const createSlackChannelAdapter = (options) => {
         // takes nothing.
         const ownerId = owner && !tiedAt && !(read.foreign < owner.at) ? owner.agentId : undefined;
         let taken;
+        const takeovers = [];
         for (const post of read.posts) {
             const takes = post.agentId === ownerId || (!post.asked && listensOf(post.agentId) === 'judge');
-            if (takes && (!taken || post.at > taken.at)) {
-                taken = post;
+            if (takes) {
+                takeovers.push(post);
+                if (!taken || post.at > taken.at) {
+                    taken = post;
+                }
             }
         }
+        // Once the owner is known, the live record learns what the thread read
+        // found, as it would have live: who owns the thread, and every post
+        // that moved it, where it sits. With only the verdict, a judge's reply
+        // to this message became the first claim this process saw and read as
+        // the owner, so the real owner answering a mention could not take the
+        // thread back (Codex 4290051968). Every take rather than the latest, so
+        // a message delivered late is placed where it was typed, and the judge's
+        // take at its own post, so a reply typed before its answer lands still
+        // goes to the judge, as this verdict says.
+        const warm = () => {
+            if (ownerId === undefined) {
+                return;
+            }
+            const key = threadKeyFor(parts);
+            noteOrigin(key, ownerId);
+            for (const post of takeovers) {
+                rememberAddressee(key, post.agentId, post.ts, true, true);
+            }
+            noteReadUntil(key, ts);
+        };
         if (taken && taken.agentId !== ownerId && (ownerId !== undefined || taken.at > read.foreign)) {
+            warm();
             return taken.agentId;
         }
         if (!owner) {
@@ -4707,7 +5264,7 @@ export const createSlackChannelAdapter = (options) => {
         if (ownerId === undefined) {
             return undefined;
         }
-        noteOrigin(threadKeyFor(parts), ownerId);
+        warm();
         return ownerId;
     };
     /**
@@ -4823,19 +5380,30 @@ export const createSlackChannelAdapter = (options) => {
     const stopTurns = (connection, sessionId, userId, channel, fromIntake = false) => {
         const running = renderers.get(sessionId) ?? [];
         const inIntake = fromIntake ? 0 : intakeInFlight.get(sessionId) ?? 0;
-        if (running.length === 0 && inIntake === 0) {
-            return false;
-        }
+        const reason = `${SLACK_STOP_REASON}${userId}`;
         for (const renderer of running) {
             if (renderer.stoppedBy === undefined) {
                 renderer.stoppedBy = userId;
-                renderer.controller.abort(new RunAbortedError(`Stopped from Slack by ${userId}`));
-            }
+                renderer.controller.abort(new RunAbortedError(reason));
+            }
+        }
+        // Also a turn no renderer of this process started (card 501): one the
+        // gateway recovered after a restart, or another caller's on this
+        // session. The gateway counts every turn still on the session, one
+        // already stopping included, so a repeated stop while a stopped turn
+        // winds down is still a stop, and once it has ended, however it ended,
+        // a stop with nothing running is an ordinary message. The renderers'
+        // started turns are among those counted.
+        const onSession = gatewayRef?.abortTurns?.(sessionId, reason) ?? 0;
+        if (running.length === 0 && inIntake === 0 && onSession === 0) {
+            return false;
         }
         if (inIntake > 0) {
             stopsBySession.set(sessionId, { count: (stopsBySession.get(sessionId)?.count ?? 0) + 1, by: userId });
         }
-        log(`slack: ${userId} stopped ${running.length + inIntake} turn(s) of ${connection.config.agentId} in ${channel}`);
+        // A renderer's started turn is also one the gateway counts, so this is
+        // the larger of the two, not their sum.
+        log(`slack: ${userId} stopped ${Math.max(running.length, onSession) + inIntake} turn(s) of ${connection.config.agentId} in ${channel}`);
         return true;
     };
     /**
@@ -5048,6 +5616,7 @@ export const createSlackChannelAdapter = (options) => {
         // Ava's transcript; only the map learns who holds the thread.
         if (threadKey && handoverTo) {
             rememberAddressee(threadKey, handoverTo, event.ts);
+            rememberSenderAddressee(threadKey, sender, handoverTo, event.ts);
         }
         // A home-channel message hands its new thread to the channel's owner
         // the way a mention would, and is recorded by every socket for the same
@@ -5109,7 +5678,7 @@ export const createSlackChannelAdapter = (options) => {
             const refusedStop = (connection.config.approvers ?? []).includes(sender) && isStopRequest(text, connection.botUserId);
             const held = threadKey === undefined
                 ? undefined
-                : (refusedStop ? holderAt(threadKey, event.ts) : undefined) ?? ownerAt(threadKey, event.ts);
+                : refusedStop ? stopHolderAt(threadKey, event.ts) : replyTargetAt(threadKey, sender, event.ts);
             if (addressed || held === connection.config.agentId) {
                 if (!alreadySeen(eventKey)) {
                     log(refusal);
@@ -5197,12 +5766,12 @@ export const createSlackChannelAdapter = (options) => {
             return { ...admission, overhear: true };
         }
         // An untagged reply. How this agent listens decides what it is: an
-        // agent that answers only mentions hears it and nothing more, and one
-        // that judges hears it and, if still attentive, takes a turn nobody
-        // asked for on it — decided in the intake, since only the session can
-        // say. Neither takes part in the holder rule below: that rule answers
-        // "whose is an untagged reply", and for these two agents the soul has
-        // already answered.
+        // agent that answers only mentions hears it and nothing more. One that
+        // judges takes a turn nobody asked for on it — one it may stay quiet
+        // on — when the reply is its own by the rule every agent shares (card
+        // 541): the agent this person last addressed, else the thread's owner.
+        // No window: an owner an hour past its last answer still hears an
+        // instruction as its own, and exactly one agent takes each reply.
         const listens = listensOf(connection.config.agentId);
         if (listens === 'mentions' || listens === 'judge') {
             // Except a stop (card 337): the holder rule decides whose it is, as
@@ -5213,13 +5782,24 @@ export const createSlackChannelAdapter = (options) => {
                 (connection.config.approvers ?? []).includes(sender) &&
                 isStopRequest(text, connection.botUserId);
             const stopHolder = approverStop ? holderAt(threadKey, event.ts) : undefined;
-            // A stop held by another agent is only heard: judging it would let an
-            // attentive agent take a turn on a stop that was never its own.
-            const stopForAnother = stopHolder !== undefined && stopHolder !== connection.config.agentId;
+            if (listens === 'judge' && !approverStop && threadKey !== undefined) {
+                const target = replyTargetAt(threadKey, sender, event.ts);
+                if (target === undefined) {
+                    // Nothing seen here says whose thread this is: the sessions and
+                    // the thread read decide, as for any agent.
+                    return { ...admission, overhear: true, judge: true, settled: false, judgeReason: 'owner, from the thread read' };
+                }
+                if (target !== connection.config.agentId) {
+                    return { ...admission, overhear: true, judgeReason: `${target}'s reply` };
+                }
+                const reason = senderAddresseeAt(threadKey, sender, event.ts) === target ? 'addressed it last' : 'owner';
+                return { ...admission, overhear: true, judge: true, judgeReason: reason };
+            }
+            // An approver's stop is never judged (card 541): it stops the turn of
+            // whoever holds the thread, and with nothing to stop it is only heard.
             return {
                 ...admission,
                 overhear: true,
-                ...(listens === 'judge' && !stopForAnother ? { judge: true } : {}),
                 ...(stopHolder === connection.config.agentId ? { holderStop: true } : {}),
                 ...(approverStop && stopHolder === undefined ? { settled: false } : {}),
             };
@@ -5234,7 +5814,7 @@ export const createSlackChannelAdapter = (options) => {
             isStopRequest(text, connection.botUserId);
         const holder = threadKey === undefined
             ? undefined
-            : (stopRequest ? holderAt(threadKey, event.ts) : undefined) ?? ownerAt(threadKey, event.ts);
+            : stopRequest ? stopHolderAt(threadKey, event.ts) : replyTargetAt(threadKey, sender, event.ts);
         if (holder !== undefined && threadKey !== undefined) {
             if (holder !== connection.config.agentId) {
                 // Standing down for the holder, whether or not the holder can still
@@ -5338,29 +5918,13 @@ export const createSlackChannelAdapter = (options) => {
             // not to be this agent's leaves an empty link behind, which is all it
             // should cost.
             let overhear = admitted.overhear;
-            // Judged, not ruled: a turn nobody asked for, while the agent is
-            // still attentive, and a free overhear past that. Read off the
-            // chain — a session the invitation is still creating reads as not
-            // there, and the message is heard rather than judged, which is the
-            // safe side. A host that cannot say leaves the agent hearing.
+            // Judged, not ruled (card 541): the intake already placed this reply
+            // with this agent, so it runs a turn nobody asked for, which may stay
+            // quiet. A reply only the sessions can place waits for them below.
             let judged = false;
-            if (admitted.judge && gateway.sessionRouting) {
-                // The pending count is taken BEFORE the store is read: a message
-                // that settles between the two would be counted by neither the
-                // other way round, and a window that runs one message short in a
-                // race is a bound kept; one that runs a message long is not.
-                const pending = pendingFor(sessionId);
-                let routing;
-                try {
-                    routing = await gateway.sessionRouting(sessionId);
-                }
-                catch (error) {
-                    warn(`slack: could not read whether ${connection.config.agentId} is attentive in ${event.channel}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                if (routing && attentive(routing, event.ts, pending)) {
-                    judged = true;
-                    overhear = false;
-                }
+            if (admitted.judge && admitted.settled) {
+                judged = true;
+                overhear = false;
             }
             if (!admitted.settled) {
                 // One verdict for this message, shared with whichever other agents
@@ -5382,6 +5946,10 @@ export const createSlackChannelAdapter = (options) => {
                     overhear = true;
                 }
                 else {
+                    if (admitted.judge) {
+                        judged = true;
+                        overhear = false;
+                    }
                     if (threadKey) {
                         // Answered from the store rather than from memory: hold it, so
                         // the rest of the thread is ordered by receipt like any other.
@@ -5397,6 +5965,12 @@ export const createSlackChannelAdapter = (options) => {
                     }
                 }
             }
+            // One line per decision a judging agent makes on an untagged reply
+            // (card 541): whether it took the turn, and why. Never the text.
+            if (admitted.judgeReason !== undefined) {
+                const reason = admitted.settled || judged ? admitted.judgeReason : 'another agent\'s, from the thread read';
+                log(`slack: judge: ${connection.config.agentId} ${judged ? 'took' : 'heard'} ${event.ts} in ${event.channel} (${reason})`);
+            }
             const cleaned = await humanizeMentions(connection, event.text ?? '');
             // Fetched inside the chain, like the lookups below: it is network
             // I/O, and a message whose screenshot is slow to arrive must not lose
@@ -5500,7 +6074,7 @@ export const createSlackChannelAdapter = (options) => {
                 // an overhear queued behind a long turn would hold the next
                 // message's place in this chain hostage to that turn.
                 return {
-                    observed: placeObserve(sessionId, gateway.observe({ sessionId, agentId: connection.config.agentId, message: userMessage, metadata })),
+                    observed: gateway.observe({ sessionId, agentId: connection.config.agentId, message: userMessage, metadata }),
                 };
             }
             // A turn nobody asked for opens its placeholder on its first text,
@@ -5590,7 +6164,7 @@ export const createSlackChannelAdapter = (options) => {
             leaveIntake();
             if (stopped !== undefined && stopped.count !== stopsAtClaim && renderer.stoppedBy === undefined) {
                 renderer.stoppedBy = stopped.by;
-                renderer.controller.abort(new RunAbortedError(`Stopped from Slack by ${stopped.by}`));
+                renderer.controller.abort(new RunAbortedError(`${SLACK_STOP_REASON}${stopped.by}`));
             }
             // In a DM each message is its own status key, and Slack stops showing
             // the running turn's once a newer message sits below it — so a
@@ -5600,6 +6174,10 @@ export const createSlackChannelAdapter = (options) => {
             renderer.showLoading(queue.length === 1 || queue[0]?.statusThread !== renderer.statusThread);
             let repeat;
             let absorbed = false;
+            const replay = replaying.get(pendingKey({ agentId: connection.config.agentId, team: connection.teamId, channel: event.channel, ts: event.ts }));
+            if (replay !== undefined) {
+                replay.dispatched = true;
+            }
             const turn = gateway.dispatch({
                 sessionId,
                 agentId: connection.config.agentId,
@@ -5619,10 +6197,16 @@ export const createSlackChannelAdapter = (options) => {
                 },
                 // Sent while a turn is running, this message is answered by the
                 // next turn together with everything else that queued (card 423);
-                // the first of them renders that answer.
-                onAbsorbed: () => {
-                    absorbed = true;
-                },
+                // the first of them renders that answer. Not a replayed message:
+                // it leaves the kept list only on its own confirmed answer, and an
+                // answer another message's renderer posts is not one it can see.
+                ...(replay === undefined
+                    ? {
+                        onAbsorbed: () => {
+                            absorbed = true;
+                        },
+                    }
+                    : {}),
             });
             return { renderer, turn, repeat: () => repeat, absorbed: () => absorbed };
         });
@@ -5675,6 +6259,15 @@ export const createSlackChannelAdapter = (options) => {
         // Likewise a message absorbed into a merged turn: the turn's leading
         // message's renderer answers for all of them.
         if (repeat() === 'live' || absorbed()) {
+            // A replayed message whose turn the start-up recovery owns is
+            // answered by that recovery's report, and only if it reached the
+            // thread; anything else leaves it kept.
+            const ahead = repeat() === 'live' && renderer.outcomeReportedAhead !== undefined
+                ? await renderer.outcomeReportedAhead
+                : undefined;
+            if (ahead?.said === true) {
+                noteReplayAnsweredAhead(connection, event.channel, event.ts);
+            }
             await renderer.withdraw();
             renderers.get(sessionId)?.[0]?.refreshLoading();
             return;
@@ -5712,6 +6305,7 @@ export const createSlackChannelAdapter = (options) => {
             }));
         }
         if (reportedAhead?.said === true) {
+            noteReplayAnsweredAhead(connection, event.channel, event.ts);
             await renderer.withdraw();
             renderers.get(sessionId)?.[0]?.refreshLoading();
             return;
@@ -5744,6 +6338,7 @@ export const createSlackChannelAdapter = (options) => {
             // interim messages already in the thread are heard either way.
             let replyLanded = false;
             const settled = finalized.then((outcome) => {
+                noteReplayOutcome(connection, event.channel, event.ts, outcome);
                 replyLanded = outcome.published;
                 return true;
             }, () => true);
@@ -5782,11 +6377,48 @@ export const createSlackChannelAdapter = (options) => {
             // not a failure of the agent. Matched by name, as this package does
             // not import the gateway. A turn nobody asked for stays silent.
             const pausedReply = failure instanceof Error && failure.name === 'IntakePausedError';
-            const { spoke, spokeAt } = renderer.stoppedBy !== undefined
+            // A daemon on its way down that still heard this (the gateway keeps
+            // channels connected through its drain): the message is kept for the
+            // next start, which handles it as if it had just arrived. Said only
+            // to a message that asked: a judged reply in the agent's thread (a
+            // turn nobody asked for) is kept so the next daemon can still judge
+            // it, but nobody asked, so a notice under it would be noise. An
+            // overheard message never gets here; it was never going to be a turn.
+            // Matched by name, like the pause.
+            const stoppingRefusal = failure instanceof Error && failure.name === 'GatewayStoppingError' && renderer.stoppedBy === undefined;
+            let deferredText;
+            if (stoppingRefusal) {
+                const restarting = failure.restarting !== false;
+                const kept = await keepForNextStart({
+                    agentId: connection.config.agentId,
+                    team,
+                    channel: event.channel,
+                    ts: event.ts,
+                    ...(event.thread_ts !== undefined ? { threadTs: event.thread_ts } : {}),
+                    user: userId,
+                    ...(event.channel_type !== undefined ? { channelType: event.channel_type } : {}),
+                    keptAt: now(),
+                });
+                if (kept) {
+                    log(`slack: ${connection.config.agentId} kept ${event.ts} in ${event.channel} to answer after the ${restarting ? 'restart' : 'stop'}`);
+                    deferredText = restarting ? RESTARTING_REPLY_TEXT : STOPPING_REPLY_TEXT;
+                }
+                else {
+                    deferredText = failure.message;
+                }
+            }
+            // A refusal (paused, or a daemon on its way down) ran no turn, so its
+            // notice is never what answers a replayed message: that one stays
+            // kept, whether or not keeping it again just worked.
+            const refused = pausedReply || stoppingRefusal;
+            const outcome = renderer.stoppedBy !== undefined
                 ? await renderer.stopped(renderer.stoppedBy)
-                : pausedReply
-                    ? await renderer.finalize(renderer.lazy ? '' : failure.message)
+                : refused
+                    ? await renderer.finalize(renderer.lazy ? '' : deferredText ?? failure.message)
                     : await renderer.fail(failure instanceof Error ? failure.message : String(failure));
+            const { spoke, spokeAt } = refused && renderer.stoppedBy === undefined
+                ? outcome
+                : noteReplayOutcome(connection, event.channel, event.ts, outcome);
             if (spoke && threadKey !== undefined) {
                 // A file it posted before breaking has still spoken, by the same
                 // rule as a reply that landed.
@@ -5803,9 +6435,14 @@ export const createSlackChannelAdapter = (options) => {
         // A channel id is unique only within its workspace, so a standing
         // grant on one is bound to the team the agent's app authenticated in.
         accountFor: (agentId) => botIdentities.get(agentId)?.teamId || undefined,
+        conversationKindFor,
         requestCredential,
         async start(gateway) {
             gatewayRef = gateway;
+            // Nothing counts as seen live until every socket is up (Codex
+            // 4321128637): a message sent while the sockets are still coming up
+            // reaches none of them, so a read stopping before it stops short.
+            liveFrom = NOT_LIVE_YET;
             unsubscribe = gateway.bus.subscribe((event) => {
                 // Approval traffic is not part of a reply: it gets its own message
                 // with its own lifetime, and routing it through the running turn's
@@ -5957,21 +6594,55 @@ export const createSlackChannelAdapter = (options) => {
                 }
             }
             settleHomeOwners();
+            const listeners = new Map();
+            // Read before any socket delivers, so each conversation with kept
+            // messages is held from the first live event on.
+            let kept = [];
+            if (pendingIntakePath !== undefined) {
+                try {
+                    kept = await readPending(pendingIntakePath);
+                }
+                catch (error) {
+                    warn(`slack: could not read the messages kept from the last restart: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                const cutoff = now() - PENDING_INTAKE_MAX_AGE_MS;
+                for (const entry of kept) {
+                    if (entry.keptAt >= cutoff && authenticated.some((connection) => keptFor(connection, entry))) {
+                        holdConversation(holdKey(entry.agentId, entry.channel));
+                    }
+                }
+            }
             for (const connection of authenticated) {
                 const { config, socket } = connection;
                 try {
                     // Returns the work it started: the SDK ignores it, and a test's fake
                     // socket waits on it rather than guessing how long it takes.
-                    const onEvent = (args) => {
-                        const handled = handleInbound(connection, args).catch((error) => {
+                    const handle = (inbound) => {
+                        const handled = inbound.catch((error) => {
                             warn(`slack event handling failed: ${error instanceof Error ? error.message : String(error)}`);
                         });
                         inflight.add(handled);
                         void handled.finally(() => inflight.delete(handled));
                         return handled;
                     };
+                    // The replay's own deliveries never wait on the hold they release.
+                    const onReplay = (args) => handle(handleInbound(connection, args));
+                    const onEvent = (args) => {
+                        const channel = args.event?.channel;
+                        const hold = typeof channel === 'string' ? replayHolds.get(holdKey(config.agentId, channel))?.held : undefined;
+                        if (hold === undefined) {
+                            return onReplay(args);
+                        }
+                        // Acked now, as any delivery is, so Slack does not redeliver a
+                        // message that is only waiting its turn; admitted after the hold.
+                        void Promise.resolve(args.ack()).catch((error) => {
+                            warn(`slack: could not ack an envelope: ${error instanceof Error ? error.message : String(error)}`);
+                        });
+                        return handle(hold.then(() => handleInbound(connection, { ...args, ack: async () => { } })));
+                    };
                     socket.on('app_mention', onEvent);
                     socket.on('message', onEvent);
+                    listeners.set(config.agentId, onReplay);
                     socket.on('interactive', (args) => {
                         const handled = handleInteractive(connection, args).catch((error) => {
                             warn(`slack interaction handling failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -5989,8 +6660,19 @@ export const createSlackChannelAdapter = (options) => {
                     warn(`slack: could not connect ${config.agentId}: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
+            const liveMs = now() + LIVE_FROM_MARGIN_MS;
+            liveFrom = `${Math.floor(liveMs / 1000)}.${String((liveMs % 1000) * 1000).padStart(6, '0')}`;
+            // Once every app is connected, so a kept message is handled with the
+            // whole roster's identities known, as a live one would be. Only for the
+            // apps that did connect: the rest stay kept for a start where they do.
+            // A kept message is from before the restart, so its thread read stops
+            // short of the start, as `liveFrom` already says (card 562).
+            replayStopping = new AbortController();
+            track(replayKept(kept, new Map([...listeners].filter(([agentId]) => connections.some((connection) => connection.config.agentId === agentId))), replayStopping.signal).finally(releaseAllConversations));
         },
         async stop() {
+            replayStopping?.abort();
+            releaseAllConversations();
             // Stop intake first, so no new INBOUND event can slip into
             // `inflight` while the drain below runs.
             await Promise.allSettled(connections.map((connection) => connection.socket.disconnect()));
@@ -6018,8 +6700,10 @@ export const createSlackChannelAdapter = (options) => {
             connections.length = 0;
             approvalPosts.clear();
             threadAddressee.clear();
+            threadTrimmedUntil.clear();
+            threadReadUntil.clear();
+            senderAddressees.clear();
             coldVerdicts.clear();
-            pendingObserves.clear();
             botIdentities.clear();
             homeOwners.clear();
             rendering.clear();