@stratusagent/channel-slack 0.12.5 → 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
@@ -2293,6 +2293,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
@@ -2813,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
@@ -2997,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;
             }
@@ -3061,7 +3059,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 +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
@@ -3334,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.
@@ -4124,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, 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,9 +4195,13 @@ 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);
@@ -4158,15 +4222,29 @@ 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;
@@ -4402,7 +4480,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 +4770,37 @@ 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);
+            }
+        };
         if (taken && taken.agentId !== ownerId && (ownerId !== undefined || taken.at > read.foreign)) {
+            warm();
             return taken.agentId;
         }
         if (!owner) {
@@ -4707,7 +4809,7 @@ export const createSlackChannelAdapter = (options) => {
         if (ownerId === undefined) {
             return undefined;
         }
-        noteOrigin(threadKeyFor(parts), ownerId);
+        warm();
         return ownerId;
     };
     /**
@@ -5048,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
@@ -5109,7 +5212,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 +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
@@ -5213,13 +5316,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 +5348,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 +5452,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 +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.
@@ -5397,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
@@ -5500,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,
@@ -5803,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;
@@ -6018,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();