jeopi-cli 16.6.11 → 16.6.12

package/src/messenger/gateway.ts

@@ -5,13 +5,15 @@ import { MessengerFatalError } from "./types";
 const MAX_MESSAGE_LENGTH = 32_000;
 const MAX_QUEUED_MESSAGES = 100;
 const MAX_SEEN_MESSAGES = 10_000;
+const STATUS_TIMEOUT_MS = 1000;
+const MAX_STATUS_IN_FLIGHT = 8;
 
 /** Include the sender even in shared threads: remote histories must not cross users. */
 export function messengerConversationKey(message: MessengerMessage): string {
 	return JSON.stringify([
 		message.platform,
 		message.accountId,
-		message.channelId,
+		message.parentChannelId ?? message.channelId,
 		message.threadId ?? "",
 		message.senderId,
 	]);
@@ -25,11 +27,14 @@ export function isMessengerMessageAllowed(message: MessengerMessage, config: Mes
 			message.channelId &&
 			message.senderId &&
 			message.messageId &&
-			message.text.trim() &&
+			(message.text.trim() ||
+				(message.platform === "discord" && config.platforms.discord?.artifactDir && message.attachments?.length)) &&
 			message.text.length <= MAX_MESSAGE_LENGTH &&
 			platform.allowedUserIds.includes(message.senderId) &&
-			(!platform.allowedChannelIds || platform.allowedChannelIds.includes(message.channelId)) &&
-			(message.direct || message.mentioned),
+			(!platform.allowedChannelIds ||
+				platform.allowedChannelIds.includes(message.channelId) ||
+				(Boolean(message.parentChannelId) && platform.allowedChannelIds.includes(message.parentChannelId!))) &&
+			(message.direct || message.mentioned || (message.platform === "discord" && Boolean(message.parentChannelId))),
 	);
 }
 
