@open-everywhere/provider-discord 0.1.0

package/dist/agent/channels/discord-backscroll.js

@@ -0,0 +1,505 @@
+// Wake-time conversation backscroll for Discord — the parity twin of slack-wake-backscroll.ts.
+//
+// Discord's name-drop WAKE and @mention paths (discord-gateway.ts) used to hand the model ONLY
+// the triggering message: a cold name-drop mid-thread arrived with no idea what's being
+// discussed, and a re-wake after auto-disengage resumed the same session with a GAP for
+// everything said while the bot was away. This module closes both by fetching recent history at
+// wake time and attaching it as the SAME untrusted-wrapped `context` strings the Slack paths use
+// (eve appends each as a user message before the delivery turn — SendPayload.context).
+//
+// SIMPLER THAN SLACK: Discord threads are their OWN channel ids, so ONE endpoint —
+// `GET /channels/{channelId}/messages` — covers both a base channel and a thread (no
+// history/replies split). We always read strictly OLDER than the trigger via `?before=<id>`
+// (Discord returns newest-first; we reverse to oldest-first). For an in-THREAD wake we then slice
+// to "since the agent last spoke" (shared sinceLastAgentReply) — a resumed thread session already
+// holds everything up to its last reply; for a BASE channel we keep the recent tail (last N).
+//
+// AUTH: reuses the Discord bot token exactly as discord-gateway.ts's REST calls do (`Bot <token>`
+// header) — no new auth path. The bot's OWN author id (msg.botId, forwarded by the relay) both
+// labels the agent's prior posts as `sender_type=agent` AND anchors the since-last-agent slice;
+// absent (older relay) it simply degrades (own posts read as a bot, no slice boundary) — never a
+// crash. The requester is injected so the fetcher unit-tests offline with NO network.
+//
+// RENDER REUSE: the ContextLine shape, the render + UNTRUSTED wrap, the caps, and the
+// since-last-agent slice all come from the shared context-render.ts — the SAME renderer Slack
+// uses — so Discord's attribution + untrusted framing are byte-identical to Slack's without
+// cross-importing a slack-named file. The untrusted wrap is a SECURITY invariant (channel content
+// is DATA, never instructions), so it must never diverge between surfaces. NO read-more hint:
+// Discord exposes no read_discord_* tools today, so naming a "fetch more" tool would be a lie —
+// the bounded backscroll (the actual win) is attached regardless.
+//
+// BOOTSTRAP BACKSCROLL is fail-soft: any error yields no context and never blocks the first wake.
+// SEAT CATCH-UP propagates the same read failure to core's shared fail-soft boundary, so the wake
+// still continues but its `seat.catch_up` row says `failed` rather than `empty` (OPE-1842).
+//
+// TWO MECHANISMS LIVE IN THIS FILE (both wake-safe, both Discord-specific fetch adapters):
+//   1. fetchDiscordBackscrollLines — the FLAT name-drop/@mention enrichment above: raw history →
+//      context-render.ts ContextLine. BOTH Discord wake dispatch paths call it directly and grade
+//      the RAW lines with gradeDiscordContextLines (OPE-475) before rendering: the gateway's NATIVE
+//      dispatch hands the graded lines to the shared renderWake as the NormalizedWake's `contextLines`
+//      (W3 — renderWake does the untrusted-wrap); the SINGLE-WINDOW divert path renders them itself
+//      via the shared renderContext (discord-gateway.ts `discordSeatContextForWindow`) — a
+//      pre-rendered `context` string, but sourced from the SAME graded lines the join reads via
+//      contextLineIngestion, so the join can never carry a line the render's own source set did
+//      not. 🔴 THAT IS NOT AN EQUALITY OF COUNTS: renderContext applies its own MAX_CHARS bound and
+//      skips a line whose text trims empty, so the render can keep FEWER lines than the join marks.
+//      The direction over-taints, which is the safe one.
+//      🔴 BOTH PATHS TAKE THE DOMAIN'S ADMISSION POLICY, and the SEAT decides, never the road
+//      (OPE-1800, discord-gateway.ts `admitDiscordSeatLines`). The policy runs wherever
+//      `grainUsesUnifiedWindow` holds for the room — which is the predicate Slack resolves `seated`
+//      from — so a wake that falls through to the native arm because its seat STOOD DOWN (the guild
+//      vouch absent) is policed too. A room with no seat at all keeps every graded line.
+//   2. fetchDiscordBackscrollWindow / fetchDiscordWakeEnvelopeBackscroll (added below) — the DROP-IN
+//      fetch adapter behind the platform-NEUTRAL gap-clustering/bounds core (backscroll-window.ts),
+//      the exact Slack shape (slack-wake-backscroll.ts fetchSlackBackscrollWindow /
+//      fetchWakeEnvelopeBackscroll): raw history → visibility-gated NormalizedMessage[] →
+//      fetchedBackscroll → session-tagged WakeMessageInput[]. This fulfils the neutral core's
+//      "Discord drop-in" seam, and it is LIVE (OPE-1726): `discordSeatCatchUpFetch` below registers it
+//      as this surface's SEAT CATCH-UP fetch, so every wake on an ongoing generation reads the channel
+//      since the seat's own last wake and renders the result as the wake envelope's `<session>`
+//      siblings (discord-gateway.ts `divertDiscordWakeToUnifiedWindow`). The BOOTSTRAP half — a fresh
+//      generation's first wake — still carries the recorded tail rather than a platform fetch.
+//      The flat path (1) continues to serve the mention/name-drop hydration on every Discord wake.
+import { sinceLastAgentReply, WAKE_BACKSCROLL_MAX, fetchedBackscroll, resolveWakeTrustFromContext, armedAuthorTrustTenants, catchUpSender, } from "@open-everywhere/core/agent/adapter-api.js";
+import { discordAuthorRoles } from "../approvals/discord-admin.js";
+// Direct bot-token GET to the Discord REST API. Mirrors discord-gateway.ts's own fetch calls
+// (`Bot <token>` header; the token is a SECRET — never logged). Fail-soft: no token / non-ok /
+// any throw → undefined. Kept local rather than imported from discord-gateway.ts so the module
+// graph stays a DAG (discord-gateway → here; importing back up would cycle).
+const liveRequest = async (channelId, query) => {
+    const token = process.env.DISCORD_BOT_TOKEN;
+    if (!token || !channelId)
+        return undefined;
+    try {
+        const qs = new URLSearchParams(query).toString();
+        const res = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages?${qs}`, {
+            headers: { authorization: `Bot ${token}` },
+        });
+        if (!res.ok)
+            return undefined;
+        return await res.json();
+    }
+    catch {
+        return undefined;
+    }
+};
+const liveDeps = { request: liveRequest };
+// Discord message `type`s we keep as ordinary conversation: 0 = DEFAULT, 19 = REPLY. Everything
+// else (7 member-join, 6 pin, channel-name-change, thread-created, …) is system noise, dropped
+// like Slack's `subtype` filter. A message with no/other type is treated conservatively as noise.
+function isConversationType(type) {
+    return type === 0 || type === 19;
+}
+/**
+ * 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 function linesFromDiscordMessages(raw, botId) {
+    const lines = [];
+    for (const m of raw) {
+        if (!isConversationType(m.type))
+            continue; // system noise (joins, pins, thread-created, …)
+        const text = typeof m.content === "string" ? m.content : "";
+        if (!text)
+            continue; // empty content (Message Content Intent off, or an embed-only post)
+        const author = typeof m.author === "object" && m.author !== null ? m.author : undefined;
+        const authorId = author && typeof author.id === "string" ? author.id : undefined;
+        const isBot = author?.bot === true;
+        const id = typeof m.id === "string" ? m.id : "";
+        if (botId !== undefined && authorId === botId)
+            lines.push({ senderType: "agent", ts: id, text });
+        else if (isBot && authorId)
+            lines.push({ senderType: "bot", senderId: authorId, ts: id, text });
+        else if (authorId)
+            lines.push({ senderType: "user", senderId: authorId, ts: id, text });
+        else
+            lines.push({ senderType: "unknown", ts: id, text });
+    }
+    return lines;
+}
+/**
+ * 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 async function gradeDiscordContextLines(lines, ctx, guildId, roleProbe = discordAuthorRoles) {
+    const withTrust = lines.map((l) => l.senderType !== "user" ? l : { ...l, trust: resolveWakeTrustFromContext(ctx, { id: l.senderId, isBot: false }) });
+    const tenantKey = guildId !== undefined ? `discord/${guildId}` : undefined;
+    // COST GATE: an unarmed tenant's register leg contributes nothing (identity/author-trust.ts —
+    // silence is not a declaration), so there is nothing worth a role fetch for. Zero new I/O here is
+    // the default posture, not an edge case.
+    if (tenantKey === undefined || !armedAuthorTrustTenants().includes(tenantKey))
+        return withTrust;
+    const candidates = new Set();
+    for (const l of withTrust) {
+        if (l.senderType === "user" && l.senderId !== undefined)
+            candidates.add(l.senderId);
+    }
+    if (candidates.size === 0)
+        return withTrust;
+    const ids = [...candidates];
+    const roleResults = await Promise.all(ids.map((id) => roleProbe(guildId, id)));
+    const rolesById = new Map(ids.map((id, i) => [id, roleResults[i]]));
+    return withTrust.map((l) => {
+        if (l.senderType !== "user" || l.senderId === undefined)
+            return l;
+        const roles = rolesById.get(l.senderId);
+        if (roles === undefined)
+            return l; // cannot check — SKIP the register query for this line entirely
+        const authorTrust = {
+            tenantKey,
+            authorId: l.senderId,
+            memberships: roles.map((r) => `${tenantKey}/role:${r}`),
+        };
+        return { ...l, authorTrust };
+    });
+}
+// Pull the message array out of a REST response, or undefined (fail-soft on junk / non-array).
+function extractDiscordMessages(res) {
+    if (!Array.isArray(res))
+        return undefined;
+    return res;
+}
+/**
+ * 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 async function fetchDiscordBackscrollLines(input, deps = liveDeps) {
+    try {
+        const res = await deps.request(input.channelId, {
+            limit: String(WAKE_BACKSCROLL_MAX),
+            // Strictly OLDER than the trigger — the trigger's text already rides on the wake message.
+            before: input.triggerMessageId,
+        });
+        const raw = extractDiscordMessages(res);
+        if (!raw)
+            return undefined;
+        // Discord returns newest-first → reverse to oldest-first for the slice + render.
+        const ordered = [...raw].reverse();
+        let lines = linesFromDiscordMessages(ordered, input.botId);
+        // In a thread, keep only what followed the agent's last reply (the disengage/re-wake gap, or
+        // "someone answered while I was away"); a base channel keeps the recent tail via the N-cap.
+        if (input.isThread)
+            lines = sinceLastAgentReply(lines);
+        const capped = lines.slice(-WAKE_BACKSCROLL_MAX);
+        if (capped.length === 0)
+            return undefined;
+        return { lines: capped, source: `discord ${input.isThread ? "thread" : "channel"} ${input.channelId}` };
+    }
+    catch {
+        return undefined; // fail-soft: a wake never depends on its backscroll
+    }
+}
+// --- neutral-core first-wake backscroll (supervisor context hydration) — DISCORD ADAPTER -----
+//
+// THIS IS THE DISCORD FETCH ADAPTER behind the platform-NEUTRAL clustering/bounds core
+// (backscroll-window.ts), the mirror of slack-wake-backscroll.ts's fetchSlackBackscrollWindow.
+// Its job: turn `GET /channels/{id}/messages` into a visibility-GATED {@link NormalizedMessage}[]
+// window, then hand it to {@link fetchedBackscroll}, which caps it most-recent-first and
+// spine/bolt + count/time/token bounds and emits session-tagged {@link WakeMessageInput}[] the wake
+// envelope renders as `<session>` groups.
+//
+// SIMPLER THAN SLACK (again): a Discord thread is its own channel id, so the SAME single endpoint
+// covers a base channel AND a thread — there is no conversations.history/replies split and thus no
+// bounded thread-reply fan-out to mirror (a base-channel window here does NOT reach into the
+// replies of threads hanging off it; that's the deliberate one-endpoint scope, matching the flat
+// path). FAIL-SOFT ABSOLUTELY throughout, exactly like {@link fetchDiscordBackscrollLines}.
+/** 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 const DISCORD_RAW_FETCH_REACHBACK_HOURS = Number(process.env.OE_SUPERVISOR_BACKSCROLL_REACHBACK_HOURS) || 168;
+/** `GET /channels/{id}/messages` page size (Discord's max is 100). */
+const DISCORD_RAW_FETCH_PAGE_LIMIT = 100;
+/** Max history pages to paginate — bounds a busy channel's fetch at ≤300 messages so a burst can't
+ *  fan out into an unbounded loop. Combined with the reachback floor (whichever binds first). */
+const DISCORD_RAW_FETCH_MAX_PAGES = 3;
+/** Discord's epoch (2015-01-01T00:00:00Z, ms) — the offset baked into every snowflake id. */
+const DISCORD_EPOCH_MS = 1_420_070_400_000;
+/**
+ * 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 function snowflakeToMs(id) {
+    try {
+        const n = BigInt(id);
+        if (n <= 0n)
+            return undefined;
+        return Number(n >> 22n) + DISCORD_EPOCH_MS;
+    }
+    catch {
+        return undefined; // not an integer id → no derivable time
+    }
+}
+/**
+ * The INVERSE of {@link snowflakeToMs}: the smallest snowflake whose encoded time is `ms`, for a
+ * `before=` anchor when the caller states a TIME and holds no message id (the catch-up fetch with no
+ * trigger). The low 22 bits (worker, process, sequence) are zero, which is exactly what "the
+ * beginning of this millisecond" means to Discord's own ordering. A time at or before Discord's epoch
+ * clamps to `1` — the smallest usable anchor — rather than producing a negative id.
+ */
+function msToSnowflake(ms) {
+    const delta = Math.max(0, Math.floor(ms) - DISCORD_EPOCH_MS);
+    const id = BigInt(delta) << 22n;
+    return (id > 0n ? id : 1n).toString();
+}
+/** The message's epoch ms: prefer the canonical ISO `timestamp` field, else decode the snowflake
+ *  `id` (both present on a REST message object). undefined ⇒ neither yielded a finite time. */
+function messageMs(m, id) {
+    const iso = typeof m.timestamp === "string" ? Date.parse(m.timestamp) : Number.NaN;
+    if (Number.isFinite(iso))
+        return iso;
+    return snowflakeToMs(id);
+}
+/**
+ * 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 function isDiscordBackscrollVisible(line) {
+    return (line.senderType === "agent" ||
+        line.senderType === "user" ||
+        (line.senderType === "bot" && line.senderId !== undefined) // attributable foreign bot: marked awareness
+    );
+}
+/**
+ * Normalize ONE raw Discord message → {@link NormalizedMessage}, reusing {@link linesFromDiscordMessages}
+ * for the exact sender classification + system/empty drop, then applying the VISIBILITY GATE and
+ * resolving the epoch ms. Returns undefined for a dropped (invisible / system / empty / timeless)
+ * message. `type`/`threadId` describe the surface the window was read from (a Discord thread is its
+ * own channel id, so a thread window tags every message `thread` with the thread's id as the root).
+ */
+function normalizeDiscordMessage(m, botId, type, threadId) {
+    const [line] = linesFromDiscordMessages([m], botId);
+    if (!line)
+        return undefined; // system type / empty content (dropped upstream)
+    if (!isDiscordBackscrollVisible(line))
+        return undefined; // VISIBILITY GATE (unattributable sender only)
+    const ms = messageMs(m, line.ts);
+    if (ms === undefined)
+        return undefined; // no derivable time → can't cluster it, drop
+    return {
+        id: line.ts,
+        ms,
+        // undefined for the bot's OWN posts (agent); the foreign bot's id for a `bot`; the user id for a
+        // human — kept raw for @-tagging / attribution.
+        authorId: line.senderId,
+        // THE SHARED SENDER RULE (OPE-1857): agent → self (our own post); bot → bot (attributable
+        // foreign bot, marked awareness); every other visible line is a `user` → human. `unknown` was
+        // already dropped by the gate above.
+        sender: catchUpSender({ self: line.senderType === "agent", bot: line.senderType === "bot" }),
+        type,
+        threadId,
+        text: line.text,
+    };
+}
+/** Paginate `GET /channels/{id}/messages` backward from `before` (exclusive), bounded by
+ *  {@link DISCORD_RAW_FETCH_MAX_PAGES} AND the reachback floor (`oldestMs`, whichever binds first).
+ *  Discord returns each page newest-first; the next page anchors on the page's OLDEST id. Returns the
+ *  raw messages (newest-first across pages — the neutral core sorts by ms anyway). Fail-soft: a
+ *  junk/empty page ends pagination with whatever's in hand. */
+async function fetchDiscordWindow(request, channelId, triggerMessageId, oldestMs) {
+    const all = [];
+    let before = triggerMessageId;
+    for (let page = 0; page < DISCORD_RAW_FETCH_MAX_PAGES; page++) {
+        const res = await request(channelId, { limit: String(DISCORD_RAW_FETCH_PAGE_LIMIT), before });
+        const msgs = extractDiscordMessages(res);
+        if (!msgs || msgs.length === 0)
+            break;
+        all.push(...msgs);
+        const oldest = msgs[msgs.length - 1]; // Discord newest-first → last is the oldest in this page
+        const oldestId = typeof oldest.id === "string" ? oldest.id : undefined;
+        if (!oldestId)
+            break;
+        const oldestMsThisPage = messageMs(oldest, oldestId);
+        if (oldestMsThisPage !== undefined && oldestMsThisPage < oldestMs)
+            break; // paged past the floor
+        if (msgs.length < DISCORD_RAW_FETCH_PAGE_LIMIT)
+            break; // short page ⇒ no more history
+        before = oldestId; // next page: strictly older than this page's oldest
+    }
+    return all;
+}
+/**
+ * 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 async function fetchDiscordBackscrollWindow(input, deps = liveDeps, failureMode = "soft") {
+    try {
+        const triggerMs = snowflakeToMs(input.triggerMessageId);
+        const reachbackHours = input.reachbackHours ?? DISCORD_RAW_FETCH_REACHBACK_HOURS;
+        // Reachback origin = the trigger's own time when derivable, else now (fail-soft — a bad trigger
+        // id still yields a sane recent window rather than nothing).
+        const originMs = triggerMs ?? Date.now();
+        // The reachback floor, then the seat's own last wake where it is LATER — never earlier, so the
+        // catch-up can only narrow the fetch (see {@link DiscordBackscrollWindowInput.sinceMs}).
+        const floorMs = originMs - reachbackHours * 3_600_000;
+        const oldestMs = typeof input.sinceMs === "number" && Number.isFinite(input.sinceMs) ? Math.max(floorMs, input.sinceMs) : floorMs;
+        const raw = await fetchDiscordWindow(deps.request, input.channelId, input.triggerMessageId, oldestMs);
+        if (raw.length === 0)
+            return [];
+        const type = input.isThread ? "thread" : "channel";
+        const threadId = input.isThread ? input.channelId : undefined;
+        const seen = new Set();
+        const out = [];
+        for (const m of raw) {
+            const n = normalizeDiscordMessage(m, input.botId, type, threadId);
+            if (!n)
+                continue;
+            if (n.ms < oldestMs)
+                continue; // outside the reachback window
+            if (seen.has(n.id))
+                continue; // dedupe (paging overlap / repeats)
+            seen.add(n.id);
+            out.push(n);
+        }
+        return out;
+    }
+    catch (err) {
+        if (failureMode === "throw")
+            throw err;
+        return []; // fail-soft: a first wake never depends on its backscroll
+    }
+}
+/**
+ * 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 async function fetchDiscordWakeEnvelopeBackscroll(input, deps = liveDeps, trustFor) {
+    try {
+        const window = await fetchDiscordBackscrollWindow(input, deps);
+        if (window.length === 0)
+            return [];
+        return fetchedBackscroll(window, undefined, trustFor);
+    }
+    catch {
+        return []; // fail-soft: a first wake never depends on its backscroll
+    }
+}
+/**
+ * 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 async function fetchDiscordSeatCatchUp(req, deps = liveDeps) {
+    const isThread = req.threadRoot !== undefined;
+    const anchor = req.threadRoot ?? req.container;
+    const triggerMessageId = req.excludeId ?? msToSnowflake(req.untilMs ?? Date.now());
+    const strictDeps = {
+        request: async (channelId, query) => {
+            const res = await deps.request(channelId, query);
+            if (!Array.isArray(res))
+                throw new Error("Discord catch-up request failed");
+            return res;
+        },
+    };
+    return fetchDiscordBackscrollWindow({ channelId: anchor, triggerMessageId, isThread, sinceMs: req.sinceMs }, strictDeps, "throw");
+}
+/**
+ * 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 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 const discordSeatCatchUpFetch = (req) => fetchDiscordSeatCatchUp(req);
+//# sourceMappingURL=discord-backscroll.js.map

package/dist/agent/channels/discord-backscroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-backscroll.js","sourceRoot":"","sources":["../../../agent/channels/discord-backscroll.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,EAAE;AACF,+FAA+F;AAC/F,wFAAwF;AACxF,wFAAwF;AACxF,gGAAgG;AAChG,iGAAiG;AACjG,uFAAuF;AACvF,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,4FAA4F;AAC5F,kGAAkG;AAClG,kGAAkG;AAClG,8FAA8F;AAC9F,EAAE;AACF,kGAAkG;AAClG,+FAA+F;AAC/F,gGAAgG;AAChG,iGAAiG;AACjG,sFAAsF;AACtF,EAAE;AACF,sFAAsF;AACtF,8FAA8F;AAC9F,4FAA4F;AAC5F,kGAAkG;AAClG,8FAA8F;AAC9F,gGAAgG;AAChG,kEAAkE;AAClE,EAAE;AACF,kGAAkG;AAClG,kGAAkG;AAClG,4FAA4F;AAC5F,EAAE;AACF,2FAA2F;AAC3F,iGAAiG;AACjG,kGAAkG;AAClG,oGAAoG;AACpG,uGAAuG;AACvG,oGAAoG;AACpG,2FAA2F;AAC3F,gGAAgG;AAChG,gGAAgG;AAChG,oGAAoG;AACpG,oGAAoG;AACpG,yDAAyD;AACzD,8FAA8F;AAC9F,wFAAwF;AACxF,oGAAoG;AACpG,oGAAoG;AACpG,yFAAyF;AACzF,qGAAqG;AACrG,oGAAoG;AACpG,oFAAoF;AACpF,0FAA0F;AAC1F,8FAA8F;AAC9F,uGAAuG;AACvG,uGAAuG;AACvG,gGAAgG;AAChG,sGAAsG;AACtG,+FAA+F;AAC/F,mGAAmG;AAEnG,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACvB,aAAa,GASd,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AA0BnE,6FAA6F;AAC7F,+FAA+F;AAC/F,+FAA+F;AAC/F,6EAA6E;AAC7E,MAAM,WAAW,GAAqB,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;IAC/D,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;IAC5C,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3C,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;QACjD,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,wCAAwC,SAAS,aAAa,EAAE,EAAE,EAAE;YAC1F,OAAO,EAAE,EAAE,aAAa,EAAE,OAAO,KAAK,EAAE,EAAE;SAC3C,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,EAAE;YAAE,OAAO,SAAS,CAAC;QAC9B,OAAO,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,QAAQ,GAA0B,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;AAEjE,gGAAgG;AAChG,+FAA+F;AAC/F,kGAAkG;AAClG,SAAS,kBAAkB,CAAC,IAAa;IACvC,OAAO,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC;AACnC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAA2C,EAAE,KAAc;IAClG,MAAM,KAAK,GAAkB,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;QACpB,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC;YAAE,SAAS,CAAC,gDAAgD;QAC3F,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5D,IAAI,CAAC,IAAI;YAAE,SAAS,CAAC,oEAAoE;QACzF,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,MAAM,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAE,CAAC,CAAC,MAAkC,CAAC,CAAC,CAAC,SAAS,CAAC;QACrH,MAAM,QAAQ,GAAG,MAAM,IAAI,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QACjF,MAAM,KAAK,GAAG,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;QACnC,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,IAAI,KAAK,KAAK,SAAS,IAAI,QAAQ,KAAK,KAAK;YAAE,KAAK,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;aAC5F,IAAI,KAAK,IAAI,QAAQ;YAAE,KAAK,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;aAC3F,IAAI,QAAQ;YAAE,KAAK,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;;YACnF,KAAK,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,KAA6B,EAC7B,GAAoB,EACpB,OAA2B,EAC3B,SAAS,GAAqB,kBAAkB;IAEhD,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAe,EAAE,CAC7C,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,2BAA2B,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAClH,CAAC;IACF,MAAM,SAAS,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,8FAA8F;IAC9F,kGAAkG;IAClG,yCAAyC;IACzC,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,uBAAuB,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IAEhG,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IACrC,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;QAC1B,IAAI,CAAC,CAAC,UAAU,KAAK,MAAM,IAAI,CAAC,CAAC,QAAQ,KAAK,SAAS;YAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtF,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,GAAG,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;IAC5B,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,CAAC,OAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAChF,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,CAAU,CAAC,CAAC,CAAC;IAE7E,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACzB,IAAI,CAAC,CAAC,UAAU,KAAK,MAAM,IAAI,CAAC,CAAC,QAAQ,KAAK,SAAS;YAAE,OAAO,CAAC,CAAC;QAClE,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,CAAC,CAAC,CAAC,gEAAgE;QACnG,MAAM,WAAW,GAAqB;YACpC,SAAS;YACT,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,SAAS,SAAS,CAAC,EAAE,CAAC;SACxD,CAAC;QACF,OAAO,EAAE,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC;IAC/B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,+FAA+F;AAC/F,SAAS,sBAAsB,CAAC,GAAY;IAC1C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,OAAO,GAAqC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,KAA6B,EAC7B,IAAI,GAA0B,QAAQ;IAEtC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE;YAC9C,KAAK,EAAE,MAAM,CAAC,mBAAmB,CAAC;YAClC,0FAA0F;YAC1F,MAAM,EAAE,KAAK,CAAC,gBAAgB;SAC/B,CAAC,CAAC;QACH,MAAM,GAAG,GAAG,sBAAsB,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG;YAAE,OAAO,SAAS,CAAC;QAC3B,iFAAiF;QACjF,MAAM,OAAO,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;QACnC,IAAI,KAAK,GAAG,wBAAwB,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3D,6FAA6F;QAC7F,4FAA4F;QAC5F,IAAI,KAAK,CAAC,QAAQ;YAAE,KAAK,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QACvD,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,mBAAmB,CAAC,CAAC;QACjD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC;IAC1G,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC,CAAC,oDAAoD;IACxE,CAAC;AACH,CAAC;AAGD,gGAAgG;AAChG,EAAE;AACF,uFAAuF;AACvF,+FAA+F;AAC/F,kGAAkG;AAClG,yFAAyF;AACzF,oGAAoG;AACpG,0CAA0C;AAC1C,EAAE;AACF,kGAAkG;AAClG,mGAAmG;AACnG,6FAA6F;AAC7F,iGAAiG;AACjG,4FAA4F;AAE5F;;;;kEAIkE;AAClE,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,wCAAwC,CAAC,IAAI,GAAG,CAAC;AAErH,sEAAsE;AACtE,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAEzC;iGACiG;AACjG,MAAM,2BAA2B,GAAG,CAAC,CAAC;AAEtC,6FAA6F;AAC7F,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,EAAU;IACtC,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACrB,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO,SAAS,CAAC;QAC9B,OAAO,MAAM,CAAC,CAAC,IAAI,GAAG,CAAC,GAAG,gBAAgB,CAAC;IAC7C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC,CAAC,wCAAwC;IAC5D,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,aAAa,CAAC,EAAU;IAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC;IAC7D,MAAM,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC;IAChC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;AACxC,CAAC;AAED;+FAC+F;AAC/F,SAAS,SAAS,CAAC,CAA0B,EAAE,EAAU;IACvD,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;IACnF,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,GAAG,CAAC;IACrC,OAAO,aAAa,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;6CAW6C;AAC7C,MAAM,UAAU,0BAA0B,CAAC,IAAiB;IAC1D,OAAO,CACL,IAAI,CAAC,UAAU,KAAK,OAAO;QAC3B,IAAI,CAAC,UAAU,KAAK,MAAM;QAC1B,CAAC,IAAI,CAAC,UAAU,KAAK,KAAK,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,6CAA6C;KACzG,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,uBAAuB,CAC9B,CAA0B,EAC1B,KAAyB,EACzB,IAA0B,EAC1B,QAA4B;IAE5B,MAAM,CAAC,IAAI,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACpD,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAC,CAAC,iDAAiD;IAC9E,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC,CAAC,+CAA+C;IACxG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IACjC,IAAI,EAAE,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC,CAAC,6CAA6C;IACrF,OAAO;QACL,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,EAAE;QACF,iGAAiG;QACjG,gDAAgD;QAChD,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,0FAA0F;QAC1F,8FAA8F;QAC9F,qCAAqC;QACrC,MAAM,EAAE,aAAa,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,KAAK,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;QAC5F,IAAI;QACJ,QAAQ;QACR,IAAI,EAAE,IAAI,CAAC,IAAI;KAChB,CAAC;AACJ,CAAC;AAED;;;;+DAI+D;AAC/D,KAAK,UAAU,kBAAkB,CAC/B,OAAyB,EACzB,SAAiB,EACjB,gBAAwB,EACxB,QAAgB;IAEhB,MAAM,GAAG,GAAmC,EAAE,CAAC;IAC/C,IAAI,MAAM,GAAG,gBAAgB,CAAC;IAC9B,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,2BAA2B,EAAE,IAAI,EAAE,EAAE,CAAC;QAC9D,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,4BAA4B,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9F,MAAM,IAAI,GAAG,sBAAsB,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM;QACtC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,yDAAyD;QAC/F,MAAM,QAAQ,GAAG,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QACvE,IAAI,CAAC,QAAQ;YAAE,MAAM;QACrB,MAAM,gBAAgB,GAAG,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACrD,IAAI,gBAAgB,KAAK,SAAS,IAAI,gBAAgB,GAAG,QAAQ;YAAE,MAAM,CAAC,uBAAuB;QACjG,IAAI,IAAI,CAAC,MAAM,GAAG,4BAA4B;YAAE,MAAM,CAAC,+BAA+B;QACtF,MAAM,GAAG,QAAQ,CAAC,CAAC,oDAAoD;IACzE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AA2BD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,KAAmC,EACnC,IAAI,GAA0B,QAAQ,EACtC,WAAW,GAAqB,MAAM;IAEtC,IAAI,CAAC;QACH,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACxD,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,IAAI,iCAAiC,CAAC;QACjF,gGAAgG;QAChG,6DAA6D;QAC7D,MAAM,QAAQ,GAAG,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;QACzC,+FAA+F;QAC/F,yFAAyF;QACzF,MAAM,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,SAAS,CAAC;QACtD,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAElI,MAAM,GAAG,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;QACtG,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAEhC,MAAM,IAAI,GAAyB,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;QACzE,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9D,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,MAAM,GAAG,GAAwB,EAAE,CAAC;QACpC,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;YACpB,MAAM,CAAC,GAAG,uBAAuB,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAClE,IAAI,CAAC,CAAC;gBAAE,SAAS;YACjB,IAAI,CAAC,CAAC,EAAE,GAAG,QAAQ;gBAAE,SAAS,CAAC,+BAA+B;YAC9D,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBAAE,SAAS,CAAC,oCAAoC;YAClE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACf,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACd,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,WAAW,KAAK,OAAO;YAAE,MAAM,GAAG,CAAC;QACvC,OAAO,EAAE,CAAC,CAAC,0DAA0D;IACvE,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,kCAAkC,CACtD,KAAmC,EACnC,IAAI,GAA0B,QAAQ,EACtC,QAA6B;IAE7B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,4BAA4B,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC/D,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QACnC,OAAO,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC,CAAC,0DAA0D;IACvE,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,GAAuB,EAAE,IAAI,GAA0B,QAAQ;IAC3G,MAAM,QAAQ,GAAG,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC;IAC9C,MAAM,MAAM,GAAG,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,SAAS,CAAC;IAC/C,MAAM,gBAAgB,GAAG,GAAG,CAAC,SAAS,IAAI,aAAa,CAAC,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACnF,MAAM,UAAU,GAA0B;QACxC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;YAClC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YACjD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;YAC5E,OAAO,GAAG,CAAC;QACb,CAAC;KACF,CAAC;IACF,OAAO,4BAA4B,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AACpI,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC;AAEhD;uEACuE;AACvE,MAAM,CAAC,MAAM,uBAAuB,GAAqB,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC"}

package/dist/agent/channels/discord-bot-name.d.ts

@@ -0,0 +1,19 @@
+import type { BotDisplayNameArm } from "@open-everywhere/core/agent/adapter-api.js";
+/** `GET /users/@me` — injectable for offline tests, same DI shape as discord-read.ts's
+ *  `DiscordReadRequester`. Returns the parsed JSON body; throws on a missing token, a non-ok
+ *  response, or a transport failure — the caller catches. */
+export type DiscordSelfRequester = () => Promise<unknown>;
+/**
+ * The bot's own Discord handle — `global_name` when Discord reports one, else `username` — or
+ * `undefined` when neither resolves. Pure but for the injected `req`, so the resolution rule is
+ * unit-testable with a canned requester: no token mint and no network call. FAIL-SOFT on
+ * everything: a thrown request (no token / non-ok status / transport failure) and a response that
+ * is not an object both read `undefined`.
+ */
+export declare function discordBotDisplayNameViaRest(req: DiscordSelfRequester): Promise<string | undefined>;
+/** Live arm: {@link discordBotDisplayNameViaRest} through the real REST transport, resolved once
+ *  per instance and registered into core's registry from register.ts. */
+export declare const discordBotDisplayName: BotDisplayNameArm;
+/** Test seam: drop the memoised handle so one test cannot inherit another's. */
+export declare function _resetDiscordBotDisplayNameForTest(): void;
+//# sourceMappingURL=discord-bot-name.d.ts.map

package/dist/agent/channels/discord-bot-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-bot-name.d.ts","sourceRoot":"","sources":["../../../agent/channels/discord-bot-name.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;AAIpF;;6DAE6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;AAyB1D;;;;;;GAMG;AACH,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAOzG;AAKD;yEACyE;AACzE,eAAO,MAAM,qBAAqB,EAAE,iBAmBnC,CAAC;AAEF,gFAAgF;AAChF,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD"}