@stratusagent/channel-slack 0.12.4 → 0.12.6

package/dist/index.js

@@ -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.
  *
@@ -69,17 +80,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
@@ -2283,6 +2283,77 @@ export const createSlackChannelAdapter = (options) => {
      * corrects it.
      */
     const threadAddressee = new Map();
+    /**
+     * Threads whose owner this process can name (card 508): `true` for one
+     * whose first message it saw, so the first claim in `threadAddressee` is
+     * the owner, or the owner itself when the thread read named it after a
+     * restart. Absent for a thread that started before this process did:
+     * its first claim here is only the first one SEEN, and an untagged reply
+     * in it asks the sessions and the thread (see `ownerAt`). Bounded like
+     * 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
@@ -2803,69 +2874,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
@@ -2987,7 +2995,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;
             }
@@ -2996,6 +3004,73 @@ export const createSlackChannelAdapter = (options) => {
             }
         }));
     };
+    /**
+     * An agent's own post into a thread, heard in its own session for that
+     * thread (card 364). A scheduled report or a `message.send` reply is a
+     * bot message, which `admit` drops on purpose, and backfill reads a
+     * thread only when a session for it is first made, so without this an
+     * agent already in the thread never knew it had posted there: a reply
+     * under its report reached a session with the question and not the
+     * report. Through `observe`, so it starts no turn and lands only in a
+     * session that already exists; a thread the agent was never in is read
+     * by backfill when somebody first replies there.
+     *
+     * Labelled as the agent's own post, at the label the SENDING session's
+     * words carry (`speaker.trust`, `sessionWriteTrust` of that session):
+     * a report written by a firing that read a web page carries what that
+     * page said, so it is heard at `external`, and one written from `user`
+     * and `agent` context is heard at `agent`. Never higher, so hearing its
+     * own report cannot launder anything into the thread. A post nobody
+     * vouches for (no speaker) is not heard at all, rather than guessed at.
+     *
+     * Not when the sender IS that thread's session: that turn already holds
+     * the call and what it said. Claimed on the intake chain BEFORE the
+     * first chunk goes to Slack, so a reply typed under the report, even
+     * while a long one is still being sent, is heard after it. `posted`
+     * settles with what Slack accepted: all of it, the chunks before one it
+     * refused (they are in the thread, so they are heard), or nothing. Not
+     * awaited by `post`, only by the shutdown drain, so a long turn running
+     * in the thread never holds up the sender, and two threads posting into
+     * each other cannot wait on each other.
+     */
+    const hearOwnPost = (connection, channel, thread, posted, speaker) => {
+        const gateway = gatewayRef;
+        if (!gateway?.observe) {
+            return;
+        }
+        const agentId = connection.config.agentId;
+        const team = connection.teamId;
+        const sessionId = channelSessionKey({ channel: 'slack', agentId, team, conversation: channel, thread });
+        if (sessionId === speaker.sessionId) {
+            return;
+        }
+        const metadata = {
+            channel: 'slack',
+            team,
+            slackChannel: channel,
+            slackUser: connection.botUserId,
+            slackThread: thread,
+            [SENDER_TRUST_METADATA_KEY]: leastTrusted('agent', speaker.trust),
+        };
+        const heard = onIntakeChain(sessionId, async () => {
+            const text = await posted;
+            if (text === undefined) {
+                return { observed: undefined };
+            }
+            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 };
+        });
+        // 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.
+        track(heard
+            .then(async ({ observed }) => {
+            await observed;
+        })
+            .catch((error) => {
+            warn(`slack: ${agentId} could not hear its own post in ${channel} thread ${thread}: ${error instanceof Error ? error.message : String(error)}`);
+        }));
+    };
     /**
      * The addressable outbound seam — the channel contract's first real
      * `OutboundConnection` implementation. Validate-then-hand-over: every
@@ -3041,16 +3116,31 @@ export const createSlackChannelAdapter = (options) => {
         // A reply under a message rather than a post beside it. Every chunk of
         // a long one goes to the same thread, so a split reply stays together.
         const thread = address.thread?.trim() || undefined;
+        const speaker = address.speaker;
         return {
             async post(text) {
                 const chunks = messageChunks(text.trim().length > 0 ? text : '(empty message)');
+                // Heard in the thread's session (card 364): its place is claimed
+                // now, before Slack shows anything, and filled once we know what
+                // Slack accepted.
+                let accepted = () => { };
+                if (thread && speaker && text.trim().length > 0) {
+                    hearOwnPost(connection, channelId, thread, new Promise((resolve) => { accepted = resolve; }), speaker);
+                }
                 let first;
-                for (const chunk of chunks) {
-                    const posted = await web.chat.postMessage({ channel: channelId, text: chunk, ...(thread ? { thread_ts: thread } : {}) });
-                    if (!first) {
-                        first = { channel: posted.channel ?? channelId, ts: posted.ts ?? '' };
+                let sent = 0;
+                try {
+                    for (const chunk of chunks) {
+                        const posted = await web.chat.postMessage({ channel: channelId, text: chunk, ...(thread ? { thread_ts: thread } : {}) });
+                        sent += 1;
+                        if (!first) {
+                            first = { channel: posted.channel ?? channelId, ts: posted.ts ?? '' };
+                        }
                     }
                 }
+                finally {
+                    accepted(sent === chunks.length ? text : sent > 0 ? chunks.slice(0, sent).join('\n') : undefined);
+                }
                 return first ?? { channel: channelId, ts: '' };
             },
             async edit(ref, text) {
@@ -3069,6 +3159,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
@@ -3242,8 +3381,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.
@@ -3977,6 +4129,34 @@ export const createSlackChannelAdapter = (options) => {
     };
     /** One thread, whichever agent is talking in it. */
     const threadKeyFor = (parts) => `${parts.team}:${parts.conversation}:${parts.thread}`;
