@open-everywhere/provider-slack 0.1.0

package/dist/agent/channels/slack-read.js

@@ -0,0 +1,205 @@
+// Component 3 of the Slack engagement model (slack-engagement-spec.md): domain-scoped
+// channel reads. "If a domain has 3 channels, the agent knows all 3 and can read them —
+// and NOTHING else." The Slack bot token is workspace-wide (it can read any channel the
+// bot is in), so the boundary is OURS to enforce at the tool layer — the same shape as the
+// connector hard-gate (access/connector-scope.ts): broad credential underneath, narrow
+// allowlist on top, FAIL CLOSED. The domain's channel list IS the allowlist.
+//
+// This module is the shared spine for the Slack read path (channels/channel-read.ts's SLACK
+// adapter, behind the generic read verbs): resolve the allowed channel ids for the session, assert a
+// requested channel is in them (or throw), and make the actual Slack Web API call. The call
+// goes through OE's `callSlackWebApi` (channels/slack-web-api.ts) — the ONE Slack Web API seam,
+// which carries the 429/`Retry-After` backoff — form-encoded with the same `SLACK_BOT_TOKEN` env
+// fallback the Slack channel itself uses.
+import { callSlackWebApi } from "./slack-web-api.js";
+import { auditChannelReadRefusal, bindFrom, getConfig, domainForChannel, resolvePartition, refutedReadAuthorIds, ChannelScopeError, markNotApplied, domainRoster, } from "@open-everywhere/core/agent/adapter-api.js";
+// The SAME per-author membership probe the wake leg uses (OPE-474) — see the adapter's own note on
+// why this is reused rather than re-derived. The direction is safe: slack-events.ts does not import
+// this module, so nothing here closes a cycle.
+import { slackAuthorIsMember } from "./slack-events.js";
+// ChannelScopeError now LIVES in core (channels/channel-read.ts) — it predates the generic read
+// verbs and the platform-parameterised assertSurfaceAllowed throws the same class, so the ONE
+// class identity must sit on the core side of the boundary. Re-exported here so the bundle's own
+// callers/tests keep their import site.
+export { ChannelScopeError };
+// A fully-qualified surface key is `platform/workspace/surface`; for Slack the surface
+// segment IS the channel id. Returns null for non-Slack keys (defensive — domains can span
+// platforms in principle, and we only gate Slack here).
+function channelIdFromKey(key) {
+    const parts = key.split("/");
+    if (parts.length !== 3 || parts[0] !== "slack")
+        return null;
+    return parts[2] || null;
+}
+/**
+ * The Slack channel ids this session may read: every Slack channel in its explicit domain,
+ * PLUS its own current channel (always readable — it's where the agent was engaged). A DM,
+ * an unassigned channel, or a criteria pseudo-domain (org/public/dm — no channel list)
+ * yields just the current channel. Empty only when the surface isn't a Slack channel.
+ */
+export function allowedChannelIds(ctx) {
+    const p = resolvePartition(ctx);
+    const ids = new Set();
+    const own = channelIdFromKey(p.surfaceKey);
+    if (own)
+        ids.add(own); // the agent can always read its own channel
+    const domain = domainForChannel(p.surfaceKey, getConfig().loadDomains());
+    if (domain) {
+        for (const key of domainRoster(domain)) {
+            const id = channelIdFromKey(key);
+            if (id)
+                ids.add(id);
+        }
+    }
+    return { ids, domain: domain?.name };
+}
+/**
+ * Assert a requested channel id is readable by this session — else AUDIT the refusal and throw
+ * (fail closed). The error names the domain so the model gets an actionable message, not a bare
+ * denial. The decision is unchanged from the silent version; only the row is new
+ * (core channels/read-scope-audit.ts).
+ */
+export async function assertChannelAllowed(ctx, channelId, deps) {
+    const { ids, domain } = allowedChannelIds(ctx);
+    if (ids.has(channelId))
+        return;
+    const p = resolvePartition(ctx);
+    await auditChannelReadRefusal(ctx, { platform: "slack", surfaceId: channelId, callerKey: p.surfaceKey, callerDomain: domain, domains: getConfig().loadDomains() }, deps);
+    const scope = domain ? `domain "${domain}"` : "this channel's (no multi-channel domain)";
+    throw new ChannelScopeError(`channel "${channelId}" is not in ${scope} read scope. The agent may only read channels in its ` +
+        `memory domain (memory/config/domains.ts). Add the channel to the domain's \`channels\` to grant it.`);
+}
+/**
+ * Low-level POST to a (read-only) Slack Web API method with the bot token, via OE's
+ * `callSlackWebApi` (form-encoded — Slack's JSON support is partial: `conversations.replies`/
+ * `history` want form). Throws on a missing token or a non-ok Slack response so the tool
+ * surfaces a real error. The explicit env pre-check keeps the actionable "not set" message
+ * (the seam itself throws a terser "SLACK_BOT_TOKEN is required.").
+ */
+export async function callSlackRead(operation, params) {
+    if (!process.env.SLACK_BOT_TOKEN) {
+        throw new Error("SLACK_BOT_TOKEN is not set — the Slack read tools need the bot token to call the Web API.");
+    }
+    // botToken omitted → the seam resolves it from SLACK_BOT_TOKEN (same fallback as before).
+    const json = (await callSlackWebApi({ botToken: undefined, operation, body: params }));
+    // DEFINITIVE (OPE-821): Slack answers HTTP 200 with `ok:false` when it READ the request and
+    // refused it, so the call had no effect. `react` is the caller that acts on this — a refused
+    // `reactions.add` proves no reaction landed. A throw from the seam (transport, or a non-2xx)
+    // never reaches this line and stays AMBIGUOUS, which is the honest answer for a call that got no
+    // reply. Marking it here rather than in `react` keeps ONE statement of what Slack's `ok:false`
+    // means, for every method that goes through this transport.
+    if (!json.ok)
+        throw markNotApplied(new Error(`Slack ${operation} failed: ${json.error ?? "unknown error"}`));
+    return json;
+}
+/**
+ * Normalize a raw Slack messages array (history/replies) to rendered lines, oldest-first.
+ *
+ * `author` IS UNCHANGED and stays the display string the model reads (`user`, else `bot_id`, else
+ * `(unknown)`) — every render golden depends on it. OPE-474 adds the two GRADING fields beside it
+ * rather than reinterpreting it: `author` is chosen for legibility and cannot be parsed back into an
+ * identity, which is exactly why the read leg had nothing to probe before.
+ *
+ * `bot_id` WINS over `user` for the machine classification, even on the messages that carry both (an
+ * app posting as a bot user). That direction is fail-OPEN — a machine is dropped from the probe and
+ * marks nothing — which is the posture the whole author leg takes.
+ */
+export function renderMessages(raw, opts = {}) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const m of raw) {
+        if (typeof m.subtype === "string" && m.subtype.length > 0)
+            continue; // skip joins/edits/system
+        const text = typeof m.text === "string" ? m.text : "";
+        if (!text)
+            continue;
+        const user = typeof m.user === "string" && m.user.length > 0 ? m.user : undefined;
+        const botId = typeof m.bot_id === "string" && m.bot_id.length > 0 ? m.bot_id : undefined;
+        out.push({
+            author: m.user ?? m.bot_id ?? "(unknown)",
+            ts: m.ts ?? "",
+            text,
+            ...(botId !== undefined ? { bot: true } : user !== undefined ? { authorId: user } : {}),
+        });
+    }
+    // conversations.history returns newest-first; replies returns oldest-first.
+    if (opts.oldestFirst === false)
+        out.reverse();
+    return out;
+}
+// --- the SLACK read adapter (moved from core channels/channel-read.ts in OPE-114 stage 4) ---
+// Registered by registerSlackProvider() via registerReadAdapter — the generic read verbs
+// (read_channel / read_thread) resolve it by platform string; behaviour is byte-identical to the
+// in-core adapter (the EXACT calls the retired per-surface Slack read tools made).
+const SLACK_CHANNEL_DEFAULT_LIMIT = 50;
+const SLACK_THREAD_DEFAULT_LIMIT = 100;
+// --- the OPE-474 non-member author leg ---------------------------------------------------------
+//
+// Slack is the one chat surface that can refute an author BY ITSELF: `users.info` reports
+// `is_restricted` / `is_ultra_restricted` / `is_stranger`, which slack-events.ts's
+// {@link slackAuthorIsMember} already folds into one TTL-cached boolean for the wake leg. The read
+// leg reuses THAT probe verbatim — a second implementation of "is this person a member?" is how a
+// wake and a read come to disagree about the same author.
+//
+// 🔴 THE COST IS BOUNDED BY PEOPLE, NOT BY MESSAGES (Tommy, 2026-08-14: no up-front member list).
+// `refutedReadAuthorIds` probes the page's DISTINCT authors, and the probe is TTL-cached across
+// calls, so a 200-message read of a busy channel is a handful of authors and mostly cache hits. An
+// up-front roster would instead size with the WORKSPACE and go stale between reads.
+//
+// THE THREE-WAY VERDICT IS KEPT THREE-WAY. `slackAuthorIsMember` answers `true` (member), `false`
+// (positively refuted) or `undefined` (lookup unavailable), and only `false` refutes. Collapsing
+// `undefined` into a refusal would mark every read on a deployment whose bot token cannot call
+// `users.info` — an always-on bit, arriving through this door.
+/** The Slack team id + the register's arming key for this session's own workspace. Both come from
+ *  the BINDING, never from inspecting an author id: the platform and the tenant are surface facts. */
+function slackReadTenant(ctx) {
+    const p = resolvePartition(ctx);
+    return { teamId: p.workspace, tenantKey: p.workspaceKey };
+}
+/** Slack read via OE's callSlackWebApi — domain-allowlist-gated, rendered oldest-first. */
+export const slackReadAdapter = {
+    platform: "slack",
+    /**
+     * OPE-929 — Slack's own spelling of "which room and which thread is this turn in".
+     *
+     * The CONTAINER is the channel the post-back target names. The THREAD ROOT is `threadTs`, which
+     * eve's Slack adapter falls back to the triggering message's own ts — so a bare channel mention
+     * carries one too, and reading "this thread" on such a turn reads the one-message thread the
+     * mention started, which is what a person means by it.
+     */
+    wakeAddress(ctx) {
+        const b = bindFrom(ctx);
+        const container = typeof b.target?.["channelId"] === "string" ? b.target["channelId"] : undefined;
+        if (!container)
+            return undefined;
+        return { container, ...(b.threadTs ? { threadRoot: b.threadTs } : {}) };
+    },
+    async readChannel(ctx, channel, limit, call = callSlackRead) {
+        await assertChannelAllowed(ctx, channel);
+        const res = await call("conversations.history", { channel, limit: limit ?? SLACK_CHANNEL_DEFAULT_LIMIT, inclusive: true });
+        return renderMessages(res.messages, { oldestFirst: false });
+    },
+    async readThread(ctx, channel, threadTs, limit, call = callSlackRead) {
+        await assertChannelAllowed(ctx, channel);
+        const res = await call("conversations.replies", { channel, ts: threadTs, limit: limit ?? SLACK_THREAD_DEFAULT_LIMIT });
+        return renderMessages(res.messages, { oldestFirst: true });
+    },
+    /** OPE-474 / OPE-534. Both legs run: Slack's own `users.info` refutation, and the operator's
+     *  author-trust register (which most Slack deployments leave unarmed, so it costs nothing there).
+     *  It answers with the refuted AUTHOR IDS, because core reads the one answer twice — the turn mark
+     *  and the `withhold` body replacement. `probe` is injected ONLY so a test can drive the grading
+     *  without a live Slack — every live call defaults. */
+    async refutedAuthorIds(ctx, lines, probe = slackAuthorIsMember) {
+        const { teamId, tenantKey } = slackReadTenant(ctx);
+        return await refutedReadAuthorIds(lines, tenantKey, {
+            surfaceRefuted: async (authorId) => {
+                const member = await probe(authorId, teamId);
+                return member === undefined ? undefined : !member; // undefined stays "cannot check"
+            },
+            // No `memberships` leg: Slack has no group-rung key a message carries, so an armed register
+            // matches this surface on principal keys alone (`slack/<team>/<user>`).
+        });
+    },
+};
+//# sourceMappingURL=slack-read.js.map

