@aitne/daemon 0.1.7 → 0.1.9

package/dist/adapters/composite-dashboard-stream.d.ts

@@ -3,20 +3,18 @@ import type { SessionInfoPayload } from "../api/chat-binding-query.js";
 /**
  * Fan-out wrapper for the dispatcher's single `IDashboardStream` slot.
  *
- * The dispatcher only knows one outbound stream at a time
- * (`setDashboardStream(adapter)`), but Phase 2 of the docs-QA pipeline
- * introduces a second dashboard-platform adapter (`DocsQAAdapter`)
- * that needs to receive the same outbound calls. Channel routing is
- * content-addressed by `channelId` (each underlying adapter no-ops on
- * unknown ids per `dashboard-adapter.ts:211-218`), so fan-out is
- * naturally safe — only the adapter that owns the channel actually
- * emits.
+ * The dispatcher knows one outbound stream at a time
+ * (`setDashboardStream(adapter)`), but the docs-QA pipeline needs a
+ * second dashboard-platform adapter (`DocsQAAdapter`) to receive the
+ * same outbound calls. Channel routing is content-addressed by
+ * `channelId` (each underlying adapter no-ops on unknown ids), so
+ * fan-out is naturally safe — only the adapter that owns the channel
+ * actually emits.
  *
  * Class members are declared concrete (no `?`) even when the
  * `IDashboardStream` member is optional — the composite always fans
  * out the call; each underlying stream may or may not implement the
- * optional method, so we guard with `s.method?.(...)` per
- * DOCS_QA_B7_DESIGN.md §11.4.
+ * optional method, so we guard with `s.method?.(...)`.
  */
 export declare class CompositeDashboardStream implements IDashboardStream {
     private readonly streams;
@@ -39,4 +37,3 @@ export declare class CompositeDashboardStream implements IDashboardStream {
         caption?: string;
     }>): void;
 }
-//# sourceMappingURL=composite-dashboard-stream.d.ts.map

package/dist/adapters/composite-dashboard-stream.js

@@ -1,20 +1,18 @@
 /**
  * Fan-out wrapper for the dispatcher's single `IDashboardStream` slot.
  *
- * The dispatcher only knows one outbound stream at a time
- * (`setDashboardStream(adapter)`), but Phase 2 of the docs-QA pipeline
- * introduces a second dashboard-platform adapter (`DocsQAAdapter`)
- * that needs to receive the same outbound calls. Channel routing is
- * content-addressed by `channelId` (each underlying adapter no-ops on
- * unknown ids per `dashboard-adapter.ts:211-218`), so fan-out is
- * naturally safe — only the adapter that owns the channel actually
- * emits.
+ * The dispatcher knows one outbound stream at a time
+ * (`setDashboardStream(adapter)`), but the docs-QA pipeline needs a
+ * second dashboard-platform adapter (`DocsQAAdapter`) to receive the
+ * same outbound calls. Channel routing is content-addressed by
+ * `channelId` (each underlying adapter no-ops on unknown ids), so
+ * fan-out is naturally safe — only the adapter that owns the channel
+ * actually emits.
  *
  * Class members are declared concrete (no `?`) even when the
  * `IDashboardStream` member is optional — the composite always fans
  * out the call; each underlying stream may or may not implement the
- * optional method, so we guard with `s.method?.(...)` per
- * DOCS_QA_B7_DESIGN.md §11.4.
+ * optional method, so we guard with `s.method?.(...)`.
  */
 export class CompositeDashboardStream {
     streams;
@@ -46,4 +44,3 @@ export class CompositeDashboardStream {
             s.sendAttachments?.(channelId, attachments);
     }
 }
-//# sourceMappingURL=composite-dashboard-stream.js.map

package/dist/adapters/dashboard-adapter.d.ts