+    /**
+     * A thread's claims cut to `THREAD_HANDOVER_DEPTH`, oldest first out, but
+     * never the two `ownerAt` reads past the rest, so at most one over: the
+     * first claim, which is who the thread belongs to, and the latest claim
+     * that took the thread.
+     * 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) => {
+        if (handovers.length <= THREAD_HANDOVER_DEPTH) {
+            return handovers;
+        }
+        const first = handovers[0];
+        let latestTake = -1;
+        for (let index = handovers.length - 1; index > 0; index -= 1) {
+            if (handovers[index]?.takes === true) {
+                latestTake = index;
+                break;
+            }
+        }
+        const tailFrom = handovers.length - (THREAD_HANDOVER_DEPTH - 1);
+        // 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);
+        return latestTake > 0 && latestTake < tailFrom
+            ? [first, handovers[latestTake], ...tail]
+            : [first, ...tail];
+    };
     /**
      * Records that `agentId` holds the thread from the message at `ts`
      * onwards, wherever in the thread's history that message falls.
@@ -3989,7 +4169,8 @@ export const createSlackChannelAdapter = (options) => {
      * later insertion would take the thread from a reply that sits below it.
      * Only the same claim twice — the same message reaching a second
      * connection — is dropped.
-     * The oldest claims are dropped past `THREAD_HANDOVER_DEPTH`, and the
+     * The oldest claims are dropped past `THREAD_HANDOVER_DEPTH` (but not
+     * the first or the latest that took the thread: `trimHandovers`), and the
      * least recently written thread past `THREAD_ADDRESSEE_CAPACITY`; both
      * losses cost a lookup, never an answer, since the sessions still hold
      * the durable version.
@@ -4003,7 +4184,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) => {
+    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) {
@@ -4011,17 +4192,28 @@ export const createSlackChannelAdapter = (options) => {
         }
         const before = handovers[at - 1];
         if (before && before.agentId === agentId && before.ts === ts) {
+            if (takes) {
+                before.takes = true;
+            }
+            // Seen live as well: no longer only a reconstruction.
+            if (!cold) {
+                delete before.cold;
+            }
             return;
         }
-        handovers.splice(at, 0, { 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, handovers.slice(-THREAD_HANDOVER_DEPTH));
+        threadAddressee.set(key, trimHandovers(handovers));
         if (threadAddressee.size > THREAD_ADDRESSEE_CAPACITY) {
             const oldest = threadAddressee.keys().next();
             if (!oldest.done) {
                 threadAddressee.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.
+                threadOrigins.delete(oldest.value);
             }
         }
     };
@@ -4030,19 +4222,122 @@ 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);
     const holderAt = (key, ts) => {
         const handovers = threadAddressee.get(key);
         if (!handovers) {
             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.
         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 ? undefined : handover.agentId;
             }
         }
         return undefined;
     };
+    /**
+     * Who an untagged reply at `ts` belongs to (card 508): the agent the
+     * thread belongs to, not whoever spoke last. That is the first to hold
+     * it — the agent its first message named, a home channel's owner, or the
+     * bot (this daemon's or another's) that posted it — unless a judging
+     * agent has since chosen to speak, which takes it (`takes`). A mention
+     * of another agent gets that agent's answer to that message and nothing
+     * more: the thread stays where it was, and so does every reply after.
+     * In a thread that began before this process did, and that the thread
+     * read has not placed yet, the first claim this process SAW stands in
+     * for the owner: the best it has, and no worse than the last-speaker
+     * rule it replaces. Undefined when this process has seen no claim at
+     * all, which sends the question to the sessions and the thread.
+     */
+    const ownerAt = (key, ts) => {
+        const origin = threadOrigins.get(key);
+        const handovers = threadAddressee.get(key) ?? [];
+        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 typeof origin === 'string' ? origin : undefined;
+    };
+    /**
+     * The agent the thread `key` belongs to, whoever holds it now: the owner
+     * the thread read settled, or else the first claim this process saw.
+     * Answering in its own thread takes the thread back from a judge that
+     * spoke since (card 508), so the owner is asked for here, not the holder.
+     */
+    const threadOwner = (key) => {
+        const origin = threadOrigins.get(key);
+        return typeof origin === 'string' ? origin : threadAddressee.get(key)?.[0]?.agentId;
+    };
+    /** Records that this process saw the thread `key` begin, or who owns it. */
+    const noteOrigin = (key, owner = true) => {
+        if (owner === true && threadOrigins.has(key)) {
+            return;
+        }
+        threadOrigins.delete(key);
+        threadOrigins.set(key, owner);
+        if (threadOrigins.size > THREAD_ADDRESSEE_CAPACITY) {
+            const oldest = threadOrigins.keys().next();
+            if (!oldest.done) {
+                threadOrigins.delete(oldest.value);
+            }
+        }
+    };
+    /**
+     * A message that starts a thread, seen by any connection: from here on
+     * this process sees the thread's first claim, so it knows the owner. One
+     * this daemon's own agent posted (a schedule's delivery, a message.send)
+     * is that agent's thread.
+     */
+    const noteThreadStart = (connection, args) => {
+        const event = args.event;
+        if (!event || (event.type !== 'message' && event.type !== 'app_mention') || event.channel_type === 'im') {
+            return;
+        }
+        if (event.thread_ts !== undefined && event.thread_ts !== event.ts) {
+            return;
+        }
+        if (event.subtype !== undefined && event.subtype !== 'bot_message' && !HUMAN_MESSAGE_SUBTYPES.has(event.subtype)) {
+            return;
+        }
+        const team = args.body?.team_id ?? connection.teamId;
+        const key = threadKeyFor({ team, conversation: event.channel, thread: event.ts });
+        if (threadOrigins.has(key)) {
+            return;
+        }
+        noteOrigin(key);
+        if (event.user !== undefined) {
+            for (const [agentId, identity] of botIdentities) {
+                if (identity.teamId === team && identity.botUserId === event.user) {
+                    rememberAddressee(key, agentId, event.ts);
+                }
+            }
+        }
+        // A team agent on another gateway that starts a thread owns it, even
+        // when its first message asks an agent here something: that agent
+        // answers the question, and the thread stays the asker's. Recorded
+        // here, ahead of the answer, since `noteForeignSpeaker` leaves out a
+        // bot's question to an agent here.
+        const bot = event.bot_id !== undefined || event.subtype === 'bot_message';
+        if (bot && event.user !== undefined && !isFleetBot(team, event.user) && !startsThreadAsIntegration(team, event.user, event.thread_ts, event.ts)) {
+            rememberAddressee(key, `${FOREIGN_SPEAKER_PREFIX}${event.user}`, event.ts);
+        }
+    };
     /**
      * Whether `user` is one of this adapter's own agents in `team`. Their
      * replies reach the holder record through `ReplyOutcome.spokeAt`, and
@@ -4056,6 +4351,24 @@ export const createSlackChannelAdapter = (options) => {
      * held it. Used live and when a thread is read back after a restart.
      */
     const asksAgentHere = (team, asker, text) => asker !== undefined && [...botIdentities].some(([agentId, identity]) => identity.teamId === team && mentions(text ?? '', identity.botUserId) && answersAgentMention(agentId, team, asker));
