@nordbyte/nordrelay 0.8.1 → 0.8.3

package/dist/{discord-channel-runtime.js → channels/discord/discord-channel-runtime.js}

@@ -1,7 +1,7 @@
 import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle, Client, } from "discord.js";
-import { DiscordChannelAdapter, } from "./channel-adapter.js";
+import { DiscordChannelAdapter, } from "../shared/channel-adapter.js";
 import { discordRateLimiter } from "./discord-rate-limit.js";
-import { redactText } from "./redaction.js";
+import { redactText } from "../../core/redaction.js";
 const DISCORD_MESSAGE_LIMIT = 2000;
 const DISCORD_SAFE_MESSAGE_LIMIT = 1900;
 export const DISCORD_ACTION_PREFIX = "nr:";

package/dist/{discord-command-surface.js → channels/discord/discord-command-surface.js}

@@ -1,6 +1,6 @@
-import { permissionForCommand } from "./access-control.js";
-import { discordCommandCatalog } from "./channel-command-catalog.js";
-import { normalizeChannelCommandName, parseChannelCommand } from "./channel-runtime.js";
+import { permissionForCommand } from "../../access/access-control.js";
+import { discordCommandCatalog } from "../shared/channel-command-catalog.js";
+import { normalizeChannelCommandName, parseChannelCommand } from "../shared/channel-runtime.js";
 export function parseDiscordMessageCommand(text) {
     return parseChannelCommand(text, { allowBotMention: false });
 }

package/dist/{bot-rendering.js → channels/shared/bot-rendering.js}

@@ -1,10 +1,10 @@
 import { InlineKeyboard } from "grammy";
