@open-everywhere/provider-slack 0.1.5 → 0.3.0

package/NOTICE

@@ -12,28 +12,28 @@ Apache License, Version 2.0.
 
 Modifications to eve
 
-The @open-everywhere/core package distributes patches/eve+0.54.3.patch. That
-patch file is a modification of eve 0.54.3. Vercel licenses eve 0.54.3 under the
-Apache License, Version 2.0. The copyright notice of eve 0.54.3 reads
+The @open-everywhere/core package distributes patches/eve+0.71.0.patch. That
+patch file is a modification of eve 0.71.0. Vercel licenses eve 0.71.0 under the
+Apache License, Version 2.0. The copyright notice of eve 0.71.0 reads
 "Copyright 2026 Vercel, Inc. and contributors". The Open Everywhere authors made
 the changes in the patch file.
 
-The patch modifies six files of eve 0.54.3:
+The patch modifies four files of eve 0.71.0:
 
-  dist/src/context/dynamic-tool-lifecycle.js
   dist/src/execution/web-fetch/request.js
   dist/src/harness/tool-loop.js
   dist/src/internal/authored-package-boundary.js
   dist/src/protocol/message.d.ts
-  dist/src/tasks/session-index.js
 
 Open Everywhere does not ship the eve package. eve is a peer dependency, so the
-consumer installs eve 0.54.3 from the registry. The patch file carries the
+consumer installs eve 0.71.0 from the registry. The patch file carries the
 modified portions of eve. The oe-eve-patch command, which
 @open-everywhere/core ships, applies them to the eve that the consumer
-installed. The command writes no file outside the consumer's own project.
+installed. The command patches no file outside the consumer's own project. To
+restore an eve that holds an older Open Everywhere patch, it also writes to npm's
+cache and to a temporary directory.
 
-The attribution notice of eve 0.54.3 follows, as section 4(d) of the Apache
+The attribution notice of eve 0.71.0 follows, as section 4(d) of the Apache
 License, Version 2.0 requires. The notices for eve's bundled code-mode runtime
 are not reproduced, because the patch modifies no part of that runtime.
 

package/README.md

@@ -15,7 +15,7 @@ asserts that **every** one of them is absent from `packages/core/agent`. For Sla
 ## Install
 
 ```sh
-npm i @open-everywhere/core @open-everywhere/provider-slack eve@0.54.3
+npm i @open-everywhere/core @open-everywhere/provider-slack eve@0.71.0
 npx oe-eve-patch
 ```
 

package/agent/app-manifest.ts

@@ -16,9 +16,16 @@
  *  operator, who has usually not deployed yet when they run it. */
 export const SLACK_DEPLOY_HOST_PLACEHOLDER = "YOUR-DEPLOY-URL";
 
-/** The app name the manifest carries when the operator names none. */
+/** The app name the manifest carries when the operator names none AND the deployment configures no
+ *  `identity.name`. The same brand default core's `agentDisplayName()` falls back to. */
 export const SLACK_DEFAULT_APP_NAME = "Open Everywhere";
 
+/** The slash command's name when the caller passes none — the shipped `identity.commandName`. */
+const SLACK_DEFAULT_COMMAND_NAME = "oe";
+
+/** Slack's limit on a shortcut's name. A longer one fails at paste time. */
+export const SLACK_SHORTCUT_NAME_MAX = 24;
+
 /** Slack's limit on an app name (`display_information.name`). A longer name fails at paste time. */
 export const SLACK_APP_NAME_MAX = 35;
 
@@ -31,17 +38,44 @@ export function slackAppNameProblem(raw: string): string | undefined {
   return undefined;
 }
 
