@nordbyte/nordrelay 0.6.0 → 0.8.0

package/dist/discord-bot.js

@@ -9,10 +9,14 @@ import { enabledAgents } from "./agent-factory.js";
 import { collectRecentWorkspaceArtifacts, ensureOutDir, formatArtifactSummary, persistWorkspaceArtifactReport } from "./artifacts.js";
 import { buildFileInstructions, outboxPath, stageFile } from "./attachments.js";
 import { AuditLogStore } from "./audit-log.js";
-import { BotPreferencesStore, parseMirrorMode, parseNotifyMode, parseVoiceBackendPreference } from "./bot-preferences.js";
+import { BotPreferencesStore } from "./bot-preferences.js";
 import { capabilitiesOf, filterActivityEvents, formatLocalDateTime, parseActivityOptions, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, trimLine } from "./bot-rendering.js";
 import { renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderQueueListAction } from "./channel-actions.js";
+import { createSharedChannelCommandDispatcher } from "./channel-command-core.js";
 import { ChannelCommandService } from "./channel-command-service.js";
+import { discordHelpCommandList } from "./channel-command-catalog.js";
+import { createChannelPromptEngine } from "./channel-prompt-engine.js";
+import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
 import { deliverChannelAction } from "./channel-runtime.js";
 import { checkAuthStatus, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
 import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
@@ -25,6 +29,7 @@ import { friendlyErrorText } from "./error-messages.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { spawnConnectorRestart, spawnSelfUpdate } from "./operations.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
+import { RemoteRelayClient } from "./peer-client.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { RelayArtifactService } from "./relay-artifact-service.js";
@@ -46,7 +51,8 @@ export function createDiscordBridge(config, registry) {
         return null;
     }
     if (!config.discordBotToken) {
-        throw new Error("DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
+        console.warn("Discord adapter disabled: DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
+        return null;
     }
     configureRedaction(config.telegramRedactPatterns);
     const intents = [
@@ -522,10 +528,44 @@ export function createDiscordBridge(config, registry) {
         await reply(request, `Session is locked by ${lock?.ownerLabel || lock?.ownerUserId || "another user"}.`);
         return true;
     };
+    const remoteClient = new RemoteRelayClient();
+    const handleRemotePrompt = async (request, envelope) => {
+        const targetPeerId = preferencesStore.get(request.contextKey).targetPeerId ?? undefined;
+        return runChannelPeerPrompt({
+            targetPeerId,
+            contextKey: request.contextKey,
+            prompt: envelope,
+            remoteClient,
+            editMinIntervalMs: EDIT_DEBOUNCE_MS,
+            typingIntervalMs: TYPING_INTERVAL_MS,
+            sendTyping: () => runtime.sendTyping(request.context),
+            sendResponse: async (text) => {
+                const rendered = trimDiscordMessage(text);
+                const sent = await runtime.sendMessage(request.context, { text: rendered, fallbackText: rendered });
+                return sent.messageId;
+            },
+            editResponse: async (messageId, text) => {
+                const rendered = trimDiscordMessage(text);
+                await runtime.editMessage(request.context, messageId, { text: rendered, fallbackText: rendered });
+            },
+            sendTurnStart: (remotePrompt) => reply(request, `Remote peer working on:\n${remotePrompt}`),
+            sendToolStart: (toolName) => reply(request, `Remote tool: ${toolName}`),
+            sendQueued: async (queueId) => {
+                await reply(request, `Remote prompt queued${queueId ? `: ${queueId}` : ""}.`, queueId ? {
+                    buttons: [[{ label: "Cancel queued message", action: `discord_peer_queue_cancel:${targetPeerId}:${queueId}` }]],
+                } : undefined);
+            },
+            sendCompleted: () => reply(request, "Remote turn completed."),
+            sendFailure: (message) => reply(request, `Remote peer failed: ${message}`),
+        });
+    };
     const handlePrompt = async (request, input, artifactOutDir, options = {}) => {
         const session = await getSession(request);
         const envelope = toPromptEnvelope(input, artifactOutDir);
         envelope.activityActor = actorFor(request);
+        if (!options.fromQueue && await handleRemotePrompt(request, envelope)) {
+            return;
+        }
         if (!options.fromQueue && await denyIfLocked(request)) {
             return;
         }
@@ -557,157 +597,41 @@ export function createDiscordBridge(config, registry) {
         }
         const busyState = getBusyState(request.contextKey);
         busyState.processing = true;
-        const typing = setInterval(() => {
-            void runtime.sendTyping(request.context).catch(() => { });
-        }, TYPING_INTERVAL_MS);
-        void runtime.sendTyping(request.context).catch(() => { });
-        let accumulatedText = "";
-        let responseMessageId;
-        let planMessageId;
-        let flushTimer;
-        let lastEditAt = 0;
-        let running = true;
-        let finalized = false;
-        const toolCounts = new Map();
-        const toolVerbosity = config.toolVerbosity;
-        const startedAt = Date.now();
-        const turnId = randomUUID().slice(0, 12);
-        const progress = {
-            status: "running",
+        const engine = createChannelPromptEngine({
+            runtime,
+            context: request.context,
+            contextKey: request.contextKey,
             promptDescription: envelope.description,
-            startedAt,
-            updatedAt: startedAt,
-            toolCounts,
-            textCharacters: 0,
-        };
+            abortAction: `discord_abort:${request.contextKey}`,
+            trimMessage: trimDiscordMessage,
+            splitMessage: splitDiscordMessage,
+            editDebounceMs: EDIT_DEBOUNCE_MS,
+            typingIntervalMs: TYPING_INTERVAL_MS,
+            toolVerbosity: config.toolVerbosity,
+            logPrefix: "Discord",
+            onResponseMessage: (messageId) => responseOwners.set(messageId, request.contextKey),
+            onToolStart: (toolName) => appendActivity(request, {
+                status: "running",
+                type: "tool_started",
+                prompt: envelope.description,
+                detail: toolName,
+                threadId: session.getInfo().threadId,
+                workspace: session.getInfo().workspace,
+                agentId: session.getInfo().agentId,
+            }),
+            onToolEnd: (isError) => appendActivity(request, {
+                status: isError ? "failed" : "completed",
+                type: isError ? "tool_failed" : "tool_completed",
+                prompt: envelope.description,
+                detail: "tool",
+                threadId: session.getInfo().threadId,
+                workspace: session.getInfo().workspace,
+                agentId: session.getInfo().agentId,
+            }),
+        });
+        const progress = engine.progress;
         turnProgress.set(request.contextKey, progress);
-        const scheduleFlush = () => {
-            if (flushTimer || !running) {
-                return;
-            }
-            const delay = Math.max(0, EDIT_DEBOUNCE_MS - (Date.now() - lastEditAt));
-            flushTimer = setTimeout(() => {
-                flushTimer = undefined;
-                void flushResponse().catch((error) => console.error("Failed to edit Discord response:", error));
-            }, delay);
-        };
-        const ensureResponse = async () => {
-            if (responseMessageId)
-                return;
-            const preview = trimDiscordMessage(accumulatedText || "Working...");
-            const sent = await runtime.sendMessage(request.context, {
-                text: preview,
-                fallbackText: preview,
-                buttons: [[{ label: "Abort", action: `discord_abort:${request.contextKey}` }]],
-            });
-            responseMessageId = sent.messageId;
-            responseOwners.set(responseMessageId, request.contextKey);
-            lastEditAt = Date.now();
-        };
-        const flushResponse = async (force = false) => {
-            if (!accumulatedText.trim())
-                return;
-            await ensureResponse();
-            if (!responseMessageId)
-                return;
-            const now = Date.now();
-            if (!force && now - lastEditAt < EDIT_DEBOUNCE_MS)
-                return;
-            await runtime.editMessage(request.context, responseMessageId, {
-                text: trimDiscordMessage(accumulatedText),
-                fallbackText: trimDiscordMessage(accumulatedText),
-                buttons: [[{ label: "Abort", action: `discord_abort:${request.contextKey}` }]],
-            });
-            lastEditAt = Date.now();
-        };
-        const finalize = async () => {
-            if (finalized) {
-                return;
-            }
-            finalized = true;
-            running = false;
-            clearInterval(typing);
-            if (flushTimer) {
-                clearTimeout(flushTimer);
-                flushTimer = undefined;
-            }
-            const finalText = accumulatedText.trim() || "Done.";
-            const chunks = splitDiscordMessage(finalText);
-            if (responseMessageId) {
-                const [first, ...rest] = chunks;
-                await runtime.editMessage(request.context, responseMessageId, { text: first ?? "Done.", fallbackText: first ?? "Done." });
-                for (const chunk of rest) {
-                    await runtime.sendMessage(request.context, { text: chunk, fallbackText: chunk });
-                }
-            }
-            else {
-                for (const chunk of chunks) {
-                    await runtime.sendMessage(request.context, { text: chunk, fallbackText: chunk });
-                }
-            }
-        };
-        const callbacks = {
-            onTextDelta: (delta) => {
-                accumulatedText += delta;
-                progress.textCharacters = accumulatedText.length;
-                progress.updatedAt = Date.now();
-                void ensureResponse().then(() => scheduleFlush()).catch((error) => console.error("Failed to send Discord response:", error));
-            },
-            onToolStart: (toolName) => {
-                toolCounts.set(toolName, (toolCounts.get(toolName) ?? 0) + 1);
-                progress.currentTool = toolName;
-                progress.lastTool = toolName;
-                progress.updatedAt = Date.now();
-                appendActivity(request, {
-                    status: "running",
-                    type: "tool_started",
-                    prompt: envelope.description,
-                    detail: toolName,
-                    threadId: session.getInfo().threadId,
-                    workspace: session.getInfo().workspace,
-                    agentId: session.getInfo().agentId,
-                });
-                if (toolVerbosity === "all") {
-                    void runtime.sendMessage(request.context, { text: `Tool started: ${toolName}`, fallbackText: `Tool started: ${toolName}` }).catch(() => { });
-                }
-            },
-            onToolUpdate: () => { },
-            onToolEnd: (_toolCallId, isError) => {
-                progress.currentTool = undefined;
-                progress.updatedAt = Date.now();
-                appendActivity(request, {
-                    status: isError ? "failed" : "completed",
-                    type: isError ? "tool_failed" : "tool_completed",
-                    prompt: envelope.description,
-                    detail: "tool",
-                    threadId: session.getInfo().threadId,
-                    workspace: session.getInfo().workspace,
-                    agentId: session.getInfo().agentId,
-                });
-            },
-            onTodoUpdate: (items) => {
-                progress.updatedAt = Date.now();
-                const text = [
-                    "Plan:",
-                    ...items.map((item) => `${item.completed ? "[x]" : "[ ]"} ${item.text}`),
-                ].join("\n");
-                if (!planMessageId) {
-                    void runtime.sendMessage(request.context, { text, fallbackText: text }).then((result) => {
-                        planMessageId = result.messageId;
-                    }).catch(() => { });
-                }
-                else {
-                    void runtime.editMessage(request.context, planMessageId, { text, fallbackText: text }).catch(() => { });
-                }
-            },
-            onTurnComplete: () => { },
-            onAgentEnd: () => {
-                progress.status = "completed";
-                progress.completedAt = Date.now();
-                progress.updatedAt = progress.completedAt;
-                void finalize().catch((error) => console.error("Failed to finalize Discord response:", error));
-            },
-        };
+        engine.start();
         try {
             const info = session.getInfo();
             if ((info.capabilities ?? capabilitiesOf(info)).auth) {
@@ -739,15 +663,15 @@ export function createDiscordBridge(config, registry) {
                 workspace: currentInfo.workspace,
                 description: envelope.description,
             });
-            await session.prompt(envelope.input, callbacks);
+            await session.prompt(envelope.input, engine.callbacks);
             updateSession(request, session);
             progress.status = "completed";
             progress.completedAt = Date.now();
             progress.updatedAt = progress.completedAt;
-            await finalize();
-            await artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, new Date(startedAt));
+            await engine.finalize();
+            await artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, engine.turnId, new Date(engine.startedAt));
             if (config.discordAutoSendArtifacts) {
-                await sendRecentDiscordArtifacts(artifactDeps, request, session, new Date(startedAt), turnId);
+                await sendRecentDiscordArtifacts(artifactDeps, request, session, new Date(engine.startedAt), engine.turnId);
             }
             appendActivity(request, {
                 status: "completed",
@@ -756,7 +680,7 @@ export function createDiscordBridge(config, registry) {
                 threadId: session.getInfo().threadId,
                 workspace: session.getInfo().workspace,
                 agentId: session.getInfo().agentId,
-                durationMs: Date.now() - startedAt,
+                durationMs: Date.now() - engine.startedAt,
             });
             audit(request, {
                 action: "prompt_completed",
@@ -772,13 +696,8 @@ export function createDiscordBridge(config, registry) {
             progress.completedAt = Date.now();
             progress.updatedAt = progress.completedAt;
             progress.error = friendlyErrorText(error);
-            const errorText = renderPromptFailure(accumulatedText, error);
-            if (responseMessageId) {
-                await runtime.editMessage(request.context, responseMessageId, { text: trimDiscordMessage(errorText), fallbackText: trimDiscordMessage(errorText) }).catch(() => { });
-            }
-            else {
-                await reply(request, errorText).catch(() => { });
-            }
+            const errorText = renderPromptFailure(engine.accumulatedText(), error);
+            await engine.fail(errorText);
             appendActivity(request, {
                 status: "failed",
                 type: "prompt_failed",
@@ -787,7 +706,7 @@ export function createDiscordBridge(config, registry) {
                 threadId: session.getInfo().threadId,
                 workspace: session.getInfo().workspace,
                 agentId: session.getInfo().agentId,
-                durationMs: Date.now() - startedAt,
+                durationMs: Date.now() - engine.startedAt,
             });
             audit(request, {
                 action: "prompt_failed",
@@ -800,8 +719,7 @@ export function createDiscordBridge(config, registry) {
             });
         }
         finally {
-            running = false;
-            clearInterval(typing);
+            engine.stop();
             busyState.processing = false;
             await drainQueue(request).catch((error) => console.error("Failed to drain Discord queue:", error));
         }
@@ -878,6 +796,58 @@ export function createDiscordBridge(config, registry) {
         if (state)
             state.artifactsDeliveredForTurnId = turnId;
     };
+    const commandDispatcher = createSharedChannelCommandDispatcher({
+        transport: "discord",
+        bindings: [
+            { names: ["start", "help"], handler: (request) => commandHelp(request) },
+            { names: ["channels"], handler: (request) => deliverChannelAction(runtime, request.context, commandService.renderChannels()).then(() => { }) },
+            { names: ["peers"], handler: (request) => deliverChannelAction(runtime, request.context, commandService.renderPeers()).then(() => { }) },
+            { names: ["target"], handler: (request, argument) => deliverChannelAction(runtime, request.context, commandService.renderTargetPreference({ source: "discord", contextKey: request.contextKey, argument, preferencesStore })).then(() => { }) },
+            { names: ["agents"], handler: (request) => deliverChannelAction(runtime, request.context, commandService.renderAgents()).then(() => { }) },
+            { names: ["agent"], handler: (request, argument) => commandAgent(request, argument) },
+            { names: ["auth"], handler: (request) => commandAuth(request) },
+            { names: ["login"], handler: (request) => commandLogin(request) },
+            { names: ["logout"], handler: (request) => commandLogout(request) },
+            { names: ["session"], handler: (request) => commandSession(request) },
+            { names: ["sessions"], handler: (request, argument) => commandSessions(request, argument) },
+            { names: ["new"], handler: (request, argument) => commandNew(request, argument) },
+            { names: ["switch", "attach"], handler: (request, argument) => commandSwitch(request, argument) },
+            { names: ["model"], handler: (request, argument) => commandModel(request, argument) },
+            { names: ["reasoning", "effort"], handler: (request, argument) => commandReasoning(request, argument) },
+            { names: ["fast"], handler: (request, argument) => commandFast(request, argument) },
+            { names: ["launch", "launch_profiles", "launch-profiles"], handler: (request, argument) => commandLaunch(request, argument) },
+            { names: ["queue"], handler: (request, argument) => commandQueue(request, argument) },
+            { names: ["clearqueue"], handler: (request) => { promptStore.clear(request.contextKey); return reply(request, "Queue cleared."); } },
+            { names: ["cancel"], handler: (request, argument) => commandQueue(request, `cancel ${argument}`) },
+            { names: ["abort", "stop"], handler: (request) => commandAbort(request) },
+            { names: ["retry"], handler: (request) => commandRetry(request) },
+            { names: ["sync"], handler: (request) => commandSync(request) },
+            { names: ["tasks", "progress"], handler: (request) => commandProgress(request) },
+            { names: ["activity"], handler: (request, argument) => commandActivity(request, argument) },
+            { names: ["audit"], handler: (request, argument) => commandAudit(request, argument) },
+            { names: ["artifacts"], handler: (request, argument) => commandArtifacts(request, argument) },
+            { names: ["logs"], handler: (request, argument) => commandLogs(request, argument) },
+            { names: ["version", "health", "status"], handler: (request) => commandVersion(request) },
+            { names: ["diagnostics", "support"], handler: (request) => commandDiagnostics(request) },
+            { names: ["restart"], handler: (request) => commandRestart(request) },
+            { names: ["update"], handler: (request, argument) => commandUpdate(request, argument) },
+            { names: ["lock"], handler: (request) => commandLock(request) },
+            { names: ["unlock"], handler: (request) => { lockStore.clear(request.contextKey); return reply(request, "Session unlocked."); } },
+            { names: ["locks"], handler: (request) => reply(request, lockStore.list().map((lock) => `${lock.contextKey}: ${lock.ownerLabel || lock.ownerUserId}`).join("\n") || "No active locks.") },
+            { names: ["mirror"], handler: (request, argument) => commandMirror(request, argument) },
+            { names: ["notify"], handler: (request, argument) => commandNotify(request, argument) },
+            { names: ["voice"], handler: (request, argument) => commandVoice(request, argument) },
+            { names: ["workspaces"], handler: (request) => commandWorkspaces(request) },
+            { names: ["pin"], handler: (request, argument) => commandPin(request, argument) },
+            { names: ["unpin"], handler: (request, argument) => commandUnpin(request, argument) },
+            { names: ["pinned"], handler: (request) => commandPinned(request) },
+            { names: ["handback"], handler: (request) => commandHandback(request) },
+            { names: ["register_channel"], handler: (request) => commandRegisterChannel(request) },
+            { names: ["link"], handler: (request, argument) => commandLink(request, argument) },
+            { names: ["whoami"], handler: (request) => reply(request, request.authUser ? `${request.authUser.user.displayName} <${request.authUser.user.email}>\nGroups: ${request.authUser.groups.map((group) => group.name).join(", ")}` : "Not linked.") },
+            { names: ["prompt"], handler: (request, argument) => handlePrompt(request, argument) },
+        ],
+    });
     const handleCommand = async (request, command, argument) => {
         const normalized = command.toLowerCase();
         const permission = requiredPermissionForDiscordCommand(normalized, argument);
@@ -885,158 +855,9 @@ export function createDiscordBridge(config, registry) {
             return;
         }
         audit(request, { action: "command", status: "ok", description: `/${normalized} ${argument}`.trim() });
-        switch (normalized) {
-            case "start":
-            case "help":
-                await commandHelp(request);
-                return;
-            case "channels":
-                await deliverChannelAction(runtime, request.context, commandService.renderChannels());
-                return;
-            case "agents":
-                await deliverChannelAction(runtime, request.context, commandService.renderAgents());
-                return;
-            case "agent":
-                await commandAgent(request, argument);
-                return;
-            case "auth":
-                await commandAuth(request);
-                return;
-            case "login":
-                await commandLogin(request);
-                return;
-            case "logout":
-                await commandLogout(request);
-                return;
-            case "session":
-                await commandSession(request);
-                return;
-            case "sessions":
-                await commandSessions(request, argument);
-                return;
-            case "new":
-                await commandNew(request, argument);
-                return;
-            case "switch":
-            case "attach":
-                await commandSwitch(request, argument);
-                return;
-            case "model":
-                await commandModel(request, argument);
-                return;
-            case "reasoning":
-            case "effort":
-                await commandReasoning(request, argument);
-                return;
-            case "fast":
-                await commandFast(request, argument);
-                return;
-            case "launch":
-            case "launch_profiles":
-            case "launch-profiles":
-                await commandLaunch(request, argument);
-                return;
-            case "queue":
-                await commandQueue(request, argument);
-                return;
-            case "clearqueue":
-                promptStore.clear(request.contextKey);
-                await reply(request, "Queue cleared.");
-                return;
-            case "cancel":
-                await commandQueue(request, `cancel ${argument}`);
-                return;
-            case "abort":
-            case "stop":
-                await commandAbort(request);
-                return;
-            case "retry":
-                await commandRetry(request);
-                return;
-            case "sync":
-                await commandSync(request);
-                return;
-            case "tasks":
-            case "progress":
-                await commandProgress(request);
-                return;
-            case "activity":
-                await commandActivity(request, argument);
-                return;
-            case "audit":
-                await commandAudit(request, argument);
-                return;
-            case "artifacts":
-                await commandArtifacts(request, argument);
-                return;
-            case "logs":
-                await commandLogs(request, argument);
-                return;
-            case "version":
-            case "health":
-            case "status":
-                await commandVersion(request);
-                return;
-            case "diagnostics":
-                await commandDiagnostics(request);
-                return;
-            case "support":
-                await commandDiagnostics(request);
-                return;
-            case "restart":
-                await commandRestart(request);
-                return;
-            case "update":
-                await commandUpdate(request, argument);
-                return;
-            case "lock":
-                await commandLock(request);
-                return;
-            case "unlock":
-                lockStore.clear(request.contextKey);
-                await reply(request, "Session unlocked.");
-                return;
-            case "locks":
-                await reply(request, lockStore.list().map((lock) => `${lock.contextKey}: ${lock.ownerLabel || lock.ownerUserId}`).join("\n") || "No active locks.");
-                return;
-            case "mirror":
-                await commandMirror(request, argument);
-                return;
-            case "notify":
-                await commandNotify(request, argument);
-                return;
-            case "voice":
-                await commandVoice(request, argument);
-                return;
-            case "workspaces":
-                await commandWorkspaces(request);
-                return;
-            case "pin":
-                await commandPin(request, argument);
-                return;
-            case "unpin":
-                await commandUnpin(request, argument);
-                return;
-            case "pinned":
-                await commandPinned(request);
-                return;
-            case "handback":
-                await commandHandback(request);
-                return;
-            case "register_channel":
-                await commandRegisterChannel(request);
-                return;
-            case "link":
-                await commandLink(request, argument);
-                return;
-            case "whoami":
-                await reply(request, request.authUser ? `${request.authUser.user.displayName} <${request.authUser.user.email}>\nGroups: ${request.authUser.groups.map((group) => group.name).join(", ")}` : "Not linked.");
-                return;
-            case "prompt":
-                await handlePrompt(request, argument);
-                return;
-            default:
-                await reply(request, `Unknown command: /${normalized}`);
+        const result = await commandDispatcher.dispatch(request, normalized, argument);
+        if (!result.matched) {
+            await reply(request, `Unknown command: /${normalized}`);
         }
     };
     const commandHelp = async (request) => {
@@ -1046,7 +867,7 @@ export function createDiscordBridge(config, registry) {
             "",
             "Send a message to prompt the selected agent, or use slash commands.",
             "",
-            "Core commands: `/agent`, `/agents`, `/auth`, `/login`, `/logout`, `/session`, `/sessions`, `/new`, `/switch`, `/attach`, `/handback`, `/workspaces`, `/pin`, `/unpin`, `/pinned`, `/model`, `/reasoning`, `/fast`, `/launch`, `/launch_profiles`, `/queue`, `/clearqueue`, `/cancel`, `/stop`, `/retry`, `/sync`, `/progress`, `/activity`, `/audit`, `/artifacts`, `/logs`, `/version`, `/diagnostics`, `/support`, `/restart`, `/update`, `/lock`, `/unlock`, `/locks`, `/mirror`, `/notify`, `/voice`, `/channels`, `/whoami`, `/link`, `/register_channel`.",
+            `Core commands: ${discordHelpCommandList()}.`,
             "",
             renderSessionInfoPlain(session.getInfo()),
         ].join("\n"));
@@ -1595,33 +1416,32 @@ export function createDiscordBridge(config, registry) {
         await deliverChannelAction(runtime, request.context, commandService.renderHandback(result));
     };
     const commandMirror = async (request, argument) => {
-        const mode = parseMirrorMode(argument, preferencesStore.get(request.contextKey).mirrorMode ?? config.discordMirrorMode);
-        preferencesStore.update(request.contextKey, { mirrorMode: mode });
-        await reply(request, `CLI mirror mode: ${mode}`);
+        const session = await getSession(request, { deferThreadStart: true });
+        const info = session.getInfo();
+        await deliverChannelAction(runtime, request.context, commandService.renderMirrorPreference({
+            source: "discord",
+            contextKey: request.contextKey,
+            argument,
+            preferencesStore,
+            cliMirrorSupported: capabilitiesOf(info).cliMirror,
+            agentLabel: info.agentLabel,
+        }));
     };
     const commandNotify = async (request, argument) => {
-        const mode = parseNotifyMode(argument, preferencesStore.get(request.contextKey).notifyMode ?? config.discordNotifyMode);
-        preferencesStore.update(request.contextKey, { notifyMode: mode });
-        await reply(request, `Notify mode: ${mode}`);
+        await deliverChannelAction(runtime, request.context, commandService.renderNotifyPreference({
+            source: "discord",
+            contextKey: request.contextKey,
+            argument,
+            preferencesStore,
+        }));
     };
     const commandVoice = async (request, argument) => {
-        const normalized = argument.trim().toLowerCase();
-        const parts = normalized.split(/\s+/).filter(Boolean);
-        if (parts[0] === "backend" && parts[1]) {
-            preferencesStore.update(request.contextKey, { voiceBackend: parseVoiceBackendPreference(parts[1]) });
-        }
-        else if (parts[0] === "language" && parts[1]) {
-            preferencesStore.update(request.contextKey, { voiceLanguage: parts[1] === "auto" ? null : parts[1] });
-        }
-        else if ((parts[0] === "transcribe-only" || parts[0] === "transcribe_only") && parts[1]) {
-            preferencesStore.update(request.contextKey, { voiceTranscribeOnly: ["on", "true", "yes", "1"].includes(parts[1]) });
-        }
-        else if (argument.trim()) {
-            await reply(request, "Usage: `/voice`, `/voice backend auto|parakeet|faster-whisper|openai`, `/voice language auto|<code>`, or `/voice transcribe_only on|off`.");
-            return;
-        }
-        const prefs = preferencesStore.get(request.contextKey);
-        await reply(request, `Voice backend: ${prefs.voiceBackend ?? config.voicePreferredBackend}\nLanguage: ${prefs.voiceLanguage ?? config.voiceDefaultLanguage ?? "auto"}\nTranscribe only: ${prefs.voiceTranscribeOnly ?? config.voiceTranscribeOnly}`);
+        await deliverChannelAction(runtime, request.context, await commandService.renderVoicePreference({
+            source: "discord",
+            contextKey: request.contextKey,
+            argument,
+            preferencesStore,
+        }));
     };
     const commandRegisterChannel = async (request) => {
         const channel = userStore.registerDiscordChannel({
@@ -1781,6 +1601,17 @@ export function createDiscordBridge(config, registry) {
             await commandQueue(request, `${queueMatch[1]} ${queueMatch[3]}`);
             return;
         }
+        const peerQueueMatch = action.match(/^discord_peer_queue_cancel:([^:]+):([^:]+)$/);
+        if (peerQueueMatch?.[1] && peerQueueMatch[2]) {
+            await remoteClient.webProxy(peerQueueMatch[1], {
+                method: "POST",
+                path: "/api/queue",
+                body: { action: "cancel", id: peerQueueMatch[2] },
+                contextKey: request.contextKey,
+            }, actorFor(request), request.contextKey);
+            await reply(request, `Cancelled remote queued prompt ${peerQueueMatch[2]}.`, { ephemeral: true });
+            return;
+        }
         const artifactMatch = action.match(/^discord_artifact_(send|zip|delete):(.+):([^:]+)$/);
         if (artifactMatch?.[1] && artifactMatch[2] === request.contextKey) {
             await commandArtifacts(request, `${artifactMatch[1]} ${artifactMatch[3]}`);