package/dist/agent/channels/slack-read.js.map

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

package/dist/agent/channels/slack-route-hold.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Run `fn` as ONE delivery, so the writes below it can be tracked.
+ *
+ * ONE caller: `slack-front.ts`'s public route handler, wrapping its whole body. Do not wrap anything
+ * else; the value means "the delivery in flight right now", and a second writer would make that
+ * false.
+ */
+export declare function withSlackRouteHold<T>(fn: () => T): T;
+/**
+ * Track a best-effort write on the delivery in flight, and hand it back so a caller that can also
+ * await it may.
+ *
+ * `work` MUST already swallow its own failures — every caller here is an audit write whose contract
+ * is "never throws, never changes the decision". Nothing is caught for it: swallowing a rejection
+ * here would let a genuinely broken writer look held.
+ *
+ * Outside a delivery (a unit test calling a door directly, a future non-route caller) there is
+ * nothing to track and the work comes straight back — so `await holdRouteWork(...)` is correct in
+ * both worlds and a caller never has to ask which one it is in.
+ */
+export declare function holdRouteWork<T>(work: Promise<T>): Promise<T>;
+/**
+ * The promise to hand the platform in place of `work`: it settles when `work` has settled AND every
+ * write {@link holdRouteWork} tracked has settled too.
+ *
+ * 🔴 CALL IT SYNCHRONOUSLY, INSIDE THE DELIVERY — it reads the delivery's tracked set at call time
+ * and closes over it, so a call from outside one silently degrades to "just `work`". `slack-front.ts`
+ * calls it from the `waitUntil` it hands down, which is exactly that position.
+ *
+ * It never rejects: a rejected `work` is the caller's own business (eve already logs its background
+ * task failures), and a hold that rejected would turn an observability write into a route error.
+ */
+export declare function routeHoldQuiesced(work: Promise<unknown>): Promise<void>;
+//# sourceMappingURL=slack-route-hold.d.ts.map

