@open-everywhere/provider-slack 0.6.0 → 0.8.0

package/dist/agent/channels/slack-front.js

@@ -38,22 +38,28 @@
 //      urlencoded body (Eve's own `eve_input:` HITL clicks, view_submission, slash
 //      commands) still forwards exactly as before.
 //   4. Idempotency + per-thread FIFO guard the wake (see EventDedupe / ThreadFifo below).
+import { auditErrorDetail } from "@open-everywhere/core/agent/adapter-api.js";
 import { parseSlackUserDeactivation, routeSlackUserDeactivation } from "./slack-offboarding.js";
 import { POST } from "eve/channels";
 import { SLACK_SIGNATURE_HEADER, SLACK_TIMESTAMP_HEADER, slackSignature, slackSignatureMatches } from "./slack-signature.js";
 import { slackSigningSecret } from "../setup/credentials.js";
 import { slackContinuationToken } from "eve/channels/slack";
 import { callSlackWebApi } from "./slack-web-api.js";
-import { auditDmBotAuthorDrop, auditDmDriverAdmitted, dmDoorAdmitsDriver, parseMessageEvent, routeMessageEvent, liveDeps, routeNameDropEvent, liveNameDropDeps, parseChannelJoinEvent, routeChannelJoinEvent, liveChannelJoinDeps, parseSlackReactionEvent, routeReactionEvent, liveReactionDeps, routeSupervisorEvent, liveSupervisorDeps, supervisorFifoKey, bindableFor, bindableForJoin, bindableForReaction, slackSingleWindowMentionPolicy, slackDomainUsesUnifiedWindow, slackFrontTenantFenceDeclined, slackInteractivityTenantFenceDeclined, } from "./slack-events.js";
+import { auditDmBotAuthorDrop, auditDmDriverAdmitted, dmDoorAdmitsDriver, UNCHANGED_EDIT_DROP_REASON, parseMessageEvent, routeMessageEvent, liveDeps, routeNameDropEvent, liveNameDropDeps, parseChannelJoinEvent, routeChannelJoinEvent, liveChannelJoinDeps, parseSlackReactionEvent, routeReactionEvent, liveReactionDeps, routeSupervisorEvent, liveSupervisorDeps, supervisorFifoKey, bindableFor, bindableForJoin, bindableForReaction, bindableForSlackIds, slackSingleWindowMentionPolicy, slackDomainUsesUnifiedWindow, slackFrontTenantFenceDeclined, slackInteractivityTenantFenceDeclined, } from "./slack-events.js";
 import { slackInteractivityTenantIds } from "./slack-tenant-fence.js";
-import { EventDedupe, ThreadFifo, getOrCreateDmSeat as liveGetOrCreateDmSeat, touchDmSeat as liveTouchDmSeat, resolvePartition, domainKeyOf, isThreadEngaged, divertInboundToUnifiedWindow, isPrunedDeploymentWakeError, markUndeliveredAfterHeal, isUndeliveredAfterHeal, healPrunedDeploymentStrand, mintWakeId, slackVendorEventTime, spreadVendorTs, resolveWakeTrust, ambientSupervisorEnabled, getConfig, getOperationalStore, OE_APPROVAL_PREFIX, handleApprovalPayload as liveHandleApprovalPayload, OE_SETKEY_ACTION_PREFIX, OE_SETKEY_MODAL_CALLBACK, handleSetKeyClick as liveHandleSetKeyClick, handleSetKeyViewSubmission as liveHandleSetKeyViewSubmission, OE_CONNECT_ACTION_PREFIX, handleConnectClick as liveHandleConnectClick, OE_GRANT_ACTION_PREFIX, handleGrantCardClick as liveHandleGrantCardClick, buildRecord, enqueue as enqueueLogRecord, flushLogShip, stampNonMemberChatAuth, externalPolicyIsInert, recordWakeTail, tailAuthorGrain, dmWindowRegistryKey, stampSurfaceEventVerified, readPersonOptOut, auditPersonOptOutRefusal, PERSON_OPT_OUT_SHORTCUT_NOTICE, PERSON_OPT_OUT_UNREADABLE_NOTICE, } from "@open-everywhere/core/agent/adapter-api.js";
+import { EventDedupe, ThreadFifo, getOrCreateDmSeat as liveGetOrCreateDmSeat, touchDmSeat as liveTouchDmSeat, resolvePartition, auditSurfaceModeFrom, domainKeyOf, isThreadEngaged, divertInboundToUnifiedWindow, isPrunedDeploymentWakeError, markUndeliveredAfterHeal, isUndeliveredAfterHeal, healPrunedDeploymentStrand, mintWakeId, slackVendorEventTime, spreadVendorTs, resolveWakeTrust, ambientSupervisorEnabled, getConfig, getOperationalStore, OE_APPROVAL_PREFIX, handleApprovalPayload as liveHandleApprovalPayload, OE_SETKEY_ACTION_PREFIX, OE_SETKEY_MODAL_CALLBACK, handleSetKeyClick as liveHandleSetKeyClick, handleSetKeyViewSubmission as liveHandleSetKeyViewSubmission, OE_CONNECT_ACTION_PREFIX, handleConnectClick as liveHandleConnectClick, OE_GRANT_ACTION_PREFIX, handleGrantCardClick as liveHandleGrantCardClick, buildRecord, enqueue as enqueueLogRecord, flushLogShip, stampNonMemberChatAuth, externalPolicyIsInert, recordWakeTail, tailAuthorGrain, dmWindowRegistryKey, stampSurfaceEventVerified, readPersonOptOut, auditPersonOptOutRefusal, PERSON_OPT_OUT_SHORTCUT_NOTICE, PERSON_OPT_OUT_UNREADABLE_NOTICE, admitAskedBotReply, deploymentOrg, } from "@open-everywhere/core/agent/adapter-api.js";
+import { botReplyCandidate, slackBotReplyFacts } from "./slack-bot-ask.js";
 import { sidePanelViewedRoom, slackDmSystemNote } from "./slack-side-panel.js";