-/** Options for {@link slackAppManifestTemplate}. */
+/** Options for {@link slackAppManifestTemplate}. This module imports nothing, so the caller reads
+ *  the deployment's settings and passes them in (OPE-2334): `agent/ops.ts` and the `/setup` page
+ *  read core's resolvers, and the setup CLI reads the app's own settings file. */
 export interface SlackAppManifestOptions {
-  /** The app name and the bot user's display name. Default {@link SLACK_DEFAULT_APP_NAME}. A
-   *  second install in one workspace needs its own name, or the two apps look the same. */
+  /** An EXPLICIT app name (`--app-name`, the ops tool's `appName`, the `/setup` form). It wins
+   *  over {@link agentName}. A second install in one workspace needs its own name, or the two apps
+   *  look the same. */
   readonly appName?: string;
+  /** The deployment's configured name — the `identity.name` setting. It names the app, the bot user,
+   *  the shortcuts and the command description when no explicit {@link appName} is given. Absent ⇒
+   *  {@link SLACK_DEFAULT_APP_NAME}. */
+  readonly agentName?: string;
+  /** The slash command's name without the slash — the `identity.commandName` setting. Absent ⇒
+   *  {@link SLACK_DEFAULT_COMMAND_NAME}. */
+  readonly commandName?: string;
+}
+
+/** The app name a manifest carries: the explicit name, else the configured name, else the default.
+ *  A configured name past Slack's limit is cut to fit, because Slack refuses the whole paste. */
+export function slackManifestAppName(opts: SlackAppManifestOptions = {}): string {
+  const explicit = opts.appName?.trim();
+  if (explicit) return explicit;
+  const configured = opts.agentName?.trim();
+  if (configured) return configured.slice(0, SLACK_APP_NAME_MAX).trim();
+  return SLACK_DEFAULT_APP_NAME;
+}
+
+/** A shortcut name that names the app, or the neutral form when the name does not fit. */
+function shortcutName(prefix: string, appName: string, neutral: string): string {
+  const named = `${prefix} ${appName}`;
+  return named.length <= SLACK_SHORTCUT_NAME_MAX ? named : neutral;
 }
 
 /** A ready-to-paste Slack app manifest (Slack's "create from manifest" flow) with the scope/event
  *  set docs/deploy/surfaces/slack.md walks through by hand. */
 export function slackAppManifestTemplate(opts: SlackAppManifestOptions = {}): string {
-  const appName = opts.appName?.trim() || SLACK_DEFAULT_APP_NAME;
+  const appName = slackManifestAppName(opts);
+  const commandName = opts.commandName?.trim() || SLACK_DEFAULT_COMMAND_NAME;
   return JSON.stringify(
     {
       display_information: { name: appName },
@@ -60,9 +94,10 @@ export function slackAppManifestTemplate(opts: SlackAppManifestOptions = {}): st
         // configures SEPARATELY from the Events request URL above.
         slash_commands: [
           {
-            command: "/oe",
+            // The `identity.commandName` setting (OPE-2334). The route checks the same name.
+            command: `/${commandName}`,
             url: `https://${SLACK_DEPLOY_HOST_PLACEHOLDER}/eve/v1/slack/commands`,
-            description: "Open Everywhere control-plane commands (stop, status, budget) — no model turn.",
+            description: `${appName} control-plane commands (stop, status, budget) — no model turn.`,
             // Every subcommand `parseOeCommandTokens` accepts (packages/core/agent/commands/core.ts).
             // scripts/slack-app-manifest-test.ts fails if one is missing here.
             usage_hint: "stop | status | budget [raise <usd> | clear] | rate <n> | help",
@@ -80,13 +115,13 @@ export function slackAppManifestTemplate(opts: SlackAppManifestOptions = {}): st
         // receives, so renaming one here changes only the trigger name the model is told about.
         shortcuts: [
           {
-            name: "Send to Open Everywhere",
+            name: shortcutName("Send to", appName, "Send to the agent"),
             type: "message",
             callback_id: "oe_message_shortcut",
             description: "Wake the agent on this message.",
           },
           {
-            name: "Ask Open Everywhere",
+            name: shortcutName("Ask", appName, "Ask the agent"),
             type: "global",
             callback_id: "oe_global_shortcut",
             description: "Wake the agent in a DM.",

package/agent/channels/slack-commands.ts

@@ -38,6 +38,7 @@ import { slackSigningSecret } from "../setup/credentials.js";
 import {
   bindFrom,
   runOeCommand,
+  oeSlash,
   parseSlackCommandText,
   resolvePartition,
   getOperationalStore,
@@ -204,13 +205,16 @@ export default defineChannel({
       }
 
       const command = formField(params, "command");
-      if (command !== "/oe") {
-        // Defensive, not a security gate: this route is dedicated to "/oe" — the Slack app's
+      // The command's name is the `identity.commandName` setting (OPE-2334), the same value the
+      // manifest declares, so a renamed command is answered here rather than refused.
+      const expected = oeSlash();
+      if (command !== expected) {
+        // Defensive, not a security gate: this route is dedicated to the one command — the Slack app's
         // Slash Command config should only ever point ONE command at it. Anything else is a
         // misconfiguration (a second command aimed at the same URL); answer politely instead
         // of a bare 404/500 so it's obvious in Slack what to fix.
-        log(`unexpected slash command "${command ?? "?"}" hit the /oe route — check the Slack app's Slash Command config`);
-        return ephemeralResponse('This endpoint only handles "/oe" — check your Slack app\'s Slash Command configuration.');
+        log(`unexpected slash command "${command ?? "?"}" hit the ${expected} route — check the Slack app's Slash Command config`);
+        return ephemeralResponse(`This endpoint only handles "${expected}" — check your Slack app's Slash Command configuration.`);
       }
 
       const cmd = parseSlackCommandText(formField(params, "text"));
@@ -223,7 +227,7 @@ export default defineChannel({
         // (e.g. proposing from a DM with no explicit scope) — surface it verbatim. Never let a
         // thrown error escape as a 500; Slack's slash-command UX for that is an ugly
         // "operation_timeout"/dispatch_failed toast.
-        log(`"/oe" command failed softly: ${String(err)}`);
+        log(`"${expected}" command failed softly: ${String(err)}`);
         return ephemeralResponse(`Couldn't complete that: ${err instanceof Error ? err.message : String(err)}`);
       }
     }),

package/agent/channels/slack-events.ts

@@ -1430,6 +1430,7 @@ 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
@@ -2600,6 +2601,7 @@ 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
@@ -3682,33 +3684,91 @@ export function fetchChannelDisplayName(channelId: string): Promise<string | und
   return p;
 }
 
+/** Slack error codes that mean this app STRUCTURALLY cannot read a room's roster (OPE-2306): a scope
+ *  the install does not hold, a room it cannot see, a permission or Grid grant it lacks. A retry
+ *  cannot change them, so the roster is `unobservable` and the observed-guest legs stay inert. Every
+ *  other non-ok code is `failed` ON PURPOSE (fail closed): an unlisted steady-state code makes the
+ *  connector-disclosure floor refuse until it is added here. */
+const SLACK_ROSTER_UNOBSERVABLE_ERRORS: ReadonlySet<string> = new Set([
+  "missing_scope",
+  "channel_not_found",
+  "not_in_channel",
+  "method_not_supported_for_channel_type",
+  "no_permission",
+  "team_access_not_granted",
+]);
+
+/** The unresolved state of a non-ok Slack answer. No answer at all (a network failure, an exhausted
+ *  429 retry, no bot token: slackForm returns `undefined`) is `failed`, and so is an unknown code. */
+function slackRosterFailureState(res: Record<string, unknown> | undefined): "unobservable" | "failed" {
+  return typeof res?.error === "string" && SLACK_ROSTER_UNOBSERVABLE_ERRORS.has(res.error) ? "unobservable" : "failed";
+}
+
 /**
  * Live Slack roster for a governance channel's floor tripwire (OPE-110, access/audience-floor.ts).
- * Two fail-closed Slack reads: conversations.info (is_private + externally-shared bit) and
- * conversations.members (member ids). The bot's own user id is excluded so the agent doesn't count
- * as a non-admin member. FAIL CLOSED: any failed/absent lookup ⇒ `resolved: false` ⇒ the floor can
- * never arm. `hasGuest` uses the channel's externally-shared bit as the available external signal;
+ * Up to three Slack reads: conversations.info (is_private + externally-shared bit),
+ * conversations.members (member ids) and auth.test (the bot's own user id). The roster excludes the
+ * bot's own user id, so the agent doesn't count as a non-admin member. A failed conversations.info
+ * or conversations.members read, a members list of a NON-SHARED channel longer than one page, or a
+ * thrown error returns `resolved: false`, with an `unresolvedState` (OPE-2306). A transient failure
+ * is `failed`: a non-ok answer outside SLACK_ROSTER_UNOBSERVABLE_ERRORS, no answer, a thrown error, a
+ * conversations.info answer with no channel object. A steady state is `unobservable`: a code in that
+ * set, or a non-shared members list longer than one page. A failed auth.test does not unresolve the roster: the roster stays resolved and counts the bot as a
+ * non-admin member, so the governance channel does not arm. `resolved: false` is closed for the
+ * governance tripwire: the floor computes to `guest`, so the channel can never arm. It is
+ * also closed for the clicker floor's beneficiary leg, which refuses on it (`unattested-room`). It
+ * is closed for the connector-disclosure floor when it is `failed`: that floor refuses until the
+ * roster resolves (OPE-2306). It is NOT closed for the observed-guest legs of the triggered-fire
+ * disclosure floor, the card-disclosure floor and the approval-card clicker floor, nor for the
+ * connector-disclosure floor on an `unobservable` roster. Those refuse only an OBSERVED guest, so
+ * they stay INERT (access/audience-floor.ts, the polarity rule). Core memoizes a `resolved: false`
+ * answer for UNRESOLVED_ROSTER_TTL_MS (30 s) only, not for the full memo TTL (OPE-2150), so one
+ * failed read disarms the inert legs, and refuses the connector-disclosure floor, for at most that
+ * short window.
+ * `hasGuest` uses the channel's externally-shared bit as the available external signal;
  * per-member guest classification rides the guest-detection work (design §2/§10 fragile-point #1) and
  * is a future tightening, not a loosening (an internal-only private channel already needs every
  * member on the roster to arm). Governance channels are small by config lint, so a single members
- * page suffices; a channel larger than one page fails closed on the (unset) cursor rather than
- * silently attesting a partial roster.
+ * page suffices. A NON-SHARED channel larger than one page returns `resolved: false` rather than a
+ * partial roster: the governance channel does not arm, and the disclosure floors stay inert
+ * (`unobservable`: the member list is incomplete and a retry gets the same page count). An
+ * EXTERNALLY-SHARED channel larger than one page resolves with `hasGuest: true` and an empty member
+ * list, without a read of the other pages (OPE-2311). The floor counts the channel's shared bit as
+ * a guest present, the same signal the one-page path uses (the bit includes a pending external
+ * invitation and an Enterprise Grid org share). So the floor is `guest` and the observed-guest legs
+ * of every consumer refuse.
  */
 export async function slackGovernanceRoster(channelId: string): Promise<RoomRoster | undefined> {
   try {
     const info = await slackForm("conversations.info", `channel=${encodeURIComponent(channelId)}`);
-    if (info?.ok !== true) return { humanMemberIds: [], resolved: false, isPrivate: false, hasGuest: false };
+    if (info?.ok !== true) {
+      return { humanMemberIds: [], resolved: false, unresolvedState: slackRosterFailureState(info), isPrivate: false, hasGuest: false };
+    }
     const facts = channelFactsFromInfo(info);
     const members = await slackForm("conversations.members", `channel=${encodeURIComponent(channelId)}&limit=200`);
     if (members?.ok !== true || !Array.isArray(members.members)) {
-      return { humanMemberIds: [], resolved: false, isPrivate: false, hasGuest: false };
+      return { humanMemberIds: [], resolved: false, unresolvedState: slackRosterFailureState(members), isPrivate: false, hasGuest: false };
     }
     const cursor = (members.response_metadata as { next_cursor?: string } | undefined)?.next_cursor;
     if (cursor && cursor.length > 0) {
-      // More than one page: a governance channel this large is off-policy (lint caps channel COUNT,
-      // not membership, but a >200-member "admin" room is a smell) — fail closed rather than attest a
-      // partial roster as if it were the whole audience.
-      return { humanMemberIds: [], resolved: false, isPrivate: false, hasGuest: false };
+      // More than one page. An externally-shared channel needs no member list: the floor counts the
+      // shared bit as a guest present, as the one-page path does (OPE-2311). So the roster resolves
+      // with `hasGuest: true` and an EMPTY member list, never a partial one. The floor is `guest` for every consumer, and
+      // the observed-guest legs refuse. The share bit is a steady state, so the full memo TTL is fine.
+      if (facts.trustChecked === true && facts.isExternal === true) {
+        return { humanMemberIds: [], resolved: true, isPrivate: facts.isPrivate === true, hasGuest: true };
+      }
+      // An ok conversations.info with no channel object is an odd answer, not a steady state: it is
+      // `failed`, as on the one-page path below.
+      if (facts.trustChecked !== true) {
+        return { humanMemberIds: [], resolved: false, unresolvedState: "failed", isPrivate: false, hasGuest: false };
+      }
+      // A non-shared channel this large: do not attest a partial roster as if it were the whole
+      // audience (a >200-member "admin" room is off-policy anyway). An unresolved roster keeps the
+      // governance channel disarmed, but it leaves the disclosure floors INERT, not closed
+      // (access/audience-floor.ts, the polarity rule). `unobservable` (OPE-2306): a retry gets the
+      // same page count.
+      return { humanMemberIds: [], resolved: false, unresolvedState: "unobservable", isPrivate: false, hasGuest: false };
     }
     const auth = await slackForm("auth.test", "");
     const botId = auth?.ok === true && typeof auth.user_id === "string" ? auth.user_id : undefined;
@@ -3718,11 +3778,13 @@ export async function slackGovernanceRoster(channelId: string): Promise<RoomRost
     return {
       humanMemberIds,
       resolved: facts.trustChecked === true, // conversations.info authoritative
+      // An ok conversations.info with no channel object is an odd answer, not a steady state.
+      ...(facts.trustChecked === true ? {} : { unresolvedState: "failed" as const }),
       isPrivate: facts.isPrivate === true,
       hasGuest: facts.isExternal === true,
     };
   } catch {
-    return { humanMemberIds: [], resolved: false, isPrivate: false, hasGuest: false };
+    return { humanMemberIds: [], resolved: false, unresolvedState: "failed", isPrivate: false, hasGuest: false };
   }
 }
 
@@ -4157,6 +4219,7 @@ 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

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
@@ -576,7 +538,7 @@ export interface FrontOptions {
    * tests can stub it without the propose/store/executor machinery it drags in.
    *
    * 🔴 IT TAKES THE ROUTE'S `waitUntil` (OPE-1709), for the same reason the Discord front's
-   * approval branch does: "Approve for session" releases the sibling cards the grant already
+   * approval branch does: "Approve for this routine" releases the sibling cards the grant already
    * covers, and each release runs a real `execute`. That work belongs off the interactivity
    * response path. The handler falls back to its old awaited shape when this is absent, which is
    * exactly what a stub that ignores the second argument gets. */
@@ -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;
@@ -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) ──────────────────────────────────
       //
@@ -2027,6 +1985,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") {
@@ -2058,7 +2017,7 @@ export function buildFrontHandler(innerHandler: RouteHandler, opts: FrontOptions
       //
       // 🔴 `args.waitUntil` RIDES ALONG (OPE-1709), and it is the HELD one (see the route hold
       // above), so the deferred work is quiesced before the delivery's own promise resolves. What
-      // it moves off this path is the session-grant release: an "Approve for session" click on a
+      // it moves off this path is the session-grant release: an "Approve for this routine" click on a
       // fan-out decides and EXECUTES the sibling cards the grant already covers, and that loop has
       // no business inside Slack's three-second interactivity budget.
       if (await handleApproval(decision.payload, { waitUntil: args.waitUntil })) {
@@ -2140,41 +2099,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}`}`;