@open-everywhere/provider-discord 0.1.0

package/dist/agent/channels/discord-approval-card.d.ts

@@ -0,0 +1,81 @@
+import { type ApprovalCardRespondFn } from "@open-everywhere/core/agent/adapter-api.js";
+import { type InteractionFollowUp } from "./discord-interaction-defer.js";
+/** The `input_response.routed` sibling for a tap — the SAME two action strings the Slack leg writes,
+ *  so "how often is a bridged approval settled by a button" is one query across surfaces rather than
+ *  one per surface. RE-EXPORTED FROM CORE since OPE-1856: two files spelling one action name is two
+ *  places it can drift, and the drift is silent. */
+export declare const APPROVAL_CARD_SETTLED_AUDIT_ACTION = "input_response.card_settled";
+export declare const APPROVAL_CARD_REFUSED_AUDIT_ACTION = "input_response.card_refused";
+/** The interaction response body this handler returns. Loosely typed, exactly as its three sibling
+ *  handlers type theirs, so the front route holds ONE seam type across all four. */
+export type DiscordApprovalCardResponse = Record<string, unknown>;
+/** The settle delivery this leg needs. CORE-OWNED and bound by the front route through
+ *  `approvalCardRespondVia(args.attachSession)` — re-exported here, never re-spelled, so the address
+ *  the answer takes cannot drift per surface (OPE-1863). */
+export type ApprovalRespondFn = ApprovalCardRespondFn;
+/** The host edges this door needs to defer. Both injected so a test drives the whole ack-then-edit
+ *  sequence with no Discord and no host. */
+export interface DiscordApprovalCardDeps {
+    /** The route's own `waitUntil`. ABSENT ⇒ no defer (see the header). */
+    readonly waitUntil?: (p: Promise<unknown>) => void;
+    /** The follow-up edit. Live default is {@link editOriginalInteractionResponse}. */
+    readonly edit?: (followUp: InteractionFollowUp, content: string) => Promise<boolean>;
+}
+/** What one verified tap did, for the front route's log line and for the test to assert on. */
+export interface ApprovalCardClickOutcome {
+    readonly handled: boolean;
+    readonly reason: string;
+    /** A line to show the tapper alone, or undefined when the outcome needs no note. */
+    readonly notice?: string;
+}
+/** The interaction fields this leg reads, narrowed so nothing here needs Discord's own types. */
+interface ParsedApprovalClick {
+    readonly actionId: string;
+    readonly channelId: string;
+    readonly userId: string;
+    readonly guildId?: string;
+    /**
+     * LEG B — Discord's own analogue of a guest: a guild member who has NOT cleared membership
+     * screening (`member.pending`). The same bundle already reads it off an interaction payload for the
+     * inbound trust grain (`discord-identity.ts`), and it is a POSITIVE per-person verdict, which is
+     * exactly what `admitInputResponse`'s guest leg takes. Absent ⇒ the probe could not be run (a DM tap
+     * carries no member record), and the leg is then INERT: "we could not ask" never becomes a refusal.
+     */
+    readonly answererIsGuest?: boolean;
+}
+/**
+ * Read the `oe_input:` custom_id out of a VERIFIED MESSAGE_COMPONENT interaction. `undefined` when
+ * the payload is not one of ours or is missing a field the decision needs — the front route then
+ * forwards it rather than half-handling it.
+ *
+ * THE CLICKER AND THE CHANNEL COME FROM THE ENVELOPE, never from a payload field the card could
+ * carry: the front has already verified Discord's Ed25519 signature over the raw body, so these are
+ * Discord's own statements. Discord puts the clicker at `user` in a DM and at `member.user` in a
+ * guild; both are read, so a DM tap and a guild tap are equally attributable.
+ */
+export declare function parseDiscordApprovalClick(raw: unknown): ParsedApprovalClick | undefined;
+/**
+ * Settle one verified `oe_input:` tap: resolve it, admit it, deliver the answer to eve, consume the
+ * rows. NEVER THROWS.
+ *
+ * 🔴 CONSUME-ONCE, AND BOTH ROWS, and only after eve accepted the delivery. The ticket goes so a
+ * second tap cannot answer a request eve has already settled; the outstanding-question row goes so
+ * the room's NEXT message is an ordinary wake again rather than a second answer. A throw above skips
+ * both, which leaves the card tappable and the question answerable in words — the safe direction.
+ *
+ * THE LIMIT OF THAT, stated rather than implied and identical to the Slack leg's: the read and the
+ * delete are not one atomic step, so two deliveries arriving together each resolve against rows that
+ * are both still present. Both must be admitted and both must name an option the request offered, and
+ * eve's own resolution refuses the second delivery for a request it already settled — so one approval
+ * can READ as decided by two taps without being decided twice.
+ */
+export declare function settleDiscordApprovalCardClick(click: ParsedApprovalClick, respond: ApprovalRespondFn): Promise<ApprovalCardClickOutcome>;
+/**
+ * Handle one verified `oe_input:` component click.
+ *
+ * Returns the interaction response body to send, or `null` for anything that is NOT one of ours —
+ * the front route then forwards it, so a click is never silently swallowed. NEVER throws.
+ */
+export declare function handleDiscordApprovalCardInteraction(raw: unknown, respond: ApprovalRespondFn, deps?: DiscordApprovalCardDeps): Promise<DiscordApprovalCardResponse | null>;
+export {};
+//# sourceMappingURL=discord-approval-card.d.ts.map

