jeopi-cli 16.6.12 → 16.6.14

package/src/messenger/activity.ts

@@ -0,0 +1,24 @@
+import type { AgentSessionEvent } from "../session/agent-session";
+import type { MessengerActivityReporter } from "./types";
+
+/**
+ * Derive one-line progress from session events: the model's declared tool intent (falling back to the
+ * tool name) and long-running lifecycle notices. Raw tool arguments, results and errors never surface.
+ */
+export function createMessengerActivityTracker(report: MessengerActivityReporter): (event: AgentSessionEvent) => void {
+	let step = 0;
+	return event => {
+		switch (event.type) {
+			case "tool_execution_start":
+				step++;
+				report(`Step ${step} · ${event.intent ?? `Using ${event.toolName}`}`);
+				return;
+			case "auto_compaction_start":
+				report("Compacting context");
+				return;
+			case "auto_retry_start":
+				report(`Retrying after a provider error (${event.attempt}/${event.maxAttempts})`);
+				return;
+		}
+	};
+}

package/src/messenger/discord.ts

@@ -14,6 +14,8 @@ const PERMANENT_CLOSE_CODES = new Set([4004, 4010, 4011, 4012, 4013, 4014]);
 // they are part of the delivered text, and consume one UTF-16 unit each.
 const DISCORD_WHITESPACE = /^[\s\u0085\u001c-\u001f]$/u;
 const DISCORD_BOUNDARY_GUARD = "\u200b";
+// SUPPRESS_EMBEDS | SUPPRESS_NOTIFICATIONS: a status line never unfurls links or pings on creation.
+const DISCORD_ACTIVITY_FLAGS = (1 << 2) | (1 << 12);
 
 function splitDiscordText(text: string): { chunks: string[]; needsAttachment: boolean } {
 	const chunks: string[] = [];
@@ -333,6 +335,7 @@ export function createDiscordAdapter(
 			if (oldest !== undefined) createdThreads.delete(oldest);
 		}
 	};
+	const activityMessages = new Map<string, string>();
 	const headers = (): Record<string, string> => {
 		if (!token) throw new DiscordConfigurationError("Discord bot token is missing");
 		return { Authorization: `Bot ${token}`, "Content-Type": "application/json" };
@@ -504,6 +507,61 @@ export function createDiscordAdapter(
 				deps.fetch,
 			);
 		},
