@open-everywhere/provider-slack 0.1.0

package/dist/agent/channels/slack-front.d.ts

@@ -0,0 +1,387 @@
+import { type Channel, type RouteHandlerArgs } from "eve/channels";
+import { liveSupervisorDeps, type SlackEventEnvelope } from "./slack-events.js";
+import { EventDedupe, ThreadFifo, type SingleWindowMentionPolicy, type DmSeat, type SetKeyViewResult } from "@open-everywhere/core/agent/adapter-api.js";
+import { type ApprovalCardClickOutcome, type ApprovalRespondFn } from "./slack-approval-card.js";
+import { type ParsedSlackShortcut } from "./slack-shortcut.js";
+/** An HTTP route handler — `RouteHandler` isn't a public eve export, so we mirror its shape. */
+type RouteHandler = (req: Request, args: RouteHandlerArgs) => Promise<Response>;
+/** The public URL Slack POSTs every subscribed event to (Event Subscriptions Request URL). */
+export declare const PUBLIC_SLACK_ROUTE = "/eve/v1/slack";
+/** The internal path the wrapped `slackChannel` is mounted at (never hit by Slack directly). */
+export declare const INTERNAL_SLACK_ROUTE = "/eve/v1/slack/mention";
+/** The decision the front route makes for one inbound request. `env` is carried on the
+ * wake/join branches, and the decoded `payload` on the approval-click branch, so the handler
+ * needn't re-parse what it already parsed to classify. */
+export type FrontDecision = {
+    readonly kind: "forward";
+    readonly reason: string;
+} | {
+    readonly kind: "wake";
+    readonly reason: string;
+    readonly env: SlackEventEnvelope;
+} | {
+    readonly kind: "join";
+    readonly reason: string;
+    readonly env: SlackEventEnvelope;
+} | {
+    readonly kind: "reaction";
+    readonly reason: string;
+    readonly env: SlackEventEnvelope;
+} | {
+    readonly kind: "approval-click";
+    readonly reason: string;
+    readonly payload: unknown;
+}
+/** A "Set API key" button click (credentials/intake.ts) — ours: verify the clicker is the intake's
+ *  requester, then views.open a native modal. Never forwarded. */
+ | {
+    readonly kind: "setkey-click";
+    readonly reason: string;
+    readonly payload: unknown;
+}
+/** A `view_submission` from our credential-intake modal — ours: encrypt + store the pasted value
+ *  host-side, and RESPOND with the modal-close/errors JSON. A `view_submission` for anyone else's
+ *  modal (Eve's own) still forwards. */
+ | {
+    readonly kind: "setkey-submit";
+    readonly reason: string;
+    readonly payload: unknown;
+}
+/** An `oe_connect:` connector-card button click (connections/connector-card.ts) — ours: re-verify
+ *  standing host-side, then mint an ephemeral OAuth URL / open the api-key intake. Never forwarded. */
+ | {
+    readonly kind: "connect-click";
+    readonly reason: string;
+    readonly payload: unknown;
+}
+/** An `oe_grant:` credential-grant card button click (access/credential-grant-card.ts) — ours: the
+ *  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
+ *  needn't re-parse what classification already parsed — same pattern as `wake`/`join`. */
+ | {
+    readonly kind: "mention";
+    readonly reason: string;
+    readonly env: SlackEventEnvelope;
+}
+/** A DM-FAMILY message — a 1:1 (`message.im`, OPE-351 stage 2) or a GROUP DM (`message.mpim`,
+ *  stage 4). OURS, never forwarded: the surface's seat is a first-class standing window, so the
+ *  event is diverted into it (`scheduleDmWake`) instead of going to eve's native `onDirectMessage`
+ *  (a 1:1) or being judged by the name-drop gate that refused it outright (a group DM). `dmKind`
+ *  is the classification the envelope DID carry, so the handler needn't re-read `channel_type`;
+ *  `env` rides along like every other wake branch. */
+ | {
+    readonly kind: "dm-wake";
+    readonly reason: string;
+    readonly env: SlackEventEnvelope;
+    readonly dmKind: "im" | "mpim";
+}
+/** A Slack SHORTCUT — a message shortcut (`message_action`) or a global one (`shortcut`),
+ *  OPE-1376. OURS, never forwarded: eve's `onShortcut` hook is unconfigured on this channel, so
+ *  a forward is a guaranteed no-op, and eve's shortcut context carries no session to wake from
+ *  anyway. The decoded shortcut rides along so the handler needn't re-parse it — same pattern as
+ *  the click branches, which carry a raw `payload` because their handlers own the decode. */
+ | {
+    readonly kind: "shortcut";
+    readonly reason: string;
+    readonly shortcut: ParsedSlackShortcut;
+};
+/**
+ * Decide how the front route handles a raw inbound body. FORWARD is the fail-safe default:
+ * anything slackChannel owns (the challenge handshake, `app_mention`, a `block_actions`/slash
+ * interaction) or anything unrecognized goes to slackChannel unchanged. The DM FAMILY is ours:
+ * `message.im` (OPE-351 stage 2) and `message.mpim` (stage 4) classify `dm-wake` and are diverted
+ * into the surface's own standing window. The other events slackChannel drops route to us too: a
+ * plain channel/group `message` → the engagement wake, `member_joined_channel` → the channel-join
+ * intro, and a urlencoded `block_actions` payload carrying an `oe_approval:` action id → the
+ * approval-click handler (ours alone). A urlencoded SHORTCUT payload (`message_action` /
+ * `shortcut`, OPE-1376) is ours too — every OTHER urlencoded body, including Eve's `eve_input:`
+ * clicks, its view_submissions and slash commands, still forwards. No network I/O and NO side
+ * effects, so every branch is unit-tested. Classification decides what a request IS; nothing here
+ * may write process state, because every gate that decides whether the request WAKES anything runs
+ * later in the handler (OPE-1442). The absence of a lookup is also why the
+ * GROUP-DM app_mention leg is decided in the HANDLER and not here: it needs a Slack lookup, because
+ * an app_mention envelope carries no `channel_type` to classify on.
+ */
+export declare function classifyEnvelope(rawBody: string, contentType: string): FrontDecision;
+/** The FIFO key a DM's wakes serialize on. Generation-INDEPENDENT (the same reasoning as
+ *  `supervisorFifoKey`): the FIFO's job is to serialize this DM's wakes, which must hold ACROSS a
+ *  rotation boundary too, so it keys on the channel and never on the generation-bearing token. Its
+ *  own namespace, so a DM's queue is never shared with a channel supervisor's or a thread's. */
+export declare function dmFifoKey(dmChannelId: string): string;
+/**
+ * Verify a Slack request signature over the RAW body (the exact bytes Slack signed).
+ * `v0=` HMAC-SHA256 of `v0:{timestamp}:{body}` keyed by the signing secret, constant-time
+ * compared, with a 5-minute replay window. Fail-closed: any missing header / secret, a stale
+ * timestamp, or a mismatch returns false. `nowMs` is injectable so the replay window is tested.
+ *
+ * The BASESTRING AND DIGEST are `channels/slack-signature.ts`'s (OPE-197), shared verbatim with the
+ * webhook-registry entry for this scheme — a difference there would be a signature that verifies on
+ * one route and 401s on the other. What stays HERE is what the two routes legitimately differ on:
+ * this one reads one env-homed secret and returns a bare boolean, because a Slack Request URL has no
+ * failure vocabulary to report into.
+ */
+export declare function verifySlackSignature(rawBody: string, headers: Headers, signingSecret: string | undefined, nowMs?: number): boolean;
+export { EventDedupe, ThreadFifo };
+export declare function resolveBotIdentity(): Promise<{
+    readonly userId?: string;
+    readonly botId?: string;
+}>;
+/** Reset the cached identity (tests only). */
+export declare function _resetBotIdentity(): void;
+/** Injectable seams so the wake path is testable without live crypto / Slack. */
+export interface FrontOptions {
+    readonly signingSecret?: string;
+    readonly dedupe?: EventDedupe;
+    readonly fifo?: ThreadFifo;
+    readonly getBotIdentity?: () => Promise<{
+        readonly userId?: string;
+        readonly botId?: string;
+    }>;
+    readonly now?: () => number;
+    /** Durable first-sighting check (true = proceed). Defaults to the operational store. */
+    readonly markEventSeen?: (org: string, key: string, atIso: string) => Promise<boolean>;
+    /** Is ambient-supervisor mode enabled for this channel's domain? (sync config lookup.)
+     *  Defaults to the live domain resolver (memory/domain.ts). Fail-closed off: when this
+     *  returns false the unowned-message dispatch is BYTE-IDENTICAL to today's name-drop path. */
+    readonly ambientEnabledFor?: (surfaceKey: string) => boolean;
+    /** Does this channel have a STANDING SEAT (OPE-1695)? Defaults to the live predicate
+     *  (slack-events.ts slackDomainUsesUnifiedWindow: the capability plus a seat domain). It decides
+     *  ONE thing here — whether an ADDRESSED wake has a seat road to take when the chattiness flag is
+     *  off. False keeps the pre-seat drop, so a deployment with the capability unarmed is unchanged. */
+    readonly seatedSurfaceFor?: (surfaceKey: string) => boolean;
+    /** Approval-click handler (defaults to the real `agent/approvals/flow.ts`). Injectable so
+     * 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
+     * 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. */
+    readonly handleApprovalPayload?: (payload: unknown, deps?: {
+        waitUntil?: (p: Promise<unknown>) => void;
+    }) => Promise<boolean>;
+    /** "Set API key" click handler (defaults to the real `agent/credentials/intake.ts`) — verifies the
+     *  clicker owns the intake, then views.open the modal. Injectable for tests. */
+    readonly handleSetKeyClick?: (payload: unknown) => Promise<boolean>;
+    /** Credential-modal `view_submission` handler (defaults to `agent/credentials/intake.ts`) —
+     *  encrypts + stores the value and returns the modal-close/errors JSON. Injectable for tests. */
+    readonly handleSetKeyViewSubmission?: (payload: unknown) => Promise<SetKeyViewResult>;
+    /** Connector-card `oe_connect:` click handler (defaults to `agent/connections/connector-card.ts`) —
+     *  re-verifies standing host-side, then mints an ephemeral OAuth URL / opens the api-key intake.
+     *  Injectable for tests. */
+    readonly handleConnectClick?: (payload: unknown) => Promise<boolean>;
+    /** Injected in tests; the live default is core's `handleGrantCardClick`. The signed grant-click
+     *  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
+     *  internal-channel confirmation). Injectable so the two mention legs are testable without a
+     *  live config/Slack; fail-closed off: the default answers "native owns it" for every
+     *  non-single-window domain, byte-identical to today. */
+    readonly mentionPolicyFor?: (channelId: string, surfaceKey: string) => Promise<SingleWindowMentionPolicy>;
+    /** Resolve (create/adopt/rotate/resume) the DM seat for a wake, KEYED ON THE SURFACE KEY since
+     *  OPE-351 stage 2 (the window token and its registry row are both surface-keyed). `channelId` is
+     *  the raw platform id the rotation distiller fetches history with; `legacyChannelId` is the
+     *  one-time adopt-from-OPE-90 probe, supplied for a 1:1 only — a group DM never had such a row.
+     *  Defaults to the live store-backed {@link liveGetOrCreateDmSeat} with the tail-carrying
+     *  distiller. Injectable for tests. */
+    readonly resolveDmSeat?: (org: string, dm: {
+        surfaceKey: string;
+        channelId?: string;
+        legacyChannelId?: string;
+    }, atIso: string) => Promise<DmSeat>;
+    /** Record one wake on the DM seat (lastWakeAt/turnCount). Defaults to {@link liveTouchDmSeat}. */
+    readonly touchDmSeatFn?: (org: string, dmSurfaceKey: string, atIso: string) => Promise<void>;
+    /** DM-partner trust lookup (`users.info`) — feeds `dm_partner_trust`, which gates a 1:1 DM's SHARED
+     *  read layer (internal ⇒ `dm` trust, external ⇒ `public`). FAIL-CLOSED: undefined ⇒ the attribute
+     *  is omitted ⇒ the binding treats the partner as external. Defaults to the live cached lookup.
+     *  NOT consulted for a GROUP DM — see `scheduleDmWake`'s note on why the attribute is 1:1-only. */
+    readonly dmPartnerTrustFor?: (userId: string, teamId: string | undefined) => Promise<"internal" | "external" | undefined>;
+    /** The channel FACTS the envelope doesn't carry (`conversations.info`, TTL-cached, fail-soft):
+     *  the surface's `channelType` — the only way to tell a GROUP-DM `app_mention` from a channel's,
+     *  since an app_mention envelope has no `channel_type` — and the trust gate's confirmed-internal
+     *  verdict, which stands in for the DM-partner check a group DM cannot make. Defaults to the live
+     *  {@link slackChannelFactsFor}. Injectable so both mpim legs are testable without Slack; a stub
+     *  answering `{ internal: false }` reproduces the missing-`mpim:read` degradation exactly.
+     *
+     *  `appCanRead` is the shortcut route's file gate (OPE-1442) and is FAIL-CLOSED: an omitted or
+     *  false value withholds the target message's files. A stub that leaves it out therefore
+     *  reproduces "the app cannot read this room", which is the safe default for a test to inherit.
+     *
+     *  `extShared`/`trustChecked` are the RAW platform halves `internal` joins away (OPE-1486) — the
+     *  group-DM wake stamps them so `bindSlack` grades an mpim on the same two facts a channel is
+     *  graded on. Both are POSITIVE-ONLY: an omitted value stamps nothing, so a stub that leaves them
+     *  out reproduces "the platform said nothing about sharing", which demotes no room. */
+    readonly channelFactsFor?: (channelId: string) => Promise<{
+        internal: boolean;
+        channelType?: string;
+        appCanRead?: boolean;
+        extShared?: boolean;
+        trustChecked?: boolean;
+    }>;
+    /** Open (or reuse) the 1:1 DM channel with a Slack member, returning its `D…` id — the landing
+     *  place a GLOBAL shortcut wakes in (OPE-1376), since a global shortcut names no conversation.
+     *  `conversations.open` is idempotent, so this is a resolve rather than a create. Needs the
+     *  `im:write` bot scope, which the runbook and the wizard manifest already require for the
+     *  governance DM-delivery arm. Defaults to the live call; FAIL-CLOSED: undefined ⇒ the shortcut
+     *  wakes nothing and says so, never a wake in a guessed room. Injectable for tests. */
+    readonly openDirectMessageChannel?: (userId: string) => Promise<string | undefined>;
+    /** The trigger author's two membership facts, from ONE `users.info` probe — the exact pair every
+     *  wake route in slack-events.ts resolves. Two readers: the native `app_mention` forward's
+     *  external-policy gate, which calls it only when that policy is not inert (so a deployment on the
+     *  shipped grains pays nothing there), and every GROUP-DM wake (OPE-1486), which reads its
+     *  `refuted` half unconditionally — a guest who writes in an mpim must mark the turn whatever the
+     *  policy grain is. Defaults to the live {@link slackWakeAuthorFacts}; injectable so both are
+     *  testable without Slack. */
+    readonly authorFactsFor?: (channelInternal: boolean, userId: string | undefined, teamId: string | undefined) => Promise<{
+        readonly surfaceInternal: boolean;
+        readonly refuted: boolean;
+    }>;
+}
+/**
+ * Turn a swallowed FIFO wake failure into a DURABLE, queryable signal (resilience S-1 / #551
+ * §3.4): a log-ship "error" record (the primary win — the failure survives the ~1h console
+ * retention) plus a best-effort `surface.wake_failed` audit row (mirrors recordQuietFailure's
+ * posture). The FIFO key encodes the channel (`${channelId}:${threadTs}` for a thread wake,
+ * `${channelId}:oe-sup` for a supervisor wake); team is unknown at this layer, so the audit
+ * partition falls back to the empty-team default exactly like recordQuietFailure's own
+ * `teamId ?? ""` — best-effort, never blocks. Never throws.
+ */
+/**
+ * Deliver a wake, and RE-DELIVER IT ONCE when the first attempt died on a pruned deployment
+ * (OPE-963, channels/stranded-seat.ts).
+ *
+ * The first attempt's failure is not wasted: `divertToUnifiedWindow` classified it and MARKED the
+ * seat's `channel_session` row for rotation before it rethrew. So the second attempt re-resolves the
+ * seat, `rotationTrigger` answers `operator-marked`, the seat takes its own rotate leg (fresh
+ * generation, carried tail), and eve opens a NEW run under the CURRENT deployment. Without this the
+ * member loses the message that hit the strand, even though the seat itself is healed.
+ *
+ * EXACTLY ONE retry, and only for this class. Every other failure rethrows untouched, straight to
+ * the FIFO's loud handler ({@link recordWakeFailure}). A second failure of the same class rethrows
+ * too — the seat could not be marked, so a third attempt would resume the same dead run.
+ *
+ * THE ROUTE FUNCTION MUST BE RE-RUNNABLE, and both wrapped routes are. Everything they do before
+ * the divert is a read or an idempotent write: TTL-cached `conversations.info` / `users.info`
+ * probes, a deterministic external-policy verdict (its private notice posts only on a verdict that
+ * RETURNS rather than throws, so a retry never reaches it), a read-only spend gate, and
+ * `markEngaged`, which upserts. `recordWakeTail` and `touchDmSeat`/`touchSession` all run AFTER the
+ * divert, so a failed attempt records nothing to duplicate. The wake id is minted fresh, which is
+ * correct — the retry is a new delivery.
+ *
+ * Applied only to the WINDOW-bearing routes — a thread seat has no `channel_session` row to mark,
+ * so a retry there could only resume the same dead run.
+ *
+ * OPE-970: when the RETRY ALSO throws, the seat is still healed for its NEXT wake — but THIS
+ * member's message got no answer, and that fact must not collapse into an ordinary send-failure
+ * row indistinguishable from a transient blip. The retry's error is tagged
+ * ({@link markUndeliveredAfterHeal}) before it rethrows, so {@link recordWakeFailure} can give the
+ * row its own reason.
+ */
+export declare function deliverWithStrandRetry<T>(deliver: () => Promise<T>): Promise<T>;
+export declare function recordWakeFailure(key: string, err: unknown): void;
+/**
+ * Build the front route handler. Buffers the body once, verifies the signature, then forwards
+ * or wakes per {@link classifyEnvelope}. `innerHandler` is slackChannel's own POST handler,
+ * invoked with a FRESH Request (re-readable body) + the same {@link RouteHandlerArgs}, so
+ * slackChannel re-verifies and dispatches exactly as if it owned the URL.
+ */
+/**
+ * SINGLE-WINDOW diversion (channels/unified-window.ts): layer the cross-channel hop onto the
+ * supervisor deps. When routeSupervisorEvent minted a `window` for a wake (the domain's
+ * crossSurfaceWindow gates hold — the wakeId is already rendered into the envelope), deliver it
+ * through eve's cross-channel `to(...).send(...)` into the synthetic `unified` channel instead of the
+ * Slack send: the effective token becomes `unified:<raw>`, shared with every surface in the
+ * domain — ONE context window. The unified channel's `receive` registers the wakeId→origin map
+ * entry (durably, BEFORE the send) and re-checks the gates fail-closed. This wrapper lives HERE
+ * because only the route handler holds `args.to` (and slack-events.ts must not import
+ * unified.ts — unified.ts imports it). A window-less wake passes through untouched, so flag-off
+ * is byte-identical. A diversion failure PROPAGATES to the FIFO's loud catch (fail-closed: a
+ * wake whose reply map couldn't be written is not delivered into the shared window).
+ *
+ * THREAD-OWNERSHIP ingress routing (§S2): the divert goes through the INBOUND variant
+ * (unified.ts divertInboundToUnifiedWindow), which — only under delegation.oneshotAgent — consults the
+ * durable ownership index and dispatches a wake landing in an OWNED thread to the owning task/
+ * thread-seat session's token instead of the standing seat's. Flag-off, and on every unowned
+ * thread, the inbound variant is a byte-identical passthrough to divertToUnifiedWindow.
+ *
+ * OPE-971: the `!input.window` (NATIVE, flag-off) branch below is Slack's own un-windowed
+ * supervisor session — the send this domain takes when it never opted into windowing at all. That
+ * send was completely unwrapped: a pruned-deployment strand there stranded the seat silently,
+ * forever (see channels/stranded-seat.ts). `deps.wake`'s own registryKey for this branch IS
+ * `surfaceKey` (supervisorGrainFor returns `{unified:false, registryKey:surfaceKey}` flag-off — the
+ * exact row `liveSupervisorDeps`'s `getOrCreateSession` already rotates), so the heal is told that
+ * key directly rather than trying to parse it back out of the per-channel token.
+ */
+export declare function withSingleWindowDiversion(deps: ReturnType<typeof liveSupervisorDeps>, to: RouteHandlerArgs["to"], surfaceKey: string): ReturnType<typeof liveSupervisorDeps>;
+/** Reset the cached DM-partner trust (tests only). */
+export declare function _resetDmTrustCache(): void;
+/**
+ * Does this `message` event DUPLICATE an `app_mention` Slack also fires, so the wake path must drop it?
+ *
+ * Slack sends TWO events for a new message that @mentions the bot: the `app_mention`, which the
+ * front's own `mention` branch owns, and a sibling carrying the same text — `message.channels` in a
+ * channel, `message.mpim` in a group DM. Acting on both is a double turn, so both the channel wake
+ * path and the group-DM leg drop the sibling through this one rule.
+ *
+ * 🔴 AN EDIT IS NEVER A SIBLING, AND SUPPRESSING ONE IS A LOST WAKE (OPE-1673). Slack delivers an
+ * edit ONLY as `message` with `subtype: "message_changed"`; no `app_mention` accompanies it, and
+ * `parseMessageEvent` reads the POST-EDIT text — so a person who edits a message in an engaged
+ * thread to add `<@bot>`, or who corrects the wording of a mention that is already there, matched
+ * this rule and was answered by nothing at all. There is no second event to prefer. The exemption is
+ * narrow by construction: an edit cannot reach the `app_mention` branch, because the front classifies
+ * the envelope on its event TYPE and a `message_changed` always arrives as a `message`.
+ *
+ * UNVERIFIED, and stated rather than assumed: Slack's docs do not say whether an edit that ADDS a
+ * mention also raises a fresh `app_mention`. If it does, the cost of this exemption is an occasional
+ * double turn — the same trade the next paragraph already takes, for the same reason.
+ *
+ * MATCH THE AUTHOR'S OWN TEXT, NEVER THE MERGED ONE (OPE-1374). `ev.text` carries forwarded and
+ * quoted content, so testing it would suppress a forward whose QUOTED message mentions the bot.
+ * UNVERIFIED for the same reason as above: whether Slack fires an `app_mention` for a mention that
+ * lives inside an attachment. If it does NOT — the shape we expect — testing the merged text loses
+ * the wake outright, because no sibling ever arrives to deliver it. If it DOES, the cost is a double
+ * turn. We take the double: an occasional double beats a drop, and a deaf agent on a forward is the
+ * failure OPE-1374 exists to prevent.
+ *
+ * Pure, so both the suppression and its exemption are unit-testable without Slack or a store. An
+ * unresolved bot user id suppresses nothing — there is no needle to match, and inventing one would
+ * drop every message.
+ */
+export declare function mentionSiblingSuppressed(input: {
+    readonly authoredText: string;
+    readonly subtype?: string;
+    readonly botUserId?: string;
+}): boolean;
+export declare function buildFrontHandler(innerHandler: RouteHandler, opts?: FrontOptions): RouteHandler;
+/**
+ * Compose the engagement front route with a wrapped `slackChannel`. `inner` must have been
+ * built with `route: INTERNAL_SLACK_ROUTE`. Returns the SAME channel value (preserving Eve's
+ * internal `__kind`/adapter/receive) with the public front route prepended — so Slack's URL
+ * hits us, and both routes share one channel name → one session namespace.
+ */
+export declare function frontSlackChannel<C extends Channel<any, any, any>>(inner: C, opts?: FrontOptions): C;
+//# sourceMappingURL=slack-front.d.ts.map

package/dist/agent/channels/slack-front.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-front.d.ts","sourceRoot":"","sources":["../../../agent/channels/slack-front.ts"],"names":[],"mappings":"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"}