package/dist/agent/channels/discord-approval-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-approval-card.d.ts","sourceRoot":"","sources":["../../../agent/channels/discord-approval-card.ts"],"names":[],"mappings":"AAyCA,OAAO,EAkBL,KAAK,qBAAqB,EAE3B,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAmF,KAAK,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAI3J;;;oDAGoD;AACpD,eAAO,MAAM,kCAAkC,gCAA0C,CAAC;AAC1F,eAAO,MAAM,kCAAkC,gCAA0C,CAAC;AAQ1F;oFACoF;AACpF,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAElE;;4DAE4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,CAAC;AAEtD;4CAC4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,uEAAuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;IACnD,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACtF;AAED,+FAA+F;AAC/F,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oFAAoF;IACpF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,iGAAiG;AACjG,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC;AAMD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,mBAAmB,GAAG,SAAS,CA2BvF;AA8BD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,8BAA8B,CAAC,KAAK,EAAE,mBAAmB,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAsG9I;AAkBD;;;;;GAKG;AACH,wBAAsB,oCAAoC,CACxD,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,iBAAiB,EAC1B,IAAI,GAAE,uBAA4B,GACjC,OAAO,CAAC,2BAA2B,GAAG,IAAI,CAAC,CAkC7C"}

package/dist/agent/channels/discord-approval-card.js