+		async activity(message, text, signal) {
+			const channelId = message.threadId ?? message.channelId;
+			const key = JSON.stringify([channelId, message.messageId]);
+			const messages = `${API}/channels/${encodeURIComponent(channelId)}/messages`;
+			const statusId = activityMessages.get(key);
+			if (text === undefined) {
+				if (!statusId) return;
+				try {
+					await messengerFetchJson(
+						`${messages}/${encodeURIComponent(statusId)}`,
+						{ method: "DELETE", headers: headers() },
+						signal,
+						deps.fetch,
+					);
+				} catch (error) {
+					// Keep the ID so the caller can retry; a missing message is already removed.
+					if (!(error instanceof MessengerHttpError && error.status === 404)) throw error;
+				}
+				activityMessages.delete(key);
+				return;
+			}
+			const content = `⏳ ${text}`;
+			if (statusId) {
+				try {
+					// Edits re-parse mentions with default allowances unless allowed_mentions is repeated.
+					await messengerFetchJson(
+						`${messages}/${encodeURIComponent(statusId)}`,
+						{
+							method: "PATCH",
+							headers: headers(),
+							body: JSON.stringify({ content, allowed_mentions: { parse: [] } }),
+						},
+						signal,
+						deps.fetch,
+					);
+					return;
+				} catch (error) {
+					if (!(error instanceof MessengerHttpError && error.status === 404)) throw error;
+					activityMessages.delete(key);
+				}
+			}
+			const created = await messengerFetchJson(
+				messages,
+				{
+					method: "POST",
+					headers: headers(),
+					body: JSON.stringify({ content, allowed_mentions: { parse: [] }, flags: DISCORD_ACTIVITY_FLAGS }),
+				},
+				signal,
+				deps.fetch,
+			);
+			if (!isRecord(created) || typeof created.id !== "string" || !created.id)
+				throw new Error("Discord activity message returned no ID");
+			activityMessages.set(key, created.id);
+		},
 		async send(message, text, signal) {
 			let files: { name: string; data: Uint8Array }[] = [];
 			if (config.artifactDir) {

package/src/messenger/gateway.ts

@@ -1,5 +1,12 @@
 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;
@@ -7,6 +14,157 @@ 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 {
@@ -19,6 +177,24 @@ export function messengerConversationKey(message: MessengerMessage): string {
 	]);
 }
 
+/** Stable per-conversation route shared by the persisted session file and its session process. */
+export function messengerSessionRoute(cwd: string, message: MessengerMessage): string {
+	return new Bun.CryptoHasher("sha256").update(JSON.stringify([cwd, messengerConversationKey(message)])).digest("hex");
+}
+
+/**
+ * Scheduling heuristic, refined after `prepare`: a top-level server message on a prepare-capable adapter
+ * (Discord) starts its own reply thread, so it is never held behind queued work; every other message waits for
+ * earlier requests in its conversation. A follow-up arriving in that new thread is ordered behind the request
+ * that created it by the prepared-conversation lock in `processRequest`.
+ */
+function schedulingKey(message: MessengerMessage, adapter: MessengerAdapter): string {
+	if (adapter.prepare && !message.direct && !message.threadId && !message.parentChannelId) {
+		return JSON.stringify([message.platform, message.accountId, message.channelId, message.messageId]);
+	}
+	return messengerConversationKey(message);
+}
+
 export function isMessengerMessageAllowed(message: MessengerMessage, config: MessengerConfig): boolean {
 	const platform = config.platforms[message.platform];
 	return Boolean(
@@ -43,6 +219,8 @@ interface PendingMessage {
 	adapter: MessengerAdapter;
 	signal: AbortSignal;
 	resolve: () => void;
+	/** Requests sharing a key never run at the same time. */
+	key: string;
 }
 
 export interface MessengerGateway {
@@ -50,11 +228,24 @@ 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;
+	/**
+	 * Requests processed at once (default 1). Requests of one prepared conversation still answer and deliver in
+	 * order; above 1 the reply implementation must accept concurrent turns for different conversations.
+	 */
+	concurrency?: number;
+}
+
 export function createMessengerGateway(
 	config: MessengerConfig,
 	adapters: MessengerAdapter[],
 	reply: MessengerReply,
+	options: MessengerGatewayOptions = {},
 ): MessengerGateway {
+	const activityIntervalMs = Math.max(0, options.activityIntervalMs ?? ACTIVITY_INTERVAL_MS);
+	const concurrency = Math.max(1, Math.trunc(options.concurrency ?? 1));
 	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,84 +254,120 @@ export function createMessengerGateway(
 	}
 	const seen = new Set<string>();
 	const queue: PendingMessage[] = [];
+	const activeKeys = new Set<string>();
+	const turns = new Set<Promise<void>>();
+	/** Settles when the latest request of a prepared conversation has delivered its reply. */
+	const conversationTails = new Map<string, Promise<void>>();
 	const lifetime = new AbortController();
-	let draining: Promise<void> | undefined;
-	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;
+	async function processRequest(pending: PendingMessage): Promise<void> {
+		const { message, adapter, signal, resolve } = pending;
+		let failed = false;
+		let activity = NO_ACTIVITY;
+		let release = (): void => {};
+		let tail: Promise<void> | undefined;
+		let conversation = "";
+		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 {
-					text = await reply(destination, signal);
-				} 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.";
-				}
-				if (!signal.aborted && text.trim()) {
-					// A failed send may already have delivered a chunk: never retry the entire reply.
-					await adapter.send(destination, text, signal);
+					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);
 				}
-				if (!signal.aborted) status(failed ? "failure" : "success");
-			} catch {
-				if (!signal.aborted) {
-					logger.warn("Messenger reply delivery failed", { platform: message.platform });
+			});
+		};
+		try {
+			if (signal.aborted) return;
+			status("processing");
+			const destination = (await adapter.prepare?.(message, signal)) ?? message;
+			// Answer and deliver in arrival order per prepared conversation, so a follow-up in a new thread can
+			// neither overtake nor interleave with the reply of the request that created it.
+			conversation = messengerConversationKey(destination);
+			const previous = conversationTails.get(conversation);
+			const done = Promise.withResolvers<void>();
+			release = done.resolve;
+			tail = done.promise;
+			conversationTails.set(conversation, tail);
+			await previous;
+			activity = createActivityReporter(adapter, destination, signal, activityIntervalMs);
+			let text: string;
+			try {
+				text = await reply(destination, signal, activity.report);
+			} catch (error) {
+				failed = true;
+				if (error instanceof MessengerFatalError) {
+					fatalError = error;
 					status("failure");
+					lifetime.abort();
+					return;
 				}
+				if (signal.aborted) return;
+				logger.warn("Messenger agent turn failed", { platform: message.platform });
+				text = "The request could not be completed. Please try again.";
 			} finally {
-				resolve();
+				// 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(destination, text, signal);
 			}
+			if (!signal.aborted) status(failed ? "failure" : "success");
+		} catch {
+			if (!signal.aborted) {
+				logger.warn("Messenger reply delivery failed", { platform: message.platform });
+				status("failure");
+			}
+		} finally {
+			await activity.close();
+			release();
+			if (tail && conversationTails.get(conversation) === tail) conversationTails.delete(conversation);
+			resolve();
+		}
+	}
+
+	/** Start queued requests in arrival order while capacity allows, skipping conversations already running. */
+	function schedule(): void {
+		for (let index = 0; index < queue.length && turns.size < concurrency; ) {
+			const pending = queue[index]!;
+			if (activeKeys.has(pending.key)) {
+				index++;
+				continue;
+			}
+			queue.splice(index, 1);
+			activeKeys.add(pending.key);
+			const turn = processRequest(pending).finally(() => {
+				activeKeys.delete(pending.key);
+				turns.delete(turn);
+				schedule();
+			});
+			turns.add(turn);
 		}
-		workerActive = false;
 	}
 
 	function handle(message: MessengerMessage, signal?: AbortSignal): Promise<void> {
@@ -155,11 +382,8 @@ export function createMessengerGateway(
 			if (oldest !== undefined) seen.delete(oldest);
 		}
 		const { promise, resolve } = Promise.withResolvers<void>();
-		queue.push({ message, adapter, signal: effectiveSignal, resolve });
-		if (!workerActive) {
-			workerActive = true;
-			draining = drain();
-		}
+		queue.push({ message, adapter, signal: effectiveSignal, resolve, key: schedulingKey(message, adapter) });
+		schedule();
 		return promise;
 	}
 
@@ -191,7 +415,7 @@ export function createMessengerGateway(
 			} finally {
 				lifetime.abort();
 				await Promise.allSettled(starts);
-				await draining;
+				while (turns.size > 0) await Promise.allSettled(turns);
 				signal.removeEventListener("abort", abort);
 			}
 		},

package/src/messenger/live-session.ts

@@ -1,5 +1,6 @@
 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";
@@ -156,7 +157,7 @@ export function createLiveDiscordBridge(
 	let localCapture: object | undefined;
 	let close: () => Promise<void>;
 	let revoke: () => Promise<void>;
-	const reply: MessengerReply = async (message, signal) => {
+	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);
@@ -190,8 +191,13 @@ export function createLiveDiscordBridge(
 			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) {
@@ -265,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) => {
@@ -277,6 +284,13 @@ 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 setRelayDestination = (channelId: string | undefined): void => {
 		if (closed || !sameSession(ctx, attachedSession, sessionId, sessionFile))