@@ -63,20 +68,57 @@ export function createMessengerGateway(
 	let workerActive = false;
 	let running = false;
 	let fatalError: MessengerFatalError | undefined;
+	let statusInFlight = 0;
 
 	async function drain(): Promise<void> {
 		while (queue.length > 0) {
 			const pending = queue.shift();
 			if (!pending) break;
 			const { message, adapter, signal, resolve } = pending;
+			let failed = false;
+			let statusChain = Promise.resolve();
+			const status = (state: "processing" | "success" | "failure"): void => {
+				if (!adapter.status) return;
+				statusChain = statusChain.then(async () => {
+					if (signal.aborted || statusInFlight >= MAX_STATUS_IN_FLIGHT) return;
+					const timeout = new AbortController();
+					const statusSignal = AbortSignal.any([signal, timeout.signal]);
+					const stopped = Promise.withResolvers<void>();
+					const onAbort = (): void => stopped.resolve();
+					statusSignal.addEventListener("abort", onAbort, { once: true });
+					statusInFlight++;
+					const operation = Promise.resolve().then(() => adapter.status!(message, state, statusSignal));
+					void operation.then(
+						() => {
+							statusInFlight--;
+						},
+						() => {
+							statusInFlight--;
+						},
+					);
+					const timer = setTimeout(() => timeout.abort(), STATUS_TIMEOUT_MS);
+					try {
+						await Promise.race([operation, stopped.promise]);
+					} catch {
+						if (!signal.aborted) logger.warn("Messenger status update failed", { platform: message.platform });
+					} finally {
+						clearTimeout(timer);
+						statusSignal.removeEventListener("abort", onAbort);
+					}
+				});
+			};
 			try {
 				if (signal.aborted) continue;
+				status("processing");
+				const destination = (await adapter.prepare?.(message, signal)) ?? message;
 				let text: string;
 				try {
-					text = await reply(message, signal);
+					text = await reply(destination, signal);
 				} catch (error) {
+					failed = true;
 					if (error instanceof MessengerFatalError) {
 						fatalError = error;
+						status("failure");
 						lifetime.abort();
 						continue;
 					}
@@ -86,10 +128,14 @@ export function createMessengerGateway(
 				}
 				if (!signal.aborted && text.trim()) {
 					// A failed send may already have delivered a chunk: never retry the entire reply.
-					await adapter.send(message, text, signal);
+					await adapter.send(destination, text, signal);
 				}
+				if (!signal.aborted) status(failed ? "failure" : "success");
 			} catch {
-				if (!signal.aborted) logger.warn("Messenger reply delivery failed", { platform: message.platform });
+				if (!signal.aborted) {
+					logger.warn("Messenger reply delivery failed", { platform: message.platform });
+					status("failure");
+				}
 			} finally {
 				resolve();
 			}

package/src/messenger/http.ts

@@ -65,6 +65,7 @@ export async function messengerFetchJson(
 			if (!response.bodyUsed) await response.body?.cancel();
 			throw new MessengerHttpError(response.status, retryAfterMs);
 		}
+		if (response.status === 204) return undefined;
 		return await response.json();
 	} catch (error) {
 		if (error instanceof MessengerHttpError) throw error;

package/src/messenger/live-session.ts

@@ -1,5 +1,6 @@
 import type { AssistantMessage, UserMessage } from "jeopi-ai";
 import type { InteractiveModeContext } from "../modes/types";
+import { messengerArtifactPrompt } from "./artifacts";
 import { loadMessengerConfig, validateMessengerEnvironment } from "./config";
 import { createDiscordAdapter, type DiscordTransportDeps } from "./discord";
 import { createMessengerGateway, isMessengerMessageAllowed, type MessengerGateway } from "./gateway";
@@ -21,12 +22,18 @@ export interface LiveDiscordBridgeDependencies {
 export interface LiveDiscordBridge {
 	readonly gateway: MessengerGateway;
 	readonly active: boolean;
+	readonly relayDestination: string | undefined;
+	setRelayDestination(channelId: string | undefined): void;
+	withLocalTurn<T>(
+		text: string,
+		submit: (onPreparedUserMessage: (message: UserMessage) => void) => Promise<T>,
+	): Promise<T>;
 	run(signal?: AbortSignal): Promise<void>;
 	close(): Promise<void>;
 }
 
 interface TurnCapture {
-	readonly promptText: string;
+	promptText: string;
 	promptSeen: boolean;
 	dispatched: boolean;
 	hostSettled: boolean;
@@ -143,7 +150,12 @@ export function createLiveDiscordBridge(
 	let currentTurn: TurnCapture | undefined;
 	let pollTimer: NodeJS.Timeout;
 	let bridgeRef: LiveDiscordBridge | undefined;
+	let relayDestination: string | undefined;
+	let relayLifetime = new AbortController();
+	let relaySend = Promise.resolve();
+	let localCapture: object | undefined;
 	let close: () => Promise<void>;
+	let revoke: () => Promise<void>;
 	const reply: MessengerReply = async (message, signal) => {
 		if (closed || signal?.aborted) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
 		if (!sameSession(ctx, attachedSession, sessionId, sessionFile)) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
@@ -156,10 +168,11 @@ export function createLiveDiscordBridge(
 			attachedSession.isBashRunning ||
 			attachedSession.isEvalRunning ||
 			attachedSession.hasPostPromptWork ||
+			localCapture ||
 			currentTurn
 		)
 			return LIVE_BUSY_MESSAGE;
-		const promptText = `[Discord:${message.messageId} sender:${message.senderId} channel:${message.channelId}] ${message.text}`;
+		let promptText = `[Discord:${message.messageId} sender:${message.senderId} channel:${message.channelId}] ${message.text}`;
 		const capture: TurnCapture = {
 			promptText,
 			promptSeen: false,
@@ -173,6 +186,10 @@ export function createLiveDiscordBridge(
 			ctx.showStatus(`Discord request from ${message.senderId}`);
 		} catch {}
 		const operationSignal = signal ? AbortSignal.any([lifetime.signal, signal]) : lifetime.signal;
+		const onAbort = (): void => {
+			void revoke();
+		};
+		operationSignal.addEventListener("abort", onAbort, { once: true });
 		const unsubscribe = attachedSession.subscribe(event => {
 			if (event.type !== "message_end") return;
 			if (event.message.role === "user") {
@@ -187,6 +204,21 @@ export function createLiveDiscordBridge(
 			if (capture.promptSeen && isCompetingMessage(event.message)) capture.conflicted = true;
 		});
 		try {
+			const guidance = await messengerArtifactPrompt(
+				scopedConfig.platforms.discord?.artifactDir,
+				message,
+				operationSignal,
+			);
+			if (guidance) promptText += `\n\n${guidance}`;
+			capture.promptText = promptText;
+			if (
+				attachedSession.isStreaming ||
+				attachedSession.isCompacting ||
+				attachedSession.isBashRunning ||
+				attachedSession.isEvalRunning ||
+				localCapture
+			)
+				throw new Error(LIVE_UNAVAILABLE_MESSAGE);
 			if (closed || operationSignal.aborted || !sameSession(ctx, attachedSession, sessionId, sessionFile))
 				throw new Error(LIVE_UNAVAILABLE_MESSAGE);
 			const promptPromise = attachedSession.prompt(promptText, {
@@ -222,6 +254,7 @@ export function createLiveDiscordBridge(
 			if (!response.trim()) throw new Error("Live Discord response unavailable");
 			return response;
 		} finally {
+			operationSignal.removeEventListener("abort", onAbort);
 			unsubscribe();
 			if (currentTurn === capture) currentTurn = undefined;
 		}
@@ -245,36 +278,179 @@ export function createLiveDiscordBridge(
 			await adapter.send(message, text, sendSignal);
 		},
 	};
-	const gateway = gatewayFactory(scopedConfig, [guardedAdapter], reply);
-	close = async (): Promise<void> => {
-		if (closed) {
-			await runPromise?.catch(() => {});
-			return;
+	const setRelayDestination = (channelId: string | undefined): void => {
+		if (closed || !sameSession(ctx, attachedSession, sessionId, sessionFile))
+			throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+		if (channelId !== undefined && !discordConfig.allowedChannelIds?.includes(channelId)) {
+			throw new Error("Discord relay destination must be an explicitly allowed channel ID");
+		}
+		relayLifetime.abort();
+		relayLifetime = new AbortController();
+		relayDestination = channelId;
+	};
+	const withLocalTurn = async <T>(
+		_text: string,
+		submit: (onPreparedUserMessage: (message: UserMessage) => void) => Promise<T>,
+	): Promise<T> => {
+		const destination = relayDestination;
+		if (!destination || closed || !sameSession(ctx, attachedSession, sessionId, sessionFile)) return submit(() => {});
+		if (
+			currentTurn ||
+			localCapture ||
+			attachedSession.isStreaming ||
+			attachedSession.isCompacting ||
+			attachedSession.isRetrying ||
+			attachedSession.isGeneratingHandoff ||
+			attachedSession.isBashRunning ||
+			attachedSession.isEvalRunning ||
+			attachedSession.hasPostPromptWork
+		) {
+			try {
+				ctx.showWarning("Discord relay skipped: another session operation is in progress.");
+			} catch {}
+			return submit(() => {});
+		}
+		const signal = AbortSignal.any([lifetime.signal, relayLifetime.signal]);
+		const capture = {};
+		localCapture = capture;
+		let promptSeen = false;
+		let preparedMessage: UserMessage | undefined;
+		let conflicted = false;
+		let response: AssistantMessage | undefined;
+		const unsubscribe = attachedSession.subscribe(event => {
+			if (event.type !== "message_end") return;
+			if (event.message.role === "user") {
+				if (!promptSeen && preparedMessage === event.message) promptSeen = true;
+				else conflicted = true;
+			} else if (isCompetingMessage(event.message)) {
+				conflicted = true;
+			} else if (promptSeen && event.message.role === "assistant") {
+				response = event.message;
+			}
+		});
+		let cleaned = false;
+		let submitting = true;
+		const cleanup = (): void => {
+			if (cleaned) return;
+			cleaned = true;
+			signal.removeEventListener("abort", cleanup);
+			unsubscribe();
+			if (!submitting && localCapture === capture) localCapture = undefined;
+		};
+		signal.addEventListener("abort", cleanup, { once: true });
+		if (signal.aborted) cleanup();
+		try {
+			const result = await submit(message => {
+				preparedMessage = message;
+			});
+			submitting = false;
+			if (cleaned && localCapture === capture) localCapture = undefined;
+			void (async () => {
+				try {
+					await awaitWithAbort(attachedSession.waitForIdle(), signal);
+					if (result === false || signal.aborted || !sameSession(ctx, attachedSession, sessionId, sessionFile))
+						return;
+					if (!promptSeen || conflicted || currentTurn) {
+						try {
+							ctx.showWarning(
+								"Discord relay skipped: could not safely identify this local turn or another turn intervened.",
+							);
+						} catch {}
+						return;
+					}
+					if (response?.stopReason !== "stop") {
+						try {
+							ctx.showWarning("Discord relay skipped: the local turn did not finish successfully.");
+						} catch {}
+						return;
+					}
+					const output = assistantMessageText(response);
+					cleanup();
+					if (!output.trim()) {
+						try {
+							ctx.showWarning("Discord relay skipped: the local response contains no text.");
+						} catch {}
+						return;
+					}
+					const message = {
+						platform: "discord" as const,
+						accountId: "",
+						channelId: destination,
+						senderId: "",
+						messageId: "",
+						text: "",
+						direct: false,
+						mentioned: false,
+					};
+					const send = relaySend.then(async () => {
+						if (signal.aborted || !sameSession(ctx, attachedSession, sessionId, sessionFile)) return;
+						await guardedAdapter.send(message, output, signal);
+					});
+					relaySend = send.catch(() => {});
+					await send;
+				} catch (error) {
+					if (!signal.aborted) {
+						try {
+							ctx.showWarning(
+								`Discord relay delivery failed: ${error instanceof Error ? error.message : String(error)}`,
+							);
+						} catch {}
+					}
+				} finally {
+					cleanup();
+				}
+			})();
+			return result;
+		} catch (error) {
+			submitting = false;
+			cleanup();
+			if (localCapture === capture) localCapture = undefined;
+			throw error;
 		}
+	};
+	const gateway = gatewayFactory(scopedConfig, [guardedAdapter], reply);
+	let revokePromise: Promise<void> | undefined;
+	revoke = (): Promise<void> => {
+		if (revokePromise) return revokePromise;
+		const completion = Promise.withResolvers<void>();
+		revokePromise = completion.promise;
+		const turn = currentTurn;
 		closed = true;
 		clearInterval(pollTimer);
+		relayLifetime.abort();
+		relayDestination = undefined;
 		lifetime.abort();
-		const turn = currentTurn;
-		if (turn && sameSession(ctx, attachedSession, sessionId, sessionFile)) {
-			if (turn.dispatched && !turn.hostSettled && !turn.conflicted) {
-				try {
-					await awaitHostAbort(attachedSession.abort({ reason: "Discord live bridge revoked" }));
-				} catch {
+		void (async () => {
+			if (turn && sameSession(ctx, attachedSession, sessionId, sessionFile)) {
+				if (turn.dispatched && !turn.hostSettled && !turn.conflicted) {
 					try {
-						ctx.showWarning("Discord live turn could not be interrupted; press Esc to interrupt it.");
+						await awaitHostAbort(attachedSession.abort({ reason: "Discord live bridge revoked" }));
+					} catch {
+						try {
+							ctx.showWarning("Discord live turn could not be interrupted; press Esc to interrupt it.");
+						} catch {}
+					}
+				} else if (!turn.hostSettled) {
+					try {
+						ctx.showWarning("A Discord-initiated turn is still running; press Esc to interrupt.");
 					} catch {}
 				}
-			} else if (!turn.hostSettled) {
-				try {
-					ctx.showWarning("A Discord-initiated turn is still running; press Esc to interrupt.");
-				} catch {}
 			}
-		}
+		})().then(completion.resolve, completion.reject);
+		return revokePromise;
+	};
+	close = async (): Promise<void> => {
+		await revoke();
 		await runPromise?.catch(() => {});
 	};
 
 	const run = (signal?: AbortSignal): Promise<void> => {
 		if (runPromise) return runPromise;
+		const onAbort = (): void => {
+			void revoke();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) onAbort();
 		const effectiveSignal = signal ? AbortSignal.any([lifetime.signal, signal]) : lifetime.signal;
 		runPromise = gateway
 			.run(effectiveSignal)
@@ -285,9 +461,9 @@ export function createLiveDiscordBridge(
 					ctx.showStatus("Discord live bridge detached: session changed");
 				}
 			})
-			.finally(() => {
-				closed = true;
-				clearInterval(pollTimer);
+			.finally(async () => {
+				signal?.removeEventListener("abort", onAbort);
+				await revoke();
 			});
 		return runPromise;
 	};
@@ -303,6 +479,11 @@ export function createLiveDiscordBridge(
 		get active() {
 			return !closed;
 		},
+		get relayDestination() {
+			return relayDestination;
+		},
+		setRelayDestination,
+		withLocalTurn,
 		run,
 		close,
 	};

package/src/messenger/session.ts

@@ -10,6 +10,7 @@ import type { AgentSession } from "../session/agent-session";
 import type { AuthStorage } from "../session/auth-storage";
 import { USER_INTERRUPT_LABEL } from "../session/messages";
 import { SessionManager } from "../session/session-manager";
+import { messengerArtifactPrompt } from "./artifacts";
 import { messengerConversationKey } from "./gateway";
 import { type MessengerConfig, MessengerFatalError, type MessengerReply } from "./types";
 
@@ -175,7 +176,13 @@ export function createMessengerSessionBridge(
 			await constrainTools(current);
 			if (closed || signal.aborted || runtimeFailed) throw new Error("Messenger session unavailable");
 			// Slash-looking text is ordinary user data, never an extension command or developer message.
-			const dispatched = await current.prompt(message.text, { expandPromptTemplates: false });
+			let prompt = message.text;
+			const artifactRoot = message.platform === "discord" ? config.platforms.discord?.artifactDir : undefined;
+			if (message.platform === "discord") {
+				const guidance = await messengerArtifactPrompt(artifactRoot, message, signal);
+				if (guidance) prompt += `\n\n${guidance}`;
+			}
+			const dispatched = await current.prompt(prompt, { expandPromptTemplates: false });
 			await current.waitForIdle();
 			await current.sessionManager.flush();
 			if (!dispatched || closed || signal.aborted || runtimeFailed) throw new Error("Messenger request failed");

package/src/messenger/types.ts

@@ -8,14 +8,22 @@ export interface MessengerMessage {
 	messageId: string;
 	text: string;
 	threadId?: string;
+	parentChannelId?: string;
 	direct: boolean;
 	mentioned: boolean;
+	attachments?: { url: string; filename: string; size: number }[];
 }
 
 export interface MessengerAdapter {
 	platform: MessengerPlatform;
 	start(onMessage: (message: MessengerMessage) => Promise<void>, signal: AbortSignal): Promise<void>;
 	send(message: MessengerMessage, text: string, signal?: AbortSignal): Promise<void>;
+	prepare?(message: MessengerMessage, signal?: AbortSignal): Promise<MessengerMessage>;
+	status?(
+		message: MessengerMessage,
+		status: "processing" | "success" | "failure",
+		signal?: AbortSignal,
+	): Promise<void>;
 }
 
 export interface MessengerPlatformConfig {
@@ -23,6 +31,8 @@ export interface MessengerPlatformConfig {
 	appTokenEnv?: string;
 	allowedUserIds: string[];
 	allowedChannelIds?: string[];
+	/** Dedicated operator-approved directory for Discord output files. */
+	artifactDir?: string;
 }
 
 export interface MessengerConfig {

package/src/modes/controllers/input-controller.ts

@@ -903,7 +903,19 @@ export class InputController {
 				try {
 					await this.ctx.withLocalSubmission(
 						text,
-						() => this.ctx.session.prompt(text, { streamingBehavior: "steer", images }),
+						() => {
+							const submit = () => this.ctx.session.prompt(text, { streamingBehavior: "steer", images });
+							const bridge = this.ctx.liveDiscordBridge;
+							return bridge?.active
+								? bridge.withLocalTurn(text, onPreparedUserMessage =>
+										this.ctx.session.prompt(text, {
+											streamingBehavior: "steer",
+											images,
+											onPreparedUserMessage,
+										}),
+									)
+								: submit();
+						},
 						{
 							imageCount: images?.length ?? 0,
 						},
@@ -1229,9 +1241,19 @@ export class InputController {
 		// Not streaming — just submit normally
 		this.ctx.editor.clearDraft(text);
 		try {
-			await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text, { images }), {
-				imageCount: images?.length ?? 0,
-			});
+			await this.ctx.withLocalSubmission(
+				text,
+				() => {
+					const submit = () => this.ctx.session.prompt(text, { images });
+					const bridge = this.ctx.liveDiscordBridge;
+					return bridge?.active
+						? bridge.withLocalTurn(text, onPreparedUserMessage =>
+								this.ctx.session.prompt(text, { images, onPreparedUserMessage }),
+							)
+						: submit();
+				},
+				{ imageCount: images?.length ?? 0 },
+			);
 		} catch (error) {
 			restoreOnError(error);
 		}

package/src/prompts/system/messenger-artifacts.md

@@ -0,0 +1,4 @@
+To deliver a requested file, write it inside {{directory}} and put [artifact:relative/path] on its own line in your final response. Only files in that directory can be uploaded; each must be at most 8 MiB. Never include credentials or secrets in output files.
+{{#if inputs}}
+Incoming files: {{inputs}}
+{{/if}}

package/src/session/agent-session.ts

@@ -97,6 +97,7 @@ import type {
 	ToolChoice,
 	Usage,
 	UsageReport,
+	UserMessage,
 } from "jeopi-ai";
 import {
 	calculateRateLimitBackoffMs,
@@ -944,6 +945,8 @@ export interface PromptOptions {
 	userInitiated?: boolean;
 	/** Explicit billing/initiator attribution for the prompt. Defaults to user prompts as `user` and synthetic prompts as `agent`. */
 	attribution?: MessageAttribution;
+	/** Observe the exact user message prepared for this submission, including queued messages. */
+	onPreparedUserMessage?: (message: UserMessage) => void;
 	/** Skip pre-send compaction checks for this prompt (internal use for maintenance flows). */
 	skipCompactionCheck?: boolean;
 }
@@ -7539,9 +7542,9 @@ export class AgentSession {
 				await this.sendCustomMessage(notice, { deliverAs: options.streamingBehavior });
 			}
 			if (options.streamingBehavior === "followUp") {
-				await this.#queueUserMessage(expandedText, options?.images, "followUp");
+				await this.#queueUserMessage(expandedText, options?.images, "followUp", options?.onPreparedUserMessage);
 			} else {
-				await this.#queueUserMessage(expandedText, options?.images, "steer");
+				await this.#queueUserMessage(expandedText, options?.images, "steer", options?.onPreparedUserMessage);
 			}
 			return true;
 		}
@@ -7568,6 +7571,7 @@ export class AgentSession {
 		const message = options?.synthetic
 			? { role: "developer" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() }
 			: { role: "user" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() };
+		if (message.role === "user") options?.onPreparedUserMessage?.(message);
 
 		const preludeMessages: AgentMessage[] = [];
 		if (eagerTodoPrelude) {
@@ -8021,6 +8025,7 @@ export class AgentSession {
 		text: string,
 		images: ImageContent[] | undefined,
 		mode: "steer" | "followUp",
+		onPreparedUserMessage?: (message: UserMessage) => void,
 	): Promise<void> {
 		// A queued user message (RPC/SDK/collab steer or follow-up, or a typed message
 		// while streaming) is a deliberate resume; re-enable advisor auto-resume that
@@ -8038,21 +8043,20 @@ export class AgentSession {
 			: undefined;
 		if (mode === "followUp") {
 			if (imageDescriptionNotice) this.agent.followUp(imageDescriptionNotice);
-			this.agent.followUp({
-				role: "user",
-				content,
-				attribution: "user",
-				timestamp: Date.now(),
-			});
+			const message: UserMessage = { role: "user", content, attribution: "user", timestamp: Date.now() };
+			onPreparedUserMessage?.(message);
+			this.agent.followUp(message);
 		} else {
 			if (imageDescriptionNotice) this.agent.steer(imageDescriptionNotice);
-			this.agent.steer({
+			const message: UserMessage = {
 				role: "user",
 				content,
 				steering: true,
 				attribution: "user",
 				timestamp: Date.now(),
-			});
+			};
+			onPreparedUserMessage?.(message);
+			this.agent.steer(message);
 		}
 		this.#scheduleIdleQueueDrain();
 	}

package/src/slash-commands/builtin-registry.ts

@@ -661,9 +661,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "discord",
 		description: "Opt in to this session from an authorized Discord channel",
-		inlineHint: "[live|stop|status] [configPath] [--allow-full-control]",
+		inlineHint: "[live|relay|stop|status] [configPath|channelId|off] [--allow-full-control]",
 		subcommands: [
 			{ name: "live", description: "Start the live Discord bridge with a private config file" },
+			{ name: "relay", description: "Relay local responses to an allowed channel, or turn relay off" },
 			{ name: "status", description: "Show live Discord bridge status" },
 			{ name: "stop", description: "Stop the live Discord bridge" },
 		],
@@ -682,10 +683,32 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				const approvalMode = String(ctx.session.settings.get("tools.approvalMode"));
 				const activeTools = ctx.session.getActiveToolNames();
 				ctx.showStatus(
-					`Discord live bridge is active with full host control acknowledged. Approval mode: ${approvalMode}; active tools: ${activeTools.length > 0 ? activeTools.join(", ") : "none"}.`,
+					`Discord live bridge is active with full host control acknowledged. Approval mode: ${approvalMode}; active tools: ${activeTools.length > 0 ? activeTools.join(", ") : "none"}. Local response relay: ${ctx.liveDiscordBridge.relayDestination ?? "off"}.`,
 				);
 				return;
 			}
+			if (verb === "relay") {
+				const bridge = ctx.liveDiscordBridge;
+				if (!bridge?.active) {
+					ctx.showError("Start the Discord live bridge before enabling relay");
+					return;
+				}
+				if (!rest || /\s/.test(rest)) {
+					ctx.showError("Usage: /discord relay <allowed-channel-id|off>");
+					return;
+				}
+				try {
+					bridge.setRelayDestination(rest === "off" ? undefined : rest);
+					ctx.showStatus(
+						rest === "off"
+							? "Discord local response relay is off"
+							: `Discord local responses will be sent to channel ${rest}; /discord relay off revokes relay.`,
+					);
+				} catch (error) {
+					ctx.showError(`Failed to configure Discord relay: ${errorMessage(error)}`);
+				}
+				return;
+			}
 			if (verb === "stop") {
 				const bridge = ctx.liveDiscordBridge;
 				const start = liveDiscordStarts.get(ctx);