@@ -0,0 +1,303 @@
+// THE DISCORD RETURN LEG FOR A BRIDGED APPROVAL CARD (OPE-1720) — what makes the button the unified
+// post arm now renders actually settle the approval it names. The sibling of
+// providers/slack/agent/channels/slack-approval-card.ts, funnelling through the SAME core decision
+// (`resolveApprovalCardClick`) exactly as access/discord-grant-click.ts funnels through
+// `resolveGrantCardClick`. Core decides; this file reads Discord's envelope and writes Discord's
+// answer.
+//
+// WHY THIS EXISTS RATHER THAN EVE'S OWN HITL ROUTE — the Slack reasoning verbatim, and it is
+// structural rather than a not-yet. eve's Discord channel resolves its own `eve_input:` component
+// clicks against the DISCORD channel's state and session address. A DM seat's parked request lives on
+// the UNIFIED window — another channel, another session, another state bag — so a click on a card OE
+// posted there has nothing for eve's route to resolve. It is OE's card, so it is OE's click.
+//
+// 🔴 THE SAME ADMISSION, THOUGH, LEG B INCLUDED. `admitInputResponse` is the ONE decision both HITL
+// answer doors take, and `ingressSpendGate` with door `"answer"` is the same spend floor, consulted
+// FIRST for the same reason: a tap RESUMES a parked turn, which is a decision to spend more on a scope
+// nobody asked whether it could afford. Leg B — the positive per-answerer guest verdict Slack supplies
+// with `slackClickerIsGuest` — rides Discord's own envelope instead of a probe: `member.pending` is
+// this platform's analogue of an unverified account, and the same bundle already reads it for the
+// inbound trust grain. A DM tap carries no member record, so the leg is INERT there rather than a
+// refusal: "we could not ask" is never a no.
+//
+// 🔴 A REFUSAL LEAVES THE CARD LIVE. Nothing here consumes a row on any outcome but a delivered
+// answer: the approval stays parked, the card stays tappable for somebody who may answer it, and the
+// question stays answerable IN WORDS through the text leg (`question-bridge.ts`), which is untouched.
+//
+// 🔴 ACK, THEN SETTLE, THEN EDIT — and Discord is the surface where that ordering is forced (the
+// OPE-1282 finding this door inherits). A settle calls `respond` into eve, which resumes a parked
+// turn; Discord does NOT redeliver an interaction it has not seen answered, and an expired token
+// leaves the tapper on a red "This interaction failed" while the approval really did settle. So this
+// door answers with a DEFERRED EPHEMERAL ack (`type 5`), hands the settle to the route's `waitUntil`,
+// and edits that placeholder with the outcome. The ephemeral flag rides the ACK, because Discord
+// fixes a response's visibility at the first response.
+//
+// 🔴 NO `waitUntil` ⇒ NO DEFER. Without somewhere to run the work a deferred ack would leave the
+// tapper on a permanent "thinking…", which is strictly worse than a slow answer. The handler awaits
+// and answers `type 4` instead, and says so in the log.
+//
+// NEVER THROWS. This endpoint answers a person who is waiting within three seconds, and an unhandled
+// throw becomes a red "interaction failed" they cannot act on.
+import { admitInputResponse, APPROVAL_BUTTON_LABELS, APPROVAL_CARD_REFUSED_AUDIT_ACTION as CORE_APPROVAL_CARD_REFUSED_AUDIT_ACTION, APPROVAL_CARD_SETTLED_AUDIT_ACTION as CORE_APPROVAL_CARD_SETTLED_AUDIT_ACTION, auditApprovalCardTap, deploymentOrg, forgetApprovalCardTicket, forgetBridgedQuestion, getOperationalStore, ingressSpendGate, OE_INPUT_CLICK_PREFIX, parseApprovalClickId, readApprovalCardTicket, readBridgedQuestion, resolveApprovalCardClick, resolvePartition, unifiedThreadRef, } from "@open-everywhere/core/agent/adapter-api.js";
+import { buildDiscordAuth } from "./discord-identity.js";
+import { deferredEphemeralResponse, editOriginalInteractionResponse, interactionFollowUp } from "./discord-interaction-defer.js";
+const log = (m) => console.log(`[open-everywhere:discord] approval card: ${m}`);
+/** The `input_response.routed` sibling for a tap — the SAME two action strings the Slack leg writes,
+ *  so "how often is a bridged approval settled by a button" is one query across surfaces rather than
+ *  one per surface. RE-EXPORTED FROM CORE since OPE-1856: two files spelling one action name is two
+ *  places it can drift, and the drift is silent. */
+export const APPROVAL_CARD_SETTLED_AUDIT_ACTION = CORE_APPROVAL_CARD_SETTLED_AUDIT_ACTION;
+export const APPROVAL_CARD_REFUSED_AUDIT_ACTION = CORE_APPROVAL_CARD_REFUSED_AUDIT_ACTION;
+// Discord interaction-response wire constants, defined locally for the same reason every sibling
+// handler in this bundle defines its own: importing eve's channel module for two integers would
+// widen this leaf's graph.
+const RESPONSE_CHANNEL_MESSAGE = 4; // CHANNEL_MESSAGE_WITH_SOURCE
+const EPHEMERAL = 64; // MessageFlags.EPHEMERAL — only the tapper sees it
+function isObject(v) {
+    return typeof v === "object" && v !== null;
+}
+/**
+ * Read the `oe_input:` custom_id out of a VERIFIED MESSAGE_COMPONENT interaction. `undefined` when
+ * the payload is not one of ours or is missing a field the decision needs — the front route then
+ * forwards it rather than half-handling it.
+ *
+ * THE CLICKER AND THE CHANNEL COME FROM THE ENVELOPE, never from a payload field the card could
+ * carry: the front has already verified Discord's Ed25519 signature over the raw body, so these are
+ * Discord's own statements. Discord puts the clicker at `user` in a DM and at `member.user` in a
+ * guild; both are read, so a DM tap and a guild tap are equally attributable.
+ */
+export function parseDiscordApprovalClick(raw) {
+    if (!isObject(raw))
+        return undefined;
+    if (raw["type"] !== 3)
+        return undefined; // not a MESSAGE_COMPONENT interaction
+    const data = isObject(raw["data"]) ? raw["data"] : undefined;
+    const actionId = typeof data?.["custom_id"] === "string" ? data["custom_id"] : undefined;
+    if (actionId === undefined || !actionId.startsWith(OE_INPUT_CLICK_PREFIX))
+        return undefined;
+    const direct = isObject(raw["user"]) ? raw["user"]["id"] : undefined;
+    const member = isObject(raw["member"]) ? raw["member"]["user"] : undefined;
+    const viaMember = isObject(member) ? member["id"] : undefined;
+    const userId = typeof direct === "string" && direct.length > 0 ? direct : typeof viaMember === "string" ? viaMember : undefined;
+    const channelRaw = raw["channel_id"];
+    const channelViaObject = isObject(raw["channel"]) ? raw["channel"]["id"] : undefined;
+    const channelId = typeof channelRaw === "string" && channelRaw.length > 0 ? channelRaw : typeof channelViaObject === "string" ? channelViaObject : undefined;
+    if (typeof userId !== "string" || userId.length === 0)
+        return undefined;
+    if (typeof channelId !== "string" || channelId.length === 0)
+        return undefined;
+    const guildId = typeof raw["guild_id"] === "string" && raw["guild_id"].length > 0 ? raw["guild_id"] : undefined;
+    // LEG B, read off the SAME verified envelope. `member.pending` is Discord's own statement that this
+    // account has not cleared the guild's membership screening; a payload that carries no member record
+    // (every DM tap) leaves the field absent, which the admission reads as "not asked".
+    const memberPending = isObject(raw["member"]) ? raw["member"]["pending"] : undefined;
+    return {
+        actionId,
+        channelId,
+        userId,
+        ...(guildId ? { guildId } : {}),
+        ...(typeof memberPending === "boolean" ? { answererIsGuest: memberPending } : {}),
+    };
+}
+/** The bindable a partition resolve and the spend gate need, built through the bundle's OWN auth
+ *  builder rather than a hand-spelled attribute bag: the partition a tap files under must be the one
+ *  a MESSAGE in the same conversation files under, and two spellings is how those drift. */
+function bindableForClick(click) {
+    return {
+        channel: { kind: "discord" },
+        session: {
+            auth: {
+                current: buildDiscordAuth({
+                    channelId: click.channelId,
+                    userId: click.userId,
+                    ...(click.guildId ? { guildId: click.guildId } : {}),
+                }),
+            },
+        },
+    };
+}
+/**
+ * The host copy that rides the delivered answer's `text` — the LABEL THIS DEPLOYMENT PUT ON THE
+ * BUTTON, read back out of the same allowlist that minted it, so the transcript says what the person
+ * actually chose. A tap carries no words, and writing the person's prose for them is not an option.
+ * The DECISION is never this value: eve settles on `optionId` alone.
+ */
+function approvalAnswerText(optionId) {
+    return APPROVAL_BUTTON_LABELS.get(optionId.toLowerCase())?.label ?? optionId.charAt(0).toUpperCase() + optionId.slice(1);
+}
+/**
+ * Settle one verified `oe_input:` tap: resolve it, admit it, deliver the answer to eve, consume the
+ * rows. NEVER THROWS.
+ *
+ * 🔴 CONSUME-ONCE, AND BOTH ROWS, and only after eve accepted the delivery. The ticket goes so a
+ * second tap cannot answer a request eve has already settled; the outstanding-question row goes so
+ * the room's NEXT message is an ordinary wake again rather than a second answer. A throw above skips
+ * both, which leaves the card tappable and the question answerable in words — the safe direction.
+ *
+ * THE LIMIT OF THAT, stated rather than implied and identical to the Slack leg's: the read and the
+ * delete are not one atomic step, so two deliveries arriving together each resolve against rows that
+ * are both still present. Both must be admitted and both must name an option the request offered, and
+ * eve's own resolution refuses the second delivery for a request it already settled — so one approval
+ * can READ as decided by two taps without being decided twice.
+ */
+export async function settleDiscordApprovalCardClick(click, respond) {
+    // 🔴 HOISTED OUT OF THE `try` SO THE `catch` CAN STAMP ITS ROW (OPE-1856) — the Slack sibling's
+    // reasoning verbatim. A throw anywhere below, the partition resolve included, must still leave a
+    // row saying this deployment took a tap and settled nothing.
+    let auditPartition;
+    try {
+        const parsed = parseApprovalClickId(click.actionId);
+        if (parsed === undefined)
+            return { handled: false, reason: "oe_input: custom_id did not parse" };
+        const org = deploymentOrg();
+        const store = getOperationalStore();
+        const bindable = bindableForClick(click);
+        const partition = resolvePartition(bindable);
+        auditPartition = partition;
+        // THE SPEND GATE FIRST, ahead of the identity admission — the same order and the same reason the
+        // Slack leg takes: over budget outranks identity, and a decline must not spend a roster lookup.
+        // A decline leaves the request PENDING.
+        // 🔴 THE `post` ARM CAPTURES, IT DOES NOT POST. The gate's refusal copy would otherwise land as
+        // a PUBLIC message in the channel the card sits in, telling the room that a person's tap was
+        // declined. This door already owns a private answer — the interaction response — so the copy is
+        // captured here and shown to the tapper alone, through the outcome's `notice`. The binding is
+        // local to this call, so two taps in flight cannot read each other's copy.
+        let declineNotice;
+        const spend = await ingressSpendGate({
+            bindable,
+            door: "answer",
+            principalId: click.userId,
+            ...(click.guildId ? { workspaceRef: click.guildId } : {}),
+            post: async (text) => {
+                declineNotice = text;
+            },
+        });
+        if (spend === "declined") {
+            // AUDITED, not only logged (OPE-1856): a decline is this deployment refusing a person's tap,
+            // and a refusal nobody can count is indistinguishable from a tap that never arrived.
+            await auditApprovalCardTap({ platform: "discord", principalId: click.userId, partition, outcome: { kind: "refused", reason: "spend-declined" } });
+            log("tap declined by the spend gate — the approval stays parked");
+            return { handled: true, reason: "spend-declined", ...(declineNotice ? { notice: declineNotice } : {}) };
+        }
+        // The room the tap came from, in the SAME vocabulary the card's ticket stored — derived through
+        // core's own codec rather than spelled here, so the two sides cannot drift on the key's shape. A
+        // guild tap and a DM tap key differently, which is exactly what the codec already knows.
+        const containerKey = unifiedThreadRef(click.guildId ? { platform: "discord", channelId: click.channelId, guildId: click.guildId } : { platform: "discord", channelId: click.channelId, dm: true }).channelKey;
+        const routing = await resolveApprovalCardClick({ ticket: parsed.ticket, optionId: parsed.optionId, containerKey }, {
+            read: (ticket) => readApprovalCardTicket(store, org, ticket),
+            // The join with the TEXT leg — fail-CLOSED on an unreadable row: a store this leg cannot read
+            // cannot say the request is still parked, and settling on that guess is the one direction
+            // that spends a governed decision twice.
+            stillOutstanding: async (bareToken, requestId) => {
+                const outstanding = await readBridgedQuestion(store, org, bareToken).catch(() => undefined);
+                return outstanding?.requestId === requestId;
+            },
+            admit: async () => {
+                const verdict = await admitInputResponse({
+                    org: partition.org,
+                    platform: partition.platform,
+                    workspace: partition.workspace,
+                    surface: partition.surface,
+                    surfaceKey: partition.surfaceKey,
+                    principalId: click.userId,
+                    responses: 1,
+                    // Leg B — the positive per-answerer verdict, and INERT when the envelope could not answer
+                    // it (`undefined` never refuses), exactly as the Slack sibling's probe is.
+                    ...(click.answererIsGuest === undefined ? {} : { answererIsGuest: click.answererIsGuest }),
+                });
+                return { ok: verdict.ok, floor: verdict.ok ? verdict.floor : "", notice: verdict.ok ? "" : verdict.notice };
+            },
+        });
+        if (routing.kind === "refuse") {
+            await auditApprovalCardTap({ platform: "discord", principalId: click.userId, partition, outcome: { kind: "refused", reason: routing.reason } });
+            log(`tap settled nothing (${routing.reason}) — the approval stays parked and answerable in words`);
+            return { handled: true, reason: routing.reason, ...(routing.notice ? { notice: routing.notice } : {}) };
+        }
+        const label = approvalAnswerText(routing.optionId);
+        // 🔴 DELIVERED BY SESSION ID, never by the window token (OPE-1863) — the Slack sibling's
+        // reasoning verbatim: a continuation token is channel-local, this route is the DISCORD channel's,
+        // and `from(bareToken)` here named a session that never existed. The token's job is the
+        // outstanding-question row on the two lines that follow.
+        await respond(routing.sessionId, { requestId: routing.requestId, optionId: routing.optionId, text: label });
+        await forgetApprovalCardTicket(store, org, parsed.ticket);
+        await forgetBridgedQuestion(store, org, routing.bareToken);
+        await auditApprovalCardTap({
+            platform: "discord",
+            principalId: click.userId,
+            partition,
+            outcome: { kind: "settled", requestId: routing.requestId, optionId: routing.optionId, floor: routing.floor },
+        });
+        log(`tap settled ${routing.requestId} as "${routing.optionId}" (floor ${routing.floor})`);
+        return { handled: true, reason: "settled", notice: `${label} — recorded. The request is settled.` };
+    }
+    catch (err) {
+        // The approval is still parked and the card is still tappable, so the honest outcome is to say so
+        // and leave both rows in place.
+        // AUDITED, not only logged (OPE-1856): a tap that threw left no trace at all, so it could not be
+        // told apart from a tap that never arrived. `auditApprovalCardTap` never throws.
+        await auditApprovalCardTap({ platform: "discord", principalId: click.userId, ...(auditPartition === undefined ? {} : { partition: auditPartition }), outcome: { kind: "refused", reason: "error" } });
+        log(`tap failed (${err?.message ?? String(err)}) — nothing was settled, the approval stays parked`);
+        return { handled: true, reason: "error", notice: "That could not be answered right now. Nothing was settled — the request is still open, and you can answer it in words." };
+    }
+}
+/**
+ * The line the tapper reads, for an outcome that carried no notice of its own.
+ *
+ * 🔴 A REFUSAL MUST NEVER READ AS A SETTLEMENT. This door ANSWERS — it edits a deferred placeholder —
+ * so a default of "Recorded." would tell somebody whose tap settled nothing that their approval had
+ * landed, and they would stop waiting for it. Core attaches a `notice` only to the `refused` arm, so
+ * `no-ticket`, `foreign-room`, `unoffered-option` and `already-answered` all arrive here bare. The
+ * Slack sibling can be SILENT in these cases, which is not a false statement; this one cannot, so the
+ * default is the honest sentence and "Recorded." is reserved for a settle.
+ */
+function tapperLine(outcome) {
+    if (outcome.notice !== undefined && outcome.notice.length > 0)
+        return outcome.notice;
+    if (outcome.reason === "settled")
+        return "Recorded.";
+    return "Nothing was settled — the request is still open, and you can answer it in words.";
+}
+/**
+ * Handle one verified `oe_input:` component click.
+ *
+ * Returns the interaction response body to send, or `null` for anything that is NOT one of ours —
+ * the front route then forwards it, so a click is never silently swallowed. NEVER throws.
+ */
+export async function handleDiscordApprovalCardInteraction(raw, respond, deps = {}) {
+    const click = parseDiscordApprovalClick(raw);
+    if (click === undefined)
+        return null;
+    const followUp = interactionFollowUp(raw);
+    if (deps.waitUntil === undefined || followUp === undefined) {
+        // NO PLACE TO RUN THE WORK, OR NO ADDRESS TO ANSWER AT ⇒ settle on the response path. Slow, and
+        // still correct: a deferred ack we could not follow up would leave a permanent "thinking…".
+        log(`tap answering synchronously (${deps.waitUntil === undefined ? "no waitUntil" : "no follow-up address"}) — a slow settle may outlive the interaction token`);
+        const outcome = await settleDiscordApprovalCardClick(click, respond);
+        if (!outcome.handled)
+            return null;
+        return { type: RESPONSE_CHANNEL_MESSAGE, data: { content: tapperLine(outcome), flags: EPHEMERAL } };
+    }
+    const edit = deps.edit ?? editOriginalInteractionResponse;
+    deps.waitUntil((async () => {
+        // TOTAL. This runs after the response has gone; a throw here reaches the host's unhandled
+        // rejection handler and tells the tapper nothing. `settleDiscordApprovalCardClick` is already
+        // total, so the catch is for the edit's own transport.
+        let text;
+        try {
+            const outcome = await settleDiscordApprovalCardClick(click, respond);
+            text = tapperLine(outcome);
+        }
+        catch (err) {
+            log(`deferred tap settle failed: ${err?.message ?? String(err)}`);
+            text = "That could not be answered right now. Nothing was settled — the request is still open, and you can answer it in words.";
+        }
+        // 🔴 A FAILED EDIT IS LOUD BUT NOT FATAL: the settle has already landed and is audited by core.
+        // What is lost is the tapper's explanation — which is exactly what an expired token loses — so
+        // it must be findable in the log.
+        const shown = await edit(followUp, text);
+        if (!shown)
+            log("tap answer could NOT be shown to the tapper — the settle landed and is audited, the tapper was not told");
+    })());
+    return deferredEphemeralResponse();
+}
+//# sourceMappingURL=discord-approval-card.js.map