@@ -20,13 +20,18 @@ export declare class DashboardAdapter implements MessageAdapter {
     readonly platformName = "dashboard";
     readonly notificationEligible = false;
     get primaryRecipient(): string | null;
+    /**
+     * Channel → set of SSE clients. Multiple tabs on one channel get
+     * fan-out; a second `registerClient(channelId, ...)` for an existing
+     * key never silently replaces an open EventSource. Callers that pass a
+     * fresh UUID per connect get the equivalent of a 1:1 mapping for free.
+     */
     private readonly clients;
     private onMessage;
     private attachmentStore;
     constructor(onMessage: OnMessageCallback);
-    /** Inject the AttachmentStore. Optional — callers without attachment
-     *  support (older tests) skip this and POST /chat/messages rejects
-     *  attachmentIds with 503. */
+    /** Inject the AttachmentStore. Optional — without it,
+     *  POST /chat/messages rejects attachmentIds with 503. */
     setAttachmentStore(store: AttachmentStore): void;
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -42,7 +47,15 @@ export declare class DashboardAdapter implements MessageAdapter {
         resumeSessionValid?: boolean;
     }): string;
     /** Unregister a client. Called from SSE route onAbort. */
-    unregisterClient(channelId: string): void;
+    unregisterClient(channelId: string, client?: SSEClient): void;
+    private addClient;
+    /**
+     * Iterate every live client for `channelId`, invoking `cb` and reaping
+     * any client whose `closed` flag is true. Used by all `send*` methods
+     * so a stale (closed) client is collected on the next outbound write
+     * rather than lingering until explicit unregister.
+     */
+    private fanOut;
     /** Handle an incoming message from HTTP POST.
      *  Optional metadata is attached to event.data for downstream consumers (e.g. Dispatcher setup mode).
      *  Optional requestedModel / requestedBackendId+requestedModelId are set
@@ -95,10 +108,9 @@ export declare class DashboardAdapter implements MessageAdapter {
     sendSessionInfo(channelId: string, info: SessionInfoPayload): void;
     /** Send error to a specific channel (named "chat_error" to avoid EventSource built-in "error" collision) */
     sendError(channelId: string, message: string): void;
-    /** Check if a channel has an active SSE connection */
+    /** Check if a channel has at least one active SSE connection */
     isConnected(channelId: string): boolean;
     /** Get all active channel IDs */
     getActiveChannels(): string[];
 }
 export {};
-//# sourceMappingURL=dashboard-adapter.d.ts.map

package/dist/adapters/dashboard-adapter.js

