@open-everywhere/provider-slack 0.1.5 → 0.3.0

package/dist/agent/channels/slack.js

@@ -20,12 +20,14 @@ import { SLACK_EVE_CREDENTIALS } from "../setup/eve-credentials.js";
 import { slackChannel, } from "eve/channels/slack";
 import { buildSlackAuth, channelFactsFromInfo, channelFactsFromRaw, forwardedSlackEnterpriseId, partnerFactsFromInfo, slackMode, } from "./slack-identity.js";
 import { resolvePartition, getOperationalStore, postOnce, outboundKey, statusVerbsFor, getConfig, finalMessageActionForTurn, NO_REPLY_SENTINEL_REASON, auditNoReplySentinelObserved, isBareStop, supervisorTextDelivery, isSupervisorProseLeak, capabilitiesForPlatform, consumeCardPostedThisTurn, consumeReactedThisTurn, consumeRepliedThisTurn, dropClosingProse, markThreadEngaged, disengageThread, getThreadEngagement, bumpThreadSilentStreak, WARM_SILENT_LIMIT, SURFACE, tierId, getProvider, providerById, writeMemoryTier, surfaceProvider, upsertUnderSection, bindFrom, authPrincipalId, isAllowedSlackDriver, planFor, extractPinnedInstructions, introMessage, instructionBullet, ONBOARDED_MARKER, STATUS_REACTION, renderPinned, isPinnedStatusMessage, classifyWakeMapping, unmappedWakeCopy, UNMAPPED_WAKE_DROP_REASON, admittedTenantsFromConfig, unadmittedTenantLog, UNADMITTED_TENANT_DROP_REASON, dmTrustTtlMs, swallowRoomOp, domainRoster, } from "@open-everywhere/core/agent/adapter-api.js";
+import { withEndsTurnFinalChannel } from "@open-everywhere/core/agent/adapter-api.js";
 import { loadConversationContext } from "./slack-context.js";
 import { slackSpendGate } from "./slack-spend-gate.js";
 import { slackTenantAdmission } from "./slack-tenant-fence.js";
 import { holdRouteWork } from "./slack-route-hold.js";
 import { frontSlackChannel, INTERNAL_SLACK_ROUTE } from "./slack-front.js";
 import { admitSlackInputResponse } from "./slack-input-response.js";
+import { taskCardConfidentiality } from "./slack-task-card.js";
 import { turnEffectsFor, botDisplayName, slackForm, isSupervisorReplyTurn, deliverSupervisorReply, dmWakeThreadOverride, replyThreadTsForState } from "./slack-events.js";
 import { markdownToSlackMrkdwn } from "./slack-mrkdwn.js";
 // WARM_SILENT_LIMIT (the warm-thread shed threshold) now lives in channels/engagement.ts so