+    /**
+     * Whether a bot message is another app starting a thread — an alert, a
+     * deploy note — rather than an agent (card 508). That starts the thread
+     * without owning it, so an agent named under it keeps the conversation it
+     * was given. A team agent (`agentMentions.team`) starting one owns it the
+     * way an agent here does, and any app replying inside a thread counts as
+     * a speaker there, since an agent on a gateway nobody listed looks like
+     * any other app.
+     */
+    const startsThreadAsIntegration = (team, user, threadTs, ts) => {
+        if (threadTs !== undefined && threadTs !== ts) {
+            return false;
+        }
+        return user === undefined || ![...botIdentities].some(([agentId, identity]) => {
+            const config = agentConfigFor(agentId);
+            return config !== undefined && teamAgentFor(config, identity.teamId, team, user) !== undefined;
+        });
+    };
     /**
      * Records a bot this adapter does not serve as the thread's holder from
      * the message it posted. An agent on another gateway answers in the same
@@ -4087,6 +4400,9 @@ export const createSlackChannelAdapter = (options) => {
         if (asksAgentHere(team, event.user, event.text)) {
             return;
         }
+        if (startsThreadAsIntegration(team, event.user, event.thread_ts, event.ts)) {
+            return;
+        }
         const thread = event.thread_ts ?? event.ts;
         rememberAddressee(threadKeyFor({ team, conversation: event.channel, thread }), `${FOREIGN_SPEAKER_PREFIX}${speaker}`, event.ts);
     };
@@ -4119,16 +4435,30 @@ export const createSlackChannelAdapter = (options) => {
             const botUserId = botIdentities.get(candidate.agentId)?.botUserId;
             if (botUserId !== undefined) {
                 byBotUser.set(botUserId, candidate.agentId);
-                held.set(candidate.agentId, 0);
+                held.set(candidate.agentId, Number.POSITIVE_INFINITY);
                 continue;
             }
             const spoke = candidate.lastSpokeAt === undefined ? Number.NaN : Date.parse(candidate.lastSpokeAt) / 1000;
-            held.set(candidate.agentId, Number.isFinite(spoke) ? spoke : 0);
+            held.set(candidate.agentId, Number.isFinite(spoke) ? spoke : Number.POSITIVE_INFINITY);
+        }
+        // Where each last held it, for a stop, which is for whoever was asked
+        // last (card 337), not for the thread's owner.
+        const last = new Map();
+        for (const [agentId, at] of held) {
+            last.set(agentId, Number.isFinite(at) ? at : 0);
         }
         const place = (agentId, at) => {
-            held.set(agentId, Math.max(held.get(agentId) ?? 0, at));
+            held.set(agentId, Math.min(held.get(agentId) ?? Number.POSITIVE_INFINITY, at));
+            last.set(agentId, Math.max(last.get(agentId) ?? 0, at));
         };
-        let foreign = 0;
+        let foreign = Number.POSITIVE_INFINITY;
+        let lastForeign = 0;
+        // Each of these agents' own messages, and whether the message before it
+        // had asked it anything: one nobody asked for is a judge taking the
+        // thread, or its owner answering in it (card 508).
+        const posts = [];
+        let asked = new Set();
+        const askedIn = (text) => new Set([...byBotUser].filter(([botUserId]) => mentions(text ?? '', botUserId)).map(([, agentId]) => agentId));
         try {
             let cursor;
             let pages = 0;
@@ -4150,14 +4480,35 @@ 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, 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.
+                        const sender = message.user;
+                        const named = sender === undefined
+                            ? []
+                            : [...askedIn(message.text)].filter((agentId) => agentId !== own && answersAgentMention(agentId, parts.team, sender));
+                        if (named.length > 0) {
+                            asked = new Set(named);
+                        }
                         continue;
                     }
                     const bot = message.bot_id !== undefined || message.subtype === 'bot_message';
                     if (bot) {
                         // A bot's mention hands nothing over live (admit ignores bots),
                         // so here it is only another app speaking, or a peer's words.
-                        if (!isFleetBot(parts.team, message.user) && !asksAgentHere(parts.team, message.user, message.text)) {
-                            foreign = Math.max(foreign, at);
+                        // A team agent's question to an agent here is not it taking the
+                        // thread, unless it started the thread with it: then the thread
+                        // is its own, as it is live.
+                        const asks = asksAgentHere(parts.team, message.user, message.text);
+                        if (asks) {
+                            asked = askedIn(message.text);
+                        }
+                        if (!isFleetBot(parts.team, message.user) &&
+                            (!asks || message.ts === parts.thread) &&
+                            !startsThreadAsIntegration(parts.team, message.user, parts.thread, message.ts ?? '')) {
+                            foreign = Math.min(foreign, at);
+                            lastForeign = Math.max(lastForeign, at);
                         }
                         continue;
                     }
@@ -4167,10 +4518,19 @@ export const createSlackChannelAdapter = (options) => {
                     if (sender === undefined) {
                         continue;
                     }
+                    asked = askedIn(message.text);
                     const named = agentNamedIn(message.text ?? '', parts.team, (agentId) => admitsSender(agentConfigFor(agentId), sender));
                     if (named !== undefined && held.has(named) && botIdentities.get(named)?.botUserId !== undefined) {
                         place(named, at);
                     }
+                    // A root that names nobody in a home channel is its owner's, as
+                    // the live home-channel rule has it.
+                    const home = message.ts === parts.thread && named === undefined
+                        ? homeOwners.get(`${parts.team}:${parts.conversation}`)
+                        : undefined;
+                    if (home !== undefined && held.has(home) && admitsSender(agentConfigFor(home), sender)) {
+                        place(home, at);
+                    }
                 }
                 cursor = page.response_metadata?.next_cursor || undefined;
             } while (cursor && pages < EARLIER_THREAD_PAGES);
@@ -4182,12 +4542,7 @@ export const createSlackChannelAdapter = (options) => {
             warn(`slack: could not read thread ${parts.thread} in ${parts.conversation} to see who spoke last, so it is routed as before: ${error instanceof Error ? error.message : String(error)}`);
             return undefined;
         }
-        return { held, foreign };
-    };
-    /** Whether another app spoke in the thread after `agentId` last held it. */
-    const foreignSpokeSince = async (agentId, parts, ts, lastSpokeAt) => {
-        const read = await threadPositions([{ agentId, ...(lastSpokeAt !== undefined ? { lastSpokeAt } : {}) }], parts, ts);
-        return read !== undefined && read.foreign > (read.held.get(agentId) ?? 0);
+        return { held, last, foreign, lastForeign, posts };
     };
     /**
      * Which of this process's agents a message names, or undefined if it
@@ -4253,25 +4608,19 @@ export const createSlackChannelAdapter = (options) => {
      * restart forgets nothing.
      *
      * Whose turn it is, is the second. In a thread with several agents an
-     * unaddressed reply belongs to **whoever spoke last**, the way it does
-     * between people: answer the voice that just answered you, and tag
-     * someone by name to change that. `lastSpokeAt` orders them — when each
-     * agent last *replied*, not when its session last changed, because a turn
-     * saves on tool results and approval checkpoints without having said
-     * anything, and a recovery resuming after a restart lands in exactly this
-     * window.
+     * unaddressed reply belongs to the agent the thread belongs to (card
+     * 508): the first to hold it, read off the thread itself. Only when the
+     * thread can't be read do the sessions decide, and then by `lastSpokeAt`
+     * — when each agent last *replied*, not when its session last changed,
+     * because a turn saves on tool results and approval checkpoints without
+     * having said anything — since that is the only order they keep.
      *
      * Nobody is the answer only when the agents cannot be *ordered* — nothing
-     * in the thread has spoken (a host whose routing carries no `lastSpokeAt`
-     * at all reads this way, and so does a thread where every agent is still
-     * on its first turn), or the newest two tie — because guessing there
-     * would put two answers under one message. An agent that simply has not
-     * spoken is a different thing and is skipped rather than fatal: it cannot
-     * have spoken last, and letting it silence the agent that did would leave
-     * a reply nobody answers. The agent alone in its thread, which is nearly
-     * every thread, is answered without the question arising.
+     * in the thread has spoken, or two tie — because guessing there would put
+     * two answers under one message. The agent alone in its thread, which is
+     * nearly every thread, is answered without the question arising.
      */