@@ -17,15 +17,20 @@ export class DashboardAdapter {
     get primaryRecipient() {
         return this.getActiveChannels()[0] ?? null;
     }
+    /**
+     * Channel → set of SSE clients. Multiple tabs on one channel get
+     * fan-out; a second `registerClient(channelId, ...)` for an existing
+     * key never silently replaces an open EventSource. Callers that pass a
+     * fresh UUID per connect get the equivalent of a 1:1 mapping for free.
+     */
     clients = new Map();
     onMessage;
     attachmentStore = null;
     constructor(onMessage) {
         this.onMessage = onMessage;
     }
-    /** Inject the AttachmentStore. Optional — callers without attachment
-     *  support (older tests) skip this and POST /chat/messages rejects
-     *  attachmentIds with 503. */
+    /** Inject the AttachmentStore. Optional — without it,
+     *  POST /chat/messages rejects attachmentIds with 503. */
     setAttachmentStore(store) {
         this.attachmentStore = store;
     }
@@ -40,7 +45,7 @@ export class DashboardAdapter {
      *  Returns the channelId (UUID) assigned to this client. */
     registerClient(client, options) {
         const channelId = randomUUID();
-        this.clients.set(channelId, client);
+        this.addClient(channelId, client);
         const includeSessionId = options?.resumeSessionId != null && options.resumeSessionValid === true;
         const info = {
             channelId,
@@ -54,10 +59,59 @@ export class DashboardAdapter {
         return channelId;
     }
     /** Unregister a client. Called from SSE route onAbort. */
-    unregisterClient(channelId) {
-        this.clients.delete(channelId);
+    unregisterClient(channelId, client) {
+        const set = this.clients.get(channelId);
+        if (!set)
+            return;
+        if (client) {
+            set.delete(client);
+            if (set.size === 0)
+                this.clients.delete(channelId);
+        }
+        else {
+            this.clients.delete(channelId);
+        }
         logger.debug({ channelId }, "Dashboard client disconnected");
     }
+    addClient(channelId, client) {
+        const existing = this.clients.get(channelId);
+        if (existing) {
+            existing.add(client);
+        }
+        else {
+            this.clients.set(channelId, new Set([client]));
+        }
+    }
+    /**
+     * Iterate every live client for `channelId`, invoking `cb` and reaping
+     * any client whose `closed` flag is true. Used by all `send*` methods
+     * so a stale (closed) client is collected on the next outbound write
+     * rather than lingering until explicit unregister.
+     */
+    fanOut(channelId, cb) {
+        const set = this.clients.get(channelId);
+        if (!set || set.size === 0)
+            return;
+        let reaped = 0;
+        for (const client of [...set]) {
+            if (client.closed) {
+                set.delete(client);
+                reaped += 1;
+                continue;
+            }
+            try {
+                cb(client);
+            }
+            catch (err) {
+                logger.warn({ err, channelId }, "Dashboard SSE write failed for one client (continuing fan-out)");
+            }
+        }
+        if (set.size === 0)
+            this.clients.delete(channelId);
+        if (reaped > 0) {
+            logger.debug({ channelId, reaped }, "Reaped closed SSE clients");
+        }
+    }
     /** Handle an incoming message from HTTP POST.
      *  Optional metadata is attached to event.data for downstream consumers (e.g. Dispatcher setup mode).
      *  Optional requestedModel / requestedBackendId+requestedModelId are set
@@ -122,8 +176,9 @@ export class DashboardAdapter {
     }
     /** Send a complete message to a specific channel */
     async sendMessage(params) {
-        const client = this.clients.get(params.channel);
-        if (!client || client.closed) {
+        const set = this.clients.get(params.channel);
+        const liveClients = set ? [...set].filter((c) => !c.closed) : [];
+        if (liveClients.length === 0) {
             throw new Error(`Dashboard channel "${params.channel}" is not connected`);
         }
         const payload = { role: "assistant", content: params.text };
@@ -136,81 +191,72 @@ export class DashboardAdapter {
                 ...(att.caption ? { caption: att.caption } : {}),
             }));
         }
-        await client.writeSSE("chat", JSON.stringify(payload));
+        const serialised = JSON.stringify(payload);
+        await Promise.all(liveClients.map((c) => c.writeSSE("chat", serialised)));
     }
     /** Send a streaming chunk to a specific channel */
     sendStreamChunk(channelId, chunk) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("chat_stream", JSON.stringify({ chunk }))
-                .catch((err) => logger.debug({ err, channelId, event: "chat_stream" }, "SSE write failed"));
-        }
+        const serialised = JSON.stringify({ chunk });
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("chat_stream", serialised).catch((err) => logger.debug({ err, channelId, event: "chat_stream" }, "SSE write failed"));
+        });
     }
     /** Signal end of stream to a specific channel */
     sendStreamEnd(channelId) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("stream_end", "")
-                .catch((err) => logger.debug({ err, channelId, event: "stream_end" }, "SSE write failed"));
-        }
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("stream_end", "").catch((err) => logger.debug({ err, channelId, event: "stream_end" }, "SSE write failed"));
+        });
     }
     /** Ship the outbound attachment list for the just-completed assistant
      *  turn — dashboard transcript reads this and renders inline thumbnails /
      *  download chips alongside the streamed message text. */
     sendAttachments(channelId, attachments) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("chat_attachments", JSON.stringify({ attachments }))
-                .catch((err) => logger.debug({ err, channelId, event: "chat_attachments" }, "SSE write failed"));
-        }
+        const serialised = JSON.stringify({ attachments });
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("chat_attachments", serialised).catch((err) => logger.debug({ err, channelId, event: "chat_attachments" }, "SSE write failed"));
+        });
     }
     /** Send metadata for the last assistant message (backend, model, duration, cost) */
     sendMessageMeta(channelId, meta) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("chat_meta", JSON.stringify(meta))
-                .catch((err) => logger.debug({ err, channelId, event: "chat_meta" }, "SSE write failed"));
-        }
+        const serialised = JSON.stringify(meta);
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("chat_meta", serialised).catch((err) => logger.debug({ err, channelId, event: "chat_meta" }, "SSE write failed"));
+        });
     }
     /** Send tool progress to a specific channel */
     sendToolProgress(channelId, tool, status) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("tool_progress", JSON.stringify({ tool, status }))