-import { CODEX_AGENT_CAPABILITIES, agentLabel } from "./agent.js";
-import { getAgentDiagnostics } from "./agent-activity.js";
-import { enabledAgents } from "./agent-factory.js";
-import { isTelegramImagePreview } from "./artifacts.js";
-import { friendlyErrorText } from "./error-messages.js";
-import { escapeHTML } from "./format.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel } from "../../agents/shared/agent.js";
+import { getAgentDiagnostics } from "../../agents/shared/agent-activity.js";
+import { enabledAgents } from "../../agents/shared/agent-factory.js";
+import { isTelegramImagePreview } from "../../artifacts/artifacts.js";
+import { friendlyErrorText } from "../../core/error-messages.js";
+import { escapeHTML } from "../../core/format.js";
 const TOOL_OUTPUT_PREVIEW_LIMIT = 500;
 const STREAMING_PREVIEW_LIMIT = 3800;
 export function renderVersionCheckPlain(check) {

package/dist/{channel-actions.js → channels/shared/channel-actions.js}

@@ -1,7 +1,7 @@
-import { formatAgentFeatureSummaryHTML, formatAgentFeatureSummaryPlain } from "./agent-feature-matrix.js";
-import { totalArtifactSize } from "./artifacts.js";
-import { escapeHTML } from "./format.js";
-import { getAgentUpdateLogPath, getUpdateLogPath } from "./operations.js";
+import { formatAgentFeatureSummaryHTML, formatAgentFeatureSummaryPlain } from "../../agents/shared/agent-feature-matrix.js";
+import { totalArtifactSize } from "../../artifacts/artifacts.js";
+import { escapeHTML } from "../../core/format.js";
+import { getAgentUpdateLogPath, getUpdateLogPath } from "../../support/operations.js";
 import { formatFileSize } from "./session-format.js";
 export function renderChannelsAction(descriptors) {
     const plain = [

package/dist/channels/shared/channel-bridge-controller.js

@@ -0,0 +1,69 @@
+export function createChannelBusyStore(defaults = () => ({ processing: false, switching: false })) {
+    const states = new Map();
+    return {
+        get(contextKey) {
+            let state = states.get(contextKey);
+            if (!state) {
+                state = defaults();
+                states.set(contextKey, state);
+            }
+            return state;
+        },
+        peek(contextKey) {
+            return states.get(contextKey);
+        },
+        delete(contextKey) {
+            states.delete(contextKey);
+        },
+    };
+}
+export function createChannelQueueStatusController(options) {
+    const states = new Map();
+    return {
+        async update(contextKey, context, text) {
+            const state = states.get(contextKey) ?? {};
+            if (state.lastText === text && state.messageId) {
+                return;
+            }
+            if (!state.messageId) {
+                state.messageId = await options.send(contextKey, context, text);
+                state.lastText = text;
+                states.set(contextKey, state);
+                return;
+            }
+            await options.edit(contextKey, context, state.messageId, text);
+            state.lastText = text;
+            states.set(contextKey, state);
+        },
+        delete(contextKey) {
+            states.delete(contextKey);
+        },
+    };
+}
+export function createChannelActivityRecorder(options) {
+    return (request, input) => {
+        return options.activityStore.append({
+            source: options.source,
+            contextKey: request.contextKey,
+            actor: input.actor ?? options.actorFor(request),
+            workspace: input.workspace ?? options.workspace,
+            threadId: input.threadId ?? null,
+            ...input,
+        });
+    };
+}
+export function createChannelAuditRecorder(options) {
+    return (request, input) => {
+        options.auditLog.append({
+            channelId: options.channelId,
+            contextKey: input.contextKey ?? request.contextKey,
+            actor: input.actor ?? options.actorFor(request),
+            actorId: request.authUser?.user.id ?? options.actorIdFor(request),
+            actorRole: request.authUser?.groups.map((group) => group.name).join(", ") ?? "unauthenticated",
+            ...input,
+        });
+    };
+}
+export function createChannelPermissionChecker(userStore) {
+    return (request, permission) => userStore.hasPermission(request.authUser, permission);
+}

package/dist/channels/shared/channel-cli-artifacts.js

@@ -0,0 +1,51 @@
+import { collectRecentWorkspaceArtifacts, formatArtifactSummary, persistWorkspaceArtifactReport, } from "../../artifacts/artifacts.js";
+import { isEmptyArtifactReport } from "./bot-rendering.js";
+export async function deliverChannelCliArtifacts(options) {
+    if (!options.startedAt || !options.turnId) {
+        return;
+    }
+    if (options.state?.artifactsDeliveredForTurnId === options.turnId) {
+        return;
+    }
+    const workspace = options.session.getInfo().workspace;
+    const report = await collectRecentWorkspaceArtifacts(workspace, {
+        since: options.startedAt,
+        until: new Date(),
+        maxFileSize: options.config.maxFileSize,
+        limit: 5,
+        ignoreDirs: options.config.artifactIgnoreDirs,
+        ignoreGlobs: options.config.artifactIgnoreGlobs,
+    });
+    if (isEmptyArtifactReport(report)) {
+        if (options.state)
+            options.state.artifactsDeliveredForTurnId = options.turnId;
+        return;
+    }
+    const persistedReport = await persistWorkspaceArtifactReport(workspace, options.turnId, report).catch((error) => {
+        console.error(`Failed to persist ${options.logPrefix} CLI artifact report:`, error);
+        return null;
+    });
+    const summary = formatArtifactSummary(report.artifacts, report.skippedCount, report.omittedCount);
+    if (options.autoSend || options.sendSummaryWhenAutoSendDisabled) {
+        await options.sendSummary(summary);
+    }
+    if (options.autoSend) {
+        for (const artifact of (persistedReport?.artifacts ?? report.artifacts).slice(0, 5)) {
+            await options.sendArtifact(artifact);
+        }
+    }
+    const info = options.session.getInfo();
+    options.appendActivity({
+        source: "cli",
+        status: "info",
+        type: options.autoSend ? "artifacts_sent" : "artifacts_detected",
+        contextKey: options.contextKey,
+        threadId: info.threadId,
+        workspace: info.workspace,
+        agentId: info.agentId,
+        actor: { channel: "cli", label: `${info.agentLabel} CLI` },
+        detail: summary,
+    });
+    if (options.state)
+        options.state.artifactsDeliveredForTurnId = options.turnId;
+}

package/dist/{channel-command-service.js → channels/shared/channel-command-service.js}

@@ -1,15 +1,15 @@
-import { listAgentAdapterDescriptors } from "./agent-adapter.js";
-import { enabledAgents } from "./agent-factory.js";
-import { formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
+import { listAgentAdapterDescriptors } from "../../agents/shared/agent-adapter.js";
+import { enabledAgents } from "../../agents/shared/agent-factory.js";
+import { formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "../../state/bot-preferences.js";
 import { logTailRequests, parseLogsCommand, renderAgentsAction, renderChannelsAction, renderLogTailsAction, } from "./channel-actions.js";
 import { listChannelDescriptors } from "./channel-adapter.js";
-import { friendlyErrorText } from "./error-messages.js";
-import { escapeHTML } from "./format.js";
-import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, } from "./operations.js";
-import { PeerStore } from "./peer-store.js";
+import { friendlyErrorText } from "../../core/error-messages.js";
+import { escapeHTML } from "../../core/format.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, } from "../../support/operations.js";
+import { PeerStore } from "../../peers/peer-store.js";
 import { formatCliPathHTML, formatCliPathPlain, renderActivityTimeline, renderAuditEvents, renderProgressHTML, renderProgressPlain, parseToggle, renderVersionCheckHTML, renderVersionCheckPlain, } from "./bot-rendering.js";
 import { renderSessionInfoHTML, renderSessionInfoPlain } from "./session-format.js";
-import { getAvailableBackends } from "./voice.js";
+import { getAvailableBackends } from "../../artifacts/voice.js";
 export class ChannelCommandService {
     config;
     constructor(config) {
@@ -176,11 +176,7 @@ export class ChannelCommandService {
             });
         }
         const mode = this.effectiveMirrorMode(options.source, options.contextKey, options.preferencesStore);
-        const minInterval = options.source === "telegram"
-            ? this.config.telegramMirrorMinUpdateMs
-            : options.source === "discord"
-                ? this.config.discordMirrorMinUpdateMs
-                : this.config.slackMirrorMinUpdateMs;
+        const minInterval = this.mirrorMinUpdateMs(options.source);
         return {
             plain: [
                 `CLI mirroring: ${mode}`,
@@ -338,25 +334,52 @@ export class ChannelCommandService {
         };
     }
     defaultMirrorMode(source) {
-        return source === "telegram"
-            ? this.config.telegramMirrorMode
-            : source === "discord"
-                ? this.config.discordMirrorMode
-                : this.config.slackMirrorMode;
+        if (source === "telegram") {
+            return this.config.telegramMirrorMode;
+        }
+        if (source === "discord") {
+            return this.config.discordMirrorMode;
+        }
+        if (source === "slack") {
+            return this.config.slackMirrorMode;
+        }
+        return this.config.webMirrorMode;
+    }
+    mirrorMinUpdateMs(source) {
+        if (source === "telegram") {
+            return this.config.telegramMirrorMinUpdateMs;
+        }
+        if (source === "discord") {
+            return this.config.discordMirrorMinUpdateMs;
+        }
+        if (source === "slack") {
+            return this.config.slackMirrorMinUpdateMs;
+        }
+        return this.config.webMirrorMinUpdateMs;
     }
     defaultNotifyMode(source) {
-        return source === "telegram"
-            ? this.config.telegramNotifyMode
-            : source === "discord"
-                ? this.config.discordNotifyMode
-                : this.config.slackNotifyMode;
+        if (source === "telegram") {
+            return this.config.telegramNotifyMode;
+        }
+        if (source === "discord") {
+            return this.config.discordNotifyMode;
+        }
+        if (source === "slack") {
+            return this.config.slackNotifyMode;
+        }
+        return this.config.notifyMode;
     }
     defaultQuietHours(source) {
-        return source === "telegram"
-            ? this.config.telegramQuietHours
-            : source === "discord"
-                ? this.config.discordQuietHours
-                : this.config.slackQuietHours;
+        if (source === "telegram") {
+            return this.config.telegramQuietHours;
+        }
+        if (source === "discord") {
+            return this.config.discordQuietHours;
+        }
+        if (source === "slack") {
+            return this.config.slackQuietHours;
+        }
+        return this.config.quietHours;
     }
     effectiveMirrorMode(source, contextKey, preferencesStore) {
         return preferencesStore.get(contextKey).mirrorMode ?? this.defaultMirrorMode(source);

package/dist/channels/shared/channel-external-mirror-controller.js

@@ -0,0 +1,193 @@
+import { renderExternalMirrorEvent, renderExternalMirrorStatus, trimLine } from "./bot-rendering.js";
+export function createChannelExternalMirrorController(options) {
+    const fullEventFilter = options.fullEventFilter ?? ((event) => event.kind === "tool" || event.kind === "task");
+    const fullEventLimit = options.fullEventLimit ?? 4;
+    const requirePreviousForTerminal = options.requirePreviousForTerminal ?? true;
+    const ensureState = (contextKey, snapshot) => {
+        const previous = options.states.get(contextKey);
+        if (previous && previous.threadId === snapshot.threadId && previous.rolloutPath === snapshot.sourcePath) {
+            return { state: previous, previous };
+        }
+        const state = {
+            threadId: snapshot.threadId,
+            rolloutPath: snapshot.sourcePath,
+            lastLine: snapshot.lineCount,
+            turnId: snapshot.activity.turnId,
+            startedAt: snapshot.activity.startedAt,
+        };
+        options.states.set(contextKey, state);
+        return { state, previous: undefined };
+    };
+    const maybeSendTyping = async (contextKey, context, state) => {
+        const now = Date.now();
+        if (state.lastTypingAt && now - state.lastTypingAt < options.typingIntervalMs) {
+            return;
+        }
+        state.lastTypingAt = now;
+        await options.sendTyping(contextKey, context, state);
+    };
+    const recordTurnStart = (contextKey, session, state, snapshot) => {
+        const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
+        if (state.activityStartedTurnKey === turnKey) {
+            return;
+        }
+        const info = session.getInfo();
+        options.appendActivity({
+            source: "cli",
+            status: "running",
+            type: "cli_turn_started",
+            contextKey,
+            threadId: snapshot.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor: options.activityActor(snapshot),
+            prompt: snapshot.latestUserMessage ?? `${snapshot.agentLabel} CLI task`,
+            detail: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
+        });
+        state.activityStartedTurnKey = turnKey;
+        state.activityFinishedTurnKey = undefined;
+        state.activityToolStartLines = [];
+        state.activityToolEndLines = [];
+    };
+    const recordToolEvents = (contextKey, session, state, snapshot) => {
+        const info = session.getInfo();
+        const loggedStartLines = new Set(state.activityToolStartLines ?? []);
+        const loggedEndLines = new Set(state.activityToolEndLines ?? []);
+        for (const event of snapshot.events.filter((event) => event.lineNumber > state.lastLine && event.kind === "tool")) {
+            if (event.status === "started" && !loggedStartLines.has(event.lineNumber)) {
+                options.appendActivity({
+                    source: "cli",
+                    status: "running",
+                    type: "cli_tool_started",
+                    contextKey,
+                    threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: options.activityActor(snapshot),
+                    prompt: snapshot.latestUserMessage ?? undefined,
+                    detail: event.toolName ?? "tool",
+                });
+                loggedStartLines.add(event.lineNumber);
+            }
+            if ((event.status === "finished" || event.status === "failed") && !loggedEndLines.has(event.lineNumber)) {
+                options.appendActivity({
+                    source: "cli",
+                    status: event.status === "failed" ? "failed" : "completed",
+                    type: event.status === "failed" ? "cli_tool_failed" : "cli_tool_completed",
+                    contextKey,
+                    threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: options.activityActor(snapshot),
+                    prompt: snapshot.latestUserMessage ?? undefined,
+                    detail: event.toolName ?? "tool",
+                });
+                loggedEndLines.add(event.lineNumber);
+            }
+        }
+        state.activityToolStartLines = [...loggedStartLines].slice(-200);
+        state.activityToolEndLines = [...loggedEndLines].slice(-200);
+    };
+    const recordTurnFinished = (contextKey, session, state, snapshot, terminalEvent) => {
+        const turnKey = terminalEvent.turnId ?? snapshot.activity.turnId ?? state.startedAt?.toString() ?? "unknown";
+        if (state.activityFinishedTurnKey === turnKey) {
+            return;
+        }
+        const info = session.getInfo();
+        const startedAt = state.startedAt instanceof Date ? state.startedAt : state.startedAt ? new Date(state.startedAt) : snapshot.activity.startedAt;
+        options.appendActivity({
+            source: "cli",
+            status: terminalEvent.status === "aborted" ? "aborted" : terminalEvent.status === "failed" ? "failed" : "completed",
+            type: "cli_turn_finished",
+            contextKey,
+            threadId: snapshot.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor: options.activityActor(snapshot),
+            prompt: snapshot.latestUserMessage ?? undefined,
+            detail: `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`,
+            durationMs: startedAt && terminalEvent.timestamp ? Math.max(0, terminalEvent.timestamp.getTime() - startedAt.getTime()) : undefined,
+        });
+        state.activityFinishedTurnKey = turnKey;
+    };
+    return {
+        async mirror(contextKey, context, session, snapshot) {
+            const { state, previous } = ensureState(contextKey, snapshot);
+            const mirrorMode = options.mirrorMode(contextKey);
+            if (snapshot.activity.active) {
+                state.turnId = snapshot.activity.turnId;
+                state.startedAt = snapshot.activity.startedAt;
+                recordTurnStart(contextKey, session, state, snapshot);
+                if (mirrorMode !== "off") {
+                    await maybeSendTyping(contextKey, context, state);
+                }
+                if (mirrorMode === "final") {
+                    await options.sendWorkingNotice(contextKey, context, state, snapshot, trimLine(snapshot.latestUserMessage ?? "", 250));
+                    state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
+                    return;
+                }
+                if (mirrorMode === "off") {
+                    state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
+                    return;
+                }
+                const status = renderExternalMirrorStatus(snapshot, options.queueLength(contextKey));
+                const now = Date.now();
+                const canUpdateStatus = !state.latestStatusAt || now - state.latestStatusAt >= options.minUpdateMs(contextKey);
+                if (!state.statusMessageId) {
+                    state.statusMessageId = await options.sendStatus(contextKey, context, state, status);
+                    state.latestStatusAt = now;
+                }
+                else if (state.latestStatus !== status.plain && canUpdateStatus) {
+                    await options.editStatus(contextKey, context, state, state.statusMessageId, status);
+                    state.latestStatusAt = now;
+                }
+                state.latestStatus = status.plain;
+                if (mirrorMode === "full") {
+                    const newEvents = snapshot.events
+                        .filter((event) => event.lineNumber > (state.latestMirroredEventLine ?? state.lastLine))
+                        .filter(fullEventFilter)
+                        .slice(-fullEventLimit);
+                    for (const event of newEvents) {
+                        const rendered = renderExternalMirrorEvent(event);
+                        if (!rendered) {
+                            continue;
+                        }
+                        await options.sendEvent(contextKey, context, state, rendered);
+                        state.latestMirroredEventLine = event.lineNumber;
+                    }
+                }
+                recordToolEvents(contextKey, session, state, snapshot);
+                state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
+                return;
+            }
+            if (requirePreviousForTerminal && !previous) {
+                state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
+                return;
+            }
+            const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
+            if (terminalEvent) {
+                recordTurnFinished(contextKey, session, state, snapshot, terminalEvent);
+                if (mirrorMode !== "off") {
+                    const doneText = `${snapshot.agentLabel} CLI task ${terminalEvent.status}.`;
+                    if (state.statusMessageId || options.shouldSendDone?.(contextKey) !== false) {
+                        await options.sendDone(contextKey, context, state, doneText);
+                    }
+                }
+                const finalAgent = snapshot.events.filter((event) => event.kind === "agent" && event.text).at(-1);
+                if (mirrorMode !== "off" && mirrorMode !== "status" && finalAgent?.text && finalAgent.lineNumber !== state.latestAgentLine) {
+                    await options.sendFinalAnswer(contextKey, context, state, snapshot, finalAgent.text);
+                    state.latestAgentLine = finalAgent.lineNumber;
+                }
+                await options.deliverArtifacts(contextKey, context, session, state, terminalEvent.turnId);
+            }
+            state.workingNoticeTurnKey = undefined;
+            state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
+        },
+        get(contextKey) {
+            return options.states.get(contextKey);
+        },
+        delete(contextKey) {
+            options.states.delete(contextKey);
+        },
+    };
+}

package/dist/channels/shared/channel-external-monitor.js

@@ -0,0 +1,52 @@
+import { getExternalSnapshotForSession } from "../../agents/shared/agent-activity.js";
+import { capabilitiesOf } from "./bot-rendering.js";
+export async function monitorChannelExternalContexts(options) {
+    const contextKeys = new Set([
+        ...options.registry.listContexts().map((context) => context.contextKey),
+        ...options.promptStore.listContextKeys(),
+    ].filter(options.isContextKey));
+    for (const contextKey of contextKeys) {
+        await monitorChannelExternalContext(options, contextKey);
+    }
+}
+async function monitorChannelExternalContext(options, contextKey) {
+    if (!options.canSendSystemMessages(contextKey) || options.isAllowed?.(contextKey) === false) {
+        return;
+    }
+    const session = await options.registry.getOrCreate(contextKey, { deferThreadStart: true }).catch(() => null);
+    const context = options.contextForKey(contextKey);
+    if (!session || !context) {
+        return;
+    }
+    const queueLength = options.promptStore.list(contextKey).length;
+    const paused = options.promptStore.isPaused(contextKey);
+    const shouldDrain = queueLength > 0 && !paused && !session.isProcessing();
+    if (!capabilitiesOf(session.getInfo()).externalActivity || !session.getActiveThreadId()) {
+        if (shouldDrain) {
+            await options.drainQueue(contextKey, context, session);
+        }
+        return;
+    }
+    const snapshot = getExternalSnapshotForSession(session, options.config, {
+        afterLine: options.previousLastLine(contextKey) ?? Number.MAX_SAFE_INTEGER,
+    }) ?? getExternalSnapshotForSession(session, options.config, { maxEvents: 1 });
+    if (!snapshot) {
+        if (shouldDrain) {
+            await options.drainQueue(contextKey, context, session);
+        }
+        return;
+    }
+    if (!session.isProcessing()) {
+        await options.mirrorSnapshot(contextKey, context, session, snapshot);
+    }
+    if (snapshot.activity.active) {
+        if (queueLength > 0) {
+            await options.updateQueueStatus(contextKey, context, `Waiting for ${snapshot.agentLabel} CLI task... ${queueLength} queued${paused ? " (paused)" : ""}.`).catch(() => { });
+        }
+        return;
+    }
+    if (shouldDrain) {
+        await options.updateQueueStatus(contextKey, context, `CLI task finished, running queued prompt 1/${queueLength}.`).catch(() => { });
+        await options.drainQueue(contextKey, context, session);
+    }
+}

package/dist/{channel-mirror-registry.js → channels/shared/channel-mirror-registry.js}

@@ -49,11 +49,7 @@ export class ChannelMirrorRegistry {
         return mirrors.some((mirror) => mirror.queuePaused) || this.promptStore.isPaused(sourceContextKey);
     }
     effectiveMirrorMode(contextKey, source, preferences) {
-        const configured = source === "telegram"
-            ? this.config.telegramMirrorMode
-            : source === "discord"
-                ? this.config.discordMirrorMode
-                : this.config.slackMirrorMode;
+        const configured = configuredMirrorMode(this.config, source);
         return preferences.get(contextKey).mirrorMode ?? configured;
     }
     snapshot() {
@@ -80,5 +76,17 @@ export function activeSessionSourceForContextKey(contextKey) {
     return "cli";
 }
 export function isMirrorChannelSource(source) {
-    return source === "telegram" || source === "discord" || source === "slack";
+    return source === "telegram" || source === "discord" || source === "slack" || source === "web";
+}
+function configuredMirrorMode(config, source) {
+    if (source === "telegram") {
+        return config.telegramMirrorMode;
+    }
+    if (source === "discord") {
+        return config.discordMirrorMode;
+    }
+    if (source === "slack") {
+        return config.slackMirrorMode;
+    }
+    return config.webMirrorMode;
 }

package/dist/{channel-peer-prompt.js → channels/shared/channel-peer-prompt.js}

@@ -1,6 +1,6 @@
-import { friendlyErrorText } from "./error-messages.js";
-import { RemoteRelayClient } from "./peer-client.js";
-import { peerPromptProxyPayload } from "./remote-prompt.js";
+import { friendlyErrorText } from "../../core/error-messages.js";
+import { RemoteRelayClient } from "../../peers/peer-client.js";
+import { peerPromptProxyPayload } from "../../runtime/remote-prompt.js";
 export async function runChannelPeerPrompt(options) {
     if (!options.targetPeerId) {
         return false;

package/dist/channels/shared/channel-prompt-queue.js

@@ -0,0 +1,37 @@
+export async function queueChannelPromptIfBusy(options) {
+    if (!options.busy.busy) {
+        return false;
+    }
+    const item = options.fromQueue && isQueuedPrompt(options.envelope)
+        ? options.envelope
+        : options.promptStore.enqueue(options.request.contextKey, options.envelope);
+    const position = options.promptStore.list(options.request.contextKey).findIndex((queued) => queued.id === item.id) + 1;
+    const text = options.busy.kind === "external"
+        ? `Queued prompt ${item.id} at position ${position}. The ${options.busy.agentLabel} session is still active and is processing a previous task.`
+        : `Queued prompt ${item.id} at position ${position}.`;
+    await options.reply(options.request, text, {
+        buttons: [[{ label: "Cancel queued message", action: `${options.actionPrefix}_queue_cancel:${options.request.contextKey}:${item.id}` }]],
+    });
+    options.appendActivity(options.request, {
+        status: "queued",
+        type: "prompt_queued",
+        prompt: item.description,
+        detail: text,
+        correlationId: item.correlationId,
+    });
+    options.audit(options.request, {
+        action: "prompt_queued",
+        status: "ok",
+        promptId: item.id,
+        correlationId: item.correlationId,
+        description: item.description,
+    });
+    return true;
+}
+function isQueuedPrompt(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === "string" && typeof candidate.createdAt === "number" && typeof candidate.description === "string";
+}