-import { renderWakeMessage, slackChannelFactsFor, slackAuthorIsMember, slackClickerIsGuest, slackWakeAuthorFacts, slackExternalPolicyForRoom, applySlackExternalPolicy, stripUnfencedSlackAttachments, slackEnterpriseIdFromEnvelope, slackForm, _resetAuthorMemberCache, } from "./slack-events.js";
+import { parseAgentSessionStopped, routeAgentSessionStop, setSlackSessionStatus, slackSessionTitle } from "./slack-agent-session.js";
+import { parseSlackFeedbackClick, routeSlackFeedbackClick } from "./slack-reply-feedback.js";
+import { followUpMessageEvent, followUpPressKey, markFollowUpPressed, parseSlackFollowUpClick } from "./slack-follow-ups.js";
+import { renderWakeMessage, slackChannelFactsFor, slackAuthorIsMember, slackClickerIsGuest, slackWakeAuthorFacts, slackExternalPolicyForRoom, applySlackExternalPolicy, stripUnfencedSlackAttachments, slackEnterpriseIdFromEnvelope, slackForm, } from "./slack-events.js";
 import { buildSlackAuth, withForwardedSlackEnvelope } from "./slack-identity.js";
 import { holdRouteWork, routeHoldQuiesced, withSlackRouteHold } from "./slack-route-hold.js";
 import { liveMemoryCanvasDeps, recheckChannelCanvas } from "./slack-memory-canvas.js";
 import { handleHomeClick, handleHomeOpened, handleHomeSubmission, liveSlackHomeDeps, parseHomeClick, parseHomeOpened, parseHomeSubmission, } from "./slack-home.js";
 import { persistSlackAttachment, registerSlackAttachment } from "./slack-attachments.js";
+import { hasSlackVoiceClip, withSlackVoiceClips } from "./slack-voice-clips.js";
 import { parseSlackShortcutPayload, shortcutMessageEvent, shortcutWakeKey, } from "./slack-shortcut.js";
 /** The public URL Slack POSTs every subscribed event to (Event Subscriptions Request URL). */
 export const PUBLIC_SLACK_ROUTE = "/eve/v1/slack";