-                .catch((err) => logger.debug({ err, channelId, event: "tool_progress" }, "SSE write failed"));
-        }
+        const serialised = JSON.stringify({ tool, status });
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("tool_progress", serialised).catch((err) => logger.debug({ err, channelId, event: "tool_progress" }, "SSE write failed"));
+        });
     }
     /** Send session info update to a specific channel (partial — frontend merges) */
     sendSessionInfo(channelId, info) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("session_info", JSON.stringify(info))
-                .catch((err) => logger.debug({ err, channelId, event: "session_info" }, "SSE write failed"));
-        }
+        const serialised = JSON.stringify(info);
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("session_info", serialised).catch((err) => logger.debug({ err, channelId, event: "session_info" }, "SSE write failed"));
+        });
     }
     /** Send error to a specific channel (named "chat_error" to avoid EventSource built-in "error" collision) */
     sendError(channelId, message) {
-        const client = this.clients.get(channelId);
-        if (client && !client.closed) {
-            client
-                .writeSSE("chat_error", JSON.stringify({ message }))
-                .catch((err) => logger.debug({ err, channelId, event: "chat_error" }, "SSE write failed"));
-        }
+        const serialised = JSON.stringify({ message });
+        this.fanOut(channelId, (c) => {
+            c.writeSSE("chat_error", serialised).catch((err) => logger.debug({ err, channelId, event: "chat_error" }, "SSE write failed"));
+        });
     }
-    /** Check if a channel has an active SSE connection */
+    /** Check if a channel has at least one active SSE connection */
     isConnected(channelId) {
-        const client = this.clients.get(channelId);
-        return client !== undefined && !client.closed;
+        const set = this.clients.get(channelId);
+        if (!set)
+            return false;
+        for (const c of set) {
+            if (!c.closed)
+                return true;
+        }
+        return false;
     }
     /** Get all active channel IDs */
     getActiveChannels() {
         return [...this.clients.keys()].filter((id) => this.isConnected(id));
     }
 }
-//# sourceMappingURL=dashboard-adapter.js.map

package/dist/adapters/discord.d.ts

@@ -12,8 +12,8 @@ export interface DiscordAdapterOptions {
     onMessage: OnMessageCallback;
     /** Called when a matching pairing challenge captures a new owner user ID. */
     onOwnerDetected?: (userId: string) => void | Promise<void>;
-    /** Phase 2: canonical attachment store for inbound media download/ingest
-     *  and outbound file delivery. When absent, media is silently skipped. */
+    /** Canonical attachment store for inbound media download/ingest and
+     *  outbound file delivery. When absent, media is silently skipped. */
     attachmentStore?: AttachmentStore;
 }
 /**
@@ -24,6 +24,8 @@ export interface DiscordAdapterOptions {
 export interface DiscordPairingChallenge {
     match: (text: string) => boolean;
     expiresAt: number;
+    /** See SlackPairingChallenge.hintReply. */
+    hintReply?: (text: string) => string | null;
 }
 /**
  * DiscordAdapter — discord.js WebSocket Gateway integration.
@@ -72,6 +74,11 @@ export declare class DiscordAdapter implements MessageAdapter {
         messageId?: string;
     }>;
     private handleRawMessage;
+    /**
+     * Atomically promote a user ID to "owner" and notify the daemon. See
+     * slack-adapter.captureOwner for the full rationale — pairing must
+     * persist through env/DB before we acknowledge it, and
+     * mutableOwnerId rolls back if the callback throws.
+     */
     private captureOwner;
 }
-//# sourceMappingURL=discord.d.ts.map

package/dist/adapters/discord.js

@@ -8,6 +8,10 @@ import { splitOutboundText } from "./outbound-text.js";
 const DISCORD_OUTBOUND_MAX_BYTES = 10 * 1024 * 1024;
 // Keep inbound aligned with the dashboard's non-image attachment cap.
 const DISCORD_INBOUND_MAX_BYTES = 25 * 1024 * 1024;
