@open-everywhere/provider-slack 0.2.1 → 0.4.0

package/agent/app-manifest.ts

@@ -240,6 +240,7 @@ export const SLACK_APP_MANIFEST_STEPS: readonly string[] = [
   "Pick the workspace, choose JSON, and paste the manifest below.",
   "Next → Create.",
   "Install to Workspace, and approve the scopes Slack lists.",
+  "Unless you set identity.name and chose your own icon, give the app the project mark: Basic Information → Display Information → App icon, and upload https://raw.githubusercontent.com/open-everywhere/open-everywhere/main/brand/png/mark-square-1024.png. Slack's manifest has no icon field, so this step stays by hand.",
   "Before the first deploy, Slack cannot verify the Event Subscriptions URL: it answers only once a deploy that holds SLACK_SIGNING_SECRET is up. After the deploy, paste the manifest again with the real host (App Manifest → Save Changes), then retry the verification under Event Subscriptions.",
 ];
 

package/agent/channels/slack-events.ts

@@ -1430,10 +1430,11 @@ export async function routeMessageEvent(ev: ParsedMessageEvent, deps: MessageRou
     authorId: ev.userId,
     surfaceInternal: authorFacts.surfaceInternal,
     channelKey: domainKeyOf(p),
+    ...(ev.enterpriseId === undefined ? {} : { enterpriseId: ev.enterpriseId }),
   });
   // ── THE EXTERNAL-PARTICIPANT POLICY (OPE-507 / OPE-504) ────────────────────────────────────────