package/dist/agent/channels/slack-route-hold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-route-hold.d.ts","sourceRoot":"","sources":["../../../agent/channels/slack-route-hold.ts"],"names":[],"mappings":"AAwDA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEpD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAG7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAWvE"}

package/dist/agent/channels/slack-route-hold.js

@@ -0,0 +1,97 @@
+// THE ROUTE HOLD (OPE-1648) — "keep this best-effort write alive until it lands".
+//
+// WHAT IT CLOSES. Every Slack door answers its 200 IMMEDIATELY: Slack retries a delivery it does
+// not see acked inside three seconds, and eve's own dispatcher returns the response and then
+// finishes the turn in the route's `waitUntil`. On Vercel the serverless invocation can freeze the
+// moment nothing is holding it, so a `void`-ed audit write races that freeze and the row never
+// lands. Those rows are not decoration: `slack.ts`'s `auditWakeDropped` header states that the
+// webhook function's console output never reaches `vercel logs`, so the row is the ONLY durable
+// signal that a wake was refused.
+//
+// 🔴 A LATE `waitUntil` CALL IS NOT A HOLD, WHICH IS WHY THIS FILE EXISTS AT ALL. eve collects the
+// route's background tasks in an array and, the moment the handler resolves, hands the platform
+// `Promise.allSettled(tasks)` (`internal/nitro/routes/channel-dispatch.js`, `flushBackgroundTasks`).
+// `allSettled` reads that array ONCE, synchronously — so a promise pushed after the handler returned
+// is in a list nobody is awaiting, and calling `waitUntil` from a wake route that runs after the 200
+// buys exactly nothing. Almost every write this module holds is in that position.
+//
+// SO THE HOLD RIDES THE WORK THE ROUTE ALREADY REGISTERED. Every one of these writes happens inside
+// a promise the front route handed to `waitUntil` while it was still running — eve's own turn
+// dispatch on the native forward, a FIFO wake, a name-drop. `slack-front.ts` wraps each of those in
+// {@link routeHoldQuiesced} before passing it on, so the promise the platform waits on settles only
+// after the delivery's tracked writes have. Nothing extra is registered: a delivery that queues no
+// background work (a 401, a dropped sibling event) hands the platform nothing, exactly as before.
+//
+// WHY AsyncLocalStorage AND NOT A PARAMETER. The writers do not hold the route args: the mention
+// door's row is written inside eve's `onAppMention` hook, several frames below a hand-off that
+// discards them, and the engagement doors' rows are written from route functions that take deps.
+// Threading a serverless-runtime concern through every wake route's signature to reach them would
+// put it in the type of each one. The front route stows it once instead, for the extent of ONE
+// delivery. One process serves many Slack deliveries at once, and a module global would mix
+// delivery A's writes into delivery B's hold. Same primitive and same reasoning as
+// slack-identity.ts's forwarded-envelope carrier, which is proven to survive the hand-off into eve's
+// handler (slack-enterprise-rung-test.ts §2).
+//
+// 🔴 IT NEVER CHANGES A DECISION, AND IT NEVER THROWS. A hold is observability plumbing: every
+// tracked write already swallows its own failures, and the quiesced promise settles rather than
+// rejects, so a broken sink can never turn a drop into a turn.
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * How many drain rounds one quiesce gets. Each round awaits everything registered so far, so a round
+ * only follows work that another round's work started. Ten is far past any real chain (a wake queues
+ * one audit write, which queues nothing) and it bounds a writer that re-registers itself forever —
+ * which would otherwise hold the invocation open until the platform killed it.
+ */
+const MAX_DRAIN_ROUNDS = 10;
+const routeHold = new AsyncLocalStorage();
+/**
+ * Run `fn` as ONE delivery, so the writes below it can be tracked.
+ *
+ * ONE caller: `slack-front.ts`'s public route handler, wrapping its whole body. Do not wrap anything
+ * else; the value means "the delivery in flight right now", and a second writer would make that
+ * false.
+ */
+export function withSlackRouteHold(fn) {
+    return routeHold.run({ pending: [] }, fn);
+}
+/**
+ * Track a best-effort write on the delivery in flight, and hand it back so a caller that can also
+ * await it may.
+ *
+ * `work` MUST already swallow its own failures — every caller here is an audit write whose contract
+ * is "never throws, never changes the decision". Nothing is caught for it: swallowing a rejection
+ * here would let a genuinely broken writer look held.
+ *
+ * Outside a delivery (a unit test calling a door directly, a future non-route caller) there is
+ * nothing to track and the work comes straight back — so `await holdRouteWork(...)` is correct in
+ * both worlds and a caller never has to ask which one it is in.
+ */
+export function holdRouteWork(work) {
+    routeHold.getStore()?.pending.push(work);
+    return work;
+}
+/**
+ * The promise to hand the platform in place of `work`: it settles when `work` has settled AND every
+ * write {@link holdRouteWork} tracked has settled too.
+ *
+ * 🔴 CALL IT SYNCHRONOUSLY, INSIDE THE DELIVERY — it reads the delivery's tracked set at call time
+ * and closes over it, so a call from outside one silently degrades to "just `work`". `slack-front.ts`
+ * calls it from the `waitUntil` it hands down, which is exactly that position.
+ *
+ * It never rejects: a rejected `work` is the caller's own business (eve already logs its background
+ * task failures), and a hold that rejected would turn an observability write into a route error.
+ */
+export function routeHoldQuiesced(work) {
+    const hold = routeHold.getStore();
+    return (async () => {
+        await Promise.allSettled([work]);
+        if (!hold)
+            return;
+        for (let round = 0; round < MAX_DRAIN_ROUNDS && hold.pending.length > 0; round++) {
+            const batch = hold.pending;
+            hold.pending = [];
+            await Promise.allSettled(batch);
+        }
+    })();
+}
+//# sourceMappingURL=slack-route-hold.js.map