-    const resolveFollowUpWinner = async (parts, ts) => {
+    const resolveFollowUpWinner = async (parts, ts, mode = 'reply') => {
         const gateway = gatewayRef;
         if (!gateway?.sessionRouting || !parts.thread) {
             return undefined;
@@ -4349,22 +4698,131 @@ export const createSlackChannelAdapter = (options) => {
             }
             for (const [agentId, identity] of botIdentities) {
                 if (identity.teamId === parts.team && identity.botUserId === parts.parentUser) {
-                    return await foreignSpokeSince(agentId, parts, ts, undefined) ? undefined : agentId;
+                    noteOrigin(threadKeyFor(parts), agentId);
+                    return agentId;
                 }
             }
             return undefined;
         }
-        if (engaged.length === 1) {
-            return await foreignSpokeSince(first.agentId, parts, ts, first.lastSpokeAt) ? undefined : first.agentId;
+        // The thread says who it belongs to: whichever of these agents held it
+        // first — its first message named it, or it posted there first — or
+        // another app that spoke before any of them did (card 508). When it
+        // can't be read, the sessions decide: the only agent in it, or, as a
+        // last resort, the one that spoke last, which is all they record.
+        // The agent that posted the root takes part even with no session here:
+        // a post made through message.send or a schedule leaves none, and a
+        // colleague named under it since must not look like the owner.
+        const candidates = [...engaged];
+        if (parts.parentUser !== undefined) {
+            for (const [agentId, identity] of botIdentities) {
+                if (identity.teamId === parts.team && identity.botUserId === parts.parentUser && !candidates.some((entry) => entry.agentId === agentId)) {
+                    candidates.push({ agentId });
+                }
+            }
+        }
+        const read = await threadPositions(candidates, parts, ts);
+        if (!read) {
+            return engaged.length === 1 ? first.agentId : lastSpeaker(engaged);
+        }
+        if (mode === 'stop') {
+            // A stop is for whoever was asked last (card 337), as `holderAt` has
+            // it live: the turn it means is that agent's, not the owner's.
+            let holder;
+            let tiedLast = false;
+            for (const entry of candidates) {
+                const at = read.last.get(entry.agentId) ?? 0;
+                if (at <= 0) {
+                    continue;
+                }
+                if (!holder || at > holder.at) {
+                    holder = { agentId: entry.agentId, at };
+                    tiedLast = false;
+                }
+                else if (at === holder.at) {
+                    tiedLast = true;
+                }
+            }
+            if (!holder) {
+                return read.lastForeign > 0 ? undefined : (engaged.length === 1 ? first.agentId : lastSpeaker(engaged));
+            }
+            return tiedLast || read.lastForeign > holder.at ? undefined : holder.agentId;
+        }
+        let owner;
+        let tiedAt = false;
+        for (const entry of candidates) {
+            const at = read.held.get(entry.agentId) ?? Number.POSITIVE_INFINITY;
+            if (!Number.isFinite(at) || at <= 0) {
+                continue;
+            }
+            if (!owner || at < owner.at) {
+                owner = { agentId: entry.agentId, at };
+                tiedAt = false;
+            }
+            else if (at === owner.at) {
+                tiedAt = true;
+            }
+        }
+        // A judging agent that spoke unasked took the thread, and the owner
+        // answering in it took it back, as live (card 508): the latest of those
+        // holds it. The live record of who took it is lost on a restart; the
+        // thread keeps it. Only a judge takes by speaking unasked, as only its
+        // turns are judged live; another agent's post there (a message.send)
+        // 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) {
+                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);
+            }
+        };
+        if (taken && taken.agentId !== ownerId && (ownerId !== undefined || taken.at > read.foreign)) {
+            warm();
+            return taken.agentId;
+        }
+        if (!owner) {
+            return Number.isFinite(read.foreign) ? undefined : (engaged.length === 1 ? first.agentId : lastSpeaker(engaged));
+        }
+        if (ownerId === undefined) {
+            return undefined;
+        }
+        warm();
+        return ownerId;
+    };
+    /**
+     * Of several agents in a thread, the one whose session says it spoke
+     * last — the sessions' only ordering, used when the thread itself can't
+     * be read. Undefined when nobody has spoken or the newest two tie, since
+     * guessing there would put two answers under one message.
+     */
+    const lastSpeaker = (engaged) => {
         let latest;
         let tied = false;
         for (const entry of engaged) {
             if (entry.lastSpokeAt === undefined) {
-                // In the thread, but has never said anything in it — mentioned and
-                // still on its first turn, or a turn that produced no text. It
-                // cannot be the one who spoke last, and it must not stop the agent
-                // that did from answering.
                 continue;
             }
             if (!latest || entry.lastSpokeAt > latest.lastSpokeAt) {
@@ -4375,34 +4833,7 @@ export const createSlackChannelAdapter = (options) => {
                 tied = true;
             }
         }
-        const bySession = tied ? undefined : latest?.agentId;
-        // Sessions date a reply by when it finished, the thread by where its
-        // placeholder went up, and an agent on another gateway may have spoken
-        // since: only the thread can say who holds it. When it can't be read,
-        // the sessions decide, as before.
-        const read = await threadPositions(engaged, parts, ts);
-        if (!read) {
-            return bySession;
-        }
-        let holder;
-        let tiedAt = false;
-        for (const entry of engaged) {
-            const at = read.held.get(entry.agentId) ?? 0;
-            if (at <= 0) {
-                continue;
-            }
-            if (!holder || at > holder.at) {
-                holder = { agentId: entry.agentId, at };
-                tiedAt = false;
-            }
-            else if (at === holder.at) {
-                tiedAt = true;
-            }
-        }
-        if (!holder) {
-            return read.foreign > 0 ? undefined : bySession;
-        }
-        return tiedAt || read.foreign > holder.at ? undefined : holder.agentId;
+        return tied ? undefined : latest?.agentId;
     };
     /**
      * `resolveFollowUpWinner`, resolved ONCE PER MESSAGE and shared by every
@@ -4422,13 +4853,15 @@ export const createSlackChannelAdapter = (options) => {
      * this after the winner has finished, and recomputing for that agent is
      * precisely the disagreement the memo exists to prevent.
      */
-    const followUpWinner = (parts, ts) => {
-        const key = `${threadKeyFor(parts)}:${ts}`;
+    const followUpWinner = (parts, ts, mode = 'reply') => {
+        // A stop asks a different question (whoever was asked last), so it
+        // gets its own verdict, the same for every agent that asks it.
+        const key = `${threadKeyFor(parts)}:${ts}${mode === 'stop' ? ':stop' : ''}`;
         const existing = coldVerdicts.get(key);
         if (existing) {
             return existing.verdict;
         }
-        const entry = { verdict: resolveFollowUpWinner(parts, ts), settled: false };
+        const entry = { verdict: resolveFollowUpWinner(parts, ts, mode), settled: false };
         coldVerdicts.set(key, entry);
         void entry.verdict.then(() => {
             entry.settled = true;
@@ -4625,6 +5058,7 @@ export const createSlackChannelAdapter = (options) => {
     const admit = (connection, args) => {
         const event = args.event;
         if (gatewayRef) {
+            noteThreadStart(connection, args);
             noteForeignSpeaker(connection, args);
         }
         if (gatewayRef && event && (event.bot_id !== undefined || event.subtype === 'bot_message')) {
@@ -4716,6 +5150,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
@@ -4772,7 +5207,12 @@ export const createSlackChannelAdapter = (options) => {
                 return undefined;
             }
             const refusal = `slack: ${connection.config.agentId} refused a message from ${sender}: not a listed principal, and admit is "principals"`;
-            const held = threadKey !== undefined ? holderAt(threadKey, event.ts) : undefined;
+            // Whose message this is, as for an admitted one: the thread's owner's
+            // (card 508), or for a stop, whoever was asked last (card 337).
+            const refusedStop = (connection.config.approvers ?? []).includes(sender) && isStopRequest(text, connection.botUserId);
+            const held = threadKey === undefined
+                ? undefined
+                : refusedStop ? stopHolderAt(threadKey, event.ts) : replyTargetAt(threadKey, sender, event.ts);
             if (addressed || held === connection.config.agentId) {
                 if (!alreadySeen(eventKey)) {
                     log(refusal);
@@ -4791,7 +5231,7 @@ export const createSlackChannelAdapter = (options) => {
                     conversation: event.channel,
                     thread,
                     ...(event.parent_user_id !== undefined ? { parentUser: event.parent_user_id } : {}),
-                }, event.ts).then((winner) => {
+                }, event.ts, refusedStop ? 'stop' : 'reply').then((winner) => {
                     if (winner === connection.config.agentId) {
                         log(refusal);
                     }
@@ -4860,12 +5300,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
@@ -4876,21 +5316,39 @@ 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 } : {}),
             };
         }
         // The record is what this process has actually seen, in the order it
         // saw it — right even inside the window before a handover reaches the
-        // store.
-        const holder = threadKey === undefined ? undefined : holderAt(threadKey, event.ts);
+        // store. Whose an untagged reply is, is the thread's owner's (card
+        // 508), not the last speaker's — except a stop, which is for whoever
+        // was asked last, since that is the turn it means (card 337).
+        const stopRequest = threadKey !== undefined &&
+            (connection.config.approvers ?? []).includes(sender) &&
+            isStopRequest(text, connection.botUserId);
+        const holder = threadKey === undefined
+            ? undefined
+            : 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
@@ -4994,39 +5452,25 @@ 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
                 // are asking about it — see `followUpWinner`.
+                const stop = (connection.config.approvers ?? []).includes(userId) &&
+                    isStopRequest(event.text ?? '', connection.botUserId);
                 const winner = await followUpWinner({
                     team,
                     conversation: event.channel,
                     thread: event.thread_ts ?? '',
                     ...(event.parent_user_id !== undefined ? { parentUser: event.parent_user_id } : {}),
-                }, event.ts);
+                }, event.ts, stop ? 'stop' : 'reply');
                 if (winner !== connection.config.agentId) {
                     // Not this agent's to answer — and, if it is in the thread,
                     // this agent's to hear, same as the two warm stand-downs. Only a
@@ -5036,6 +5480,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.
@@ -5051,6 +5499,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
@@ -5154,7 +5608,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,
@@ -5418,7 +5872,12 @@ export const createSlackChannelAdapter = (options) => {
                 // the reader's next untagged message is for the lower of the two.
                 // Late, either way, for a message typed while the turn was still
                 // running, which the other may therefore still take.
-                rememberAddressee(threadKey, connection.config.agentId, spokeAt ?? event.ts);
+                // Under the owner rule (card 508) only two replies move the thread:
+                // a judging agent that chose to speak, and the owner answering in
+                // its own thread, which takes it back from a judge that spoke above.
+                // An answer to a mention is that message's answer and no more.
+                const takes = renderer.lazy || threadOwner(threadKey) === connection.config.agentId;
+                rememberAddressee(threadKey, connection.config.agentId, spokeAt ?? event.ts, takes);
             }
             // The reply just posted took the thread's status down with it, and a
             // turn queued behind this one is still working.
@@ -5437,8 +5896,10 @@ export const createSlackChannelAdapter = (options) => {
                     ? await renderer.finalize(renderer.lazy ? '' : failure.message)
                     : await renderer.fail(failure instanceof Error ? failure.message : String(failure));
             if (spoke && threadKey !== undefined) {
-                // A file it posted before breaking is still the last thing said.
-                rememberAddressee(threadKey, connection.config.agentId, spokeAt ?? event.ts);
+                // A file it posted before breaking has still spoken, by the same
+                // rule as a reply that landed.
+                const takes = renderer.lazy || threadOwner(threadKey) === connection.config.agentId;
+                rememberAddressee(threadKey, connection.config.agentId, spokeAt ?? event.ts, takes);
             }
             renderers.get(sessionId)?.[0]?.refreshLoading();
         }
@@ -5450,6 +5911,7 @@ 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;
@@ -5665,8 +6127,8 @@ export const createSlackChannelAdapter = (options) => {
             connections.length = 0;
             approvalPosts.clear();
             threadAddressee.clear();
+            senderAddressees.clear();
             coldVerdicts.clear();
-            pendingObserves.clear();
             botIdentities.clear();
             homeOwners.clear();
             rendering.clear();