+// Discord CDN / REST timeouts. Without a hard wall-clock cap, a hung CDN
+// stalls the raw-packet handler and blocks subsequent DMs. 30s is
+// generous for 25 MB attachments over slow links.
+const DISCORD_HTTP_TIMEOUT_MS = 30_000;
 const logger = createLogger("discord-adapter");
 /**
  * DiscordAdapter — discord.js WebSocket Gateway integration.
@@ -61,6 +65,16 @@ export class DiscordAdapter {
     startPairing(challenge) {
         this.pairingChallenge = challenge;
         logger.info({ ttlMs: challenge.expiresAt - Date.now() }, "discord pairing challenge registered");
+        // TTL sweep — see SlackAdapter.startPairing for rationale.
+        const ttlMs = Math.max(0, challenge.expiresAt - Date.now());
+        const sweep = setTimeout(() => {
+            if (this.pairingChallenge === challenge) {
+                this.pairingChallenge = null;
+                logger.debug("discord pairing challenge expired (TTL sweep)");
+            }
+        }, ttlMs);
+        if (typeof sweep.unref === "function")
+            sweep.unref();
     }
     cancelPairing() {
         this.pairingChallenge = null;
@@ -79,6 +93,7 @@ export class DiscordAdapter {
     static async fetchBotInfo(botToken) {
         const res = await fetch("https://discord.com/api/v10/users/@me", {
             headers: { Authorization: `Bot ${botToken}` },
+            signal: AbortSignal.timeout(DISCORD_HTTP_TIMEOUT_MS),
         });
         if (!res.ok) {
             throw new Error(`Discord /users/@me failed: ${res.status} ${res.statusText}`);
@@ -94,11 +109,11 @@ export class DiscordAdapter {
         };
     }
     async start() {
+        const rawClient = this.client;
         // Remove all listeners first to prevent duplicates on re-start
         this.client.removeAllListeners(Events.Error);
         this.client.removeAllListeners(Events.Warn);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.client.removeAllListeners("raw");
+        rawClient.removeAllListeners("raw");
         this.client.on(Events.Error, (err) => {
             logger.error({ error: err.message }, "Discord client error");
         });
@@ -122,8 +137,7 @@ export class DiscordAdapter {
         // unmodified. If a future discord.js release fixes the bug, we stay
         // on the raw path regardless — re-enabling Events.MessageCreate
         // would produce duplicate deliveries without deduplication plumbing.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.client.on("raw", (packet) => {
+        rawClient.on("raw", (packet) => {
             if (packet.t === "MESSAGE_CREATE" && packet.d) {
                 void this.handleRawMessage(packet.d).catch((err) => {
                     logger.error({ err }, "discord raw message handler threw");
@@ -222,6 +236,15 @@ export class DiscordAdapter {
         if (data.author?.bot)
             return;
         // channel_type 1 = DM, 3 = GroupDM. Guild text channels are 0 etc.
+        // Reject GroupDM (type 3) outright. Otherwise the !isDm + isMention
+        // path would emit agent replies into a channel visible to non-owner
+        // participants — violating the single-owner scope invariant in
+        // CLAUDE.md. Block the entire packet here, before any pairing or
+        // owner check.
+        if (data.channel_type === 3) {
+            logger.debug({ channel: data.channel_id }, "discord message dropped: GroupDM rejected");
+            return;
+        }
         const isDm = data.channel_type === 1;
         const isMention = !isDm
             && this.botUserId !== null
@@ -234,13 +257,37 @@ export class DiscordAdapter {
         // Pairing-challenge check: only DMs (not channel mentions) can capture
         // ownership, and only if the message text satisfies the registered
         // matcher. No "first DM wins" fallback.
-        if (isDm && this.isPairingActive() && this.pairingChallenge.match(content)) {
-            logger.info({ senderId: authorId }, "discord pairing challenge matched");
-            this.captureOwner(authorId);
-            this.cancelPairing();
-            // Do NOT fall through — see slack-adapter for rationale. The
-            // welcome DM from recordDetectedOwner is the user response.
-            return;
+        if (isDm && this.isPairingActive()) {
+            const challenge = this.pairingChallenge;
+            if (challenge.match(content)) {
+                logger.info({ senderId: authorId }, "discord pairing challenge matched");
+                // Await captureOwner so the env/DB write inside onOwnerDetected
+                // completes before pairing is acknowledged. cancelPairing only
+                // fires on success — if the callback throws (e.g. .env unwritable)
+                // the matcher stays armed so the user can retry by resending the
+                // phrase.
+                const ok = await this.captureOwner(authorId);
+                if (ok) {
+                    this.cancelPairing();
+                }
+                // Do NOT fall through — see slack-adapter for rationale. The
+                // welcome DM from recordDetectedOwner is the user response.
+                return;
+            }
+            // P2-23 — wrapped-phrase hint (see SlackAdapter for rationale).
+            const hint = challenge.hintReply?.(content);
+            if (hint) {
+                try {
+                    const ch = await this.client.channels.fetch(data.channel_id ?? "");
+                    if (ch && "send" in ch) {
+                        await ch.send(hint);
+                    }
+                }
+                catch (err) {
+                    logger.warn({ err, channel: data.channel_id }, "discord pairing hint reply failed");
+                }
+                return;
+            }
         }
         if (!this.mutableOwnerId || authorId !== this.mutableOwnerId) {
             logger.debug({ senderId: authorId, channel: data.channel_id }, "discord message dropped: unauthorized sender");
@@ -263,9 +310,26 @@ export class DiscordAdapter {
                     continue;
                 }
                 try {
-                    const res = await fetch(att.url);
+                    const res = await fetch(att.url, {
+                        signal: AbortSignal.timeout(DISCORD_HTTP_TIMEOUT_MS),
+                    });
                     if (!res.ok) {
                         logger.warn({ status: res.status, filename: att.filename }, "discord file download failed");
+                        // Discord CDN URLs expire after ~24h. If the daemon is
+                        // late picking up a DM (queue, restart, throttle), the URL is
+                        // already dead. Surface a sentinel so the agent prompt can
+                        // include "attachment couldn't be fetched — please resend"
+                        // rather than silently dropping the file from the turn.
+                        attachmentRefs.push({
+                            id: "",
+                            originalFilename: att.filename,
+                            mimeType: mimeType ?? "application/octet-stream",
+                            sizeBytes: 0,
+                            missing: true,
+                            missingReason: res.status === 404 || res.status === 403
+                                ? "cdn_expired_or_blocked"
+                                : `http_${res.status}`,
+                        });
                         continue;
                     }
                     const buf = Buffer.from(await res.arrayBuffer());
@@ -287,6 +351,14 @@ export class DiscordAdapter {
                 }
                 catch (err) {
                     logger.error({ err, filename: att.filename }, "discord file ingest failed");
+                    attachmentRefs.push({
+                        id: "",
+                        originalFilename: att.filename,
+                        mimeType: mimeType ?? "application/octet-stream",
+                        sizeBytes: 0,
+                        missing: true,
+                        missingReason: "ingest_error",
+                    });
                 }
             }
         }
@@ -319,21 +391,25 @@ export class DiscordAdapter {
         });
         this.onMessage(event);
     }
-    captureOwner(userId) {
+    /**
+     * Atomically promote a user ID to "owner" and notify the daemon. See
+     * slack-adapter.captureOwner for the full rationale — pairing must
+     * persist through env/DB before we acknowledge it, and
+     * mutableOwnerId rolls back if the callback throws.
+     */
+    async captureOwner(userId) {
+        const previousOwnerId = this.mutableOwnerId;
         this.mutableOwnerId = userId;
-        if (this.onOwnerDetected) {
-            try {
-                const maybe = this.onOwnerDetected(userId);
-                if (maybe && typeof maybe.then === "function") {
-                    maybe.catch((err) => {
-                        logger.error({ err }, "discord onOwnerDetected callback failed");
-                    });
-                }
-            }
-            catch (err) {
-                logger.error({ err }, "discord onOwnerDetected callback threw");
-            }
+        if (!this.onOwnerDetected)
+            return true;
+        try {
+            await this.onOwnerDetected(userId);
+            return true;
+        }
+        catch (err) {
+            this.mutableOwnerId = previousOwnerId;
+            logger.error({ err, userId }, "discord onOwnerDetected callback failed; pairing rolled back");
+            return false;
         }
     }
 }