@@ -217,6 +223,19 @@ export function classifyEnvelope(rawBody, contentType) {
         if (grantClick !== undefined) {
             return { kind: "grant-click", reason: "block_actions oe_grant: click — ours, never forwarded", payload: grantClick };
         }
+        // OPE-2520 — the native thumbs under an answer. Its action id is exactly `oe_feedback`, which no
+        // prefix above matches, so the order among these branches does not matter.
+        const feedbackPayload = decodeInteractivityPayload(rawBody);
+        const feedbackClick = parseSlackFeedbackClick(feedbackPayload);
+        if (feedbackClick !== undefined) {
+            return { kind: "feedback-click", reason: `block_actions oe_feedback ${feedbackClick.rating} — ours, never forwarded`, payload: feedbackPayload, click: feedbackClick };
+        }
+        // OPE-2516 — a suggested follow-up under an answer. Its action ids start `oe_followup:`, which no
+        // branch above matches.
+        const followUpClick = parseSlackFollowUpClick(feedbackPayload);
+        if (followUpClick !== undefined) {
+            return { kind: "followup-click", reason: "block_actions oe_followup: press in a DM — ours, never forwarded", payload: feedbackPayload, click: followUpClick };
+        }
         // THE HOME TAB (OPE-2451). Its clicks carry an `oe_home:` action id and its one modal a callback
         // id of its own, so neither can be mistaken for another door's payload, nor for eve's.
         const homePayload = decodeInteractivityPayload(rawBody);
@@ -279,6 +298,10 @@ export function classifyEnvelope(rawBody, contentType) {
         // forward costs eve a parse and a re-verify for every click the person makes in Slack.
         return { kind: "context-change", reason: "app_context_changed — the room rides the next side-panel message; nothing to wake" };
     }
+    if (eventType === "agent_session_stopped") {
+        // SLACK'S NATIVE STOP (OPE-2519). The subscription is what makes Slack show the button at all.
+        return { kind: "session-stop", reason: "agent_session_stopped — stop the session's running turn", env };
+    }
     if (eventType === "user_change") {
         // OPE-2423: slackChannel drops it, and a DEACTIVATED user is ours — automatic offboarding.
         return { kind: "user-change", reason: "user_change — a deactivation report candidate", env };
@@ -377,10 +400,6 @@ export function resolveBotIdentity() {
     }
     return botIdentityPromise;
 }
-/** Reset the cached identity (tests only). */
-export function _resetBotIdentity() {
-    botIdentityPromise = undefined;
-}
 const OK = () => new Response("ok");
 /**
  * The Enterprise Grid rung a forwarded delivery carries, paired with the message it describes
@@ -517,7 +536,7 @@ const logOutcome = (path, channelId, ts) => (outcome) => {
  * ({@link markUndeliveredAfterHeal}) before it rethrows, so {@link recordWakeFailure} can give the
  * row its own reason.
  */
-export async function deliverWithStrandRetry(deliver) {
+async function deliverWithStrandRetry(deliver) {
     try {
         return await deliver();
     }
@@ -547,10 +566,11 @@ export function recordWakeFailure(key, err) {
     // `void`-ed write sits OUTSIDE that promise and so races the freeze after the 200 all the same.
     void holdRouteWork((async () => {
         try {
-            const p = resolvePartition({
+            const bindable = {
                 channel: { kind: "slack" },
                 session: { auth: { current: { attributes: { team_id: "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
-            });
+            };
+            const p = resolvePartition(bindable);
             // OPE-970: a retry that ALSO failed after the pruned-deployment heal gets its own reason —
             // otherwise it is indistinguishable from any other send failure, and the only way to tell
             // "the seat is fine now but this message was lost" from "a transient blip" was to read the
@@ -562,10 +582,11 @@ export function recordWakeFailure(key, err) {
                 platform: p.platform,
                 workspace: p.workspace,
                 surface: p.surface,
+                ...auditSurfaceModeFrom(bindable),
                 action: "surface.wake_failed",
                 detail: {
                     fifoKey: key,
-                    message: String(err instanceof Error ? err.message : err).slice(0, 500),
+                    message: auditErrorDetail(err).error,
                     ...(undeliveredAfterHeal
                         ? { reason: "pruned-deployment-heal-retry-failed", remedy: "seat healed for its next wake; this message got no answer" }
                         : {}),
@@ -661,10 +682,6 @@ async function liveDmPartnerTrust(userId, teamId) {
     const member = await slackAuthorIsMember(userId, teamId);
     return member === undefined ? undefined : member ? "internal" : "external";
 }
-/** Reset the cached DM-partner trust (tests only). */
-export function _resetDmTrustCache() {
-    _resetAuthorMemberCache();
-}
 // `wrapDmSeatFrom` (OPE-90) is DELETED at OPE-351 stage 2. It existed to remap the address of eve's
 // NATIVE DM send onto a rotatable seat token — a bolt-on to a dispatch path a DM no longer takes. The
 // DM is now diverted onto the `unified` channel before the forward ever happens (`scheduleDmWake`
@@ -716,9 +733,27 @@ export function mentionSiblingSuppressed(input) {
         return false;
     return input.authoredText.includes(`<@${input.botUserId}>`);
 }
+/**
+ * Would a TYPED message in this thread reach the agent (OPE-2524)? The thread roads hear a voice clip only then, so a clip
+ * is handled exactly as the same words typed. That is an engagement row that was not stood down: an invited thread, or a
+ * name-drop watcher thread (whose typed follow-ups `shouldDeliverReply` admits, and which wakes with `oeUninvited`). A
+ * STOOD-DOWN row is the one case `isThreadEngaged` admits and the road then drops (`shouldDeliverReply`'s `stopped`
+ * leg, `routeSupervisorEvent`'s stood-down silence), so a clip heard there would be downloaded and billed for nothing.
+ * Fail-closed: an unreadable row is not heard.
+ */
+async function threadHearsClips(p, threadTs) {
+    try {
+        const row = await getOperationalStore().getEngagement(p.org, p.surfaceKey, threadTs);
+        return row !== null && row.stopped !== true;
+    }
+    catch {
+        return false;
+    }
+}
 export function buildFrontHandler(innerHandler, opts = {}) {
     const dedupe = opts.dedupe ?? new EventDedupe();
     const fifo = opts.fifo ?? new ThreadFifo(recordWakeFailure);
+    const hearVoice = opts.hearVoiceClips ?? ((ev) => withSlackVoiceClips(ev));
     const getBotIdentity = opts.getBotIdentity ?? resolveBotIdentity;
     const now = opts.now ?? (() => Date.now());
     // THE SIGNING SECRET RESOLVES PER REQUEST, AND IT IS ASYNC SINCE OPE-2231. It used to be a
@@ -747,6 +782,7 @@ export function buildFrontHandler(innerHandler, opts = {}) {
     const homeClicked = opts.handleHomeClick ?? ((click) => handleHomeClick(click, liveSlackHomeDeps()));
     const recheckCanvas = opts.recheckChannelCanvas ?? ((input) => recheckChannelCanvas(input, liveMemoryCanvasDeps()));
     const homeSubmitted = opts.handleHomeSubmission ?? ((submission) => handleHomeSubmission(submission, liveSlackHomeDeps()));
+    const admitBotReply = opts.admitBotReply ?? ((ev, self) => admitAskedBotReply(slackBotReplyFacts(ev, deploymentOrg(), self), ev.authoredText));
     const ambientEnabledFor = opts.ambientEnabledFor ?? ((surfaceKey) => ambientSupervisorEnabled(surfaceKey, getConfig().loadDomains()));
     const seatedSurface = opts.seatedSurfaceFor ?? slackDomainUsesUnifiedWindow;
     const mentionPolicyFor = opts.mentionPolicyFor ?? slackSingleWindowMentionPolicy;
@@ -922,7 +958,11 @@ export function buildFrontHandler(innerHandler, opts = {}) {
         // `onWake` runs SYNCHRONOUSLY, once, immediately before a wake is scheduled — and never on the
         // addressed-drop path below. The shortcut route (OPE-1442) uses it to seed the attachment
         // registry only for a click that actually wakes something; every other caller omits it.
-        const scheduleUnownedWake = (ev, label, directMention = false, onWake, seatEngaged = false) => {
+        // `hearsMentionClip` (OPE-2524) is an explicit opt-in, set by the diverted @mention road ONLY. `directMention` alone
+        // is not enough: a channel MESSAGE SHORTCUT is also an addressed wake, but the clip on its target message is someone
+        // ELSE's speech, which the shortcut fences as untrusted, and hearing it would put that person's words outside the
+        // fence at the presser's trust. A shortcut's clip is not heard.
+        const scheduleUnownedWake = (ev, label, directMention = false, onWake, seatEngaged = false, hearsMentionClip = false) => {
             let ambient = false;
             let surfaceKey;
             try {
@@ -971,7 +1011,24 @@ export function buildFrontHandler(innerHandler, opts = {}) {
                 // supervisorFifoKey needs no store read either, so it stays a stable, synchronous key
                 // on the hot path exactly like the token-based key did.
                 const supKey = supervisorFifoKey(ev.channelId);
-                args.waitUntil(fifo.enqueue(supKey, () => deliverWithStrandRetry(() => routeSupervisorEvent(ev, withSingleWindowDiversion(liveSupervisorDeps(send), args.to, surfaceKey), directMention ? { directMention: true } : undefined).then(logOutcome(`${label}-supervisor`, ev.channelId, ev.ts)))));
+                args.waitUntil(fifo.enqueue(supKey, async () => {
+                    // A voice clip is heard on an ADDRESSED seat wake only — a mention, or an engaged thread that was not stood
+                    // down. An ambient wake on unaddressed talk never downloads a room's audio (OPE-2524, slack-voice-clips.ts).
+                    // A bot author is dropped by the seat's own gate, so its clip is never paid for. The clip test comes first, so
+                    // a message with no clip pays no extra store read. The thread leg also asks the room's fail-closed internal
+                    // confirmation FIRST, the one `shouldSupervisorWake` drops on later: a thread in a room that became shared, or
+                    // cannot be confirmed internal, wakes nothing, so its clip must not reach speech-to-text. (A mention already
+                    // passed that confirmation in the single-window policy.)
+                    const hears = !ev.botId &&
+                        hasSlackVoiceClip(ev) &&
+                        ((directMention && hearsMentionClip) ||
+                            (seatEngaged &&
+                                ev.threadTs !== undefined &&
+                                (await channelFactsFor(ev.channelId).then((f) => f.internal === true, () => false)) &&
+                                (await threadHearsClips(resolvePartition(bindableFor(ev)), ev.threadTs))));
+                    const heard = hears ? await hearVoice(ev) : ev;
+                    return deliverWithStrandRetry(() => routeSupervisorEvent(heard, withSingleWindowDiversion(liveSupervisorDeps(send), args.to, surfaceKey), directMention ? { directMention: true } : undefined).then(logOutcome(`${label}-supervisor`, ev.channelId, ev.ts)));
+                }));
                 return;
             }
             // 🔴 A NAME-DROP WAKES THE ROOM'S STANDING SEAT (OPE-1725). `routeNameDropEvent` stays the
@@ -1053,7 +1110,15 @@ export function buildFrontHandler(innerHandler, opts = {}) {
         const scheduleDmWake = async (ev, dmKind, 
         /** The DM door admitted this bot author as the deployment's named e2e driver (OPE-1023).
          *  Defaults FALSE, so every existing call site is unchanged. */
-        driverAdmitted = false) => {
+        driverAdmitted = false, 
+        /** Set only for a real `message.im` the person sent, which belongs to a Slack agent session
+         *  (OPE-2519): the words the person TYPED, before any voice clip was heard. A shortcut's minted
+         *  ts names no message, and a group DM has no agent session, so both leave it undefined and
+         *  leave the session untouched. The title reads only these words: a voice clip's transcript
+         *  rides `authoredText` behind a `[voice clip]` marker, and a clip OE could not hear adds a
+         *  host-written line, so neither is the person's typed text. */
+        agentSessionTypedText) => {
+            const opensAgentSession = agentSessionTypedText !== undefined;
             // 🔴 THE TENANT FENCE, AND THIS IS ITS CHOKEPOINT FOR THE WHOLE DM FAMILY (OPE-1644). Before
             // this line `slack-front.ts` consulted the fence NOWHERE, while the mention door, the four
             // dispatching engagement routes, the channel-join door and the `/oe` slash door all did — so a
@@ -1204,6 +1269,8 @@ export function buildFrontHandler(innerHandler, opts = {}) {
                 channelType: dmKind,
                 isPrivate: true,
                 ...(partnerTrust ? { dmPartnerTrust: partnerTrust } : {}),
+                // OPE-2519: the 1:1 message's Slack agent session — its thread, or itself when top-level.
+                ...(opensAgentSession && !isGroup ? { agentSessionTs: ev.threadTs ?? ev.ts } : {}),
                 // 🔴 THE GROUP DM CARRIES THE PLATFORM'S OWN SHARING VERDICT (OPE-1486), which is what a
                 // channel wake has always stamped (`authForEvent`) and an mpim wake never did. `bindSlack`
                 // reads the pair through `slackTrust`, so this is the binding's only route to the fact
@@ -1256,6 +1323,18 @@ export function buildFrontHandler(innerHandler, opts = {}) {
                 wakeId,
                 ...(seat.freshGeneration && seat.tail.length > 0 ? { backscroll: seat.tail } : {}),
             });
+            // THE SESSION TITLE (OPE-2519). A top-level 1:1 message opens a new conversation in the Messages
+            // tab or the side panel, and Slack keys its agent session by that message. Create the session with
+            // a title from the person's own words BEFORE the wake: the turn's `processing` call would
+            // otherwise create it untitled first, and Slack applies a title only on creation. That same rule
+            // keeps a title the person typed over ours. A group DM, a shortcut and a thread reply open no new
+            // session. The title reads the TYPED text alone, before any voice clip was heard: `text` also
+            // carries the lines of a forwarded or quoted message, which are another conversation's words.
+            if (opensAgentSession && !isGroup && !ev.threadTs && ev.ts) {
+                const title = slackSessionTitle(agentSessionTypedText);
+                if (title)
+                    await setSlackSessionStatus({ channelId: ev.channelId, threadTs: ev.ts, status: "active", title });
+            }
             // 🔴 NO `replyAnchorTs` ON A TOP-LEVEL DM — the reply stays FLAT in the conversation. The
             // CHANNEL divert DOES set one (slack-events.ts), because threading an answer under its trigger
             // keeps a busy shared channel tidy; the slack post arm reads `threadTs ?? replyAnchorTs`
@@ -1395,6 +1474,16 @@ export function buildFrontHandler(innerHandler, opts = {}) {
             // is the one cost no placement in this branch avoids.
             if (slackFrontTenantFenceDeclined(dev, `dm-${decision.dmKind}`, "front-dm-branch"))
                 return fencedAck(OK());
+            // 🔴 AN EDIT THAT CHANGED NOTHING IS NOT A WAKE (OPE-2577). OE's own agent-session status calls
+            // edit the person's root message, and each edit reaches this door as a `message_changed` with
+            // the person as author. Woken, each one was a new inbound wake that made the answer to the
+            // person's real message stale. See {@link isUnchangedSlackEdit}. Above the driver carve-out, so
+            // the driver's DM and a person's DM take the same drop. A log line only, no audit row: three of
+            // these follow every DM turn, the same reasoning that keeps our own reply echo out of the trail.
+            if (dev.unchangedEdit) {
+                console.log(`[open-everywhere:slack-front] ${decision.dmKind} ${dev.channelId}/${dev.ts}: no wake — ${UNCHANGED_EDIT_DROP_REASON}`);
+                return OK();
+            }
             // A bot-authored DM is never a wake — a no-op 200. NOT a forward: forwarding a bot_message
             // would hand eve's native door a turn the DM window is meant to own.
             //
@@ -1484,7 +1573,10 @@ export function buildFrontHandler(innerHandler, opts = {}) {
             // never shared with a channel supervisor's or a thread's. The mention-carried divert below
             // enqueues on the SAME key, so a group DM's two legs can never run concurrently on one seat.
             args.waitUntil(fifo.enqueue(dmFifoKey(dev.channelId), async () => {
-                await deliverWithStrandRetry(() => scheduleDmWake(dev, decision.dmKind, driverAdmitted));
+                // A voice clip is heard ONCE, before the retry wrapper, so a strand retry never pays for a second
+                // transcription (OPE-2524, slack-voice-clips.ts). A DM is always addressed, so its clips are always heard.
+                const heard = await hearVoice(dev);
+                await deliverWithStrandRetry(() => scheduleDmWake(heard, decision.dmKind, driverAdmitted, decision.dmKind === "im" ? dev.authoredText : undefined));
                 console.log(`[open-everywhere:slack-front] ${decision.dmKind} ${dev.channelId}/${dev.ts}: woke — diverted to the DM window seat`);
             }));
             return OK();
@@ -1643,7 +1735,7 @@ export function buildFrontHandler(innerHandler, opts = {}) {
                 // directMention path (slack-events.ts routeSupervisorEvent) and re-checks its own
                 // fail-closed internal confirmation — the SAME process-local TTL-cached conversations.info
                 // the policy just populated, so the two reads on this one webhook are cache-coherent.
-                scheduleUnownedWake(mev, "single-window-mention", true);
+                scheduleUnownedWake(mev, "single-window-mention", true, undefined, false, true);
                 return OK();
             }
             // 🔴 THE GROUP-DM MENTION LEG (OPE-351 stage 4). An @mention is how a human addresses the bot in
@@ -1680,7 +1772,9 @@ export function buildFrontHandler(innerHandler, opts = {}) {
                     // re-reading a field that was never there; `scheduleDmWake` stamps it onto the wake auth,
                     // which is what makes `bindSlack` bind mode `mpim` on this leg exactly as on the other.
                     args.waitUntil(fifo.enqueue(dmFifoKey(mev.channelId), async () => {
-                        await deliverWithStrandRetry(() => scheduleDmWake({ ...mev, channelType: "mpim" }, "mpim"));
+                        // A bot's group-DM mention is not heard: `scheduleDmWake` drops a bot author after this step.
+                        const heard = mev.botId ? mev : await hearVoice(mev);
+                        await deliverWithStrandRetry(() => scheduleDmWake({ ...heard, channelType: "mpim" }, "mpim"));
                     }));
                     return OK();
                 }
@@ -1827,6 +1921,51 @@ export function buildFrontHandler(innerHandler, opts = {}) {
             }));
             return new Response(null, { status: 200 });
         }
+        if (decision.kind === "feedback-click") {
+            // THE TENANT FENCE FIRST (OPE-1680), as every click branch: a foreign workspace writes no row.
+            if (slackInteractivityTenantFenceDeclined(interactivityFenceIds(decision.payload), "feedback-click", "front-interactivity-branch")) {
+                return fencedAck(new Response(null, { status: 200 }));
+            }
+            // OPE-2520 — a rating, recorded after the acknowledgement. Slack draws the pressed state itself,
+            // so the empty 200 is the whole answer, and the row write never holds the click up.
+            const click = decision.click;
+            args.waitUntil(routeSlackFeedbackClick(click)
+                .then((recorded) => {
+                if (!recorded)
+                    console.warn("[open-everywhere:slack-front] a thumbs click was not recorded");
+            })
+                .catch(() => undefined));
+            return new Response(null, { status: 200 });
+        }
+        if (decision.kind === "followup-click") {
+            // OPE-2516 — the person pressed a suggested follow-up under an answer in their DM.
+            // THE TENANT FENCE FIRST (OPE-1680), as every click branch. `scheduleDmWake` refuses the same
+            // workspace on its own; this spares an unadmitted one the rewrite and the dedupe write.
+            const click = decision.click;
+            const sev = followUpMessageEvent(click, now());
+            if (slackInteractivityTenantFenceDeclined(interactivityFenceIds(decision.payload), "followup-click", "front-interactivity-branch")) {
+                return fencedAck(new Response(null, { status: 200 }));
+            }
+            // One answer takes one press: a double press, or Slack's redelivery of one, wakes the seat once.
+            if (!(await notYetSeenKey(followUpPressKey(click), sev)))
+                return new Response(null, { status: 200 });
+            // ACK FIRST, WORK AFTER, as the shortcut branch: the rewrite and the wake both ride `waitUntil`.
+            // The rewrite removes the buttons and shows what the person sent. The wake takes the SAME road a
+            // typed DM takes, so the seat, the trust probe, the external-participant policy and the spend
+            // gate all decide it. The agent session is touched only when the answer sits in a thread: a
+            // top-level answer has no session thread for a minted ts to name.
+            args.waitUntil(markFollowUpPressed(click)
+                .then((rewritten) => {
+                if (!rewritten)
+                    console.log(`[open-everywhere:slack-front] follow-up press in ${click.channelId}: the answer was not rewritten`);
+            })
+                .catch(() => undefined));
+            args.waitUntil(fifo.enqueue(dmFifoKey(click.channelId), async () => {
+                await deliverWithStrandRetry(() => scheduleDmWake(sev, "im", false, click.threadTs === undefined ? undefined : click.text));
+                console.log(`[open-everywhere:slack-front] follow-up press in ${click.channelId}: woke the DM window`);
+            }));
+            return new Response(null, { status: 200 });
+        }
         if (decision.kind === "home-open" || decision.kind === "home-click" || decision.kind === "home-submit") {
             // THE HOME TAB (OPE-2451). THE TENANT FENCE FIRST (OPE-1680), for the reason the approval branch
             // states: the page reads and changes a person's memory, keyed to a bare per-workspace member id,
@@ -1980,6 +2119,42 @@ export function buildFrontHandler(innerHandler, opts = {}) {
             args.waitUntil(routeUserDeactivation(deactivation).then((outcome) => console.log(`[open-everywhere:slack-front] user_change ${deactivation.userId}: offboarding ${outcome.kind}${outcome.kind === "refused" ? ` (${outcome.reason})` : ""}`)));
             return OK();
         }
+        if (decision.kind === "session-stop") {
+            // SLACK'S NATIVE STOP (OPE-2519) — the same cancel door as the ✋ arm below, with the same fence
+            // in front of it: an unadmitted workspace's press must never reach `args.attachSession`.
+            const stop = parseAgentSessionStopped(decision.env);
+            if (!stop)
+                return OK();
+            const stopEnterpriseId = slackEnterpriseIdFromEnvelope(decision.env);
+            if (slackInteractivityTenantFenceDeclined({
+                ...(stop.teamId === undefined ? {} : { teamId: stop.teamId }),
+                ...(stopEnterpriseId === undefined ? {} : { enterpriseId: stopEnterpriseId }),
+                channelId: stop.channelId,
+                userId: stop.userId,
+            }, "session-stop", "front-session-stop-branch")) {
+                return fencedAck(OK());
+            }
+            // A Slack RETRY of the same press must not send a second cancel: in-memory first, then durable.
+            const skey = wakeKey(decision.env, stop.channelId, stop.eventTs ?? stop.threadTs);
+            if (dedupe.seen(skey, now()))
+                return OK();
+            dedupe.mark(skey, now());
+            try {
+                const org = resolvePartition(bindableForSlackIds({ teamId: stop.teamId, channelId: stop.channelId, userId: stop.userId })).org;
+                if (!(await markEventSeen(org, skey, new Date(now()).toISOString())))
+                    return OK();
+            }
+            catch {
+                /* unresolvable partition → in-memory dedupe only (fail-open, as for a reaction) */
+            }
+            if (!args.attachSession) {
+                console.warn(`[open-everywhere:slack-front] session stop ${stop.channelId}/${stop.threadTs}: no cancel door on this route — nothing stopped`);
+                return OK();
+            }
+            const attachSession = args.attachSession;
+            args.waitUntil(routeAgentSessionStop(stop, { attachSession }).then((r) => console.log(`[open-everywhere:slack-front] session stop ${stop.channelId}/${stop.threadTs}: ${r.outcome}`)));
+            return OK();
+        }
         if (decision.kind === "reaction") {
             // Inbound reaction (feedback signal). Parse it; an unusable envelope is a no-op 200.
             const rev = parseSlackReactionEvent(decision.env);
@@ -2034,10 +2209,35 @@ export function buildFrontHandler(innerHandler, opts = {}) {
         const ev = parseMessageEvent(decision.env);
         if (!ev)
             return OK();
+        // An edit that changed no words and no files (a link unfurl, for example) is not news here either:
+        // the engagement and supervisor gates keep `message_changed` so a person's REAL edit wakes, and
+        // this keeps a metadata-only one out (OPE-2577, {@link isUnchangedSlackEdit}).
+        if (ev.unchangedEdit)
+            return OK();
         persistAttachments(ev); // durable upload registry (task #107) — so a delegated worker can read this message's files
+        // 🔴 THE ASKED-THREAD EXCEPTION (OPE-2426): the only road by which another bot's message WAKES the
+        // agent on a real deployment. (An attributable bot's earlier post can still enter a woken seat's
+        // backscroll as context-only awareness: slack-wake-backscroll.ts `isBackscrollVisible`.) The other bot admissions are the test-bed e2e driver settings (OPE-1023):
+        // `wake.driverAllowlist` on the engagement and mention doors, channel messages included, and
+        // `wake.e2eDrivers` on the DM door and the seat's own reads. A real deployment leaves both empty. A bot's reply in a thread where the person's DM asked THAT bot, inside the window, is
+        // relayed to the person's DM and stops here: it never wakes this channel's seat, and the host posts
+        // nothing in the thread. Every other bot message — a top-level post, a thread nobody asked it in, a
+        // different bot, a late reply, an edit — gets null and falls through to the ordinary bot-author drop
+        // below, unchanged. It runs BEFORE mention suppression, so a reply that also @mentions the agent is
+        // still relayed. Its `app_mention` twin is dropped as a bot author further down: by
+        // `shouldSupervisorWake` on the single-window road, or by the native mention handler (slack.ts). The relay
+        // claims each message once, so a retried event relays nothing twice.
+        const identity = await getBotIdentity();
+        if (botReplyCandidate(ev)) {
+            const admitted = await admitBotReply(ev, identity).catch(() => null);
+            if (admitted) {
+                args.waitUntil(admitted.relay().then((route) => console.log(`[open-everywhere:slack-front] asked-thread bot reply ${ev.channelId}/${ev.threadTs}: relayed to the asker's DM (${String(route)})`)));
+                return OK();
+            }
+        }
         // Mention-sibling suppression — see {@link mentionSiblingSuppressed} for the whole rule and for
         // why an EDIT is exempt from it.
-        const { userId: botUserId } = await getBotIdentity();
+        const { userId: botUserId } = identity;
         if (mentionSiblingSuppressed({ authoredText: ev.authoredText, ...(ev.subtype === undefined ? {} : { subtype: ev.subtype }), ...(botUserId === undefined ? {} : { botUserId }) })) {
             return OK();
         }
@@ -2095,7 +2295,14 @@ export function buildFrontHandler(innerHandler, opts = {}) {
         // failure mode — two burst replies racing — is cosmetic, unlike the duplicate-delivery
         // problem the durable dedupe above closes.)
         const threadKey = slackContinuationToken(ev.channelId, ev.threadTs);
-        args.waitUntil(fifo.enqueue(threadKey, () => routeMessageEvent(ev, liveDeps(send)).then(logOutcome("engaged-thread", ev.channelId, ev.threadTs))));
+        args.waitUntil(
+        // A human's voice clip is heard here unless the thread was stood down (OPE-2524): `shouldDeliverReply` drops a bot
+        // author and a stood-down thread, so their clips are never paid for. The clip test comes first, so a message with
+        // no clip pays no extra store read.
+        fifo.enqueue(threadKey, async () => {
+            const heard = !ev.botId && hasSlackVoiceClip(ev) && (await threadHearsClips(p, ev.threadTs)) ? await hearVoice(ev) : ev;
+            return routeMessageEvent(heard, liveDeps(send)).then(logOutcome("engaged-thread", ev.channelId, ev.threadTs));
+        }));
         return OK();
     }
 }