jeopi-cli 16.6.9 → 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

@@ -0,0 +1,502 @@
+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";
+import type { MessengerAdapter, MessengerConfig, MessengerReply } from "./types";
+
+const DEFAULT_POLL_INTERVAL_MS = 250;
+const LIVE_HOST_ABORT_TIMEOUT_MS = 1000;
+const LIVE_BUSY_MESSAGE = "The live session is busy. Please try again when it is idle.";
+const LIVE_UNAVAILABLE_MESSAGE = "The live Discord bridge is no longer attached to this session.";
+
+export interface LiveDiscordBridgeDependencies {
+	createAdapter?: typeof createDiscordAdapter;
+	createGateway?: typeof createMessengerGateway;
+	env?: Record<string, string | undefined>;
+	transport?: DiscordTransportDeps;
+	pollIntervalMs?: number;
+}
+
+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 {
+	promptText: string;
+	promptSeen: boolean;
+	dispatched: boolean;
+	hostSettled: boolean;
+	conflicted: boolean;
+}
+
+export interface LiveDiscordBridgeOptions {
+	/** Explicit acknowledgement that Discord requests may use this host session's tools. */
+	acknowledgeFullControl?: boolean;
+}
+
+function userMessageText(message: UserMessage): string {
+	if (typeof message.content === "string") return message.content;
+	return message.content
+		.filter(block => block.type === "text")
+		.map(block => block.text)
+		.join("");
+}
+function assistantMessageText(message: AssistantMessage): string {
+	return message.content
+		.filter(block => block.type === "text")
+		.map(block => block.text)
+		.join("\n");
+}
+
+function sameSession(
+	ctx: InteractiveModeContext,
+	attachedSession: InteractiveModeContext["session"],
+	sessionId: string,
+	sessionFile: string | undefined,
+): boolean {
+	return (
+		ctx.session === attachedSession &&
+		!attachedSession.isDisposed &&
+		ctx.sessionManager.getSessionId() === sessionId &&
+		ctx.sessionManager.getSessionFile() === sessionFile &&
+		!ctx.shutdownRequested &&
+		!ctx.isShuttingDown
+	);
+}
+
+function isCompetingMessage(message: { role: string; attribution?: string }): boolean {
+	if (message.role === "user") return true;
+	const attribution = message.attribution ?? "agent";
+	return (
+		(message.role === "custom" || message.role === "developer" || message.role === "hookMessage") &&
+		attribution !== "agent"
+	);
+}
+
+async function awaitWithAbort<T>(operation: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+	if (!signal) return operation;
+	if (signal.aborted) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+	const cancellation = Promise.withResolvers<never>();
+	const onAbort = () => cancellation.reject(new Error(LIVE_UNAVAILABLE_MESSAGE));
+	signal.addEventListener("abort", onAbort, { once: true });
+	if (signal.aborted) onAbort();
+	try {
+		return await Promise.race([operation, cancellation.promise]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+
+async function awaitHostAbort(operation: Promise<void>): Promise<void> {
+	const timeout = Promise.withResolvers<never>();
+	const timer = setTimeout(
+		() => timeout.reject(new Error("Live Discord host abort timed out")),
+		LIVE_HOST_ABORT_TIMEOUT_MS,
+	);
+	try {
+		await Promise.race([operation, timeout.promise]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+function liveConfig(config: MessengerConfig): MessengerConfig {
+	const discord = config.platforms.discord;
+	if (!discord) throw new Error("Live Discord requires a discord platform configuration");
+	if (discord.allowedChannelIds === undefined || discord.allowedChannelIds.length === 0) {
+		throw new Error("Live Discord requires an explicit nonempty allowedChannelIds list");
+	}
+	return { ...config, platforms: { discord } };
+}
+
+/**
+ * Attach an authorized Discord transport to the already-running interactive session.
+ * This never creates, switches, or disposes an AgentSession. The caller owns activation
+ * and must retain the returned bridge to close it when the TUI shuts down.
+ */
+export function createLiveDiscordBridge(
+	ctx: InteractiveModeContext,
+	config: MessengerConfig,
+	dependencies: LiveDiscordBridgeDependencies = {},
+	options: LiveDiscordBridgeOptions = {},
+): LiveDiscordBridge {
+	if (!options.acknowledgeFullControl) {
+		throw new Error(
+			"Live Discord requires explicit full-control acknowledgement (--allow-full-control); " +
+				"Discord requests run in the active session with its tools and approval policy",
+		);
+	}
+	const scopedConfig = liveConfig(config);
+	validateMessengerEnvironment(scopedConfig, dependencies.env);
+	const attachedSession = ctx.session;
+	const sessionId = ctx.sessionManager.getSessionId();
+	const sessionFile = ctx.sessionManager.getSessionFile();
+	if (!sessionId) throw new Error("Live Discord requires a persisted session identity");
+
+	const lifetime = new AbortController();
+	let closed = false;
+	let runPromise: Promise<void> | undefined;
+	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);
+		if (!isMessengerMessageAllowed(message, scopedConfig)) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+		if (
+			attachedSession.isStreaming ||
+			attachedSession.isCompacting ||
+			attachedSession.isGeneratingHandoff ||
+			attachedSession.isRetrying ||
+			attachedSession.isBashRunning ||
+			attachedSession.isEvalRunning ||
+			attachedSession.hasPostPromptWork ||
+			localCapture ||
+			currentTurn
+		)
+			return LIVE_BUSY_MESSAGE;
+		let promptText = `[Discord:${message.messageId} sender:${message.senderId} channel:${message.channelId}] ${message.text}`;
+		const capture: TurnCapture = {
+			promptText,
+			promptSeen: false,
+			dispatched: false,
+			hostSettled: false,
+			conflicted: false,
+		};
+		currentTurn = capture;
+
+		try {
+			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") {
+				const text = userMessageText(event.message);
+				if (!capture.promptSeen && text === capture.promptText) {
+					capture.promptSeen = true;
+				} else if (capture.promptSeen) {
+					capture.conflicted = true;
+				}
+				return;
+			}
+			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, {
+				expandPromptTemplates: false,
+				attribution: "user",
+			});
+			capture.dispatched = true;
+			const dispatched = await awaitWithAbort(promptPromise, operationSignal);
+			capture.dispatched = dispatched;
+			await awaitWithAbort(attachedSession.waitForIdle(), operationSignal);
+			capture.hostSettled = true;
+			const turnMessages = attachedSession.messages;
+			const promptIndices = turnMessages.flatMap((turnMessage, index) =>
+				turnMessage.role === "user" && userMessageText(turnMessage) === promptText ? [index] : [],
+			);
+			capture.promptSeen = capture.promptSeen || promptIndices.length === 1;
+			if (
+				closed ||
+				!dispatched ||
+				!sameSession(ctx, attachedSession, sessionId, sessionFile) ||
+				capture.conflicted ||
+				promptIndices.length !== 1
+			)
+				throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+			const promptIndex = promptIndices[0]!;
+			const messagesAfterPrompt = turnMessages.slice(promptIndex + 1);
+			if (messagesAfterPrompt.some(isCompetingMessage)) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+			const finalAssistant = messagesAfterPrompt.findLast(
+				(turnMessage): turnMessage is AssistantMessage => turnMessage.role === "assistant",
+			);
+			if (finalAssistant?.stopReason !== "stop") throw new Error("Live Discord response unavailable");
+			const response = assistantMessageText(finalAssistant);
+			if (!response.trim()) throw new Error("Live Discord response unavailable");
+			return response;
+		} finally {
+			operationSignal.removeEventListener("abort", onAbort);
+			unsubscribe();
+			if (currentTurn === capture) currentTurn = undefined;
+		}
+	};
+
+	const discordConfig = scopedConfig.platforms.discord;
+	if (!discordConfig) throw new Error("Live Discord configuration unavailable");
+	const adapterFactory = dependencies.createAdapter ?? createDiscordAdapter;
+	const gatewayFactory = dependencies.createGateway ?? createMessengerGateway;
+	const adapter = adapterFactory(discordConfig, dependencies.env, dependencies.transport);
+	const guardedAdapter: MessengerAdapter = {
+		...adapter,
+		send: async (message, text, signal) => {
+			if (closed || !sameSession(ctx, attachedSession, sessionId, sessionFile)) {
+				throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+			}
+			const sendSignal = signal ? AbortSignal.any([lifetime.signal, signal]) : lifetime.signal;
+			if (sendSignal.aborted || !sameSession(ctx, attachedSession, sessionId, sessionFile)) {
+				throw new Error(LIVE_UNAVAILABLE_MESSAGE);
+			}
+			await adapter.send(message, text, sendSignal);
+		},
+	};
+	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();
+		void (async () => {
+			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 {
+						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 {}
+				}
+			}
+		})().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)
+			.then(() => {
+				if (ctx.liveDiscordBridge !== bridgeRef) return;
+				ctx.liveDiscordBridge = undefined;
+				if (!sameSession(ctx, attachedSession, sessionId, sessionFile)) {
+					ctx.showStatus("Discord live bridge detached: session changed");
+				}
+			})
+			.finally(async () => {
+				signal?.removeEventListener("abort", onAbort);
+				await revoke();
+			});
+		return runPromise;
+	};
+
+	const pollInterval = Math.max(50, Math.trunc(dependencies.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS));
+	pollTimer = setInterval(() => {
+		if (!closed && !sameSession(ctx, attachedSession, sessionId, sessionFile)) void close().catch(() => {});
+	}, pollInterval);
+	pollTimer.unref?.();
+
+	const bridge: LiveDiscordBridge = {
+		gateway,
+		get active() {
+			return !closed;
+		},
+		get relayDestination() {
+			return relayDestination;
+		},
+		setRelayDestination,
+		withLocalTurn,
+		run,
+		close,
+	};
+	bridgeRef = bridge;
+	return bridge;
+}
+
+export async function loadAndCreateLiveDiscordBridge(
+	ctx: InteractiveModeContext,
+	configPath: string,
+	dependencies: LiveDiscordBridgeDependencies = {},
+	options: LiveDiscordBridgeOptions = {},
+): Promise<LiveDiscordBridge> {
+	const config = await loadMessengerConfig(configPath);
+	return createLiveDiscordBridge(ctx, config, dependencies, options);
+}

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 {