package/dist/agent/channels/slack-route-hold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-route-hold.js","sourceRoot":"","sources":["../../../agent/channels/slack-route-hold.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,EAAE;AACF,iGAAiG;AACjG,6FAA6F;AAC7F,mGAAmG;AACnG,+FAA+F;AAC/F,+FAA+F;AAC/F,gGAAgG;AAChG,kCAAkC;AAClC,EAAE;AACF,mGAAmG;AACnG,gGAAgG;AAChG,qGAAqG;AACrG,qGAAqG;AACrG,qGAAqG;AACrG,kFAAkF;AAClF,EAAE;AACF,oGAAoG;AACpG,8FAA8F;AAC9F,oGAAoG;AACpG,oGAAoG;AACpG,mGAAmG;AACnG,kGAAkG;AAClG,EAAE;AACF,iGAAiG;AACjG,+FAA+F;AAC/F,iGAAiG;AACjG,kGAAkG;AAClG,+FAA+F;AAC/F,4FAA4F;AAC5F,mFAAmF;AACnF,qGAAqG;AACrG,8CAA8C;AAC9C,EAAE;AACF,+FAA+F;AAC/F,gGAAgG;AAChG,+DAA+D;AAE/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAQrD;;;;;GAKG;AACH,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAE5B,MAAM,SAAS,GAAG,IAAI,iBAAiB,EAAa,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAI,EAAW;IAC/C,OAAO,SAAS,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAI,IAAgB;IAC/C,SAAS,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAsB;IACtD,MAAM,IAAI,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;IAClC,OAAO,CAAC,KAAK,IAAI,EAAE;QACjB,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACjC,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,gBAAgB,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;YACjF,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;YAClB,MAAM,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;AACP,CAAC"}

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