package/dist/agent/channels/discord-approval-card.js.map

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

package/dist/agent/channels/discord-backscroll.d.ts

@@ -0,0 +1,209 @@
+import { type ContextLine, type NormalizedMessage, type BackscrollTrustFor, type SeatCatchUpFetch, type SeatCatchUpRequest, type WakeMessageInput, type BindableContext } from "@open-everywhere/core/agent/adapter-api.js";
+/** The triggering wake, narrowed to what the backscroll needs. */
+export interface DiscordBackscrollInput {
+    /** The surface to READ — the channel/thread the human's message is IN (msg.channelId), NOT the
+     *  re-keyed reply thread. A Discord thread is its own channel id, so this is one endpoint. */
+    readonly channelId: string;
+    /** The triggering message's id — we read strictly OLDER than this (`?before=`). */
+    readonly triggerMessageId: string;
+    /** True when `channelId` is a thread (types 10/11/12): apply the since-last-agent slice. A base
+     *  channel keeps the recent tail (last N) instead — mirrors Slack's replies/history split. */
+    readonly isThread: boolean;
+    /** The bot's OWN Discord author id (relay `botId`) — labels agent lines + anchors the slice.
+     *  Absent (older relay) → own posts read as a bot and there's no slice boundary (fail-soft). */
+    readonly botId?: string;
+}
+/** A Discord REST caller: GETs `/channels/{channelId}/messages?<query>`, returns parsed JSON
+ *  (an array of message objects) or undefined on ANY failure (fail-soft). Injected so the fetcher
+ *  runs without a network in tests but defaults to the live bot-token call. */
+export type DiscordRequester = (channelId: string, query: Record<string, string>) => Promise<unknown>;
+export interface DiscordBackscrollDeps {
+    readonly request: DiscordRequester;
+}
+/**
+ * Map raw Discord message objects (`GET /channels/{id}/messages` — raw REST JSON, probe
+ * defensively) into {@link ContextLine}s, dropping system-type + empty-content messages. `botId`
+ * is the agent's own author id: a message by it is labelled `agent` (Discord uses one `author.id`
+ * for everyone — bots included — so we compare ids, same idea as Slack comparing bot_id/user_id).
+ * Order is PRESERVED — the caller reverses to oldest-first before rendering. Pure. Exported for
+ * the test oracle. Kept HERE (not shared): Discord's message JSON is shaped differently from
+ * Slack's, so the mapping is genuinely platform-specific; only the ContextLine target + renderer
+ * are shared (context-render.ts).
+ */
+export declare function linesFromDiscordMessages(raw: ReadonlyArray<Record<string, unknown>>, botId?: string): ContextLine[];
+/** Resolves a sibling author's real guild roles for the register query below — injected so the
+ *  grading step is unit-testable offline. Live wiring: {@link discordAuthorRoles}. `undefined` =
+ *  cannot check (never a guess); a real (possibly empty) array = verified role evidence. */
+export type DiscordRoleProbe = (guildId: string, userId: string) => Promise<readonly string[] | undefined>;
+/**
+ * PER-LINE trust for a mention/name-drop backscroll's {@link ContextLine}s (OPE-475) — the Discord
+ * analogue of Slack's regrade step, converging both backscroll shapes on ONE trust story rather than
+ * a second mechanism. Two additive facts, mirroring exactly what the TRIGGER already carries
+ * (discord-gateway.ts `resolveWakeTrustFromContext` + `authorFacts`), resolved per SIBLING:
+ *
+ *   `trust`       — {@link resolveWakeTrustFromContext} off the SAME binding the trigger reads, with
+ *                    `principalFallback` OFF (a sibling has its own author — see that function's own
+ *                    per-message-resolution note). Read by the RENDER. Resolved for every `user` line,
+ *                    unconditionally — no I/O, no gate.
+ *   `authorTrust` — the OPERATOR's author-trust register query (identity/author-trust.ts, OPE-516):
+ *                    Discord's ONLY per-author refutation reachable here. `member.pending` (the
+ *                    trigger's own signal) is NOT available: it rides the gateway relay's MESSAGE_CREATE
+ *                    member object, and Discord's documented Message object (the shape
+ *                    `GET /channels/{id}/messages` — what this backscroll fetch reads — returns) has
+ *                    no `member` field at all. Read ONLY by the taint join.
+ *
+ * 🔴 THE REGISTER QUERY IS BUILT FROM VERIFIED ROLE EVIDENCE, NEVER FROM AN UNCHECKED GUESS (fixed
+ * after a caught bug: an earlier revision hardcoded `memberships: []` on EVERY sibling — on a guild
+ * armed the documented-usual way, `{ membership: "discord/<g>/role:*" }`, that made EVERY sibling
+ * look role-less and therefore `external`, so a mention wake that hydrated ordinary colleagues'
+ * messages marked the taint bit on a role-armed guild — the always-on-bit failure this whole plane
+ * exists to avoid). So the role fetch is COST-GATED and FAIL-OPEN, in that order:
+ *
+ *   1. UNARMED tenant (the common case — `armedAuthorTrustTenants()` doesn't list `discord/<guild>`):
+ *      no register query is even worth building, so NO role fetch runs at all. Zero new I/O on the
+ *      default posture.
+ *   2. ARMED tenant: each DISTINCT candidate author (a `user` line with a `senderId`) gets ONE
+ *      {@link DiscordRoleProbe} call (TTL-cached — {@link discordAuthorRoles}), mirroring exactly how
+ *      {@link regradeSlackContextLineTrust}'s probe is one call per distinct author, not per message.
+ *   3. The probe's THREE outcomes are kept apart, never collapsed to a boolean: a real (possibly
+ *      empty, on a verified 404) roles array builds the SAME group-rung `{tenantKey}/role:<id>` keys
+ *      the trigger's own `authorFacts` builds from `msg.memberRoles`; `undefined` (no token, a
+ *      network error, an unreadable body) means "cannot check", and that line gets NO `authorTrust`
+ *      at all — SKIPPED, never an unverified `[]`. "Cannot check" is not "checked and empty".
+ *
+ * 🔴 THE REGISTER LEG NEVER DEMOTES `trust` — it matches the trigger, and access/taint-signal.ts's own
+ * design: the register is a JOIN-ONLY refutation, decoupled from the render (see `nonMemberChatTrust`).
+ * So a register-refuted Discord backscroll sibling marks the turn but does not render the reference-only
+ * note — an honest limit of what this endpoint can tell the model, not a shortfall against Slack's
+ * parity (Slack's refutation is a SURFACE fact and demotes the render; Discord has none here).
+ *
+ * `agent`/`bot`/`unknown` lines are left untouched — machine or unattributable authors are not this
+ * leg's question.
+ */
+export declare function gradeDiscordContextLines(lines: readonly ContextLine[], ctx: BindableContext, guildId: string | undefined, roleProbe?: DiscordRoleProbe): Promise<ContextLine[]>;
+/**
+ * Fetch recent conversation history for a Discord wake/mention as RAW, oldest-first
+ * {@link ContextLine}s, capped at {@link WAKE_BACKSCROLL_MAX}. `undefined` = nothing to add OR any
+ * failure — always non-fatal. Both Discord wake dispatch paths (discord-gateway.ts, native and
+ * single-window divert) call this directly, grade the lines with gradeDiscordContextLines
+ * (OPE-475), and render them via the shared renderContext THEMSELVES — no pre-rendered string is
+ * built inside this module.
+ *
+ * One endpoint (`GET /channels/{channelId}/messages?limit&before`) for both cases:
+ *   - IN-THREAD (`isThread`): strictly-older messages, then sliced to "since the agent's last
+ *     reply" (a resumed thread session already holds everything up to its last reply).
+ *   - BASE CHANNEL: strictly-older messages, most recent N.
+ */
+export declare function fetchDiscordBackscrollLines(input: DiscordBackscrollInput, deps?: DiscordBackscrollDeps): Promise<{
+    readonly lines: ContextLine[];
+    readonly source: string;
+} | undefined>;
+/** Reachback (hours) for the raw Discord window: how far back from the trigger we paginate. Shares
+ *  the SAME env + 7d default as the Slack adapter (slack-wake-backscroll.ts RAW_FETCH_REACHBACK_HOURS)
+ *  — it is one supervisor-backscroll concept, kept in sync by reading the same knob. Generous enough
+ *  that the spine (the most-recent cluster, exempt from the 36h enrichment cap) still spans a
+ *  weekend/overnight gap, yet a hard floor bounding the fetch. */
+export declare const DISCORD_RAW_FETCH_REACHBACK_HOURS: number;
+/**
+ * The creation time (epoch ms) encoded in a Discord snowflake id: the top 42 bits are
+ * `(unix_ms - DISCORD_EPOCH_MS)`. Robust — every message id carries it, so we can derive a time even
+ * when the raw `timestamp` field is absent/garbled. Returns undefined for a non-numeric / non-positive
+ * id (fail-soft; the caller drops that message from the window rather than guessing a time).
+ */
+export declare function snowflakeToMs(id: string): number | undefined;
+/**
+ * The VISIBILITY / TRUST GATE (the load-bearing SECURITY filter) — the Discord parity of
+ * slack-wake-backscroll.ts isBackscrollVisible, kept LOCAL (not imported from a slack-named file, the
+ * same DAG discipline as linesFromDiscordMessages). Backscroll must never surface a message it can't
+ * ATTRIBUTE. KEEPS: the bot's OWN prior posts (`agent` → `self`); identifiable humans (`user` →
+ * `human`); ATTRIBUTABLE foreign bots (`bot` WITH a bot id → `bot`) as MARKED AWARENESS (clearly
+ * bot-flagged, CONTEXT-ONLY, never a wake trigger — dropping them would break conversational
+ * coherence when a human replies to a bot post). DROPS ONLY unattributable senders (`unknown`, or a
+ * `bot` with no id) — no auth'd author ⇒ fail closed. (System-subtype / empty-content noise is already
+ * dropped upstream by linesFromDiscordMessages.) The neutral core never sets `trigger` on backscroll,
+ * and the gateway's live wake gate still drops bot authors as triggers, so a bot post here is
+ * awareness, never a response obligation. */
+export declare function isDiscordBackscrollVisible(line: ContextLine): boolean;
+/** The triggering first wake, narrowed to what the neutral-core window needs (mirrors Slack's
+ *  {@link import("./slack-wake-backscroll.js").WakeEnvelopeBackscrollInput}). */
+export interface DiscordBackscrollWindowInput {
+    /** The surface to READ — the channel/thread the trigger is IN (a Discord thread is its own id). */
+    readonly channelId: string;
+    /** The triggering message's id — the window's upper (exclusive) bound (`before=`) and, decoded to
+     *  ms, the reachback origin the core clusters against. */
+    readonly triggerMessageId: string;
+    /** True when `channelId` is a thread (types 10/11/12) — every message is then tagged `thread`. */
+    readonly isThread: boolean;
+    /** The bot's OWN Discord author id (relay `botId`) — labels its own posts `self`. Absent (older
+     *  relay) → own posts read as an attributable bot (still visible), never a crash. */
+    readonly botId?: string;
+    /** Hours to look back from the trigger for the raw fetch. Defaults to
+     *  {@link DISCORD_RAW_FETCH_REACHBACK_HOURS}. */
+    readonly reachbackHours?: number;
+    /**
+     * THE CATCH-UP BOUND (OPE-1726, the Slack seam's exact field): epoch milliseconds of the seat's own
+     * LAST WAKE, so this read returns what the channel said since the seat last looked. It only ever
+     * NARROWS the window — the reachback floor above still applies — so a seat quiet for a month reads
+     * the recent tail, and a seat with no recorded wake reads the bootstrap window unchanged.
+     */
+    readonly sinceMs?: number;
+}
+/**
+ * DISCORD FETCH SEAM: fetch a bounded, visibility-GATED, NORMALIZED backscroll window for a first
+ * wake. This is the platform boundary — the neutral core ({@link fetchedBackscroll}) consumes its
+ * output. FAIL-SOFT: any error/failure yields `[]`. Deduped by message id.
+ */
+export declare function fetchDiscordBackscrollWindow(input: DiscordBackscrollWindowInput, deps?: DiscordBackscrollDeps, failureMode?: "soft" | "throw"): Promise<NormalizedMessage[]>;
+/**
+ * Fetch + cluster a Discord first-wake backscroll into session-tagged {@link WakeMessageInput}
+ * entries (oldest-first, no `trigger`). Thin orchestration over the Discord fetch seam
+ * ({@link fetchDiscordBackscrollWindow}) + the neutral clustering/bounds core
+ * ({@link fetchedBackscroll}) — the exact parity of slack-wake-backscroll.ts
+ * fetchWakeEnvelopeBackscroll. FAIL-SOFT ABSOLUTELY.
+ *
+ * Per-message trust mirrors the Slack seam: pass a `trustFor` resolver (build it with
+ * identity/wake-trust.ts `backscrollTrustResolver`, off the confirmInternal verdict + domain-grain
+ * channelKey) so each backscroll author gets its real roster/gate-derived tier (F3). When omitted,
+ * fetchedBackscroll's fail-closed per-sender default applies (a human → `unauth`, self/bot →
+ * `relay`), never a blanket `peer`.
+ *
+ * NOTE: this is a proven DROP-IN with no live caller yet — Discord has no wake-envelope render
+ * surface to render the `<session>` output on a live wake (see the file header + the
+ * TODO(discord-supervisor-backscroll) at discord-gateway.ts's dispatch seam). The `trustFor` seam
+ * is wired here ahead of that surface so, when the Discord supervisor lands, it passes the resolver
+ * exactly as slack-events.ts's live supervisor deps do for fetchWakeEnvelopeBackscroll.
+ */
+export declare function fetchDiscordWakeEnvelopeBackscroll(input: DiscordBackscrollWindowInput, deps?: DiscordBackscrollDeps, trustFor?: BackscrollTrustFor): Promise<WakeMessageInput[]>;
+/**
+ * DISCORD'S REGISTERED CATCH-UP FETCH (OPE-1726) — the one thing this surface contributes to the
+ * shared since-last-wake path (core channels/seat-catch-up.ts). It reuses the window fetch above,
+ * addressed by the neutral request shape: the seat's container, bounded below by its last wake.
+ * 🔴 THE UPPER BOUND IS A MESSAGE ID, not a time, because `GET /channels/:id/messages` pages with
+ * `before=<snowflake>` and takes no timestamp. `excludeId` IS that snowflake (the trigger's own id),
+ * and with none the read anchors on a snowflake synthesised from `untilMs` — Discord ids embed their
+ * own millisecond, so the synthesised anchor orders correctly even though it names no real message.
+ * The shared path re-applies both bounds on its own side, so a page that overshoots is trimmed there.
+ * `threadRoot` present ⇒ the seat is bound to a thread, and a Discord thread IS its own channel id,
+ * so the read addresses that id and tags every message `thread`.
+ * A transport/read failure propagates to core's shared boundary, which keeps the wake alive and
+ * records `failed` instead of reporting a quiet channel (OPE-1842). Bootstrap callers keep the
+ * window fetch's default fail-soft mode.
+ */
+export declare function fetchDiscordSeatCatchUp(req: SeatCatchUpRequest, deps?: DiscordBackscrollDeps): Promise<readonly NormalizedMessage[]>;
+/**
+ * A Discord snowflake encodes MILLISECONDS and the ISO `timestamp` field carries them too (OPE-1847,
+ * `core/agent/channels/seat-catch-up.ts` {@link SeatCatchUpDeclaration.timestampPrecisionMs}).
+ * 🔴 ONE MILLISECOND IS NOT ZERO WIDENING. The road widens the LOWER bound by nothing here and the
+ * UPPER bound by exactly one millisecond, so a message stamped at the trigger's own instant is
+ * INSIDE the window and `excludeId` is the only thing that removes the trigger. The paging call
+ * already anchors on `before=<the trigger snowflake>`, which is exclusive, and a message that did
+ * arrive would carry that snowflake as its id.
+ * 🔴 IT IS STILL DECLARED, and the parity test requires it. The declaration is what makes "this
+ * surface needs the finest unit" a CHECKED claim rather than an omission, and an omission is
+ * indistinguishable from the GitHub and Notion defect this whole mechanism exists to close.
+ */
+export declare const DISCORD_TIMESTAMP_PRECISION_MS = 1;
+/** The registered form — the transport seam is fixed to the live one. Tests drive
+ *  {@link fetchDiscordSeatCatchUp} with a canned requester instead. */
+export declare const discordSeatCatchUpFetch: SeatCatchUpFetch;
+//# sourceMappingURL=discord-backscroll.d.ts.map

package/dist/agent/channels/discord-backscroll.d.ts.map

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