-//# sourceMappingURL=discord.js.map

package/dist/adapters/docs-qa-adapter.d.ts

@@ -24,7 +24,7 @@ export interface DocsQAScopeOptions {
      * the time the adapter sees this field both fields are guaranteed
      * to round-trip cleanly through `requestedBackendId` /
      * `requestedModelId` on the MessageEvent. The dispatcher's hard-
-     * override path (`backend-router.ts:618`) then routes the turn on
+     * override path (see `backend-router.ts`) then routes the turn on
      * the picked model regardless of `process_backend_config` pins.
      */
     modelOverride?: {
@@ -34,7 +34,7 @@ export interface DocsQAScopeOptions {
 }
 /**
  * DocsQAAdapter — SSE-based MessageAdapter for the operator-facing
- * Docs Q&A panel (DOCS_QA_B7_DESIGN.md §3.2).
+ * Docs Q&A panel (see DOCS_QA_B7_DESIGN.md).
  *
  * Parallel to `DashboardAdapter`: same SSE/HTTP transport, same
  * dispatcher entry point, but a separate channel registry and a
@@ -46,10 +46,10 @@ export interface DocsQAScopeOptions {
  * Implements:
  *   - `IDashboardStream`: dispatcher fans outbound calls out to this
  *     adapter via `CompositeDashboardStream`. The streaming validator
- *     splice lives inside `sendStreamChunk` per §11.3. The
- *     persistence-side `validateAndRewrite` runs in the dispatcher
- *     (gated on `isDocsQAMessage(event)` per §11.1) — not here — so
- *     this adapter never sees the full assembled output.
+ *     splice lives inside `sendStreamChunk`. The persistence-side
+ *     `validateAndRewrite` runs in the dispatcher (gated on
+ *     `isDocsQAMessage(event)`) — not here — so this adapter never
+ *     sees the full assembled output.
  *   - `MessageAdapter`: registered with `MessageHub` so the standard
  *     adapter lifecycle (`start`/`stop`) and `notificationEligible`
  *     contract apply. `sendMessage` is required by the interface but
@@ -71,12 +71,11 @@ export declare class DocsQAAdapter implements MessageAdapter, IDashboardStream {
     /**
      * Register a new SSE client. Mints a `channelId`, emits the initial
      * `session_info` event so the dashboard knows the id to echo on
-     * subsequent POSTs (D5 — SSE-first channelId minting), and returns
-     * the id for the route's `onAbort` to unregister with.
+     * subsequent POSTs, and returns the id for the route's `onAbort` to
+     * unregister with.
      *
-     * No `resumeSessionId` parameter (§11.6): QA panel state lives in
-     * React state in-memory; the panel does not persist transcripts
-     * across reload.
+     * No `resumeSessionId` parameter: QA panel state lives in React state
+     * in-memory; the panel does not persist transcripts across reload.
      */
     registerClient(client: SSEClient): string;
     /** Drop a client. Called by the SSE route's `onAbort`. */
@@ -89,15 +88,16 @@ export declare class DocsQAAdapter implements MessageAdapter, IDashboardStream {
      * Translate an HTTP POST into a `MessageEvent` and feed it to the
      * dispatcher. Forces `intent: "docs_qa"`, `platform: "dashboard"`,
      * `isDm: true` regardless of the body — the route already guarded
-     * the body shape; this is the second forced-fields layer per §3.3.
+     * the body shape; this is the second forced-fields layer.
      */
     handleIncomingMessage(channelId: string, content: string, options: DocsQAScopeOptions): void;
     /**
      * Forward a streaming text delta through the per-channel citation
      * validator and emit the validated suffix. Unknown channelIds
-     * silently no-op (matches `dashboard-adapter.ts:211-218`) so the
-     * `CompositeDashboardStream` fan-out works without per-channel
-     * ownership tracking — only the adapter that owns the id emits.
+     * silently no-op (matches `dashboard-adapter.ts`'s unknown-channel
+     * no-op) so the `CompositeDashboardStream` fan-out works without
+     * per-channel ownership tracking — only the adapter that owns the
+     * id emits.
      */
     sendStreamChunk(channelId: string, chunk: string): void;
     /**
@@ -120,4 +120,3 @@ export declare class DocsQAAdapter implements MessageAdapter, IDashboardStream {
     getActiveChannels(): string[];
 }
 export {};
-//# sourceMappingURL=docs-qa-adapter.d.ts.map