jeopi-cli 16.6.11 → 16.6.13

package/src/messenger/gateway.ts

@@ -1,17 +1,177 @@
 import { logger } from "jeopi-utils";
-import type { MessengerAdapter, MessengerConfig, MessengerMessage, MessengerReply } from "./types";
+import { MessengerHttpError } from "./http";
+import type {
+	MessengerActivityReporter,
+	MessengerAdapter,
+	MessengerConfig,
+	MessengerMessage,
+	MessengerReply,
+} from "./types";
 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;
+const MAX_ACTIVITY_LENGTH = 120;
+// Status edits are cosmetic: keep them sparse so they never compete with reply delivery for rate limits.
+const ACTIVITY_INTERVAL_MS = 2_000;
+const ACTIVITY_TIMEOUT_MS = 3_000;
+
+/** Collapse to one bounded line: drop invisible format characters, fold control and whitespace runs. */
+function activityLine(text: string): string {
+	const line = text
+		.replace(/\p{Cf}/gu, "")
+		.replace(/[\p{Cc}\p{Z}\s]+/gu, " ")
+		.trim();
+	if (line.length <= MAX_ACTIVITY_LENGTH) return line;
+	let end = MAX_ACTIVITY_LENGTH - 1;
+	const last = line.charCodeAt(end - 1);
+	if (last >= 0xd800 && last <= 0xdbff) end--;
+	return `${line.slice(0, end).trimEnd()}…`;
+}
+
+interface ActivityReporter {
+	report: MessengerActivityReporter;
+	/** Stop updates and remove any shown line; idempotent and never rejects. */
+	close(): Promise<void>;
+}
+
+const NO_ACTIVITY: ActivityReporter = { report() {}, close: () => Promise.resolve() };
+
+/**
+ * Bound a cosmetic adapter call: a stalled provider request must not hold up the request queue. A timeout
+ * rejects so callers can retry; cancellation through `signal` resolves because the request is ending.
+ */
+async function boundedActivity(run: (signal: AbortSignal) => Promise<void>, signal?: AbortSignal): Promise<void> {
+	const timeout = new AbortController();
+	const callSignal = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
+	const stopped = Promise.withResolvers<void>();
+	const onStop = (): void => {
+		if (timeout.signal.aborted) stopped.reject(new Error("Messenger activity update timed out"));
+		else stopped.resolve();
+	};
+	callSignal.addEventListener("abort", onStop, { once: true });
+	const timer = setTimeout(() => timeout.abort(), ACTIVITY_TIMEOUT_MS);
+	try {
+		await Promise.race([Promise.resolve().then(() => run(callSignal)), stopped.promise]);
+	} finally {
+		clearTimeout(timer);
+		callSignal.removeEventListener("abort", onStop);
+	}
+}
+
+/**
+ * Coalesce a request's activity into one status line: show the first report at once, then at most the
+ * latest line per interval. Removal skips the request signal so an aborted request still retires its line.
+ */
+function createActivityReporter(
+	adapter: MessengerAdapter,
+	destination: MessengerMessage,
+	signal: AbortSignal,
+	intervalMs: number,
+): ActivityReporter {
+	const activity = adapter.activity;
+	if (!activity) return NO_ACTIVITY;
+	let latest: string | undefined;
+	let sent: string | undefined;
+	let shown = false;
+	let closed = false;
+	let pumping = false;
+	let pump = Promise.resolve();
+	let nextAt = 0;
+	let wake: (() => void) | undefined;
+	let closing: Promise<void> | undefined;
+	const update = (text: string | undefined, callSignal?: AbortSignal): Promise<void> =>
+		boundedActivity(bounded => activity.call(adapter, destination, text, bounded), callSignal);
+	const pause = async (ms: number): Promise<void> => {
+		const { promise, resolve } = Promise.withResolvers<void>();
+		const timer = setTimeout(resolve, ms);
+		wake = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		try {
+			await promise;
+		} finally {
+			wake = undefined;
+		}
+	};
+	const run = async (): Promise<void> => {
+		try {
+			while (!closed && !signal.aborted && latest !== sent) {
+				const delay = nextAt - Date.now();
+				if (delay > 0) {
+					await pause(delay);
+					continue;
+				}
+				const text = latest;
+				sent = text;
+				shown = true;
+				let spacing = intervalMs;
+				try {
+					await update(text, signal);
+				} catch (error) {
+					if (error instanceof MessengerHttpError && error.status === 429) {
+						// Keep the line pending: a rate-limited update is retried unless a newer line replaces it.
+						sent = undefined;
+						spacing = Math.max(spacing, error.retryAfterMs ?? 1_000);
+					} else if (!signal.aborted) {
+						logger.warn("Messenger activity update failed", { platform: destination.platform });
+					}
+				}
+				nextAt = Date.now() + spacing;
+			}
+		} finally {
+			pumping = false;
+		}
+	};
+	return {
+		report(text) {
+			if (closed || signal.aborted) return;
+			const line = activityLine(text);
+			if (!line) return;
+			latest = line;
+			if (pumping) return;
+			pumping = true;
+			pump = run();
+		},
+		close() {
+			closing ??= (async () => {
+				closed = true;
+				wake?.();
+				await pump;
+				if (!shown) return;
+				for (let attempt = 0; ; attempt++) {
+					try {
+						await update(undefined);
+						return;
+					} catch (error) {
+						const wait =
+							error instanceof MessengerHttpError && error.status === 429
+								? (error.retryAfterMs ?? 1_000)
+								: 1_000;
+						// One bounded retry: removal holds the request queue.
+						if (attempt > 0 || wait > ACTIVITY_TIMEOUT_MS) {
+							logger.warn("Messenger activity removal failed", { platform: destination.platform });
+							return;
+						}
+						await Bun.sleep(wait);
+					}
+				}
+			})();
+			return closing;
+		},
+	};
+}
 
 /** 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 +185,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))),
 	);
 }
 
@@ -45,11 +208,18 @@ export interface MessengerGateway {
 	handle(message: MessengerMessage, signal?: AbortSignal): Promise<void>;
 }
 
+export interface MessengerGatewayOptions {
+	/** Minimum spacing between in-place activity edits for one request. */
+	activityIntervalMs?: number;
+}
+
 export function createMessengerGateway(
 	config: MessengerConfig,
 	adapters: MessengerAdapter[],
 	reply: MessengerReply,
+	options: MessengerGatewayOptions = {},
 ): MessengerGateway {
+	const activityIntervalMs = Math.max(0, options.activityIntervalMs ?? ACTIVITY_INTERVAL_MS);
 	const byPlatform = new Map(adapters.map(adapter => [adapter.platform, adapter]));
 	if (byPlatform.size !== adapters.length) throw new Error("Duplicate messenger adapter");
 	for (const platform of Object.keys(config.platforms)) {
@@ -63,34 +233,81 @@ 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 activity = NO_ACTIVITY;
+			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;
+				activity = createActivityReporter(adapter, destination, signal, activityIntervalMs);
 				let text: string;
 				try {
-					text = await reply(message, signal);
+					text = await reply(destination, signal, activity.report);
 				} catch (error) {
+					failed = true;
 					if (error instanceof MessengerFatalError) {
 						fatalError = error;
+						status("failure");
 						lifetime.abort();
 						continue;
 					}
 					if (signal.aborted) continue;
 					logger.warn("Messenger agent turn failed", { platform: message.platform });
 					text = "The request could not be completed. Please try again.";
+				} finally {
+					// Retire the status line alongside reply delivery rather than delaying the reply on it.
+					void activity.close();
 				}
 				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 {
+				await activity.close();
 				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,7 @@
 import type { AssistantMessage, UserMessage } from "jeopi-ai";
 import type { InteractiveModeContext } from "../modes/types";
+import { createMessengerActivityTracker } from "./activity";
+import { messengerArtifactPrompt } from "./artifacts";
 import { loadMessengerConfig, validateMessengerEnvironment } from "./config";
 import { createDiscordAdapter, type DiscordTransportDeps } from "./discord";
 import { createMessengerGateway, isMessengerMessageAllowed, type MessengerGateway } from "./gateway";
@@ -21,12 +23,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,8 +151,13 @@ 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>;
-	const reply: MessengerReply = async (message, signal) => {
+	let revoke: () => Promise<void>;
+	const reply: MessengerReply = async (message, signal, onActivity) => {
 		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);
@@ -156,10 +169,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,8 +187,17 @@ 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 track = onActivity && createMessengerActivityTracker(onActivity);
 		const unsubscribe = attachedSession.subscribe(event => {
-			if (event.type !== "message_end") return;
+			if (event.type !== "message_end") {
+				// Report only this Discord turn: its prompt event precedes the turn's tool and retry events.
+				if (capture.promptSeen && !capture.conflicted) track?.(event);
+				return;
+			}
 			if (event.message.role === "user") {
 				const text = userMessageText(event.message);
 				if (!capture.promptSeen && text === capture.promptText) {
@@ -187,6 +210,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 +260,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;
 		}
@@ -232,6 +271,7 @@ export function createLiveDiscordBridge(
 	const adapterFactory = dependencies.createAdapter ?? createDiscordAdapter;
 	const gatewayFactory = dependencies.createGateway ?? createMessengerGateway;
 	const adapter = adapterFactory(discordConfig, dependencies.env, dependencies.transport);
+	const activity = adapter.activity;
 	const guardedAdapter: MessengerAdapter = {
 		...adapter,
 		send: async (message, text, signal) => {
@@ -244,37 +284,187 @@ export function createLiveDiscordBridge(
 			}
 			await adapter.send(message, text, sendSignal);
 		},
+		// New status text requires the attached session; removal must still retire a shown line after close.
+		activity:
+			activity &&
+			(async (message, text, signal) => {
+				if (text !== undefined && (closed || !sameSession(ctx, attachedSession, sessionId, sessionFile))) return;
+				await activity.call(adapter, message, text, signal);
+			}),
 	};
-	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 +475,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 +493,11 @@ export function createLiveDiscordBridge(
 		get active() {
 			return !closed;
 		},
+		get relayDestination() {
+			return relayDestination;
+		},
+		setRelayDestination,
+		withLocalTurn,
 		run,
 		close,
 	};

package/src/messenger/session.ts

@@ -10,6 +10,8 @@ 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 { createMessengerActivityTracker } from "./activity";
+import { messengerArtifactPrompt } from "./artifacts";
 import { messengerConversationKey } from "./gateway";
 import { type MessengerConfig, MessengerFatalError, type MessengerReply } from "./types";
 
@@ -122,12 +124,13 @@ export function createMessengerSessionBridge(
 		activeRoute = route;
 	}
 
-	const reply: MessengerReply = async (message, signal) => {
+	const reply: MessengerReply = async (message, signal, onActivity) => {
 		if (closed || signal.aborted) throw new Error("Messenger session is closed");
 		if (activeTurn) throw new Error("Messenger turns must be serialized");
 		const finished = Promise.withResolvers<void>();
 		activeTurn = finished.promise;
 		let aborting: Promise<void> | undefined;
+		let unsubscribe: (() => void) | undefined;
 		const onAbort = (): void => {
 			if (session && !aborting) {
 				aborting = session.abort({ reason: USER_INTERRUPT_LABEL });
@@ -175,7 +178,15 @@ 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}`;
+			}
+			// Turns are serialized, so every event until idle belongs to this request.
+			if (onActivity) unsubscribe = current.subscribe(createMessengerActivityTracker(onActivity));
+			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");
@@ -190,6 +201,7 @@ export function createMessengerSessionBridge(
 			if (!text.trim()) throw new Error("Messenger response is empty");
 			return text;
 		} finally {
+			unsubscribe?.();
 			signal.removeEventListener("abort", onAbort);
 			await aborting?.catch(() => {});
 			activeTurn = undefined;