@addozhang/dsh-discord 0.1.0

package/lib/index.js

@@ -0,0 +1,869 @@
+import { DEFAULT_DISCORD_SETTINGS, DiscordSettingsSchema, installDiscordSettings, normalizeDiscordSettings, } from './settings.js';
+import { settingsNamespace } from '@deepseek-ai/dsh-settings';
+import { installCancellationRoot } from './lifecycle.js';
+import { ALLOWED_MENTIONS_NONE, DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, OUTBOUND_EPHEMERAL_FLAGS } from './policy/disclosure.js';
+import { validateHostCapabilities } from './startup.js';
+import { createAdapterStatusTracker, installAdapterStatusRpc, } from './features/adapter-status.js';
+import { DISCORD_BOT_TOKEN_REF, describeDiscordCredential, resolveDiscordBotToken } from './credential.js';
+import { createSharedRestClient } from './discord/rest.js';
+import { createRestThreadPort } from './discord/thread-port.js';
+import { createComponentRegistry } from './discord/components.js';
+import { buildCommandRegistrations } from './discord/commands.js';
+import { startDiscordAdapter } from './compose.js';
+import { createWorkspaceCatalogPort, createWorkspaceResolver, readWorkspaceDetail, promptSession, createSessionViaProxy, cancelSessionViaProxy, steerSession, removeQueueItemViaProxy } from './dsh/api-proxy-face.js';
+import { createApprovalStore } from './features/approval-store.js';
+import { createAskWiring } from './features/ask-wiring.js';
+import { sweepExpiredApprovals } from './features/approval-expiry.js';
+import { sweepExpiredQuestions } from './features/question-expiry.js';
+import { createQuestionStore } from './features/question-store.js';
+import { handleSelectInput, handleModalSubmit } from './features/question-routing.js';
+import { createCopy } from './i18n.js';
+import { createInteractionRouter } from './features/interaction-router.js';
+import { channelBindingKey, parseChannelBindingKey, threadBindingKey, parseThreadBindingKey, discordDomainSpec, CHANNEL_BINDINGS_TABLE, THREAD_BINDINGS_TABLE, INTENTS_TABLE } from './state/domain.js';
+import { planBindingReconciliation } from './features/reconcile-bindings.js';
+import { guildKeysToForget, sweepExpired } from './state/retention.js';
+import { listSessionIds, createClientRespondPort } from './dsh/api-proxy-face.js';
+import { createBindingStore } from './state/bindings.js';
+import { createIntentStore } from './state/intents.js';
+import { createTurnTracker } from './features/turn-ownership.js';
+import { createThreadCreationFlow } from './features/thread-creation.js';
+import { createSessionCreationFlow } from './features/session-creation.js';
+import { createPromptSubmissionFlow } from './features/prompt-submission.js';
+import { createSessionMainline, requestIdFor } from './features/session-mainline.js';
+import { startLiveRender } from './stream/live.js';
+import { planWorkspaceChannel, workspaceChannelName } from './features/workspace-channel.js';
+/** Stable Cordis plugin name for diagnostics. */
+export const name = 'dsh-discord';
+/** Host services required by the complete embedded adapter. */
+export const inject = ['apiProxy', 'credentials', 'settings', 'storageDomain', 'connection'];
+export const Config = DiscordSettingsSchema;
+/**
+ * Fixed Milestone 1 Gateway intents: guilds, messages, content. Member data
+ * rides MESSAGE_CREATE/INTERACTION_CREATE payloads, so the privileged
+ * GUILD_MEMBERS bit (1 << 1) is not requested — without the Dev Portal
+ * toggle Discord rejects identify with 4014, which is terminal for us.
+ */
+const GATEWAY_INTENTS = (1 << 0) | (1 << 9) | (1 << 15);
+/**
+ * Emit through the Host's logger service only when it is actually wired:
+ * bare or fake Cordis contexts must not turn an error path into an
+ * unhandled rejection.
+ */
+function emitLog(ctx, level, message) {
+    const logger = ctx.logger;
+    const emit = logger?.[level];
+    if (typeof emit === 'function')
+        emit.call(logger, message);
+}
+/**
+ * Mount the embedded Discord adapter. Composition of the runtime path
+ * (Gateway → ingress → command/mention dispatch → Discord REST, plus the
+ * reconciliation sweeps) lives in `src/compose.ts` and is started from here.
+ */
+export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
+    validateHostCapabilities(name => ctx.get(name));
+    installCancellationRoot(ctx);
+    let current = normalizeDiscordSettings(config);
+    /**
+     * Discord-visible copy, re-resolved on every access so a language change
+     * on the settings card applies without rebuilding the composition. The
+     * 'auto' preference follows the DSH locale (the `locale` namespace the
+     * Host app registers); non-Chinese locales fall back to English.
+     */
+    const resolveLanguage = () => {
+        if (current.language !== 'auto')
+            return current.language;
+        const locale = ctx.get('settings').get(settingsNamespace('locale'));
+        return typeof locale?.preference === 'string' && locale.preference.startsWith('zh') ? 'zh' : 'en';
+    };
+    const copy = new Proxy({}, {
+        get: (_target, key) => createCopy(resolveLanguage())[key],
+    });
+    // Reassigned once the async composition has built the real registrar.
+    let registerCommands = async () => { };
+    const onGuildsChanged = () => { void registerCommands(); };
+    installDiscordSettings(ctx, current, (next) => {
+        const guildsChanged = next.allowedGuildIds.join(',') !== current.allowedGuildIds.join(',');
+        current = next;
+        if (guildsChanged)
+            onGuildsChanged();
+        emitLog(ctx, 'debug', {
+            event: 'discord_settings_applied',
+            enabled: current.enabled,
+            allowedGuildCount: current.allowedGuildIds.length,
+        });
+    });
+    // The settings card's status surface: credential presence seeded now, the
+    // Gateway observation fed by the adapter composition as it starts.
+    // Services resolve through the same accessor the startup boundary probes.
+    const statusTracker = createAdapterStatusTracker();
+    // Late-bound so the management channel can reach the runtime built inside
+    // the composition IIFE below (the card's Connect button).
+    const runtimeRef = { current: undefined };
+    installAdapterStatusRpc(ctx.get('connection'), statusTracker, {
+        tracker: statusTracker,
+        setToken: async (value) => {
+            await ctx.get('credentials').set(DISCORD_BOT_TOKEN_REF, value);
+            statusTracker.setCredential({ configured: true });
+        },
+        connect: () => { runtimeRef.current?.connect(); },
+        disconnect: () => { runtimeRef.current?.disconnect(); },
+    });
+    void describeDiscordCredential(ctx.get('credentials'))
+        .then((view) => { statusTracker.setCredential(view); })
+        .catch((cause) => {
+        emitLog(ctx, 'warn', { event: 'discord_credential_probe_failed', cause: String(cause) });
+        statusTracker.setCredential({ configured: false });
+    });
+    const credentials = ctx.get('credentials');
+    // The in-process apiProxy face: domain methods resolve RpcRequest →
+    // RpcResponse and never throw business errors; boundedness and outcome
+    // logging live in src/dsh/api-proxy-face.ts.
+    const apiProxy = ctx.get('apiProxy');
+    // Every apiProxy outcome is visible on stderr: the live profile pass reads
+    // this channel, and a silent call can never again be misread as a hang.
+    const rpcLog = (event, detail) => {
+        console.error(`[dsh-discord] ${event}:`, typeof detail === 'string' ? detail : JSON.stringify(detail ?? null));
+        emitLog(ctx, 'debug', { event, detail: typeof detail === 'string' ? detail : JSON.stringify(detail ?? null) });
+    };
+    void (async () => {
+        // The durable domain gates the whole composition: no adapter starts
+        // without its bindings/intents tables, and close() drains queued writes
+        // on teardown (fail-closed across restarts, design §10).
+        const domain = await ctx.storageDomain.open(discordDomainSpec);
+        ctx.effect(() => () => { void domain.close(); }, 'discord durable domain');
+        const catalogPort = createWorkspaceCatalogPort(apiProxy, { log: rpcLog });
+        const policy = () => ({
+            allowedGuildIds: [...current.allowedGuildIds],
+            memberUserIds: [...current.memberUserIds],
+            memberRoleIds: [...current.memberRoleIds],
+            administratorUserIds: [...current.administratorUserIds],
+            administratorRoleIds: [...current.administratorRoleIds],
+            deniedUserIds: [...current.deniedUserIds],
+            deniedRoleIds: [...current.deniedRoleIds],
+            hostOperatorUserIds: [...current.hostOperatorUserIds],
+        });
+        // Channel→Workspace and Thread→Session bindings, inbound-intent records,
+        // and the adapter-owned turn tracker. The first three are DURABLE through
+        // the storage-domain tables opened above (design §10); reads are
+        // synchronous from the domain's in-memory projection, writes queue on
+        // its durable chain. queueSnapshots stays process-local by design. The
+        // Discord application id equals the bot user id, resolved at start.
+        const applicationIdRef = { current: 'dsh-discord' };
+        const channelTable = domain.table(CHANNEL_BINDINGS_TABLE);
+        const threadTable = domain.table(THREAD_BINDINGS_TABLE);
+        const intentTable = domain.table(INTENTS_TABLE);
+        const bindingStore = createBindingStore(channelTable);
+        const threadBindingStore = createBindingStore(threadTable);
+        const intents = createIntentStore(intentTable);
+        const turnTracker = createTurnTracker();
+        // Approvals: process-local backing (minutes-lived; DSH replays pending
+        // asks on mux reopen). turnActors maps submitted request ids to their
+        // Discord authors — the ownership fact for approval/question clicks.
+        const approvalRows = new Map();
+        const approvalsStore = createApprovalStore({
+            get: key => approvalRows.get(key),
+            put: (key, record) => {
+                approvalRows.set(key, record);
+                return Promise.resolve();
+            },
+        });
+        const questionsStore = createQuestionStore();
+        const turnActors = new Map();
+        const sharedRegistry = createComponentRegistry();
+        const questionCancelPort = {
+            cancel: async ({ sessionId }) => {
+                const cancelled = await cancelSessionViaProxy(apiProxy, { sessionId }, { log: rpcLog });
+                const turn = turnTracker.active(sessionId);
+                if (turn !== undefined)
+                    turnTracker.complete(turn.requestId);
+                return cancelled.outcome === 'accepted'
+                    ? { outcome: 'accepted' }
+                    : cancelled.outcome === 'rejected'
+                        ? { outcome: 'rejected', reason: cancelled.reason }
+                        : { outcome: 'unknown' };
+            },
+        };
+        const askWiring = createAskWiring({
+            registry: sharedRegistry,
+            approvals: approvalsStore,
+            questions: questionsStore,
+            cancelPort: questionCancelPort,
+            nowMs: () => Date.now(),
+            log: rpcLog,
+            activeTurnRequestId: sessionId => turnTracker.active(sessionId)?.requestId,
+            turnActor: requestId => turnActors.get(requestId),
+            threadOwner: threadId => {
+                for (const key of threadTable.keys()) {
+                    if (!key.endsWith(`:${threadId}`))
+                        continue;
+                    const createdBy = threadTable.get(key)?.createdBy;
+                    if (typeof createdBy === 'string' && createdBy !== '')
+                        return createdBy;
+                }
+                return undefined;
+            },
+            postMessage: async (threadId, payload) => {
+                const rest = await sharedRest();
+                if (rest === undefined)
+                    return { stored: false, reason: 'rest unavailable' };
+                const sent = await rest.request('POST', `/channels/${threadId}/messages`, payload);
+                if (sent.outcome !== 'completed') {
+                    return {
+                        stored: false,
+                        reason: sent.outcome === 'rejected'
+                            ? `HTTP ${String(sent.status)} ${sent.error.message}`
+                            : sent.reason,
+                    };
+                }
+                if (typeof sent.body?.id !== 'string')
+                    return { stored: false, reason: `HTTP ${String(sent.status)}: response missing message id` };
+                return { stored: true, messageId: sent.body.id };
+            },
+        });
+        const componentFollowUp = async (_interactionId, interactionToken, content) => {
+            const rest = await sharedRest();
+            if (rest === undefined)
+                return;
+            const posted = await rest.request('POST', `/webhooks/${applicationIdRef.current}/${interactionToken}`, { content, flags: OUTBOUND_EPHEMERAL_FLAGS });
+            if (posted.outcome !== 'completed') {
+                rpcLog('discord_followup_failed', posted.outcome === 'rejected' ? `HTTP ${String(posted.status)}` : posted.reason);
+            }
+        };
+        const bindings = {
+            workspaceForChannel: (guildId, channelId) => bindingStore.get(channelBindingKey({
+                applicationId: applicationIdRef.current, guildId, channelId,
+            }))?.workspaceId,
+            sessionForThread: (guildId, threadId) => threadBindingStore.get(threadBindingKey({
+                applicationId: applicationIdRef.current, guildId, threadId,
+            }))?.sessionId,
+        };
+        // ── Session mainline: mention → thread → session → prompt → turn ──────
+        const restThreadPort = (() => {
+            const port = createRestThreadPort({
+                request: async (method, path, body) => {
+                    const rest = await sharedRest();
+                    if (rest === undefined)
+                        return { outcome: 'unknown', reason: 'network-unreachable' };
+                    return rest.request(method, path, body);
+                },
+            }, { autoArchiveMinutes: () => current.threadAutoArchiveMinutes });
+            return {
+                ...port,
+                // The join only affects sidebar visibility, but a silent refusal is
+                // still indistinguishable from a working one — log it (runbook rule).
+                joinThread: async (request) => {
+                    const joined = await port.joinThread(request);
+                    if (joined.outcome !== 'completed') {
+                        rpcLog('discord_thread_join_failed', request);
+                    }
+                    return joined;
+                },
+            };
+        })();
+        const dshSessionPort = {
+            createSession: request => createSessionViaProxy(apiProxy, request, { log: rpcLog }),
+        };
+        const dshPromptPort = {
+            submit: request => promptSession(apiProxy, { sessionId: request.sessionId, prompt: request.prompt }, { log: rpcLog, rpcId: request.requestId }),
+        };
+        const composedMainline = createSessionMainline({
+            threads: createThreadCreationFlow({
+                intents,
+                discord: restThreadPort,
+                nowMs: () => Date.now(),
+            }),
+            sessions: createSessionCreationFlow({
+                sessions: dshSessionPort,
+                threadBindings: threadBindingStore,
+                newSessionId: () => crypto.randomUUID(),
+            }),
+            prompts: createPromptSubmissionFlow({
+                prompts: dshPromptPort,
+                intents,
+                nowMs: () => Date.now(),
+            }),
+            turns: turnTracker,
+        });
+        /** Mainline outcome → copy key; the string resolves live per language. */
+        const MAINLINE_FAILURE_KEYS = {
+            'thread-conflict': 'mainlineThreadConflict',
+            'thread-failed': 'mainlineThreadFailed',
+            'session-rejected': 'mainlineSessionRejected',
+            'session-unknown': 'mainlineSessionUnknown',
+            'prompt-rejected': 'mainlinePromptRejected',
+            'prompt-unknown': 'mainlinePromptUnknown',
+        };
+        const mainline = {
+            admitMention: async (request) => {
+                const result = await composedMainline.admitMention(request);
+                if (result.outcome === 'admitted') {
+                    // Ownership fact: this request id's turn belongs to this author —
+                    // approval/question clicks authorize against it.
+                    turnActors.set(requestIdFor(request.messageId), request.authorId);
+                    rpcLog('discord_mention_admitted', { messageId: request.messageId, threadId: result.threadId, sessionId: result.sessionId });
+                }
+                else {
+                    rpcLog('discord_mention_not_admitted', { messageId: request.messageId, outcome: result.outcome });
+                    const notice = copy[MAINLINE_FAILURE_KEYS[result.outcome]];
+                    void withRest(rest => rest.request('POST', `/channels/${request.channelId}/messages`, { content: notice, flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, allowed_mentions: ALLOWED_MENTIONS_NONE }))
+                        .catch((cause) => { rpcLog('discord_mainline_notice_failed', String(cause)); });
+                }
+                return result;
+            },
+            continueInThread: async (request) => {
+                const result = await composedMainline.continueInThread(request);
+                if (result.outcome === 'rejected' || result.outcome === 'unknown') {
+                    rpcLog('discord_continuation_not_queued', { messageId: request.messageId, outcome: result.outcome });
+                    const notice = result.outcome === 'rejected' ? copy.continuationRejected : copy.continuationUnknown;
+                    void withRest(rest => rest.request('POST', `/channels/${request.threadId}/messages`, { content: notice, flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, allowed_mentions: ALLOWED_MENTIONS_NONE }))
+                        .catch((cause) => { rpcLog('discord_mainline_notice_failed', String(cause)); });
+                }
+                return result;
+            },
+        };
+        // Bind provision resolves the selection against the live catalog; the
+        // Discord confirm button carries only opaque registry ids between the
+        // command and the write.
+        const resolver = createWorkspaceResolver(apiProxy, { log: rpcLog });
+        // Adapter-owned guild surfaces: the "DeepSeek Harness" category, the
+        // general control channel (both provisioned on READY), and — on bind —
+        // one channel per Workspace, named after its display title. Nothing
+        // outside the category is ever touched.
+        const CATEGORY_NAME = 'DeepSeek Harness';
+        const ensureCategory = async (rest, guildId) => {
+            const listed = await rest.request('GET', `/guilds/${guildId}/channels`);
+            if (listed.outcome !== 'completed')
+                return undefined;
+            const channels = listed.body;
+            let category = channels.find((c) => c.type === 4 && c.name.toLowerCase() === CATEGORY_NAME.toLowerCase());
+            if (category === undefined) {
+                const made = await rest.request('POST', `/guilds/${guildId}/channels`, { name: CATEGORY_NAME, type: 4 });
+                if (made.outcome !== 'completed')
+                    return undefined;
+                category = made.body;
+            }
+            return { channels, categoryId: category.id };
+        };
+        /**
+         * ONE process-wide REST client, rebuilt only when the resolved token
+         * changes. Per-route serialization lives inside the client, so concurrent
+         * sends/edits/typing into one channel queue behind each other instead of
+         * racing the bucket; every composition path goes through here.
+         */
+        let sharedRestCache;
+        const sharedRest = async () => {
+            const token = (await resolveDiscordBotToken(credentials)) ?? '';
+            if (token === '')
+                return undefined;
+            if (sharedRestCache?.token !== token) {
+                const apiBase = process.env['DSH_DISCORD_REST_BASE'];
+                sharedRestCache = {
+                    token,
+                    client: createSharedRestClient({ token, ...(apiBase === undefined ? {} : { apiBase }) }),
+                };
+            }
+            return sharedRestCache.client;
+        };
+        const withRest = async (run) => {
+            const rest = await sharedRest();
+            if (rest === undefined)
+                return undefined;
+            return run(rest);
+        };
+        /**
+         * Reconcile an unobservable message send (rest.ts contract): the send
+         * carried a nonce, so a message that actually landed is findable among
+         * the channel's recent messages — authored by this bot. `undefined`
+         * means the outcome stays unobservable (no evidence either way).
+         */
+        const findSentMessageByNonce = async (rest, channelId, nonce) => {
+            // The list body is untrusted wire data: narrow every row by shape.
+            const listed = await rest.request('GET', `/channels/${channelId}/messages?limit=50`);
+            if (listed.outcome !== 'completed' || !Array.isArray(listed.body))
+                return undefined;
+            for (const row of listed.body) {
+                if (typeof row !== 'object' || row === null)
+                    continue;
+                const record = row;
+                if (record['nonce'] !== nonce)
+                    continue;
+                const author = record['author'];
+                if (typeof author !== 'object' || author === null)
+                    continue;
+                if (author['id'] !== applicationIdRef.current)
+                    continue;
+                if (typeof record['id'] === 'string')
+                    return record['id'];
+            }
+            return undefined;
+        };
+        const bindChannelKey = (guildId, channelId) => channelBindingKey({ applicationId: applicationIdRef.current, guildId, channelId });
+        /** The guild channel already serving this Workspace, if any (one-project-one-channel lookup). */
+        const findBoundChannelFor = (guildId, workspaceId) => {
+            for (const [key, binding] of channelTable.entries()) {
+                if (binding.workspaceId !== workspaceId)
+                    continue;
+                const scope = parseChannelBindingKey(key);
+                if (scope?.guildId === guildId)
+                    return scope.channelId;
+            }
+            return undefined;
+        };
+        /**
+         * Ensure the Workspace's home channel exists under the adapter category
+         * and serves this Workspace (one-project-one-channel: the
+         * Workspace's existing bound channel wins outright). A same-name channel
+         * is reused only when unbound; a channel serving another Workspace is
+         * never stolen — a `-2` sibling is created instead.
+         */
+        const ensureWorkspaceChannel = async (options) => {
+            return withRest(async (rest) => {
+                const ensured = await ensureCategory(rest, options.guildId);
+                if (ensured === undefined)
+                    return undefined;
+                // The control channel (general, the control-channel analog) is
+                // the command surface — it must never become a Workspace home.
+                const controlChannelId = ensured.channels.find((c) => c.type === 0 && c.name.toLowerCase() === 'general' && c.parent_id === ensured.categoryId)?.id;
+                const bindingOf = (channelId) => {
+                    if (channelId === controlChannelId)
+                        return 'other-workspace';
+                    const bound = bindingStore.get(bindChannelKey(options.guildId, channelId));
+                    if (bound === undefined)
+                        return 'unbound';
+                    return bound.workspaceId === options.workspaceId ? 'this-workspace' : 'other-workspace';
+                };
+                const existing = findBoundChannelFor(options.guildId, options.workspaceId);
+                const record = { workspaceId: options.workspaceId, boundBy: options.actorId, boundAtMs: Date.now() };
+                const placement = planWorkspaceChannel({
+                    channels: ensured.channels.map((c) => ({ id: c.id, name: c.name, parentId: c.parent_id })),
+                    categoryId: ensured.categoryId,
+                    desiredName: workspaceChannelName(options.title),
+                    bindingOf,
+                    existingForWorkspace: existing,
+                });
+                if (placement.outcome === 'reuse') {
+                    if (placement.needsBind) {
+                        await bindingStore.bind(bindChannelKey(options.guildId, placement.channelId), record);
+                    }
+                    return { channelId: placement.channelId, created: false };
+                }
+                const made = await rest.request('POST', `/guilds/${options.guildId}/channels`, {
+                    name: placement.name,
+                    type: 0,
+                    parent_id: ensured.categoryId,
+                });
+                if (made.outcome !== 'completed') {
+                    rpcLog('discord_workspace_channel_create_failed', made.outcome === 'rejected' ? `HTTP ${String(made.status)}` : made.reason);
+                    return undefined;
+                }
+                await bindingStore.bind(bindChannelKey(options.guildId, made.body.id), record);
+                return { channelId: made.body.id, created: true };
+            });
+        };
+        // ── Reconciliation (reconciliation spec): on READY, verify every
+        // persisted mapping against the DSH baseline and Discord's live
+        // surface. Retirement ever deletes only adapter records; unverifiable
+        // mappings stay blocked (logged) rather than guessed away.
+        let reconciling = false;
+        const reconcileOnReady = async () => {
+            if (reconciling)
+                return;
+            reconciling = true;
+            try {
+                const rest = await sharedRest();
+                if (rest === undefined)
+                    return;
+                const catalog = await catalogPort.listWorkspaces();
+                if (catalog.outcome !== 'completed') {
+                    rpcLog('discord_reconcile_blocked', 'workspace-catalog-unavailable');
+                    return;
+                }
+                const sessionIds = await listSessionIds(apiProxy, { log: rpcLog });
+                if (sessionIds.outcome !== 'completed') {
+                    rpcLog('discord_reconcile_blocked', 'session-list-unavailable');
+                    return;
+                }
+                for (const guildId of current.allowedGuildIds) {
+                    const facts = {};
+                    const channels = await rest.request('GET', `/guilds/${guildId}/channels`);
+                    if (channels.outcome === 'completed') {
+                        for (const channel of channels.body)
+                            facts[channel.id] = 'ok';
+                        const threads = await rest.request('GET', `/guilds/${guildId}/threads/active`);
+                        if (threads.outcome === 'completed' && Array.isArray(threads.body?.threads)) {
+                            for (const thread of threads.body.threads)
+                                facts[thread.id] = 'ok';
+                        }
+                    }
+                    const plan = planBindingReconciliation({
+                        channelBindings: [...channelTable.entries()].map(([key, record]) => {
+                            const scope = parseChannelBindingKey(key);
+                            return { channelId: scope?.channelId ?? '', ...record };
+                        }).filter(binding => binding.channelId !== ''),
+                        threadBindings: [...threadTable.entries()].map(([key, record]) => {
+                            const scope = parseThreadBindingKey(key);
+                            return { threadId: scope?.threadId ?? '', ...record };
+                        }).filter(binding => binding.threadId !== ''),
+                        baseline: {
+                            workspaces: catalog.workspaces.map(workspace => ({ workspaceId: workspace.id, title: workspace.title, path: '' })),
+                            sessionIds: sessionIds.ids,
+                        },
+                        discord: { channels: facts },
+                    });
+                    for (const action of plan.channelActions) {
+                        if (action.action !== 'retire')
+                            continue;
+                        const scope = parseChannelBindingKey(channelBindingKey({ applicationId: applicationIdRef.current, guildId, channelId: action.channelId }));
+                        if (scope === undefined)
+                            continue;
+                        await channelTable.delete(channelBindingKey(scope));
+                        rpcLog('discord_reconcile_channel_retired', { channelId: action.channelId, reason: action.reason });
+                    }
+                    for (const action of plan.threadActions) {
+                        if (action.action !== 'retire')
+                            continue;
+                        const scope = parseThreadBindingKey(threadBindingKey({ applicationId: applicationIdRef.current, guildId, threadId: action.threadId }));
+                        if (scope === undefined)
+                            continue;
+                        await threadTable.delete(threadBindingKey(scope));
+                        rpcLog('discord_reconcile_thread_retired', { threadId: action.threadId, reason: action.reason });
+                    }
+                }
+                rpcLog('discord_reconcile_done', {});
+            }
+            finally {
+                reconciling = false;
+            }
+        };
+        // ── Retention sweep: completed intents age out on the durable table;
+        // interaction records are still process-local stubs and thus omitted.
+        const retentionTimer = setInterval(() => {
+            const plan = sweepExpired({ intents: [...intentTable.entries()].map(([key, record]) => [key, record]), resolvedInteractions: [] }, { nowMs: Date.now() });
+            for (const key of plan.intentKeys) {
+                void intentTable.delete(key).then(() => {
+                    rpcLog('discord_retention_intent_expired', { key });
+                });
+            }
+        }, 6 * 60 * 60_000);
+        ctx.effect(() => () => { clearInterval(retentionTimer); }, 'discord retention sweep');
+        // Approval/question expiry: 30s sweep — approvals auto-reject before
+        // their controls expire; question expiry cancels the owning turn.
+        const expiryTimer = setInterval(() => {
+            void sweepExpiredApprovals({
+                store: approvalsStore,
+                port: approvalRespondPort,
+                controls: { disable: key => askWiring.disableControl(key) },
+                nowMs: () => Date.now(),
+            }).catch((cause) => { rpcLog('discord_approval_expiry_threw', String(cause)); });
+            void sweepExpiredQuestions({
+                store: questionsStore,
+                cancelPort: questionCancelPort,
+                controls: { disable: key => askWiring.disableControl(key) },
+                nowMs: () => Date.now(),
+            }).catch((cause) => { rpcLog('discord_question_expiry_threw', String(cause)); });
+        }, 30_000);
+        ctx.effect(() => () => { clearInterval(expiryTimer); }, 'discord interaction expiry sweep');
+        // DSH approval respond face: the client-response echoes the ask's rpcId.
+        const clientRespond = createClientRespondPort(apiProxy, { log: rpcLog });
+        const approvalRespondPort = {
+            respond: async ({ rpcId, sessionId, approvalId, outcome }) => {
+                const receipt = await clientRespond.respond(rpcId, { sessionId, approvalId, outcome });
+                rpcLog('discord_approval_respond_receipt', { rpcId, approvalId, outcome, receipt });
+                return receipt;
+            },
+        };
+        const queueSnapshots = new Map();
+        /** Delete every adapter-owned record for one guild (DSH untouched). */
+        const forgetGuild = async (guildId) => {
+            const plan = guildKeysToForget({
+                guildId,
+                channelBindingKeys: [...channelTable.keys()],
+                threadBindingKeys: [...threadTable.keys()],
+            });
+            for (const key of plan.channelKeys)
+                await channelTable.delete(key);
+            for (const key of plan.threadKeys)
+                await threadTable.delete(key);
+            rpcLog('discord_guild_forget_deleted', { guildId, channels: plan.channelKeys.length, threads: plan.threadKeys.length });
+        };
+        const questionRespondPort = {
+            respond: async (input) => {
+                const receipt = await clientRespond.respond(input.rpcId, { sessionId: input.sessionId, answer: input.answer });
+                rpcLog('discord_question_respond_receipt', { rpcId: input.rpcId, receipt });
+                return receipt;
+            },
+        };
+        const questionRoutingDeps = {
+            registry: sharedRegistry,
+            store: questionsStore,
+            port: questionRespondPort,
+            nowMs: () => Date.now(),
+            controls: { disable: key => askWiring.disableControl(key) },
+        };
+        const interactionRouter = createInteractionRouter({
+            policy,
+            applicationId: () => applicationIdRef.current,
+            registry: sharedRegistry,
+            copy,
+            approvals: approvalsStore,
+            approvalRespondPort,
+            turnTracker,
+            queueSnapshots,
+            forgetGuild,
+            componentFollowUp,
+            disableControl: key => askWiring.disableControl(key),
+            handleQuestionComponent: input => handleSelectInput(questionRoutingDeps, input),
+            handleQuestionModal: input => handleModalSubmit(questionRoutingDeps, input),
+            dsh: {
+                cancel: sessionId => cancelSessionViaProxy(apiProxy, { sessionId }, { log: rpcLog }),
+                steer: (sessionId, prompt) => steerSession(apiProxy, { sessionId, prompt }, { log: rpcLog }),
+                removeQueueItem: (sessionId, itemId) => removeQueueItemViaProxy(apiProxy, { sessionId, itemId }, { log: rpcLog }),
+                readWorkspaceDetail: reference => readWorkspaceDetail(apiProxy, reference, { log: rpcLog }),
+            },
+            catalogPort,
+            resolver,
+            channelBinding: (guildId, channelId) => bindingStore.get(bindChannelKey(guildId, channelId)),
+            findBoundChannelFor,
+            sessionForThread: (guildId, threadId) => bindings.sessionForThread(guildId, threadId),
+            ensureWorkspaceChannel,
+            rest: sharedRest,
+            log: rpcLog,
+            warn: (event, detail) => {
+                emitLog(ctx, 'warn', { event, detail: typeof detail === 'string' ? detail : JSON.stringify(detail ?? null) });
+            },
+        });
+        runtimeRef.current = startDiscordAdapter({
+            tokenProvider: async () => (await resolveDiscordBotToken(credentials)) ?? undefined,
+            socketFactory: (url) => {
+                const ws = new WebSocket(url);
+                // Translate the browser-style WebSocket event API (undici) into the
+                // adapter's plain-callback contract. onclose MUST pass the numeric
+                // close code: terminal codes drive the fail-closed status surface.
+                const socket = {
+                    url,
+                    onopen: null,
+                    onmessage: null,
+                    onclose: null,
+                    onerror: null,
+                    close: (code) => { ws.close(code ?? 1000); },
+                    terminate: () => { ws.close(1000); },
+                    send: (data) => { ws.send(data); },
+                };
+                ws.onopen = () => { socket.onopen?.(); };
+                ws.onmessage = (ev) => { socket.onmessage?.(typeof ev.data === 'string' ? ev.data : String(ev.data)); };
+                ws.onclose = (ev) => { socket.onclose?.(ev.code); };
+                ws.onerror = () => { socket.onerror?.(new Error('socket error')); };
+                return socket;
+            },
+            policy,
+            selfUserIdProvider: async () => {
+                const rest = await sharedRest();
+                if (rest === undefined)
+                    throw new TypeError('discord bot token unavailable');
+                const me = await rest.request('GET', '/users/@me');
+                if (me.outcome !== 'completed')
+                    throw new TypeError('cannot resolve bot identity');
+                return me.body.id;
+            },
+            intents: GATEWAY_INTENTS,
+            // Twin-E2E seams: both overrides default to the production surfaces and
+            // exist only so a local Discord API twin can host the real protocol.
+            ...(process.env['DSH_DISCORD_GATEWAY_URL'] === undefined
+                ? {}
+                : { gatewayUrl: process.env['DSH_DISCORD_GATEWAY_URL'] }),
+            allowedGuildIds: [...current.allowedGuildIds],
+            applicationId: () => applicationIdRef.current,
+            mainline,
+            bindings,
+            unboundNotice: (request) => {
+                const content = request.audience === 'administrator'
+                    ? copy.unboundNoticeAdministrator
+                    : copy.unboundNoticeMember;
+                void withRest(async (rest) => {
+                    const sent = await rest.request('POST', `/channels/${request.channelId}/messages`, { content, flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, allowed_mentions: ALLOWED_MENTIONS_NONE });
+                    if (sent.outcome !== 'completed') {
+                        rpcLog('discord_unbound_notice_send_failed', sent.outcome === 'rejected' ? `HTTP ${String(sent.status)}` : sent.reason);
+                    }
+                }).catch((cause) => {
+                    rpcLog('discord_unbound_notice_threw', String(cause));
+                });
+            },
+            ensureGuildChannels: async (guildId) => {
+                await withRest(async (rest) => {
+                    const ensured = await ensureCategory(rest, guildId);
+                    if (ensured === undefined)
+                        return;
+                    // Never touch channels outside our category: create our own only.
+                    const hasControl = ensured.channels.some((c) => c.type === 0 && c.name.toLowerCase() === 'general' && c.parent_id === ensured.categoryId);
+                    if (hasControl)
+                        return;
+                    await rest.request('POST', `/guilds/${guildId}/channels`, { name: 'general', type: 0, parent_id: ensured.categoryId });
+                });
+            },
+            approvals: approvalsStore,
+            questions: questionsStore,
+            status: statusTracker,
+            registry: sharedRegistry,
+            onReady: () => reconcileOnReady(),
+            routeInteraction: (event, token) => {
+                // The router speaks the interaction dialect only (compose forwards
+                // interactions exclusively).
+                if (event.kind !== 'interaction')
+                    return;
+                return interactionRouter.route(event, token);
+            },
+            logger: {
+                warn: (event, detail) => {
+                    emitLog(ctx, 'warn', { event, detail: typeof detail === 'string' ? detail : JSON.stringify(detail ?? null) });
+                },
+            },
+        });
+        // Register the Milestone 1 command set per allowed Guild (instant
+        // propagation, unlike global commands) once the bot identity is known.
+        // Re-runs whenever the allowlist changes — apply-time settings may still
+        // be loading, so the first non-empty list wins.
+        let registering = false;
+        registerCommands = async () => {
+            if (registering || current.allowedGuildIds.length === 0)
+                return;
+            registering = true;
+            try {
+                const rest = await sharedRest();
+                if (rest === undefined)
+                    return;
+                const me = await rest.request('GET', '/users/@me');
+                if (me.outcome !== 'completed')
+                    return;
+                applicationIdRef.current = me.body.id;
+                const registrations = buildCommandRegistrations();
+                for (const guildId of current.allowedGuildIds) {
+                    const result = await rest.request('PUT', `/applications/${me.body.id}/guilds/${guildId}/commands`, registrations);
+                    if (result.outcome !== 'completed') {
+                        emitLog(ctx, 'warn', { event: 'discord_command_register_failed', guildId });
+                    }
+                }
+            }
+            finally {
+                registering = false;
+            }
+        };
+        void registerCommands().catch((cause) => {
+            emitLog(ctx, 'warn', { event: 'discord_command_register_failed', cause: String(cause) });
+        });
+        // ── Live streaming: DSH events.mux → per-thread Discord rendering ─────
+        // The queue snapshot cache (declared with the interaction router) is the
+        // /queue surface's data source: DSH 0.1.1 has no queue-list RPC, only the
+        // authoritative whole-snapshot mux frame.
+        const threadForSession = (sessionId) => {
+            for (const [key, record] of threadTable.entries()) {
+                if (record.sessionId !== sessionId)
+                    continue;
+                const scope = parseThreadBindingKey(key);
+                if (scope !== undefined)
+                    return scope.threadId;
+            }
+            return undefined;
+        };
+        const liveRef = { current: undefined };
+        liveRef.current = startLiveRender({
+            frames: (signal) => {
+                const events = apiProxy.events;
+                if (events === undefined)
+                    throw new TypeError('apiProxy.events is unavailable on this Host');
+                return events.mux({ rpcId: crypto.randomUUID(), payload: {} }, signal);
+            },
+            threadForSession,
+            delivery: {
+                send: async (request) => {
+                    const rest = await sharedRest();
+                    if (rest === undefined)
+                        return { outcome: 'failed' };
+                    // The nonce lets an unobservable send be reconciled instead of
+                    // blindly retried (rest.ts contract): a message that actually
+                    // landed is found by its nonce and reported completed.
+                    const nonce = crypto.randomUUID();
+                    const sent = await rest.request('POST', `/channels/${request.channelId}/messages`, {
+                        content: request.content,
+                        flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG,
+                        allowed_mentions: ALLOWED_MENTIONS_NONE,
+                        nonce,
+                    });
+                    if (sent.outcome === 'completed' && typeof sent.body?.id === 'string') {
+                        return { outcome: 'completed', messageId: sent.body.id };
+                    }
+                    if (sent.outcome === 'unknown') {
+                        const reconciled = await findSentMessageByNonce(rest, request.channelId, nonce);
+                        if (reconciled !== undefined)
+                            return { outcome: 'completed', messageId: reconciled };
+                        rpcLog('discord_live_send_unknown', { channelId: request.channelId });
+                        return { outcome: 'unknown' };
+                    }
+                    rpcLog('discord_live_send_failed', { channelId: request.channelId, outcome: sent.outcome });
+                    return { outcome: 'failed' };
+                },
+                edit: async (request) => {
+                    const rest = await sharedRest();
+                    if (rest === undefined)
+                        return { outcome: 'failed' };
+                    const edited = await rest.request('PATCH', `/channels/${request.channelId}/messages/${request.messageId}`, {
+                        content: request.content,
+                        flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG,
+                        allowed_mentions: ALLOWED_MENTIONS_NONE,
+                    });
+                    return edited.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                },
+                typing: async (channelId) => {
+                    const rest = await sharedRest();
+                    if (rest === undefined)
+                        return;
+                    await rest.request('POST', `/channels/${channelId}/typing`);
+                },
+                delete: async (request) => {
+                    const rest = await sharedRest();
+                    if (rest === undefined)
+                        return { outcome: 'failed' };
+                    const deleted = await rest.request('DELETE', `/channels/${request.channelId}/messages/${request.messageId}`);
+                    return deleted.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                },
+                renameThread: async (request) => {
+                    const rest = await sharedRest();
+                    if (rest === undefined)
+                        return { outcome: 'failed' };
+                    const renamed = await rest.request('PATCH', `/channels/${request.channelId}`, { name: request.name });
+                    return renamed.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                },
+            },
+            threadName: async (channelId) => {
+                const rest = await sharedRest();
+                if (rest === undefined)
+                    return undefined;
+                const got = await rest.request('GET', `/channels/${channelId}`);
+                return got.outcome === 'completed' && typeof got.body?.name === 'string' ? got.body.name : undefined;
+            },
+            updateIntervalMs: current.streamUpdateIntervalMs,
+            typingIntervalMs: current.typingIntervalMs,
+            approvalTimeoutMs: current.approvalTimeoutMs,
+            questionTimeoutMs: current.questionTimeoutMs,
+            verbosity: current.defaultVerbosity,
+            log: rpcLog,
+            interruptedMarker: () => copy.interruptedMarker,
+            onQueueSnapshot: (sessionId, items) => { queueSnapshots.set(sessionId, items); },
+            onTurnEnded: (sessionId) => {
+                const turn = turnTracker.active(sessionId);
+                if (turn !== undefined)
+                    turnTracker.complete(turn.requestId);
+                rpcLog('discord_turn_ended', { sessionId, hadActiveTurn: turn !== undefined });
+            },
+            requests: askWiring,
+        });
+        ctx.effect(() => () => { liveRef.current?.dispose(); }, 'dsh-discord live render');
+        ctx.effect(() => () => { runtimeRef.current?.dispose(); }, 'dsh-discord composed runtime');
+    })().catch((cause) => {
+        console.error('[dsh-discord] composition failed:', cause);
+        emitLog(ctx, 'warn', { event: 'discord_compose_failed', cause: String(cause) });
+        statusTracker.setGateway('disconnected');
+    });
+}
+export { DEFAULT_DISCORD_SETTINGS, DISCORD_SETTINGS_NAMESPACE, DiscordSettingsSchema, normalizeDiscordSettings, validateDiscordSettings, } from './settings.js';
+export { DISCORD_BOT_TOKEN_REF, describeDiscordCredential, resolveDiscordBotToken, } from './credential.js';