@@ -689,489 +691,537 @@ const slackMentionChannel = slackChannel({
     // session-limit prompt. The admission runs the SAME room floor the approval click runs
     // (approvals/clicker-floor.ts); see channels/slack-input-response.ts for the shape.
     onInputResponse: (ctx, submission) => admitSlackInputResponse(ctx, submission),
-    events: {
-        // Snapshot the supervisor's REAL per-turn reply target, then run eve's default
-        // turn.started body. eve wraps turn.started specially (verified in the compiled
-        // slackChannel): it always sets `triggeringUserId` from the auth, THEN calls the
-        // authored handler IN PLACE OF `defaultEvents["turn.started"]` — so authoring this
-        // handler REPLACES the default's state-clear + "Working…" typing. We therefore
-        // replicate that default body verbatim below so NON-supervisor turns stay
-        // byte-identical to today; the supervisor snapshot is the only addition, gated on the
-        // `oeSupervisor` flag (T1.3's wake state).
-        //
-        // Why snapshot here (T1.4 / C1): a supervisor session's `state.threadTs` is a NON-EMPTY
-        // sentinel (amendment A), so it can't carry the turn's real target. But eve rewrites
-        // `session.auth.current` from the DELIVERY's auth on every delivery, and Slack auth
-        // attributes carry `channel_id`/`thread_ts` — so at turn.started they are THIS turn's
-        // real trigger. We copy them into `channel.state.oeReplyTarget` for message.completed to
-        // post to. `thread_ts` present ⇔ the trigger was threaded (buildSlackAuth only sets it
-        // when the message had a thread_ts); absent ⇔ a top-level channel message.
-        "turn.started": async (_data, channel, ctx) => {
-            // Supervisor target snapshot FIRST — must not depend on the typing call succeeding.
-            if (isSupervisorReplyTurn(channel.state)) {
-                const attrs = ctx?.session?.auth?.current?.attributes;
-                const channelId = typeof attrs?.channel_id === "string" ? attrs.channel_id : undefined;
-                const threadTs = typeof attrs?.thread_ts === "string" ? attrs.thread_ts : undefined;
-                // channelId missing ⇒ leave no stale target from a prior turn (fail safe: no target
-                // means message.completed posts NOTHING, never to a guessed channel).
-                channel.state.oeReplyTarget = channelId
-                    ? { channelId, threadTs }
-                    : undefined;
-            }
-            // OPE-645: REPLY PRINCIPAL snapshot — same T1.4 pattern as the supervisor target above, for the
-            // same reason: message.completed has no live auth ctx, so the canonical row it writes cannot
-            // derive WHO from ctx at that point. Since OPE-2006 that row is the DROP row, never a
-            // `reply.post`. authPrincipalId(ctx) is the exact read bindFrom(ctx).principalId falls back to
-            // for an ordinary human turn (identity/binding.ts) — snapshotting it here means the drop row
-            // names the same person the turn's egress.policy rows already do.
-            channel.state.oeReplyPrincipalId = authPrincipalId(ctx);
-            // OPE-98: DM-SEAT per-wake anchor. A DM seat (OPE-90) is ONE per-channel eve session spanning
-            // many assistant threads, but eve freezes the session's reply target to the FIRST wake's
-            // thread (`state.threadTs`, seeded once at session birth — see slack-events.ts's
-            // dmWakeThreadOverride header). Snapshot THIS wake's thread from the delivery auth (rewritten
-            // per delivery ⇒ the waking message's thread) so the reply + thinking-status ride it. SCOPED
-            // to `im` DMs — every channel/supervisor/mpim turn leaves `oeWakeThreadTs` unset, so their
-            // targeting stays byte-identical.
-            {
-                const attrs = ctx?.session?.auth?.current?.attributes;
-                if (attrs?.channel_type === "im") {
-                    channel.state.oeWakeThreadTs =
-                        typeof attrs.thread_ts === "string" ? attrs.thread_ts : undefined;
-                }
-            }
-            // eve's default turn.started body, byte-preserved (see header above).
-            channel.state.pendingToolCallMessage = null;
-            channel.state.lastReasoningTypingAtMs = null;
-            channel.state.lastReasoningTypingStatus = null;
-            await setWakeTyping(channel, "Working...");
-        },
-        // Keep the model's REASONING out of the channel. GLM-5.2 runs with reasoning:"medium",
-        // and Eve's default `reasoning.appended` handler pipes the chain-of-thought straight into
-        // the Slack typing-status line (startTyping(reasoningText)). That leaks internal thinking
-        // into the surface. We override it to refresh a GENERIC status instead — the indicator
-        // stays alive (so a long reasoning phase doesn't look stalled) without echoing the
-        // reasoning itself. Throttled to the default's ~5s cadence to avoid spamming startTyping.
-        // The clean final answer leaves by the `reply` TOOL and by nothing else: this channel authors
-        // its own `message.completed`, and since OPE-2006 that handler DROPS the turn's closing prose
-        // and records it (`channels/closing-prose-drop.ts`). Re-delegating to eve's default poster here
-        // would re-open the road this ticket removed, on the surface OPE-771 measured the loss on.
-        "reasoning.appended": async (_data, channel) => {
-            const now = Date.now();
-            const last = channel.state.lastReasoningTypingAtMs;
-            if (last != null && now - last >= 0 && now - last < 5000)
-                return;
-            channel.state.lastReasoningTypingAtMs = now;
-            await refreshTypingStatus(channel);
-        },
-        // Eve's default falls back to "Running bash, read_channel..." for a tool-call
-        // step, which means nothing to non-engineers and advertises the toolbox to the whole
-        // channel — so we override with a generic status. We ALSO used to show the model's own
-        // preamble text here (its line before the tool call, written for humans, Tag-style) —
-        // dropped 2026-07 (Tommy, live): that text streams in mid-sentence, so the typing
-        // indicator would flash a truncated fragment ("I'll go away and look to setu…") for a
-        // moment before reverting, which read as broken. Always the clean status verb now,
-        // same as reasoning.appended.
-        "actions.requested": async (_data, channel) => {
-            await refreshTypingStatus(channel);
-        },
-        // Override the reply-posting handler for TWO additions: (1) a woken (non-mention) turn
-        // is told to judge whether a reply is warranted and to end with NO_REPLY when it isn't
-        // (slack-events.ts renderWakeMessage) — that sentinel must be swallowed, not posted;
-        // (2) a turn where a propose tool already posted a code-rendered approval card
-        // (approvals/flow.ts's requestApproval, signalled via approvals/card-signal.ts)
-        // suppresses the model's redundant text — the card already said it (Tommy, live: "the
-        // card should suffice"). Everything else mirrors Eve's default handler byte-for-byte
-        // (tool-calls is an intermediate step with no turn-final effects; empty final message
-        // posts nothing), via the pure, unit-tested finalMessageAction()/turnEffectsFor().
-        "message.completed": async (data, channel, ctx) => {
-            // The eve session id for this turn — stamped into the terminal audit rows below so an
-            // audited reply/silence/dropped-prose joins back to its transcript (control-read transcript).
-            const sessionId = ctx?.session?.id;
-            // OPE-1647: the TURN ID, so the stand-down silence mark (channels/stand-down-silence.ts) can
-            // prove it belongs to THIS turn. Same extraction idiom this file already uses for the §POSTED
-            // consume below.
-            // 🔴 SINCE OPE-2006 IT SERVES THE SILENCE DECISION ALONE. It is read once here and handed to
-            // `finalMessageActionForTurn`, whose `consumeStandDownSilenceThisTurn(turnId)` is its only
-            // reader on this path. There is no reply audit below to stamp it onto: this surface DROPS its
-            // closing prose, so the durable latch that guarded the old post has no door left to shut here.
-            const turnId = ctx?.session?.turn?.id;
-            const action = finalMessageActionForTurn(data.finishReason, data.message, turnId);
-            if (action.kind === "buffer-tool-status") {
-                // An intermediate tool-call step, not the turn's end — nothing to decide yet. In
-                // particular: don't read the card-posted flag here, the tool this step is about to
-                // run may be the one that posts the card.
-                return;
-            }
-            // Read-and-reset whether an approval card already posted THIS turn — consumed once,
-            // right before the turn's terminal effects are decided, so the next turn always
-            // starts clean (mirrors how oeSilentTurn/oeUninvited below are REASSIGNED on every
-            // terminal call rather than cleared as a separate step).
-            const cardPostedThisTurn = consumeCardPostedThisTurn();
-            // Same read-and-reset contract, for the bare-stop check right below. A turn that
-            // reacted OR posted mid-turn via the reply-tool family (reply-signal.ts) acted, so
-            // both signals are consumed here and OR'd into the bare-stop input.
-            const reactedThisTurn = consumeReactedThisTurn();
-            // TURN-ID KEYED (OPE-805): a bare read-and-reset let a mark this turn never consumed answer a
-            // LATER turn's read — see reply-signal.ts's header.
-            const repliedThisTurn = consumeRepliedThisTurn(ctx?.session?.turn?.id);
-            if (action.kind === "silent") {
-                // Remember the turn ended silent so session.waiting doesn't stamp a ❓ status
-                // reaction on a conversation the agent chose NOT to join (live-observed: a
-                // judged-silent name-drop left a ❓ on the triggering message).
-                channel.state.oeSilentTurn = true;
-                // Silence is designed to leave no trace ON THE SURFACE — but the operator
-                // needs to distinguish "judged NO_REPLY" from "never woke" (bit us live).
-                // action.reason distinguishes the sentinel route from the no_reply TOOL route
-                // (finalMessageActionForTurn folds both into "silent").
-                console.log(`[open-everywhere:slack] judged silence (${action.reason}) — nothing posted (${channel.state.channelId ?? "?"}/${channel.state.threadTs ?? "?"})`);
-                // ACTIONS-ONLY posture (audit-wedge build plan §1c, 2026-07-14): a judged silence on an
-                // ambient chat surface is NOT an audited action — an agent meant to reply to ~1% of channel
-                // messages would otherwise produce a table that is ~99% silence rows. "Why did it stay
-                // quiet?" is answered by the session transcript (GET /control/v1/session/:id/transcript),
-                // not the audit log. The console line above stays (operator-legible, free); the bare-stop
-                // row below stays (an ANOMALY — a judgment went missing — not a judged silence).
+    // 🔴 eve 0.69.0 REPLACED `events` WITH A RENDERER CHAIN, AND NOT CALLING `next` IS THE PORT
+    // (OPE-2247). Through 0.68.x, `slackChannel({ events })` REPLACED eve's own rendering for every
+    // event it named — each handler below says so in its own words, and several replicate eve's
+    // default body verbatim because of it. 0.69.0 turns the same handlers into one link of a chain
+    // that ENDS in eve's default, and the default runs only when a handler awaits `next`. So the
+    // behaviour-preserving port is this wrapper and nothing else: no handler here calls `next`, which
+    // keeps every rendering decision below exactly as it reads today.
+    //
+    // 🔴 THE TASK CARD IS EVE'S OWN, BEHIND A CONFIDENTIALITY LINK (OPE-2255). OPE-2247 ported the
+    // card OFF (a `taskCard` link that returned null) and left the content ruling to this ticket. eve's
+    // default card now runs, so a turn that starts a task shows eve's live card. The FIRST link,
+    // `taskCardConfidentiality` (channels/slack-task-card.ts), changes the view eve draws from, and
+    // nothing else:
+    //   * a row shows its own title (the worker BRIEF) only in a 1:1 DM with the turn's own caller;
+    //     every other room shows a generic label made from the task's name;
+    //   * no row ever shows the worker's result excerpt, which would bypass `approvals/review-surface.ts`.
+    // eve builds the notification `text` from the titles, so the redaction covers it too. The link must
+    // stay FIRST: its event handlers record the room and then call `next`, and the next link's handlers
+    // do not call `next`, so a recorder placed after them would never run.
+    //
+    // Also eve's default, by ruling (OPE-2255): the `received` acknowledgement (`Thinking...`, then this
+    // file's own "Working..." from `turn.started`), and the private-to-principal approval feedback. This
+    // channel names no `approvalChannel`, so an eve-native approval card (`post_file`) posts once, in the
+    // thread, and only a refused responder's feedback goes privately to that responder.
+    renderers: [
+        // FIRST, always. See the 🔴 note above before moving it.
+        taskCardConfidentiality,
+        {
+            events: {
+                // Snapshot the supervisor's REAL per-turn reply target, then run eve's default
+                // turn.started body. eve wraps turn.started specially (verified in the compiled
+                // slackChannel): it always sets `triggeringUserId` from the auth, THEN calls the
+                // authored handler IN PLACE OF `defaultEvents["turn.started"]` — so authoring this
+                // handler REPLACES the default's state-clear + "Working…" typing. We therefore
+                // replicate that default body's state-clear below, with this channel's own typing call;
+                // the supervisor snapshot is the only addition, gated on the `oeSupervisor` flag (T1.3's
+                // wake state).
                 //
-                // ONE exception (OPE-890): the model ended the turn on the bare NO_REPLY sentinel — the
-                // TOOL route already carries an always-on `reply.no_reply_observed` row (tools/no_reply.ts,
-                // OPE-649); this is the sentinel route's twin, same action name, best-effort.
-                if (action.reason === NO_REPLY_SENTINEL_REASON) {
-                    try {
-                        const p = resolvePartition({
-                            channel: { kind: "slack" },
-                            session: { auth: { current: { attributes: { team_id: channel.state.teamId ?? "", channel_id: channel.state.channelId ?? "" }, principalId: "", principalType: "slack-user" } } },
-                        });
-                        await auditNoReplySentinelObserved(p, sessionId);
+                // Why snapshot here (T1.4 / C1): a supervisor session's `state.threadTs` is a NON-EMPTY
+                // sentinel (amendment A), so it can't carry the turn's real target. But eve rewrites
+                // `session.auth.current` from the DELIVERY's auth on every delivery, and Slack auth
+                // attributes carry `channel_id`/`thread_ts` — so at turn.started they are THIS turn's
+                // real trigger. We copy them into `channel.state.oeReplyTarget` for message.completed to
+                // post to. `thread_ts` present ⇔ the trigger was threaded (buildSlackAuth only sets it
+                // when the message had a thread_ts); absent ⇔ a top-level channel message.
+                "turn.started": async (_data, channel, ctx) => {
+                    // Supervisor target snapshot FIRST — must not depend on the typing call succeeding.
+                    if (isSupervisorReplyTurn(channel.state)) {
+                        const attrs = ctx?.session?.auth?.current?.attributes;
+                        const channelId = typeof attrs?.channel_id === "string" ? attrs.channel_id : undefined;
+                        const threadTs = typeof attrs?.thread_ts === "string" ? attrs.thread_ts : undefined;
+                        // channelId missing ⇒ leave no stale target from a prior turn (fail safe: no target
+                        // means message.completed posts NOTHING, never to a guessed channel).
+                        channel.state.oeReplyTarget = channelId
+                            ? { channelId, threadTs }
+                            : undefined;
                     }
-                    catch (err) {
-                        console.warn(`[open-everywhere:slack] sentinel no_reply audit write failed: ${String(err)}`);
-                    }
-                }
-                // Bare-stop enforcement (feature 2's investigation — see slack-events.ts's
-                // isBareStop header for why this is DETECT-AND-LOG, not a hard gate): a turn
-                // that went silent with NO explanation (no sentinel, no no_reply tool) and
-                // NO react either did, as far as anyone can tell, nothing at all. Loud warn
-                // + a best-effort audit row; never a post — silence stays silence.
-                if (isBareStop(action, reactedThisTurn || repliedThisTurn)) {
-                    const channelId = channel.state.channelId ?? undefined;
-                    const threadTs = channel.state.threadTs ?? undefined;
-                    console.warn(`[open-everywhere:slack] BARE STOP — turn ended with no reply, no react, and no no_reply ` +
-                        `(${channelId ?? "?"}/${threadTs ?? "?"}) — this usually means a judgment call went missing, not that one was made.`);
-                    try {
-                        const p = resolvePartition({
-                            channel: { kind: "slack" },
-                            session: { auth: { current: { attributes: { team_id: channel.state.teamId ?? "", channel_id: channelId ?? "" }, principalId: "", principalType: "slack-user" } } },
-                        });
-                        await getOperationalStore().appendAudit({
-                            ts: new Date().toISOString(),
-                            org: p.org,
-                            platform: p.platform,
-                            workspace: p.workspace,
-                            surface: p.surface,
-                            action: "turn.bare_stop",
-                            detail: { threadTs, ...(sessionId ? { sessionId } : {}) },
-                        });
+                    // OPE-645: REPLY PRINCIPAL snapshot — same T1.4 pattern as the supervisor target above, for the
+                    // same reason: message.completed has no live auth ctx, so the canonical row it writes cannot
+                    // derive WHO from ctx at that point. Since OPE-2006 that row is the DROP row, never a
+                    // `reply.post`. authPrincipalId(ctx) is the exact read bindFrom(ctx).principalId falls back to
+                    // for an ordinary human turn (identity/binding.ts) — snapshotting it here means the drop row
+                    // names the same person the turn's egress.policy rows already do.
+                    channel.state.oeReplyPrincipalId = authPrincipalId(ctx);
+                    // OPE-98: DM-SEAT per-wake anchor. A DM seat (OPE-90) is ONE per-channel eve session spanning
+                    // many assistant threads, but eve freezes the session's reply target to the FIRST wake's
+                    // thread (`state.threadTs`, seeded once at session birth — see slack-events.ts's
+                    // dmWakeThreadOverride header). Snapshot THIS wake's thread from the delivery auth (rewritten
+                    // per delivery ⇒ the waking message's thread) so the reply + thinking-status ride it. SCOPED
+                    // to `im` DMs — every channel/supervisor/mpim turn leaves `oeWakeThreadTs` unset, so their
+                    // targeting stays byte-identical.
+                    {
+                        const attrs = ctx?.session?.auth?.current?.attributes;
+                        if (attrs?.channel_type === "im") {
+                            channel.state.oeWakeThreadTs =
+                                typeof attrs.thread_ts === "string" ? attrs.thread_ts : undefined;
+                        }
                     }
-                    catch (err) {
-                        console.warn(`[open-everywhere:slack] bare-stop audit write failed: ${String(err)}`);
+                    // eve's default turn.started body, minus its thread-status renderer (see header above).
+                    // eve 0.71.0's default clears `pendingTaskResults` and `pendingToolCallMessage`, then shows
+                    // "Thinking..." through its module-private `showStatus`, which records `state.threadStatus`.
+                    // This channel keeps its own "Working..." typing call and its own reasoning throttle key
+                    // below. Adoption of eve's persistent thread status is a separate decision (OPE-2289).
+                    channel.state.pendingTaskResults = null;
+                    channel.state.pendingToolCallMessage = null;
+                    channel.state.oeReasoningTypingAtMs = null;
+                    await setWakeTyping(channel, "Working...");
+                },
+                // Keep the model's REASONING out of the channel. GLM-5.2 runs with reasoning:"medium",
+                // and Eve's default `reasoning.appended` handler pipes the chain-of-thought straight into
+                // the Slack typing-status line (startTyping(reasoningText)). That leaks internal thinking
+                // into the surface. We override it to refresh a GENERIC status instead — the indicator
+                // stays alive (so a long reasoning phase doesn't look stalled) without echoing the
+                // reasoning itself. Throttled to one refresh per 5 s to avoid spamming startTyping. eve 0.71.0
+                // dropped the state field this throttle used (`lastReasoningTypingAtMs`), so the timestamp
+                // lives on this channel's own `oeReasoningTypingAtMs` state key.
+                // The clean final answer leaves by the `reply` TOOL and by nothing else: this channel authors
+                // its own `message.completed`, and since OPE-2006 that handler DROPS the turn's closing prose
+                // and records it (`channels/closing-prose-drop.ts`). Re-delegating to eve's default poster here
+                // would re-open the road this ticket removed, on the surface OPE-771 measured the loss on.
+                "reasoning.appended": async (_data, channel) => {
+                    const now = Date.now();
+                    const state = channel.state;
+                    const last = state.oeReasoningTypingAtMs;
+                    if (typeof last === "number" && now - last >= 0 && now - last < 5000)
+                        return;
+                    state.oeReasoningTypingAtMs = now;
+                    await refreshTypingStatus(channel);
+                },
+                // 🔴 THE SAME FENCE, ON THE SECOND EVENT (OPE-2289). Through eve 0.70.0 the default
+                // `reasoning.completed` only cleared state. eve 0.71.0's default calls `showReasoning`: it takes
+                // the last `**heading**` or prose sentence of the reasoning, shows it as the typing status and
+                // records it in `state.threadStatus`, which the default `step.started` then shows again. So this
+                // channel must own this event too, with the same generic status. `slack-reasoning-fence-test.ts`
+                // drives both events through the exported adapter.
+                "reasoning.completed": async (_data, channel) => {
+                    await refreshTypingStatus(channel);
+                },
+                // Eve's default falls back to "Running bash, read_channel..." for a tool-call
+                // step, which means nothing to non-engineers and advertises the toolbox to the whole
+                // channel — so we override with a generic status. We ALSO used to show the model's own
+                // preamble text here (its line before the tool call, written for humans, Tag-style) —
+                // dropped 2026-07 (Tommy, live): that text streams in mid-sentence, so the typing
+                // indicator would flash a truncated fragment ("I'll go away and look to setu…") for a
+                // moment before reverting, which read as broken. Always the clean status verb now,
+                // same as reasoning.appended.
+                "actions.requested": async (_data, channel) => {
+                    await refreshTypingStatus(channel);
+                },
+                // Override the reply-posting handler for TWO additions: (1) a woken (non-mention) turn
+                // is told to judge whether a reply is warranted and to end with NO_REPLY when it isn't
+                // (slack-events.ts renderWakeMessage) — that sentinel must be swallowed, not posted;
+                // (2) a turn where a propose tool already posted a code-rendered approval card
+                // (approvals/flow.ts's requestApproval, signalled via approvals/card-signal.ts)
+                // suppresses the model's redundant text — the card already said it (Tommy, live: "the
+                // card should suffice"). Everything else mirrors Eve's default handler byte-for-byte
+                // (tool-calls is an intermediate step with no turn-final effects; empty final message
+                // posts nothing), via the pure, unit-tested finalMessageAction()/turnEffectsFor().
+                "message.completed": async (data, channel, ctx) => {
+                    // The eve session id for this turn — stamped into the terminal audit rows below so an
+                    // audited reply/silence/dropped-prose joins back to its transcript (control-read transcript).
+                    const sessionId = ctx?.session?.id;
+                    // OPE-1647: the TURN ID, so the stand-down silence mark (channels/stand-down-silence.ts) can
+                    // prove it belongs to THIS turn. Same extraction idiom this file already uses for the §POSTED
+                    // consume below.
+                    // 🔴 SINCE OPE-2006 IT SERVES THE SILENCE DECISION ALONE. It is read once here and handed to
+                    // `finalMessageActionForTurn`, whose `consumeStandDownSilenceThisTurn(turnId)` is its only
+                    // reader on this path. There is no reply audit below to stamp it onto: this surface DROPS its
+                    // closing prose, so the durable latch that guarded the old post has no door left to shut here.
+                    const turnId = ctx?.session?.turn?.id;
+                    const action = finalMessageActionForTurn(data.finishReason, data.message, turnId);
+                    if (action.kind === "buffer-tool-status") {
+                        // An intermediate tool-call step, not the turn's end — nothing to decide yet. In
+                        // particular: don't read the card-posted flag here, the tool this step is about to
+                        // run may be the one that posts the card.
+                        return;
                     }
-                }
-                // Warm auto-disengage: a WARM (non-participating) thread that keeps judging silence
-                // is shed after WARM_SILENT_LIMIT turns, so a one-off name-drop doesn't leave the
-                // bot quietly following forever. PARTICIPATING threads are exempt — they're sticky,
-                // only an explicit stop disengages them — so a missing record OR participating:true
-                // is a no-op here. Build the partition exactly like the post branch does; all
-                // best-effort, engagement bookkeeping never throws out of the handler.
-                try {
-                    const { channelId, teamId, threadTs } = channel.state;
-                    if (channelId && threadTs) {
-                        const p = resolvePartition({
-                            channel: { kind: "slack" },
-                            session: { auth: { current: { attributes: { team_id: teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
-                        });
-                        const rec = await getThreadEngagement(p, threadTs);
-                        if (rec && rec.participating !== true) {
-                            const streak = await bumpThreadSilentStreak(p, threadTs);
-                            if (streak >= WARM_SILENT_LIMIT) {
-                                await disengageThread(p, threadTs);
-                                console.log(`[open-everywhere:slack] warm thread shed after ${streak} silent turns — disengaged (${channelId}/${threadTs})`);
+                    // Read-and-reset whether an approval card already posted THIS turn — consumed once,
+                    // right before the turn's terminal effects are decided, so the next turn always
+                    // starts clean (mirrors how oeSilentTurn/oeUninvited below are REASSIGNED on every
+                    // terminal call rather than cleared as a separate step).
+                    const cardPostedThisTurn = consumeCardPostedThisTurn();
+                    // Same read-and-reset contract, for the bare-stop check right below. A turn that
+                    // reacted OR posted mid-turn via the reply-tool family (reply-signal.ts) acted, so
+                    // both signals are consumed here and OR'd into the bare-stop input.
+                    const reactedThisTurn = consumeReactedThisTurn();
+                    // TURN-ID KEYED (OPE-805): a bare read-and-reset let a mark this turn never consumed answer a
+                    // LATER turn's read — see reply-signal.ts's header.
+                    const repliedThisTurn = consumeRepliedThisTurn(ctx?.session?.turn?.id);
+                    if (action.kind === "silent") {
+                        // Remember the turn ended silent so session.waiting doesn't stamp a ❓ status
+                        // reaction on a conversation the agent chose NOT to join (live-observed: a
+                        // judged-silent name-drop left a ❓ on the triggering message).
+                        channel.state.oeSilentTurn = true;
+                        // Silence is designed to leave no trace ON THE SURFACE — but the operator
+                        // needs to distinguish "judged NO_REPLY" from "never woke" (bit us live).
+                        // action.reason distinguishes the sentinel route from the no_reply TOOL route
+                        // (finalMessageActionForTurn folds both into "silent").
+                        console.log(`[open-everywhere:slack] judged silence (${action.reason}) — nothing posted (${channel.state.channelId ?? "?"}/${channel.state.threadTs ?? "?"})`);
+                        // ACTIONS-ONLY posture (audit-wedge build plan §1c, 2026-07-14): a judged silence on an
+                        // ambient chat surface is NOT an audited action — an agent meant to reply to ~1% of channel
+                        // messages would otherwise produce a table that is ~99% silence rows. "Why did it stay
+                        // quiet?" is answered by the session transcript (GET /control/v1/session/:id/transcript),
+                        // not the audit log. The console line above stays (operator-legible, free); the bare-stop
+                        // row below stays (an ANOMALY — a judgment went missing — not a judged silence).
+                        //
+                        // ONE exception (OPE-890): the model ended the turn on the bare NO_REPLY sentinel — the
+                        // TOOL route already carries an always-on `reply.no_reply_observed` row (tools/no_reply.ts,
+                        // OPE-649); this is the sentinel route's twin, same action name, best-effort.
+                        if (action.reason === NO_REPLY_SENTINEL_REASON) {
+                            try {
+                                const p = resolvePartition({
+                                    channel: { kind: "slack" },
+                                    session: { auth: { current: { attributes: { team_id: channel.state.teamId ?? "", channel_id: channel.state.channelId ?? "" }, principalId: "", principalType: "slack-user" } } },
+                                });
+                                await auditNoReplySentinelObserved(p, sessionId);
+                            }
+                            catch (err) {
+                                console.warn(`[open-everywhere:slack] sentinel no_reply audit write failed: ${String(err)}`);
                             }
                         }
-                    }
-                }
-                catch (err) {
-                    console.warn(`[open-everywhere:slack] warm silent-streak bookkeeping failed: ${String(err)}`);
-                }
-                try {
-                    await setWakeTyping(channel);
-                }
-                catch {
-                    /* typing reset is best-effort */
-                }
-                return;
-            }
-            // action.kind === "post" here — the pure decision (unit-tested in slack-events.ts)
-            // gates ONLY whether the text itself posts; every other effect below is unconditional.
-            const effects = turnEffectsFor(action, cardPostedThisTurn);
-            if (effects.kind !== "reply") {
-                // Unreachable: turnEffectsFor only returns "silent" for a "silent" input action,
-                // and action.kind === "post" is established above. Kept as a narrowing guard.
-                return;
-            }
-            channel.state.oeSilentTurn = false;
-            // --- SUPERVISOR host-side reply targeting (T1.4 / C1 workaround) ----------------
-            // A channel-supervisor session's `state.threadTs` is a NON-EMPTY sentinel (T1.3 /
-            // amendment A), so eve's default `channel.thread.post` (bound to state.threadTs) would
-            // post the answer INTO the sentinel pseudo-thread — a leak. The supervisor MUST post
-            // host-side via `slackForm` to the REAL per-turn target snapshotted at turn.started,
-            // and MUST NEVER call `channel.thread.post` (that path also re-anchors an empty binding).
-            // Gated strictly on `oeSupervisor` (isSupervisorReplyTurn) so non-supervisor turns fall
-            // through to the byte-identical default path below. NO_REPLY/no_reply/react/card are all
-            // upstream (the `silent` branch already returned; a supervisor NO_REPLY posts nothing,
-            // same as today). FAIL SAFE: no resolvable target ⇒ deliverSupervisorReply posts NOTHING.
-            //
-            // UNIFIED cross-surface note (formerly TODO(unified-reply) — the non-Slack legs are wired,
-            // 2026-07-11): this leg is Slack-specific (posts host-side via slackForm to a Slack target)
-            // and that is CORRECT — each surface's own completion handler fires for its own deliveries
-            // (eve namespaces continuation tokens per channel, so a GitHub/Linear/Notion wake completes
-            // on THAT channel's message.completed, which posts via its own arm to its own per-wake
-            // snapshot: github.ts / linear.ts / notion.ts supervisor branches, all behind the same
-            // message-tool-only gate). See unified-supervisor.ts's cross-surface-reply header for the
-            // whole model + the per-platform session-namespacing caveat pending a live run.
-            if (isSupervisorReplyTurn(channel.state)) {
-                const target = channel.state.oeReplyTarget;
-                // The channel/org is always known (the supervisor owns one channel) — build its
-                // partition from the session state, independent of whether a reply target resolved.
-                const channelId = channel.state.channelId ?? undefined;
-                const teamId = channel.state.teamId;
-                const partition = channelId
-                    ? resolvePartition({
-                        channel: { kind: "slack" },
-                        session: { auth: { current: { attributes: { team_id: teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
-                    })
-                    : undefined;
-                // --- MESSAGE-TOOL-ONLY hard-silence gate (OpenClaw steal, slack-events.ts) -----------
-                // A supervisor's terminal completion text is NOT a reply: a visible reply must come from
-                // the `reply` tool (which posted mid-turn via reply-post.ts + marked repliedThisTurn).
-                // Force-drop the terminal prose so a judge that emits stray narration leaks NOTHING to the
-                // watched channel; binding below is unaffected (deliverSupervisorReply binds regardless of
-                // postText). Fail-open only where the surface has no reply tool (never true for Slack).
-                const delivery = supervisorTextDelivery(true /* action.kind==="post" ⇒ non-empty prose */, capabilitiesForPlatform("slack").midTurnPost);
-                if (delivery.droppedProse && isSupervisorProseLeak(true, repliedThisTurn, cardPostedThisTurn)) {
-                    // The load-bearing leak case: the judge produced terminal prose but took NO positive
-                    // action to post it (no `reply`, no card). Drop it (never post), but make the silence
-                    // auditable — mirrors OpenClaw's suppressed-delivery metadata (`didSendViaMessagingTool:
-                    // false`) so "why did the judge go quiet on prose it wrote" always has an answer.
-                    console.warn(`[open-everywhere:slack] supervisor message-tool-only: DROPPED terminal prose (judge emitted text without calling reply) — nothing posted (${channelId ?? "?"}/${target?.threadTs ?? "top-level"})`);
-                    if (partition) {
+                        // Bare-stop enforcement (feature 2's investigation — see slack-events.ts's
+                        // isBareStop header for why this is DETECT-AND-LOG, not a hard gate): a turn
+                        // that went silent with NO explanation (no sentinel, no no_reply tool) and
+                        // NO react either did, as far as anyone can tell, nothing at all. Loud warn
+                        // + a best-effort audit row; never a post — silence stays silence.
+                        if (isBareStop(action, reactedThisTurn || repliedThisTurn)) {
+                            const channelId = channel.state.channelId ?? undefined;
+                            const threadTs = channel.state.threadTs ?? undefined;
+                            console.warn(`[open-everywhere:slack] BARE STOP — turn ended with no reply, no react, and no no_reply ` +
+                                `(${channelId ?? "?"}/${threadTs ?? "?"}) — this usually means a judgment call went missing, not that one was made.`);
+                            try {
+                                const p = resolvePartition({
+                                    channel: { kind: "slack" },
+                                    session: { auth: { current: { attributes: { team_id: channel.state.teamId ?? "", channel_id: channelId ?? "" }, principalId: "", principalType: "slack-user" } } },
+                                });
+                                await getOperationalStore().appendAudit({
+                                    ts: new Date().toISOString(),
+                                    org: p.org,
+                                    platform: p.platform,
+                                    workspace: p.workspace,
+                                    surface: p.surface,
+                                    action: "turn.bare_stop",
+                                    detail: { threadTs, ...(sessionId ? { sessionId } : {}) },
+                                });
+                            }
+                            catch (err) {
+                                console.warn(`[open-everywhere:slack] bare-stop audit write failed: ${String(err)}`);
+                            }
+                        }
+                        // Warm auto-disengage: a WARM (non-participating) thread that keeps judging silence
+                        // is shed after WARM_SILENT_LIMIT turns, so a one-off name-drop doesn't leave the
+                        // bot quietly following forever. PARTICIPATING threads are exempt — they're sticky,
+                        // only an explicit stop disengages them — so a missing record OR participating:true
+                        // is a no-op here. Build the partition exactly like the post branch does; all
+                        // best-effort, engagement bookkeeping never throws out of the handler.
                         try {
-                            await getOperationalStore().appendAudit({
-                                ts: new Date().toISOString(),
-                                org: partition.org,
-                                platform: partition.platform,
-                                workspace: partition.workspace,
-                                surface: partition.surface,
-                                action: "turn.supervisor_prose_dropped",
-                                detail: { threadTs: target?.threadTs, chars: action.text.length, ...(sessionId ? { sessionId } : {}) },
-                            });
+                            const { channelId, teamId, threadTs } = channel.state;
+                            if (channelId && threadTs) {
+                                const p = resolvePartition({
+                                    channel: { kind: "slack" },
+                                    session: { auth: { current: { attributes: { team_id: teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
+                                });
+                                const rec = await getThreadEngagement(p, threadTs);
+                                if (rec && rec.participating !== true) {
+                                    const streak = await bumpThreadSilentStreak(p, threadTs);
+                                    if (streak >= WARM_SILENT_LIMIT) {
+                                        await disengageThread(p, threadTs);
+                                        console.log(`[open-everywhere:slack] warm thread shed after ${streak} silent turns — disengaged (${channelId}/${threadTs})`);
+                                    }
+                                }
+                            }
                         }
                         catch (err) {
-                            console.warn(`[open-everywhere:slack] supervisor prose-dropped audit write failed: ${String(err)}`);
+                            console.warn(`[open-everywhere:slack] warm silent-streak bookkeeping failed: ${String(err)}`);
                         }
+                        try {
+                            await setWakeTyping(channel);
+                        }
+                        catch {
+                            /* typing reset is best-effort */
+                        }
+                        return;
                     }
-                }
-                await deliverSupervisorReply({
-                    postText: delivery.postText,
-                    text: action.text,
-                    target,
-                    async post(cid, tts, text) {
-                        // Idempotency (operational/post-once.ts): this raw supervisor-reply post bypasses
-                        // eve's durable reply primitive, so a `deliver`-step re-run after it lands would
-                        // double-post. postOnce (org-partitioned, short TTL) skips the resume duplicate. No
-                        // stableId — a deliver hook has no eve callId — so the key is channel+thread+text.
-                        // Fail-open (incl. an unresolved partition ⇒ undefined org): still posts.
-                        await postOnce({
-                            org: partition?.org,
-                            key: outboundKey({ surface: "slack", channel: cid, threadTs: tts, action: "slack.supervisor-reply", payload: text }),
-                            run: async () => {
-                                await slackForm("chat.postMessage", supervisorPostFormBody(cid, tts, text));
+                    // action.kind === "post" here — the pure decision (unit-tested in slack-events.ts)
+                    // gates ONLY whether the text itself posts; every other effect below is unconditional.
+                    const effects = turnEffectsFor(action, cardPostedThisTurn);
+                    if (effects.kind !== "reply") {
+                        // Unreachable: turnEffectsFor only returns "silent" for a "silent" input action,
+                        // and action.kind === "post" is established above. Kept as a narrowing guard.
+                        return;
+                    }
+                    channel.state.oeSilentTurn = false;
+                    // --- SUPERVISOR host-side reply targeting (T1.4 / C1 workaround) ----------------
+                    // A channel-supervisor session's `state.threadTs` is a NON-EMPTY sentinel (T1.3 /
+                    // amendment A), so eve's default `channel.thread.post` (bound to state.threadTs) would
+                    // post the answer INTO the sentinel pseudo-thread — a leak. The supervisor MUST post
+                    // host-side via `slackForm` to the REAL per-turn target snapshotted at turn.started,
+                    // and MUST NEVER call `channel.thread.post` (that path also re-anchors an empty binding).
+                    // Gated strictly on `oeSupervisor` (isSupervisorReplyTurn) so non-supervisor turns fall
+                    // through to the byte-identical default path below. NO_REPLY/no_reply/react/card are all
+                    // upstream (the `silent` branch already returned; a supervisor NO_REPLY posts nothing,
+                    // same as today). FAIL SAFE: no resolvable target ⇒ deliverSupervisorReply posts NOTHING.
+                    //
+                    // UNIFIED cross-surface note (formerly TODO(unified-reply) — the non-Slack legs are wired,
+                    // 2026-07-11): this leg is Slack-specific (posts host-side via slackForm to a Slack target)
+                    // and that is CORRECT — each surface's own completion handler fires for its own deliveries
+                    // (eve namespaces continuation tokens per channel, so a GitHub/Linear/Notion wake completes
+                    // on THAT channel's message.completed, which posts via its own arm to its own per-wake
+                    // snapshot: github.ts / linear.ts / notion.ts supervisor branches, all behind the same
+                    // message-tool-only gate). See unified-supervisor.ts's cross-surface-reply header for the
+                    // whole model + the per-platform session-namespacing caveat pending a live run.
+                    if (isSupervisorReplyTurn(channel.state)) {
+                        const target = channel.state.oeReplyTarget;
+                        // The channel/org is always known (the supervisor owns one channel) — build its
+                        // partition from the session state, independent of whether a reply target resolved.
+                        const channelId = channel.state.channelId ?? undefined;
+                        const teamId = channel.state.teamId;
+                        const partition = channelId
+                            ? resolvePartition({
+                                channel: { kind: "slack" },
+                                session: { auth: { current: { attributes: { team_id: teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
+                            })
+                            : undefined;
+                        // --- MESSAGE-TOOL-ONLY hard-silence gate (OpenClaw steal, slack-events.ts) -----------
+                        // A supervisor's terminal completion text is NOT a reply: a visible reply must come from
+                        // the `reply` tool (which posted mid-turn via reply-post.ts + marked repliedThisTurn).
+                        // Force-drop the terminal prose so a judge that emits stray narration leaks NOTHING to the
+                        // watched channel; binding below is unaffected (deliverSupervisorReply binds regardless of
+                        // postText). Fail-open only where the surface has no reply tool (never true for Slack).
+                        const delivery = supervisorTextDelivery(true /* action.kind==="post" ⇒ non-empty prose */, capabilitiesForPlatform("slack").midTurnPost);
+                        if (delivery.droppedProse && isSupervisorProseLeak(true, repliedThisTurn, cardPostedThisTurn)) {
+                            // The load-bearing leak case: the judge produced terminal prose but took NO positive
+                            // action to post it (no `reply`, no card). Drop it (never post), but make the silence
+                            // auditable — mirrors OpenClaw's suppressed-delivery metadata (`didSendViaMessagingTool:
+                            // false`) so "why did the judge go quiet on prose it wrote" always has an answer.
+                            console.warn(`[open-everywhere:slack] supervisor message-tool-only: DROPPED terminal prose (judge emitted text without calling reply) — nothing posted (${channelId ?? "?"}/${target?.threadTs ?? "top-level"})`);
+                            if (partition) {
+                                try {
+                                    await getOperationalStore().appendAudit({
+                                        ts: new Date().toISOString(),
+                                        org: partition.org,
+                                        platform: partition.platform,
+                                        workspace: partition.workspace,
+                                        surface: partition.surface,
+                                        action: "turn.supervisor_prose_dropped",
+                                        detail: { threadTs: target?.threadTs, chars: action.text.length, ...(sessionId ? { sessionId } : {}) },
+                                    });
+                                }
+                                catch (err) {
+                                    console.warn(`[open-everywhere:slack] supervisor prose-dropped audit write failed: ${String(err)}`);
+                                }
+                            }
+                        }
+                        await deliverSupervisorReply({
+                            postText: delivery.postText,
+                            text: action.text,
+                            target,
+                            async post(cid, tts, text) {
+                                // Idempotency (operational/post-once.ts): this raw supervisor-reply post bypasses
+                                // eve's durable reply primitive, so a `deliver`-step re-run after it lands would
+                                // double-post. postOnce (org-partitioned, short TTL) skips the resume duplicate. No
+                                // stableId — a deliver hook has no eve callId — so the key is channel+thread+text.
+                                // Fail-open (incl. an unresolved partition ⇒ undefined org): still posts.
+                                await postOnce({
+                                    org: partition?.org,
+                                    key: outboundKey({ surface: "slack", channel: cid, threadTs: tts, action: "slack.supervisor-reply", payload: text }),
+                                    run: async () => {
+                                        await slackForm("chat.postMessage", supervisorPostFormBody(cid, tts, text));
+                                    },
+                                });
+                            },
+                            async resolveOwnerToken() {
+                                if (!partition)
+                                    return undefined;
+                                try {
+                                    return (await getOperationalStore().getChannelSession(partition.org, partition.surfaceKey))?.token;
+                                }
+                                catch {
+                                    return undefined;
+                                }
+                            },
+                            async bind(tts, ownerToken) {
+                                if (!partition)
+                                    return;
+                                // ownerToken = the supervisor's registry token → the thread is now owned by the
+                                // supervisor session (Tag: "the channel session answers a cheap thread and now
+                                // owns it"). markThreadEngaged is best-effort (never fails a delivered reply).
+                                // `byOwnPost` for the same reason as the delivery promotion below (OPE-1669): the
+                                // trigger here is the agent's own delivered reply, never a person inviting it back, so
+                                // it must not lift a stand-down. The ownership bind itself is unaffected.
+                                await markThreadEngaged(partition, tts, new Date().toISOString(), { participating: true, ownerToken, byOwnPost: true });
                             },
                         });
-                    },
-                    async resolveOwnerToken() {
-                        if (!partition)
-                            return undefined;
-                        try {
-                            return (await getOperationalStore().getChannelSession(partition.org, partition.surfaceKey))?.token;
+                        // Clear the uninvited flag only on ACTUAL participation — the supervisor replied via the
+                        // `reply` tool, or a card narrated for it. Under message-tool-only the terminal text is
+                        // dropped, so stray prose is NOT participation and must not promote the session (a judge
+                        // that leaked prose it never posted stays uninvited, so its later errors keep quiet).
+                        if (repliedThisTurn || cardPostedThisTurn) {
+                            channel.state.oeUninvited = false;
                         }
-                        catch {
-                            return undefined;
+                        return; // NEVER fall through to channel.thread.post — that would post into the sentinel.
+                    }
+                    if (effects.postText) {
+                        // 🔴 THE CLOSING PROSE IS DROPPED, NOT POSTED (OPE-2006). This branch used to route the
+                        // engaged-thread terminal reply through `postTerminalProse`, with a raw `channel.thread.post`
+                        // fallback for a state that named no channel. Both are gone: the `reply` tool is the only
+                        // channel a seat's words leave by, so a turn that ended in prose and never called `reply`
+                        // has said nothing here. The row is the record — no re-send, no queue, no host-side re-post.
+                        // WHAT TELLS THE MODEL is the seat prompt, not this handler: Slack declares
+                        // `closingProseDropped`, so a conversational seat here reads the `reply-only` delivery arm,
+                        // whose copy states that the turn-final text is discarded. It reaches a supervisor-shaped
+                        // seat inside its persona and a `native`-grain @mention thread — the seat this branch mostly
+                        // serves — through the `delivery` slot (instructions/access.ts `renderDeliverySlot`).
+                        const channelId = channel.state.channelId ?? undefined;
+                        const replyThreadTs = replyThreadTsForState(channel.state);
+                        if (channelId) {
+                            const p = resolvePartition({
+                                channel: { kind: "slack" },
+                                session: { auth: { current: { attributes: { team_id: channel.state.teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
+                            });
+                            await dropClosingProse({
+                                row: {
+                                    org: p.org,
+                                    platform: p.platform,
+                                    workspace: p.workspace,
+                                    surface: p.surface,
+                                    principalId: channel.state.oeReplyPrincipalId,
+                                },
+                                chars: action.text.length,
+                                ...(sessionId ? { sessionId } : {}),
+                                // OPE-98: the PER-WAKE thread (dmWakeThreadOverride ?? state.threadTs) — the anchor the
+                                // post would have used, so the row names the conversation the answer was owed to.
+                                anchor: { threadTs: replyThreadTs ?? null },
+                                log: (m) => console.warn(`[open-everywhere:slack] ${m} (${channelId}/${replyThreadTs ?? "?"})`),
+                            });
                         }
-                    },
-                    async bind(tts, ownerToken) {
-                        if (!partition)
-                            return;
-                        // ownerToken = the supervisor's registry token → the thread is now owned by the
-                        // supervisor session (Tag: "the channel session answers a cheap thread and now
-                        // owns it"). markThreadEngaged is best-effort (never fails a delivered reply).
-                        // `byOwnPost` for the same reason as the delivery promotion below (OPE-1669): the
-                        // trigger here is the agent's own delivered reply, never a person inviting it back, so
-                        // it must not lift a stand-down. The ownership bind itself is unaffected.
-                        await markThreadEngaged(partition, tts, new Date().toISOString(), { participating: true, ownerToken, byOwnPost: true });
-                    },
-                });
-                // Clear the uninvited flag only on ACTUAL participation — the supervisor replied via the
-                // `reply` tool, or a card narrated for it. Under message-tool-only the terminal text is
-                // dropped, so stray prose is NOT participation and must not promote the session (a judge
-                // that leaked prose it never posted stays uninvited, so its later errors keep quiet).
-                if (repliedThisTurn || cardPostedThisTurn) {
-                    channel.state.oeUninvited = false;
-                }
-                return; // NEVER fall through to channel.thread.post — that would post into the sentinel.
-            }
-            if (effects.postText) {
-                // 🔴 THE CLOSING PROSE IS DROPPED, NOT POSTED (OPE-2006). This branch used to route the
-                // engaged-thread terminal reply through `postTerminalProse`, with a raw `channel.thread.post`
-                // fallback for a state that named no channel. Both are gone: the `reply` tool is the only
-                // channel a seat's words leave by, so a turn that ended in prose and never called `reply`
-                // has said nothing here. The row is the record — no re-send, no queue, no host-side re-post.
-                // WHAT TELLS THE MODEL is the seat prompt, not this handler: Slack declares
-                // `closingProseDropped`, so a conversational seat here reads the `reply-only` delivery arm,
-                // whose copy states that the turn-final text is discarded. It reaches a supervisor-shaped
-                // seat inside its persona and a `native`-grain @mention thread — the seat this branch mostly
-                // serves — through the `delivery` slot (instructions/access.ts `renderDeliverySlot`).
-                const channelId = channel.state.channelId ?? undefined;
-                const replyThreadTs = replyThreadTsForState(channel.state);
-                if (channelId) {
-                    const p = resolvePartition({
-                        channel: { kind: "slack" },
-                        session: { auth: { current: { attributes: { team_id: channel.state.teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
-                    });
-                    await dropClosingProse({
-                        row: {
-                            org: p.org,
-                            platform: p.platform,
-                            workspace: p.workspace,
-                            surface: p.surface,
-                            principalId: channel.state.oeReplyPrincipalId,
-                        },
-                        chars: action.text.length,
-                        ...(sessionId ? { sessionId } : {}),
-                        // OPE-98: the PER-WAKE thread (dmWakeThreadOverride ?? state.threadTs) — the anchor the
-                        // post would have used, so the row names the conversation the answer was owed to.
-                        anchor: { threadTs: replyThreadTs ?? null },
-                        log: (m) => console.warn(`[open-everywhere:slack] ${m} (${channelId}/${replyThreadTs ?? "?"})`),
-                    });
-                }
-                else {
-                    // 🔴 NO CHANNEL ID, SO NO PARTITION TO FILE IT UNDER, SO NO ROW. `resolvePartition` answers
-                    // `surface: "default"` for a blank channel, and a lost answer filed against a surface that
-                    // names no room pollutes the drop count for everything else that resolves to `default`.
-                    // The drop still happens and the log line is the whole record — the same honest degradation
-                    // the three sibling handlers take, and the same one the deleted poster's fallback took.
-                    console.warn(`[open-everywhere:slack] closing prose DROPPED (${action.text.length}c) — nothing posted, and no partition to audit it under (?/${replyThreadTs ?? "?"})`);
-                }
-            }
-            else {
-                // A card already posted this turn — suppress the redundant narration, but this is
-                // STILL a participating reply for everything below (👀 clears, thread engages,
-                // oeUninvited clears), same as an ordinary post.
-                console.log(`[open-everywhere:slack] approval card already posted this turn — suppressing the redundant text reply (${channel.state.channelId ?? "?"}/${channel.state.threadTs ?? "?"})`);
-            }
-            // DID THIS TURN ACTUALLY DELIVER ANYTHING? Since OPE-2006 the closing prose is dropped, so
-            // reaching this point no longer means a message left. Only a `reply` tool call or an approval
-            // card put bytes in the room, and the two promotions below are what a delivery earns.
-            // 🔴 IT IS THE RULE THE SUPERVISOR BRANCH ABOVE ALREADY STATES — "stray prose is NOT
-            // participation and must not promote the session" — applied to the seat that used to be the
-            // exception because its prose posted. A turn whose only output was dropped prose stays
-            // uninvited and leaves the thread's engagement exactly as it found it.
-            const deliveredThisTurn = repliedThisTurn || cardPostedThisTurn;
-            // The agent is now a PARTICIPANT: an uninvited (name-drop) session that posts
-            // earns normal standing, so later failures go loud like any engaged thread's.
-            if (deliveredThisTurn)
-                channel.state.oeUninvited = false;
-            // Remove the 👀 WITH the reply, not at park: session.waiting fires a workflow
-            // step later and can lag the post by many seconds (live-observed), leaving a
-            // stale "working" mark on an already-answered message. The waiting/completed
-            // removals below stay as the idempotent safety net (e.g. for turns whose final
-            // delivery goes through a path that skips this handler).
-            await setStatusReaction(channel.slack, "none", dmWakeThreadOverride(channel.state));
-            // A posted reply = the agent is participating in this thread → follow it. For
-            // mention threads this is an idempotent refresh (onInbound already engaged); for a
-            // name-drop reply it's what ESTABLISHES engagement, so follow-ups flow without a
-            // mention. Best-effort — engagement must never fail a delivered reply.
-            try {
-                const { channelId, teamId, threadTs } = channel.state;
-                if (deliveredThisTurn && channelId && threadTs) {
-                    const p = resolvePartition({
-                        channel: { kind: "slack" },
-                        session: { auth: { current: { attributes: { team_id: teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
-                    });
-                    // A posted reply PROMOTES the thread: participating:true so a warm (name-drop)
-                    // thread becomes an invited participant (sticky, streak cleared, failures loud).
-                    // 🔴 `byOwnPost` IS WHAT KEEPS A STAND-DOWN STOOD DOWN (OPE-1669). This promotion carries
-                    // no promoter id, so without the flag it CLEARS the durable `stopped` marker — and the
-                    // acknowledgement `stand_down` asks for travels by the agent's own `reply`, so it reaches
-                    // this promotion and would lift the very stop it was acknowledging. See
-                    // channels/engagement.ts.
-                    await markThreadEngaged(p, threadTs, new Date().toISOString(), { participating: true, byOwnPost: true });
-                }
-            }
-            catch {
-                /* best-effort */
-            }
-        },
-        // Safe to own (no built-in default): turn's over → REMOVE the 👀 (absence = done;
-        // the reply is the result). Silent turns skip entirely — no trace, no API calls, on
-        // a conversation the agent declined to join.
-        "session.completed": async (_data, channel) => {
-            if (channel.state.oeSilentTurn !== true) {
-                await setStatusReaction(channel.slack, "none", dmWakeThreadOverride(channel.state));
-            }
-            await syncPinnedStatus(channel);
-        },
-        // Parked waiting for the next human message — same removal: a parked session is the
-        // steady state of a durable thread, not a "needs input" condition worth a ❓.
-        "session.waiting": async (_data, channel) => {
-            if (channel.state.oeSilentTurn === true)
-                return;
-            await setStatusReaction(channel.slack, "none", dmWakeThreadOverride(channel.state));
-        },
-        // Eve's default posts "I hit an error while handling your request…" into the
-        // thread. Keep that for INVITED turns (failures must stay visible to whoever asked)
-        // but suppress it for uninvited ones — a name-drop turn that would have judged
-        // NO_REPLY must not spam the conversation with an error instead (log + audit only).
-        "turn.failed": async (data, channel) => {
-            if (isUninvited(channel.state)) {
-                await recordQuietFailure(channel.state, "turn.failed", data.message);
-                return;
-            }
-            await setStatusReaction(channel.slack, "blocked", dmWakeThreadOverride(channel.state));
-            try {
-                await postWakeText(channel, `:octagonal_sign: I hit an error while handling your request (${data.message}). Please try again or rephrase.`);
-            }
-            catch {
-                /* best-effort */
-            }
-        },
-        // Override carefully: 🛑 blocked + re-post the error the default would have,
-        // so failures stay visible. Same uninvited-turn suppression as turn.failed.
-        "session.failed": async (data, channel) => {
-            if (isUninvited(channel.state)) {
-                await recordQuietFailure(channel.state, "session.failed", data.message);
-                return;
-            }
-            await setStatusReaction(channel.slack, "blocked", dmWakeThreadOverride(channel.state));
-            try {
-                await postWakeText(channel, `:octagonal_sign: Task failed: ${data.message}`);
-            }
-            catch {
-                /* best-effort */
-            }
-            await syncPinnedStatus(channel);
+                        else {
+                            // 🔴 NO CHANNEL ID, SO NO PARTITION TO FILE IT UNDER, SO NO ROW. `resolvePartition` answers
+                            // `surface: "default"` for a blank channel, and a lost answer filed against a surface that
+                            // names no room pollutes the drop count for everything else that resolves to `default`.
+                            // The drop still happens and the log line is the whole record — the same honest degradation
+                            // the three sibling handlers take, and the same one the deleted poster's fallback took.
+                            console.warn(`[open-everywhere:slack] closing prose DROPPED (${action.text.length}c) — nothing posted, and no partition to audit it under (?/${replyThreadTs ?? "?"})`);
+                        }
+                    }
+                    else {
+                        // A card already posted this turn — suppress the redundant narration, but this is
+                        // STILL a participating reply for everything below (👀 clears, thread engages,
+                        // oeUninvited clears), same as an ordinary post.
+                        console.log(`[open-everywhere:slack] approval card already posted this turn — suppressing the redundant text reply (${channel.state.channelId ?? "?"}/${channel.state.threadTs ?? "?"})`);
+                    }
+                    // DID THIS TURN ACTUALLY DELIVER ANYTHING? Since OPE-2006 the closing prose is dropped, so
+                    // reaching this point no longer means a message left. Only a `reply` tool call or an approval
+                    // card put bytes in the room, and the two promotions below are what a delivery earns.
+                    // 🔴 IT IS THE RULE THE SUPERVISOR BRANCH ABOVE ALREADY STATES — "stray prose is NOT
+                    // participation and must not promote the session" — applied to the seat that used to be the
+                    // exception because its prose posted. A turn whose only output was dropped prose stays
+                    // uninvited and leaves the thread's engagement exactly as it found it.
+                    const deliveredThisTurn = repliedThisTurn || cardPostedThisTurn;
+                    // The agent is now a PARTICIPANT: an uninvited (name-drop) session that posts
+                    // earns normal standing, so later failures go loud like any engaged thread's.
+                    if (deliveredThisTurn)
+                        channel.state.oeUninvited = false;
+                    // Remove the 👀 WITH the reply, not at park: session.waiting fires a workflow
+                    // step later and can lag the post by many seconds (live-observed), leaving a
+                    // stale "working" mark on an already-answered message. The waiting/completed
+                    // removals below stay as the idempotent safety net (e.g. for turns whose final
+                    // delivery goes through a path that skips this handler).
+                    await setStatusReaction(channel.slack, "none", dmWakeThreadOverride(channel.state));
+                    // A posted reply = the agent is participating in this thread → follow it. For
+                    // mention threads this is an idempotent refresh (onInbound already engaged); for a
+                    // name-drop reply it's what ESTABLISHES engagement, so follow-ups flow without a
+                    // mention. Best-effort — engagement must never fail a delivered reply.
+                    try {
+                        const { channelId, teamId, threadTs } = channel.state;
+                        if (deliveredThisTurn && channelId && threadTs) {
+                            const p = resolvePartition({
+                                channel: { kind: "slack" },
+                                session: { auth: { current: { attributes: { team_id: teamId ?? "", channel_id: channelId }, principalId: "", principalType: "slack-user" } } },
+                            });
+                            // A posted reply PROMOTES the thread: participating:true so a warm (name-drop)
+                            // thread becomes an invited participant (sticky, streak cleared, failures loud).
+                            // 🔴 `byOwnPost` IS WHAT KEEPS A STAND-DOWN STOOD DOWN (OPE-1669). This promotion carries
+                            // no promoter id, so without the flag it CLEARS the durable `stopped` marker — and the
+                            // acknowledgement `stand_down` asks for travels by the agent's own `reply`, so it reaches
+                            // this promotion and would lift the very stop it was acknowledging. See
+                            // channels/engagement.ts.
+                            await markThreadEngaged(p, threadTs, new Date().toISOString(), { participating: true, byOwnPost: true });
+                        }
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                },
+                // Safe to own (no built-in default): turn's over → REMOVE the 👀 (absence = done;
+                // the reply is the result). Silent turns skip entirely — no trace, no API calls, on
+                // a conversation the agent declined to join.
+                "session.completed": async (_data, channel) => {
+                    if (channel.state.oeSilentTurn !== true) {
+                        await setStatusReaction(channel.slack, "none", dmWakeThreadOverride(channel.state));
+                    }
+                    await syncPinnedStatus(channel);
+                },
+                // Parked waiting for the next human message — same removal: a parked session is the
+                // steady state of a durable thread, not a "needs input" condition worth a ❓.
+                "session.waiting": async (_data, channel) => {
+                    if (channel.state.oeSilentTurn === true)
+                        return;
+                    await setStatusReaction(channel.slack, "none", dmWakeThreadOverride(channel.state));
+                },
+                // Eve's default posts "I hit an error while handling your request…" into the
+                // thread. Keep that for INVITED turns (failures must stay visible to whoever asked)
+                // but suppress it for uninvited ones — a name-drop turn that would have judged
+                // NO_REPLY must not spam the conversation with an error instead (log + audit only).
+                "turn.failed": async (data, channel) => {
+                    if (isUninvited(channel.state)) {
+                        await recordQuietFailure(channel.state, "turn.failed", data.message);
+                        return;
+                    }
+                    await setStatusReaction(channel.slack, "blocked", dmWakeThreadOverride(channel.state));
+                    try {
+                        await postWakeText(channel, `:octagonal_sign: I hit an error while handling your request (${data.message}). Please try again or rephrase.`);
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                },
+                // Override carefully: 🛑 blocked + re-post the error the default would have,
+                // so failures stay visible. Same uninvited-turn suppression as turn.failed.
+                "session.failed": async (data, channel) => {
+                    if (isUninvited(channel.state)) {
+                        await recordQuietFailure(channel.state, "session.failed", data.message);
+                        return;
+                    }
+                    await setStatusReaction(channel.slack, "blocked", dmWakeThreadOverride(channel.state));
+                    try {
+                        await postWakeText(channel, `:octagonal_sign: Task failed: ${data.message}`);
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    await syncPinnedStatus(channel);
+                },
+            },
         },
-    },
+    ],
 });
 // Front the public Slack URL with the engagement route so plain (non-mention) thread replies
 // wake the engaged thread's session, while everything slackChannel owns is forwarded through.
-export default frontSlackChannel(slackMentionChannel);
+// OPE-2252 — `reply`/`no_reply` end the turn natively (`endsTurn`) and eve then emits no final message,
+// so the wrapper decides such a turn at `turn.completed` (core `channels/ends-turn-final.ts`).
+export default withEndsTurnFinalChannel(frontSlackChannel(slackMentionChannel));
 //# sourceMappingURL=slack.js.map