@@ -0,0 +1,162 @@
+import { type WakeAttachment } from "@open-everywhere/core/agent/adapter-api.js";
+import { type ParsedMessageEvent } from "./slack-events.js";
+/**
+ * A decoded Slack shortcut invocation, narrowed to the fields a wake needs.
+ *
+ * The two shortcut families share every field but the target: a `message` shortcut carries the
+ * channel it was invoked in and the message it was invoked on; a `global` shortcut carries
+ * neither, because Slack fires it from the composer with no conversation in scope.
+ *
+ * Field-compatible with eve's own `SlackShortcut` union (`eve/channels/slack`), which is the
+ * public contract for the same two payloads. We parse the raw payload ourselves because eve's
+ * `parseShortcutPayload` is internal to its interactivity handler and is not exported.
+ */
+export interface ParsedSlackShortcut {
+    /** `message` for a `message_action` payload, `global` for a `shortcut` payload. */
+    readonly kind: "message" | "global";
+    /** The shortcut's registered callback id — the operator-chosen name of this trigger. */
+    readonly callbackId: string;
+    /** Slack's per-invocation trigger id — unique per click. Used as the wake's idempotency key on
+     *  the ASSUMPTION that a Slack redelivery of one click carries the same trigger id. UNMEASURED:
+     *  Slack documents stable-`event_id` retry semantics for the Events API, not for interactivity
+     *  payloads. If the assumption is wrong the cost is a double wake, which is the same fail-open
+     *  posture the rest of the dedupe layer already takes. See {@link shortcutWakeKey}. */
+    readonly triggerId: string;
+    /** The Slack user who invoked the shortcut. The wake's principal. */
+    readonly userId: string;
+    readonly teamId?: string;
+    /**
+     * The Enterprise Grid organisation the invocation's workspace sits in (`E…`), when the payload
+     * named one (OPE-1559). A shortcut never arrives as an event envelope, so there is no
+     * `enterprise_id` envelope field to read; the interactivity route names the Grid on the payload
+     * itself, in THREE spellings, and all three are read ({@link parseSlackShortcutPayload}).
+     *
+     * 🔴 IT IS THE ROOM'S GRID, NEVER THE INVOKER'S. Both spellings sit on the payload's own
+     * `enterprise` / `team` object, which describes WHERE the invocation happened. The invoker's
+     * `user.enterprise_user.enterprise_id` describes where THEY belong, and reading it would let a
+     * Slack Connect stranger's own Grid declaration vouch our room. So the author leg keeps its own
+     * source (`users.info`, slack-identity.ts) and this one never touches it.
+     */
+    readonly enterpriseId?: string;
+    /** Present on a `message` shortcut only — the conversation the message lives in. */
+    readonly channelId?: string;
+    /** Present on a `message` shortcut only. */
+    readonly message?: {
+        /** The target message's text, verbatim. UNTRUSTED — it is somebody's Slack message. */
+        readonly text: string;
+        readonly ts: string;
+        /** The thread the target message sits in, when it sits in one. */
+        readonly threadTs?: string;
+        /** The target message's AUTHOR — never the wake's principal (see the file header). */
+        readonly userId?: string;
+        /** Image/file REFERENCES off the target message's `files[]`, parsed by the SAME
+         *  {@link parseSlackFiles} the Events API path uses. A shortcut on a message carrying a
+         *  screenshot must surface that screenshot, exactly as reading the message in the channel
+         *  would — otherwise the same message means less through this door than through that one.
+         *  A REFERENCE ONLY: it reaches a wake, and the bot token, solely through
+         *  {@link shortcutMessageEvent}'s `admitAttachments` gate. */
+        readonly attachments?: readonly WakeAttachment[];
+    };
+}
+/**
+ * Decode an already-JSON-parsed interactivity payload into a {@link ParsedSlackShortcut}, or
+ * `null` for anything that is not a shortcut. TOTAL AND PURE: it never throws and it writes
+ * nothing.
+ *
+ * 🔴 PURITY IS A SECURITY PROPERTY HERE, NOT A STYLE CHOICE (OPE-1442). This runs inside
+ * `classifyEnvelope`, which decides what a request IS — long before the dedupe, the readability
+ * gate and the ambient-off drop decide whether it wakes anything. An earlier revision registered
+ * the target message's attachments right here, so every click seeded the process-global registry
+ * (a 1000-entry LRU) even when the shortcut went on to wake NOTHING: repeated clicks on a domain
+ * with the unified window off evicted the records real uploads depend on, and `describe_image`
+ * then failed closed on a genuine image. The registry is now seeded by the front door's shortcut
+ * branch, after the gates it must sit behind.
+ *
+ * A payload is REFUSED (null) when it cannot produce a wake:
+ *   • the outer `type` is neither `message_action` nor `shortcut`;
+ *   • `callback_id`, `trigger_id` or `user.id` is missing — the first two are the trigger's name
+ *     and its idempotency key, and the third is the principal, so a wake without any of them
+ *     would have to be invented rather than derived;
+ *   • a `message_action` that carries no `channel.id` or no `message.ts` — a message shortcut
+ *     whose target cannot be addressed is not a message shortcut.
+ * Refusing is FAIL-CLOSED: the front route acks Slack and wakes nothing.
+ *
+ * `message.text` is allowed to be EMPTY and still parses. Slack sends an empty `text` for a message
+ * whose content lives entirely in blocks or files, and dropping a click a person made is the worse
+ * answer. The wake then renders an empty body — it says nothing ABOUT the emptiness. Files on that
+ * message ride through as attachments only where the front door admits them
+ * ({@link shortcutMessageEvent}'s `admitAttachments`), so a shortcut on a screenshot in a room the
+ * app cannot read wakes with an empty body and no file.
+ */
+export declare function parseSlackShortcutPayload(raw: unknown): ParsedSlackShortcut | null;
+/**
+ * The idempotency key for one shortcut invocation.
+ *
+ * Keyed on `trigger_id`, NOT on the target message. What that buys is certain: a person stays free
+ * to invoke the same shortcut on the same message twice on purpose, which keying on `channel:ts`
+ * (the shape an Events API wake falls back to) would have swallowed for ten minutes.
+ *
+ * What it de-dupes rests on an UNMEASURED assumption — that a Slack redelivery of one click carries
+ * the same trigger id (see {@link ParsedSlackShortcut.triggerId}). Wrong ⇒ a double wake, never a
+ * missed one, which is the direction the whole dedupe layer already fails in.
+ *
+ * It carries no bot-identity prefix, unlike `slack-front.ts`'s `wakeKey`. A trigger id is minted by
+ * Slack per app, so two apps in one workspace cannot collide on one; the `oe-shortcut:` prefix
+ * keeps it out of the Events API key space.
+ */
+export declare function shortcutWakeKey(sc: ParsedSlackShortcut): string;
+/**
+ * The body a GLOBAL shortcut wakes with. It has no message, so the trigger's own name is the whole
+ * content — which is the honest thing to hand the model: somebody pressed a named button.
+ *
+ * The callback id is operator-authored configuration, not somebody's Slack message, so it is NOT
+ * fenced as untrusted content — the same reasoning that leaves a slash-command name unfenced.
+ */
+export declare function globalShortcutText(sc: ParsedSlackShortcut): string;
+/**
+ * Map a shortcut onto the shared {@link ParsedMessageEvent} shape, so the front door's existing
+ * wake spine (partition → seat → window → dedupe → gates → divert) runs over it unchanged.
+ *
+ * 🔴 `userId` IS THE INVOKER on both kinds. See the file header: the target message's author never
+ * becomes the wake's principal.
+ *
+ * THE TWO TEXT FIELDS CARRY THE MESSAGE-SHORTCUT SPLIT EXACTLY AS THEY ALREADY MEAN IT. A message
+ * shortcut is a FORWARD with no covering note — the invoker typed nothing and pointed at somebody
+ * else's message — and {@link ParsedMessageEvent} already draws that line: `text` is "own text
+ * plus any quoted message", `authoredText` is "the author's OWN typed text". So `text` carries the
+ * target message and `authoredText` is empty. Any rule that asks "what did this person SAY?" then
+ * correctly answers "nothing", which is true, and the model still receives the message as the
+ * wake's content.
+ *
+ * `ts` differs by kind, and deliberately:
+ *   • a MESSAGE shortcut takes the target message's real ts, so the reply anchors under the
+ *     message the shortcut was invoked on (`routeSupervisorEvent` reads `threadTs ?? ts`);
+ *   • a GLOBAL shortcut has no message, so it MINTS one from `nowMs` in Slack's own
+ *     `seconds.microseconds` shape. 🔴 It must be ts-SHAPED, not merely unique: the envelope
+ *     renders `sent-at` by running `Number.parseFloat` over this field (`slackTsToIso`), so a
+ *     non-numeric id silently becomes a nonsense date — the trigger id `13345224609.7384…` parses
+ *     to the year 2392. Minting from the clock makes `sent-at` the truth: the moment the person
+ *     pressed the button. Uniqueness is not this field's job — the wake's idempotency key is
+ *     {@link shortcutWakeKey}, which does key on the trigger id.
+ *
+ * `isAppMention` is false on both. It reports whether the TEXT contains `<@bot>`, and neither body
+ * does; the "was the agent addressed?" question is answered by the caller passing `directMention`,
+ * which is the same seam the single-window mention divert uses.
+ *
+ * 🔴 `admitAttachments` GATES THE TARGET MESSAGE'S FILES, AND IT DEFAULTS TO FALSE (OPE-1442).
+ * Slack delivers a `message_action` for a room the app is not in, and the payload carries that
+ * message's `files[].url_private` — bytes the app's own channel reads refuse. So the files ride
+ * through only when the caller has POSITIVELY established that the app can read the room
+ * (`slackChannelFactsFor`'s `appCanRead`). The default is closed because the cost of the two
+ * mistakes is not symmetric: a withheld file is a wake that says less, an admitted one is the bot
+ * token downloading somebody's private upload from a room the agent cannot open.
+ *
+ * WITHHOLDING DROPS THE REFERENCE TOO, rather than passing an id that resolves to nothing. The
+ * envelope renders an attachment as an id and `describe_image` fails closed on an id the registry
+ * never saw, so an advertised-but-unresolvable file tells the model an image exists and then
+ * cannot show it — worse than not mentioning it.
+ */
+export declare function shortcutMessageEvent(sc: ParsedSlackShortcut, channelId: string, channelType?: string, nowMs?: number, opts?: {
+    readonly admitAttachments?: boolean;
+}): ParsedMessageEvent;
+//# sourceMappingURL=slack-shortcut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slack-shortcut.d.ts","sourceRoot":"","sources":["../../../agent/channels/slack-shortcut.ts"],"names":[],"mappings":"AA6BA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG7E;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IACpC,wFAAwF;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;2FAIuF;IACvF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,oFAAoF;IACpF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE;QACjB,uFAAuF;QACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,kEAAkE;QAClE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,sFAAsF;QACtF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB;;;;;sEAK8D;QAC9D,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;KAClD,CAAC;CACH;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CA6ClF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,mBAAmB,GAAG,MAAM,CAE/D;AAsCD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,mBAAmB,GAAG,MAAM,CAElE;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,mBAAmB,EACvB,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,EACpB,KAAK,GAAE,MAAmB,EAC1B,IAAI,GAAE;IAAE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GACjD,kBAAkB,CAuBpB"}