@open-everywhere/provider-slack 0.1.5 → 0.3.0

package/agent/channels/slack.ts

@@ -89,12 +89,14 @@ import {
   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, type SupervisorReplyTarget } from "./slack-events.js";
 import { markdownToSlackMrkdwn } from "./slack-mrkdwn.js";
 
@@ -787,488 +789,536 @@ 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 as Record<string, unknown> | undefined;
-        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 as unknown as Record<string, unknown>).oeReplyTarget = channelId
-          ? ({ channelId, threadTs } satisfies SupervisorReplyTarget)
-          : 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 as unknown as Record<string, unknown>).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 as Record<string, unknown> | undefined;
-        if (attrs?.channel_type === "im") {
-          (channel.state as unknown as Record<string, unknown>).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 as unknown as { session?: { turn?: { id?: string } } })?.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 as unknown as { session?: { turn?: { id?: string } } })?.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 as unknown as Record<string, unknown>).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);
-          } catch (err) {
-            console.warn(`[open-everywhere:slack] sentinel no_reply audit write failed: ${String(err)}`);
+        // 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 as Record<string, unknown> | undefined;
+            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 as unknown as Record<string, unknown>).oeReplyTarget = channelId
+              ? ({ channelId, threadTs } satisfies SupervisorReplyTarget)
+              : undefined;
           }
-        }
-        // 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)}`);
+          // 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 as unknown as Record<string, unknown>).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 as Record<string, unknown> | undefined;
+            if (attrs?.channel_type === "im") {
+              (channel.state as unknown as Record<string, unknown>).oeWakeThreadTs =
+                typeof attrs.thread_ts === "string" ? attrs.thread_ts : undefined;
+            }
           }
-        }
-        // 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})`,
-                );
+          // 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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>;
+          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 as unknown as { session?: { turn?: { id?: string } } })?.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 as unknown as { session?: { turn?: { id?: string } } })?.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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).oeReplyTarget as SupervisorReplyTarget | undefined;
-        // 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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).oeReplyTarget as SupervisorReplyTarget | undefined;
+            // 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;
-            } catch {
-              return undefined;
+            // 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 as unknown as Record<string, unknown>).oeUninvited = false;
             }
-          },
-          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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).oeReplyPrincipalId as string | undefined,
-            },
-            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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).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);
+            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 as unknown as Record<string, unknown>).oeReplyPrincipalId as string | undefined,
+                },
+                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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).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 as unknown as Record<string, unknown>).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));