-  // Inert on the shipped grains (`taint` / `engage`), so a deployment that has not opted in is
-  // byte-identical. It sits here because this is where the author evidence first exists — see the
+  // Inert only on the `taint` / `engage` opt-out, where it is byte-identical to before it
+  // existed; the shipped grains suppress here. It sits here because this is where the author evidence first exists — see the
   // block comment on `slackExternalVerdict` for why that is lower than Discord's gate.
   {
     const verdict = await applySlackExternalPolicy(ev, p, { trust: wakeTrust, refuted: authorFacts.refuted }, "routeMessageEvent");
@@ -1861,7 +1862,7 @@ export async function auditDmBotAuthorDrop(
     dmKind,
     botId: ev.botId,
     team: ev.teamId ?? null,
-    // TRUE ⇒ the `OE_TEST_DRIVER_IDS` allowlist vouches for this bot at the engagement and mention
+    // TRUE ⇒ the `wake.driverAllowlist` setting vouches for this bot at the engagement and mention
     // doors, and the DM door dropped it anyway. That is not a defect: the DM door reads its OWN,
     // narrower lever (`wake.e2eDrivers`, {@link dmDoorAdmitsDriver}), so a bot on the channel
     // allowlist has no DM standing. The row carries the distinction as data.
@@ -1883,7 +1884,7 @@ export async function auditDmBotAuthorDrop(
  * DM leg in the pack exercised a synthetic envelope and a regression in Slack's own DM delivery to
  * us was invisible. This carve-out lets the driver in through the real front door.
  *
- * WHY IT IS NOT THE `OE_TEST_DRIVER_IDS` ALLOWLIST, which already lifts the same bot at the
+ * WHY IT IS NOT THE `wake.driverAllowlist` SETTING, which already lifts the same bot at the
  * engagement and mention doors. A DM seat holds a window token, delegation and memory, so admitting
  * a bot into a DM is a strictly larger grant than admitting one into a watched channel. Reusing the
  * channel allowlist would have widened the DM door for every deployment that already sets it, on
@@ -2267,7 +2268,7 @@ export interface NameDropRouteDeps {
   readonly backscroll?: (input: { channelId: string; ts: string; threadTs?: string; threadAdmissionSlice?: boolean }) => Promise<WakeBackscrollLines | null>;
   /** The per-author membership probe the hydrated-context withhold uses (OPE-525,
    *  {@link withholdNameDropContext}). Defaults to the live {@link slackAuthorIsMember}; injectable
-   *  so the withhold is testable without Slack. Never called on the shipped `taint` grain. */
+   *  so the withhold is testable without Slack. Never called on the `taint` opt-out grain. */
   readonly authorIsMember?: SlackMemberProbe;
   /** Start the judged turn in a thread rooted at the triggering message. `context` (when present)
    *  is the backscroll — ADDITIONAL history the channel appends before the delivery turn. */
@@ -2481,7 +2482,7 @@ export async function routeNameDropEvent(ev: ParsedMessageEvent, deps: NameDropR
     // reference-only and marks the taint join too — not just the trigger's own author. Fail-soft:
     // a regrade failure keeps the fetched (ungraded) lines, exactly like every other backscroll leg.
     // 🔴 THE REGRADE KEEPS THE LIVE PROBE, and `deps.authorIsMember` must NOT be threaded here. That
-    // dep is the WITHHOLD's probe and its contract is "never called on the shipped `taint` grain"
+    // dep is the WITHHOLD's probe and its contract is "never called on the `taint` opt-out grain"
     // (OPE-525); this regrade runs on every hydration, whatever the grain, so sharing the dep would
     // break that contract and make a grain-gated lookup look grain-blind. The two share the
     // TTL-cached probe underneath, which is where the call is actually saved.
@@ -2600,10 +2601,11 @@ export async function routeNameDropEvent(ev: ParsedMessageEvent, deps: NameDropR
     authorId: ev.userId,
     surfaceInternal: authorFacts.surfaceInternal,
     channelKey: domainKeyOf(p),
+    ...(ev.enterpriseId === undefined ? {} : { enterpriseId: ev.enterpriseId }),
   });
   // ── THE EXTERNAL-PARTICIPANT POLICY (OPE-507 / OPE-504) ────────────────────────────────────────
   // A name-drop is AMBIENT by construction (the gate above disqualifies an @mention), so an excluded
-  // author's name-drop is owed nothing and is suppressed in silence. Inert on the shipped grains.
+  // author's name-drop is owed nothing and is suppressed in silence. Inert only on the opt-out grains.
   {
     const verdict = await applySlackExternalPolicy(ev, p, { trust: wakeTrust, refuted: authorFacts.refuted }, "routeNameDropEvent");
     if (verdict !== "proceed") return { deliver: false, reason: externalPolicyDropReason(verdict), woke: false };
@@ -2620,7 +2622,7 @@ export async function routeNameDropEvent(ev: ParsedMessageEvent, deps: NameDropR
   // about the people quoted in that hydration: a member name-drops the bot in a channel where a
   // refuted guest has been talking, and without this the guest's bytes reach the model verbatim.
   // `withholdNameDropContext` runs the shared transform and returns the wake BY REFERENCE on the
-  // shipped `taint` grain, so nothing moves for a deployment that has not opted in.
+  // `taint` opt-out grain, so nothing moves for a deployment that opted out.
   const rendered = renderWake(
     await withholdNameDropContext(
       slackNameDropWake(ev, name!, {
@@ -3203,7 +3205,7 @@ function externalPolicyDropReason(verdict: SlackExternalVerdict): string {
  * other in the plane. A `bot` line carries a bot id, and a machine author is never excluded, so only
  * `senderType: "user"` lines are asked about.
  *
- * COSTS NOTHING ON THE SHIPPED GRAIN: `taint` returns the wake by reference before any probe runs.
+ * COSTS NOTHING ON THE OPT-OUT GRAIN: `taint` returns the wake by reference before any probe runs.
  * On `withhold` it costs one TTL-cached `users.info` per DISTINCT hydrated author, resolved in
  * parallel, and the render budget caps the hydration at ten lines.
  */
@@ -3822,8 +3824,8 @@ export function liveNameDropDeps(send: WakeSend): NameDropRouteDeps {
 
 // --- channel-supervisor delivery (Slack Claude-Tag parity, T1.3) ---------------
 //
-// The "always-on teammate" leg. When a channel's domain opts into ambientSupervisor
-// (memory/domain.ts, fail-closed off) AND the channel is POSITIVELY confirmed internal,
+// The "always-on teammate" leg. When a channel's domain has ambientSupervisor on
+// (memory/domain.ts, default ON since OPE-2409) AND the channel is POSITIVELY confirmed internal,
 // an unowned message (top-level, or in-thread but not engaged) is delivered to a single
 // long-lived CHANNEL-SUPERVISOR session instead of the name-drop-only path. The supervisor
 // is one durable eve session per channel, addressed by a RESERVED continuation token
@@ -4001,7 +4003,7 @@ export interface SupervisorRouteDeps {
    *  {@link withholdNameDropContext}) — the same dep, spelled the same way, as the native route it
    *  replaces ({@link NameDropRouteDeps.authorIsMember}). Defaults to the live
    *  {@link slackAuthorIsMember}; injectable so the withhold is testable without Slack. Never called
-   *  on the shipped `taint` grain, and never on a wake that carries no hydrated lines. */
+   *  on the `taint` opt-out grain, and never on a wake that carries no hydrated lines. */
   readonly authorIsMember?: SlackMemberProbe;
   /**
    * Start/continue the supervisor session under its reserved token. `window` is present ONLY on
@@ -4068,7 +4070,7 @@ export interface SupervisorRouteDeps {
  * Route one unowned message to the channel supervisor: pure disqualifiers, then the
  * fail-closed internal-channel confirmation (which also surfaces the member count for the
  * envelope), then create-or-fetch the supervisor session and deliver the judged wake. The
- * caller (slack-front) only reaches here once the domain has opted into ambientSupervisor.
+ * caller (slack-front) only reaches here once the domain has ambientSupervisor on (the default).
  *
  * `opts.directMention` (SINGLE-WINDOW @mention routing — the GitHub reference's
  * `treatMentionAsDirect`/`directMention` shape): the trigger is the `message.channels` SIBLING of
@@ -4217,10 +4219,11 @@ export async function routeSupervisorEvent(
     authorId: ev.userId,
     surfaceInternal: authorFacts.surfaceInternal,
     channelKey: domainKeyOf(p),
+    ...(ev.enterpriseId === undefined ? {} : { enterpriseId: ev.enterpriseId }),
   });
   // ── THE EXTERNAL-PARTICIPANT POLICY (OPE-507 / OPE-504) ────────────────────────────────────────
   // ABOVE THE SESSION MINT, deliberately: a suppressed wake must not rotate a generation or claim a
-  // fresh generation's first-wake backscroll. Inert on the shipped grains (`taint` / `engage`).
+  // fresh generation's first-wake backscroll. Inert only on the `taint` / `engage` opt-out.
   const externalPolicy = slackExternalPolicyForRoom(domainKeyOf(p));
   {
     const verdict = await applySlackExternalPolicy(ev, p, { trust: wakeTrust, refuted: authorFacts.refuted }, "routeSupervisorEvent");
@@ -4355,8 +4358,8 @@ export async function routeSupervisorEvent(
   // BEHAVIOUR 3 (OPE-507) — the ARRIVED-MARKER over the first-wake backscroll. The trigger author
   // cleared the gate above, so this wake fires; a SIBLING the probe refuted has not, and under
   // `withhold` their bytes must not enter. The transform replaces the body, the pre-edit body and the
-  // attachments, and it returns the SAME ARRAY by reference on the shipped `taint` grain, so no
-  // golden moves on a deployment that has not opted in.
+  // attachments, and it returns the SAME ARRAY by reference on the `taint` opt-out grain, so no
+  // golden moves on a deployment that opted out.
   const backscroll = priorContext.map((m) => (withholdsBody(m, externalPolicy) ? withheldWakeMessage(m) : m));
 
   // POSITIVELY confirmed internal → stamp the trust verdict into the wake auth, exactly like the
@@ -4371,7 +4374,7 @@ export async function routeSupervisorEvent(
   //
   // 🔴 A WITHHELD SIBLING NEVER KEYS TAINT. `ingestedAfterWithholding` REMOVES the entries the
   // transform above stripped, because their bytes did not enter — a join over a message that did not
-  // ingest would claim an exposure that did not happen. On the shipped `taint` grain it returns the
+  // ingest would claim an exposure that did not happen. On the `taint` opt-out grain it returns the
   // SAME ARRAY by reference, so the auth bag is byte-identical.
   //
   // 🔴 THE HYDRATED NAME-DROP LINES JOIN TOO (OPE-475/OPE-525, carried onto the seat road by
@@ -4476,8 +4479,8 @@ export async function routeSupervisorEvent(
     // and without this the guest's bytes reach the model verbatim. It is the SAME function the
     // native route calls, over the WHOLE wake — so the envelope backscroll's own withholding (the
     // `priorContext` map above) and the hydrated lines are decided by one transform, and it returns
-    // the wake BY REFERENCE on the shipped `taint` grain, so nothing moves for a deployment that has
-    // not opted in. Run only on the name-drop tier, which is the only tier that carries the slot.
+    // the wake BY REFERENCE on the `taint` opt-out grain, so nothing moves for a deployment that
+    // opted out. Run only on the name-drop tier, which is the only tier that carries the slot.
     const wake = slackChannelWatchWake(ev, {
       mode: "supervisor",
       trust: wakeTrust,

package/agent/channels/slack-front.ts

@@ -105,7 +105,6 @@ import {
   OE_CONNECT_ACTION_PREFIX,
   handleConnectClick as liveHandleConnectClick,
   OE_GRANT_ACTION_PREFIX,
-  OE_INPUT_CLICK_PREFIX,
   handleGrantCardClick as liveHandleGrantCardClick,
   buildRecord,
   enqueue as enqueueLogRecord,
@@ -118,7 +117,6 @@ import {
   recordWakeTail,
   tailAuthorGrain,
   dmWindowRegistryKey,
-  approvalCardRespondVia,
   stampSurfaceEventVerified,
 } from "@open-everywhere/core/agent/adapter-api.js";
 import {
@@ -136,11 +134,6 @@ import {
 import { buildSlackAuth, withForwardedSlackEnvelope, type ForwardedSlackEnvelope } from "./slack-identity.js";
 import { holdRouteWork, routeHoldQuiesced, withSlackRouteHold } from "./slack-route-hold.js";
 import { persistSlackAttachment, registerSlackAttachment } from "./slack-attachments.js";
-import {
-  handleSlackApprovalCardClick as liveHandleApprovalCardClick,
-  type ApprovalCardClickOutcome,
-  type ApprovalRespondFn,
-} from "./slack-approval-card.js";
 import {
   parseSlackShortcutPayload,
   shortcutMessageEvent,
@@ -181,11 +174,6 @@ export type FrontDecision =
    *  OWNER of the ask answered it in their own DM. Core verifies the clicker IS that owner, then
    *  approves or declines. Never forwarded. */
   | { readonly kind: "grant-click"; readonly reason: string; readonly payload: unknown }
-  /** A tap on a BRIDGED APPROVAL CARD the unified post arm rendered (OPE-1720). OURS, never
-   *  forwarded: eve's own interactivity route resolves a click against its Slack channel's state and
-   *  session address, and this card's parked request lives on the unified window — see
-   *  `slack-approval-card.ts`'s header for why a forward could only drop it. */
-  | { readonly kind: "input-click"; readonly reason: string; readonly payload: unknown }
   /** An `app_mention` — the native slackChannel path owns it UNLESS the handler's single-window
    *  policy says the unified window does (then the forward is suppressed and the mention's
    *  `message.channels` sibling carries it as an addressed wake). Carries `env` so the handler
@@ -298,28 +286,6 @@ function parseOeGrantClickPayload(rawBody: string): unknown | undefined {
   return isOurs ? p : undefined;
 }
 
-/**
- * Best-effort decode of a urlencoded body into an `oe_input:` bridged-approval-card `block_actions`
- * payload (core channels/approval-card.ts) — undefined for anything that isn't one. Never throws.
- *
- * 🔴 NOT eve's `eve_input:`, which still FORWARDS. The two prefixes are one character apart on
- * purpose — both name an input request — and only one of them is ours. `startsWith` distinguishes
- * them cleanly because neither is a prefix of the other, and the order of the two branches never
- * matters: eve's clicks reach no branch here at all and fall to the urlencoded forward.
- */
-function parseOeInputClickPayload(rawBody: string): unknown | undefined {
-  const p = decodeInteractivityPayload(rawBody);
-  if (!p || p.type !== "block_actions" || !Array.isArray(p.actions)) return undefined;
-  const isOurs = (p.actions as unknown[]).some(
-    (a) =>
-      typeof a === "object" &&
-      a !== null &&
-      typeof (a as Record<string, unknown>).action_id === "string" &&
-      ((a as Record<string, unknown>).action_id as string).startsWith(OE_INPUT_CLICK_PREFIX),
-  );
-  return isOurs ? p : undefined;
-}
-
 /**
  * Best-effort decode of a urlencoded body into OUR credential-intake `view_submission` (its
  * `view.callback_id` is our modal's) — undefined for any other view_submission (Eve's own modals
@@ -399,10 +365,6 @@ export function classifyEnvelope(rawBody: string, contentType: string): FrontDec
     if (grantClick !== undefined) {
       return { kind: "grant-click", reason: "block_actions oe_grant: click — ours, never forwarded", payload: grantClick };
     }
-    const inputClick = parseOeInputClickPayload(rawBody);
-    if (inputClick !== undefined) {
-      return { kind: "input-click", reason: "block_actions oe_input: click — ours, never forwarded", payload: inputClick };
-    }
     // A SHORTCUT (OPE-1376) — a `message_action` or `shortcut` payload. Ours, never forwarded; see
     // the `shortcut` arm of FrontDecision for why a forward could not do anything with it. It is
     // matched LAST among the urlencoded branches and cannot race any of them: every branch above
@@ -595,10 +557,6 @@ export interface FrontOptions {
    *  branch schedules it through the route's `waitUntil`, so this handler may outlive the empty
    *  Slack acknowledgement. */
   readonly handleGrantCardClick?: (payload: unknown) => Promise<boolean>;
-  /** Bridged-approval-card `oe_input:` tap handler (OPE-1720, defaults to
-   *  `./slack-approval-card.ts`). Injectable so the classification and the branch are testable
-   *  without a store, a Slack token or eve's `respond` primitive. */
-  readonly handleApprovalCardClick?: (payload: unknown, respond: ApprovalRespondFn) => Promise<ApprovalCardClickOutcome>;
   /** SINGLE-WINDOW mention policy for one (channel, surface) — should the unified window own an
    *  @mention here (suppress the native forward + keep the sibling as an addressed wake)?
    *  Defaults to the live {@link slackSingleWindowMentionPolicy} (grain + fail-closed
@@ -1034,7 +992,6 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
   const handleSetKeyViewSubmission = opts.handleSetKeyViewSubmission ?? liveHandleSetKeyViewSubmission;
   const handleConnectClick = opts.handleConnectClick ?? liveHandleConnectClick;
   const handleGrantCardClick = opts.handleGrantCardClick ?? liveHandleGrantCardClick;
-  const handleApprovalCardClick = opts.handleApprovalCardClick ?? liveHandleApprovalCardClick;
   const ambientEnabledFor = opts.ambientEnabledFor ?? ((surfaceKey: string) => ambientSupervisorEnabled(surfaceKey, getConfig().loadDomains()));
   const seatedSurface = opts.seatedSurfaceFor ?? slackDomainUsesUnifiedWindow;
   const mentionPolicyFor = opts.mentionPolicyFor ?? slackSingleWindowMentionPolicy;
@@ -1199,16 +1156,16 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
     const notYetSeen = (env: SlackEventEnvelope, ev: ParsedMessageEvent): Promise<boolean> =>
       notYetSeenKey(wakeKey(env, ev.channelId, ev.ts), ev);
 
-    // UNOWNED message dispatch (top-level, or in-thread but not engaged): today's default is the
-    // name-drop path (per-domain opt-in, fail-closed). When the channel's domain opts into
-    // ambientSupervisor, the SAME unowned traffic routes to the channel-supervisor session instead
+    // UNOWNED message dispatch (top-level, or in-thread but not engaged): the fallback is the
+    // name-drop path (per-domain opt-in, fail-closed). When the channel's domain has
+    // ambientSupervisor on (the default since OPE-2409), the SAME unowned traffic routes to the channel-supervisor session instead
     // (slack-events.ts routeSupervisorEvent) — the "always-on teammate" leg. `directMention` is the
     // SINGLE-WINDOW addressed-mention divert (an app_mention event routed here from the mention
     // branch): it forces the supervisor path (the only road into the unified window) and renders an
     // addressed `direct-mention` wake. The supervisor wake serializes on its OWN FIFO key (the
     // supervisor token), never shared with a thread FIFO. Fail-closed: any partition/config error,
     // or the flag off, falls through to the UNCHANGED name-drop dispatch — so ambientSupervisor-off
-    // is byte-identical to today. Parametrised on `ev` so both the app_mention divert and a plain
+    // is byte-identical to the pre-ambient path. Parametrised on `ev` so both the app_mention divert and a plain
     // message.channels wake feed one dispatcher.
     // `onWake` runs SYNCHRONOUSLY, once, immediately before a wake is scheduled — and never on the
     // addressed-drop path below. The shortcut route (OPE-1442) uses it to seed the attachment
@@ -1449,6 +1406,7 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
         authorId: ev.userId,
         surfaceInternal,
         channelKey: p.surfaceKey,
+        ...(ev.enterpriseId === undefined ? {} : { enterpriseId: ev.enterpriseId }),
       });
       // ── THE EXTERNAL-PARTICIPANT POLICY (OPE-507 author grain) ──────────────────────────────────
       //
@@ -1466,10 +1424,9 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
       // 🔴 A GROUP DM IS SUPPRESSIBLE ON THE AUTHOR GRAIN TOO (OPE-1486). It was not before, because
       // an mpim resolved no refutation at all — the limit the old note here recorded. The author leg
       // above now resolves one from the same probe a channel uses, so an operator who set
-      // `externalPolicy.authorGrain: "withhold"` gets that rule in a group DM as well. Nothing moves
-      // on the SUPPRESSION PATH for a default deployment: `withholdsBody` is inert under the shipped
-      // `taint` grain, so only a deployment that explicitly excluded refuted authors is suppressed
-      // here — which is the rule it asked for. That is a claim about SUPPRESSION alone: on `taint`
+      // `externalPolicy.authorGrain: "withhold"` (shipped since 2026-10-10) gets that rule in a group
+      // DM as well. `withholdsBody` is inert only under the `taint` opt-out, so a deployment that opted
+      // out is never suppressed here. That is a claim about SUPPRESSION alone: on `taint`
       // the same refutation still newly stamps `oe_chat_nonmember` and still newly fences the body,
       // which is the fix. The room leg stays off for the whole DM family by the note above: on a DM
       // the trust plane asks about the PARTNER, not about the room.
@@ -2009,7 +1966,7 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
       //
       // 🔴 IT COSTS A PROBE, SO IT IS SKIPPED WHEN IT CANNOT MATTER. Unlike the three routes, this
       // leg resolves no author facts of its own, so gating it means one `users.info` call. The inert
-      // check runs first: on the shipped `taint` / `engage` pair no evidence is resolved at all and
+      // check runs first: on the `taint` / `engage` opt-out pair no evidence is resolved at all and
       // this whole block is a single config read. The probe is TTL-cached per author on top of that.
       //
       // FAIL-OPEN on anything unreadable — an unparseable event, an unresolvable partition, a probe
@@ -2027,6 +1984,7 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
               authorId: mev.userId,
               surfaceInternal: facts.surfaceInternal,
               channelKey: roomKey,
+              ...(mev.enterpriseId === undefined ? {} : { enterpriseId: mev.enterpriseId }),
             });
             const verdict = await applySlackExternalPolicy(mev, p, { trust: wakeTrust, refuted: facts.refuted }, "native-mention-forward");
             if (verdict !== "proceed") {
@@ -2140,41 +2098,6 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
       return new Response(null, { status: 200 });
     }
 
-    if (decision.kind === "input-click") {
-      // THE TENANT FENCE (OPE-1680), above the handler, for the same reason every other interactivity
-      // branch carries it: a tap RESUMES a parked turn, which is this deployment spending on a scope
-      // an unadmitted workspace never had standing to decide.
-      if (slackInteractivityTenantFenceDeclined(interactivityFenceIds(decision.payload), "input-click", "front-interactivity-branch")) {
-        return fencedAck(new Response(null, { status: 200 }));
-      }
-      // Ours (core channels/approval-card.ts): somebody tapped a bridged eve approval this
-      // deployment posted onto a unified origin. The handler resolves the ticket, admits the tap
-      // through the SAME floor the typed answer takes, and delivers `respond([{requestId, optionId}])`
-      // to the parked WINDOW session.
-      //
-      // 🔴 THE DELIVERY GOES BY SESSION ID (OPE-1863). `args.from` is CHANNEL-LOCAL — on this route
-      // it addresses `slack:<token>`, while the parked session lives at `unified:<token>` — so the
-      // settle threw "the target session was not found" and every tap left the approval parked.
-      // `args.attachSession` dispatches by durable session id from any channel, and
-      // `approvalCardRespondVia` is the one road every surface binds. Bound HERE and injected because
-      // the route handler is the only place eve hands out either primitive.
-      //
-      // The 200 goes out AFTER the settle, deliberately, and the cost is stated rather than hidden:
-      // Slack expects this endpoint to answer in about three seconds, and a settle that runs longer
-      // leaves the tapper waiting on whatever Slack does then. Acking first and settling in the
-      // background would fix the delay and WIDEN the handler's own non-atomic window — see the
-      // "THE LIMIT OF THAT" paragraph in `slack-approval-card.ts`, which also records that the
-      // past-deadline behaviour is unmeasured here.
-      const respondToApproval: ApprovalRespondFn = approvalCardRespondVia(args.attachSession);
-      const tap = await handleApprovalCardClick(decision.payload, respondToApproval);
-      console.log(`[open-everywhere:slack] oe_input: tap — ${tap.reason}`);
-      // `handled:false` means the payload carried our prefix but not a shape the handler could read.
-      // Forward it rather than swallow it, the same defensive shape the grant and setkey branches
-      // take: a click this deployment cannot act on is better handed on than silently dropped.
-      if (!tap.handled) return forwardNative();
-      return new Response(null, { status: 200 });
-    }
-
     if (decision.kind === "setkey-submit") {
       // THE TENANT FENCE (OPE-1680), above the handler — this is the branch that WRITES A SECRET into
       // this deployment's store, keyed to the intake the payload names. A `view_submission` carries

package/agent/channels/slack-post-arm.ts

@@ -162,44 +162,9 @@ async function liveSlackPost(origin: SlackOrigin, text: string, replier?: Replie
   return postSlackMessage(body, replier, "unified reply couldn't post to Slack");
 }
 
-/**
- * UNIFIED, WITH BUTTONS (OPE-1720) — `liveSlackPost` plus one `actions` block, so an interactive card
- * can reach a unified origin (a DM seat, a single-window channel) instead of only a DM.
- *
- * IDENTICAL GEOMETRY TO THE PLAIN POST: same channel, same `thread_ts` resolution, same replier
- * fallback through {@link postSlackMessage} — the ONLY difference is the `blocks` field, so a card
- * lands exactly where the same reply would have. An `actions` list that renders to NOTHING (every
- * entry over Slack's caps) posts the plain message rather than a `blocks` array with an empty row.
- */
-async function liveSlackPostWithActions(origin: SlackOrigin, text: string, actions: readonly DirectMessageAction[], replier?: ReplierLabel): Promise<string> {
-  return postSlackMessage(slackUnifiedActionForm(origin, text, actions), replier, "unified reply couldn't post to Slack");
-}
-
-/**
- * PURE: the exact `chat.postMessage` form a unified card post sends. Split out from the dispatch so
- * the BLOCK PAYLOAD itself is pinned by a contract test with no Slack token and no transport — the
- * shape is the contract, and a shape Slack rejects costs the room the whole message, not just the
- * buttons.
- */
-export function slackUnifiedActionForm(origin: Pick<SlackOrigin, "channelId" | "threadTs" | "replyAnchorTs">, text: string, actions: readonly DirectMessageAction[]): URLSearchParams {
-  const rendered = markdownToSlackMrkdwn(text);
-  const body = new URLSearchParams({ channel: origin.channelId, text: rendered });
-  const threadTarget = slackThreadTarget(origin);
-  if (threadTarget) body.set("thread_ts", threadTarget);
-  const actionBlock = slackDirectMessageActionBlock(actions);
-  if (actionBlock !== undefined) {
-    // The text block rides ALONGSIDE the buttons, for the reason `deliverSlackDirectMessage` states:
-    // once `blocks` is present `text` is only the notification fallback, so without the section the
-    // room would see a row of buttons over an empty message.
-    body.set("blocks", JSON.stringify([{ text: { text: rendered, type: "mrkdwn" }, type: "section" }, actionBlock]));
-  }
-  return body;
-}
-
 /**
  * THE COMPONENT PLANE (OPE-1060 S3) — the `actions` a {@link DirectMessageRequest} carries, rendered
- * as ONE Slack `actions` block of buttons. Shared since OPE-1720 with the unified post above, so a
- * bridged approval card and a DM card cannot drift in how a button is built or capped.
+ * as ONE Slack `actions` block of buttons.
  *
  * 🔴 THE TEXT STILL STANDS ON ITS OWN. `post-arms.ts` states the contract: an arm with no component
  * plane delivers the text alone and never fakes the buttons, so every caller's copy already says what
@@ -298,12 +263,6 @@ export const slackPostArm: PostArm = {
   dispatchReply: (target, text, replier) => dispatchSlackReply(target as SlackTarget, text, replier),
   dispatchUnified: (origin, text, deps: UnifiedReplyDeps, replier) =>
     deps.postSlack ? deps.postSlack(origin as SlackOrigin, text) : liveSlackPost(origin as SlackOrigin, text, replier),
-  // OPE-1720: Slack declares the unified component plane because the tap route exists on it —
-  // `slack-front.ts` classifies the `oe_input:` click and `slack-approval-card.ts` settles it. The
-  // injected `postSlack` override is honoured VERBATIM and drops the buttons: a test that scripted a
-  // text-only post must not start receiving a card it never asked for.
-  dispatchUnifiedActions: (origin, text, actions, deps: UnifiedReplyDeps, replier) =>
-    deps.postSlack ? deps.postSlack(origin as SlackOrigin, text) : liveSlackPostWithActions(origin as SlackOrigin, text, actions, replier),
   describeRedriveTarget: (origin) => {
     const o = origin as SlackOrigin;
     return `slack ${o.threadTs ? `thread in ${o.channelId}` : `channel ${o.channelId}`}`;

package/agent/channels/slack-wake-backscroll.ts

@@ -39,6 +39,7 @@ import {
   type SeatCatchUpFetch,
   type SeatCatchUpRequest,
   type WakeMessageInput,
+  SUPERVISOR_BACKSCROLL_REACHBACK_HOURS,
 } from "@open-everywhere/core/agent/adapter-api.js";
 
 // Re-export the shared cap so this module's public surface (and its test, which imports it from
@@ -271,8 +272,8 @@ function cappedEntry(lines: readonly ContextLine[], source: string): WakeBackscr
 /** Reachback (hours) for the raw Slack window: how far back from the trigger conversations.history
  *  is paginated. Generous enough that the SPINE (the most-recent cluster, exempt from the 36h
  *  enrichment cap) can still reach across a weekend/overnight gap (~66h Fri-4pm→Mon-10am), yet a
- *  hard floor that bounds the fetch. 7d default; overridable for ops/testing. */
-export const RAW_FETCH_REACHBACK_HOURS = Number(process.env.OE_SUPERVISOR_BACKSCROLL_REACHBACK_HOURS) || 168;
+ *  hard floor that bounds the fetch. 7 days — the core constant both adapters take (OPE-2411). */
+export const RAW_FETCH_REACHBACK_HOURS = SUPERVISOR_BACKSCROLL_REACHBACK_HOURS;
 
 /** conversations.history page size (Slack max is 1000; 200 keeps each page cheap). */
 const RAW_FETCH_PAGE_LIMIT = 200;

package/agent/channels/slack.ts

@@ -589,7 +589,7 @@ async function onInbound(
   // wake: burned inference at best, a mention ping-pong at worst. Our own engagement and
   // name-drop wake paths drop bot authors too (slack-events.ts authorIsBot); this closes
   // the one remaining leg. ONE carve-out, same as the Discord gateway: an allowlisted e2e
-  // driver (OE_TEST_DRIVER_IDS `teamId:botId`). The driver posts with a USER token, but
+  // driver (a `wake.driverAllowlist` `teamId:botId` pair). The driver posts with a USER token, but
   // Slack stamps app-authored posts with the app's bot_id regardless (live 2026-07-07 —
   // the plan's "xoxp needs no seam" premise was wrong). Fail-closed, guild^Wteam-pinned,
   // exact-id, loud — see testing/driver-allowlist.ts for the full posture.
@@ -599,7 +599,7 @@ async function onInbound(
   // binds fail-closed external and memoryless". That was the bug, not a tolerable degradation:
   // an un-gated model turn ran on every non-allowlisted bot mention, ABOVE the spend gate, so a
   // capped surface kept spending. It is now a REAL drop (see DROP). Note the consequence for the
-  // e2e driver: if its `teamId:botId` isn't in OE_TEST_DRIVER_IDS, its mentions no longer produce
+  // e2e driver: if its `teamId:botId` is not in `wake.driverAllowlist`, its mentions no longer produce
   // a degraded reply — they produce NO reply plus a `surface.wake_dropped` audit row saying so.
   if (message.author?.isBot) {
     const rawBotId = typeof (message.raw as { bot_id?: unknown })?.bot_id === "string" ? (message.raw as { bot_id: string }).bot_id : undefined;