jeopi-cli 16.6.9 → 16.6.12

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/modes/interactive-mode.ts

@@ -80,6 +80,7 @@ import {
 	MCP_CONNECTION_STATUS_EVENT_CHANNEL,
 	type McpConnectionStatusEvent,
 } from "../mcp/startup-events";
+import type { LiveDiscordBridge } from "../messenger/live-session";
 import {
 	humanizePlanTitle,
 	type PlanApprovalDetails,
@@ -491,6 +492,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	oauthManualInput: OAuthManualInputManager = new OAuthManualInputManager();
 	collabHost?: CollabHost;
 	collabGuest?: CollabGuestLink;
+	liveDiscordBridge?: LiveDiscordBridge;
 
 	#pendingSlashCommands: SlashCommand[] = [];
 	#cleanupUnsubscribe?: () => void;
@@ -796,10 +798,27 @@ export class InteractiveMode implements InteractiveModeContext {
 		// signal arriving mid-Ctrl+C no-ops instead of racing a second dispose.
 		this.#signalTeardown = createSessionTeardown({
 			getDraftText: () => this.editor.getText(),
+			beforeDispose: async () => {
+				const liveDiscordBridge = this.liveDiscordBridge;
+				this.liveDiscordBridge = undefined;
+				try {
+					await liveDiscordBridge?.close();
+				} catch (error) {
+					logger.warn("Failed to close live Discord bridge before teardown", { error: String(error) });
+				}
+			},
 			beginDispose: () => this.session.beginDispose(),
 			saveDraft: text => this.sessionManager.saveDraft(text),
-			disposeSession: reason =>
-				this.session.dispose({ mnemopiConsolidateTimeoutMs: SHUTDOWN_CONSOLIDATE_BUDGET_MS, reason }),
+			disposeSession: async reason => {
+				const liveDiscordBridge = this.liveDiscordBridge;
+				this.liveDiscordBridge = undefined;
+				try {
+					await liveDiscordBridge?.close();
+				} catch (error) {
+					logger.warn("Failed to close live Discord bridge during teardown", { error: String(error) });
+				}
+				await this.session.dispose({ mnemopiConsolidateTimeoutMs: SHUTDOWN_CONSOLIDATE_BUDGET_MS, reason });
+			},
 		});
 		// Forward the postmortem reason (SIGTERM/SIGHUP/uncaughtException/…) so the
 		// persisted `session_exit` diagnostic carries the real trigger. Postmortem
@@ -3349,14 +3368,19 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#isShuttingDown = true;
 
 		this.#btwController.dispose();
-		this.#omfgController.dispose();
 		this.#focusController.dispose();
-
+		this.#omfgController.dispose();
 		// Surface an explicit "Closing session…" line so the user sees a reason
 		// for the pause while `session.dispose()` flushes memory consolidate and
-		// other cleanups (issue #3641). The await on the next line yields the
-		// event loop, giving requestRender() a tick to paint the status before
-		// dispose blocks.
+		// other cleanups (issue #3641). The bridge is closed before disposal so
+		// revoked Discord work cannot race session teardown.
+		const liveDiscordBridge = this.liveDiscordBridge;
+		this.liveDiscordBridge = undefined;
+		try {
+			await liveDiscordBridge?.close();
+		} catch (error) {
+			logger.warn("Failed to close live Discord bridge during shutdown", { error: String(error) });
+		}
 		this.showStatus("Closing session…");
 
 		// Persist the draft and dispose the session through the shared teardown

package/src/modes/session-teardown.test.ts

@@ -66,6 +66,67 @@ describe("createSessionTeardown", () => {
 		expect(order).toEqual(["snapshot", "beginDispose", "saveDraft:start", "saveDraft:done", "disposeSession"]);
 	});
 
+	it("awaits beforeDispose before marking the session disposing", async () => {
+		const order: string[] = [];
+		const release = Promise.withResolvers<void>();
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "draft",
+			beforeDispose: async () => {
+				order.push("beforeDispose:start");
+				await release.promise;
+				order.push("beforeDispose:done");
+			},
+			beginDispose: () => {
+				order.push("beginDispose");
+			},
+			saveDraft: async () => {
+				order.push("saveDraft");
+			},
+			disposeSession: async () => {
+				order.push("disposeSession");
+			},
+		});
+
+		const running = teardown();
+		expect(order).toEqual(["beforeDispose:start"]);
+		release.resolve();
+		await running;
+
+		expect(order).toEqual([
+			"beforeDispose:start",
+			"beforeDispose:done",
+			"beginDispose",
+			"saveDraft",
+			"disposeSession",
+		]);
+	});
+
+	it("continues teardown when beforeDispose rejects", async () => {
+		const order: string[] = [];
+
+		const teardown = createSessionTeardown({
+			getDraftText: () => "draft",
+			beforeDispose: async () => {
+				order.push("beforeDispose");
+				throw new Error("revocation failed");
+			},
+			beginDispose: () => {
+				order.push("beginDispose");
+			},
+			saveDraft: async () => {
+				order.push("saveDraft");
+			},
+			disposeSession: async () => {
+				order.push("disposeSession");
+			},
+		});
+
+		await teardown();
+
+		expect(order).toEqual(["beforeDispose", "beginDispose", "saveDraft", "disposeSession"]);
+	});
+
 	it("still disposes when saveDraft rejects — never leaves session_shutdown unemitted", async () => {
 		let disposed = false;
 

package/src/modes/session-teardown.ts

@@ -16,11 +16,16 @@ export interface SessionTeardownDeps {
 	/** Snapshot the current editor text; called once, before disposal touches session state. */
 	getDraftText: () => string;
 	/**
-	 * Synchronously mark the session as disposing before any awaited teardown
-	 * work. This closes the async gap where deferred jobs could otherwise start
-	 * after a signal requested shutdown but before `disposeSession()` begins.
+	 * Synchronously mark the session as disposing after asynchronous revocation
+	 * completes and before any further awaited teardown work. This closes the async
+	 * gap where deferred jobs could otherwise start after a signal requested shutdown.
 	 */
 	beginDispose: () => void;
+	/**
+	 * Complete asynchronous revocation before the session is marked disposed.
+	 * Failures are logged and never skip the disposal chain.
+	 */
+	beforeDispose?: () => Promise<void>;
 	/**
 	 * Persist the snapshotted draft. Called even for an empty string so a
 	 * previously-persisted draft sidecar is cleared on a clean exit.
@@ -44,11 +49,11 @@ export interface SessionTeardownDeps {
 export type SessionTeardown = (reason?: postmortem.Reason) => Promise<void>;
 
 /**
- * Build a promise-memoized teardown function. The first call snapshots the
- * draft text, marks the session disposing synchronously, runs `saveDraft`
- * (draft-loss protection for `--resume`), then `disposeSession`; subsequent
- * calls await the same settled promise, so the keypress
- * `InteractiveMode.shutdown()` path and the postmortem signal callback cannot
+ * Build a promise-memoized teardown: snapshot the draft, complete asynchronous
+ * revocation, mark the session disposing synchronously, run `saveDraft` (draft-loss
+ * protection for `--resume`), then `disposeSession`; subsequent calls await the same
+ * settled promise so the keypress `InteractiveMode.shutdown()` path and the postmortem
+ * signal callback cannot
  * double-emit `session_shutdown`, double-dispose the session's async-job
  * manager, or race each other.
  *
@@ -67,6 +72,13 @@ export function createSessionTeardown(deps: SessionTeardownDeps): SessionTeardow
 	let pending: Promise<void> | undefined;
 	const run = async (reason?: postmortem.Reason): Promise<void> => {
 		const draftText = deps.getDraftText();
+		if (deps.beforeDispose) {
+			try {
+				await deps.beforeDispose();
+			} catch (err) {
+				logger.warn("Failed pre-dispose cleanup during teardown", { error: String(err) });
+			}
+		}
 		deps.beginDispose();
 		try {
 			await deps.saveDraft(draftText);

package/src/modes/types.ts

@@ -16,6 +16,7 @@ import type {
 import type { CompactOptions } from "../extensibility/extensions/types";
 import type { Skill } from "../extensibility/skills";
 import type { MCPManager } from "../mcp";
+import type { LiveDiscordBridge } from "../messenger/live-session";
 import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession } from "../session/agent-session";
 import type { CompactMode } from "../session/compact-modes";
@@ -134,6 +135,7 @@ export interface InteractiveModeContext {
 	collabGuest?: CollabGuestLink;
 	eventController: EventController;
 	eventBus?: EventBus;
+	liveDiscordBridge?: LiveDiscordBridge;
 
 	// State
 	isInitialized: boolean;

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/sdk.ts

@@ -1921,11 +1921,18 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const refreshedProviders = new Set<string>();
 		for (const selector of discoverySelectors) {
 			if (!selector) continue;
-			const parsed = parseModelString(selector, {
-				allowMaxAlias: true,
-				allowAutoAlias: true,
-				isLiteralModelId: (provider, id) => modelRegistry.find(provider, id) !== undefined,
-			});
+			const parsed =
+				parseModelString(selector, {
+					allowMaxAlias: true,
+					allowAutoAlias: true,
+					isLiteralModelId: (provider, id) => modelRegistry.find(provider, id) !== undefined,
+				}) ??
+				(!selector.includes("/") &&
+				!/[?*[\]]/.test(selector) &&
+				/argon|gemini-(?:3\.8|4)/i.test(selector) &&
+				!parseModelPattern(selector, modelRegistry.getAll(), modelMatchPreferences).model
+					? { provider: "google-antigravity", id: selector.split(":")[0] }
+					: undefined);
 			if (!parsed || /[?*[\]]/.test(parsed.id)) continue;
 			const existing = modelRegistry.find(parsed.provider, parsed.id);
 			if (existing && hasModelAuth(existing)) break;

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

@@ -24,6 +24,7 @@ import {
 	MarketplaceManager,
 } from "../extensibility/plugins/marketplace";
 import { resolveMemoryBackend } from "../memory-backend";
+import { loadAndCreateLiveDiscordBridge } from "../messenger/live-session";
 import { describeLoopLimitRuntime } from "../modes/loop-limit";
 import { theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
@@ -66,6 +67,13 @@ import type {
 
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 
+interface LiveDiscordStart {
+	cancelled: boolean;
+	promise: Promise<void>;
+}
+
+const liveDiscordStarts = new WeakMap<InteractiveModeContext, LiveDiscordStart>();
+
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
 
@@ -650,6 +658,125 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "discord",
+		description: "Opt in to this session from an authorized Discord channel",
+		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" },
+		],
+		allowArgs: true,
+		getTuiAutocompleteDescription: runtime =>
+			runtime.ctx.liveDiscordBridge?.active ? "Discord live bridge: active" : "Discord live bridge: off",
+		handleTui: async (command, runtime) => {
+			const ctx = runtime.ctx;
+			ctx.editor.setText("");
+			const { verb, rest } = parseSubcommand(command.args.trim());
+			if (verb === "status") {
+				if (!ctx.liveDiscordBridge?.active) {
+					ctx.showStatus("Discord live bridge is off");
+					return;
+				}
+				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"}. 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);
+				if (!bridge && start) {
+					start.cancelled = true;
+					ctx.showStatus("Discord live bridge startup cancellation requested");
+					return;
+				}
+				if (!bridge) {
+					ctx.showStatus("Discord live bridge is not active");
+					return;
+				}
+				ctx.liveDiscordBridge = undefined;
+				try {
+					await bridge.close();
+					ctx.showStatus("Discord live bridge stopped; access revoked");
+				} catch (error) {
+					ctx.showError(`Failed to stop Discord live bridge: ${errorMessage(error)}`);
+				}
+				return;
+			}
+			const acknowledgment = /^(.+?)\s+--allow-full-control$/.exec(rest);
+			if (verb !== "live" || !acknowledgment) {
+				ctx.showError("Usage: /discord live <private messenger.json> --allow-full-control");
+				return;
+			}
+			if (ctx.liveDiscordBridge?.active || liveDiscordStarts.has(ctx)) {
+				ctx.showError("Discord live bridge is already active or starting (/discord stop first)");
+				return;
+			}
+			let resolveStart!: () => void;
+			const startPromise = new Promise<void>(resolve => {
+				resolveStart = resolve;
+			});
+			const startState: LiveDiscordStart = { cancelled: false, promise: startPromise };
+			liveDiscordStarts.set(ctx, startState);
+			try {
+				const configPath = resolveToCwd(acknowledgment[1]!, ctx.sessionManager.getCwd());
+				const bridge = await loadAndCreateLiveDiscordBridge(ctx, configPath, {}, { acknowledgeFullControl: true });
+				if (startState.cancelled || ctx.shutdownRequested || ctx.isShuttingDown) {
+					await bridge.close().catch(() => {});
+					return;
+				}
+				if (ctx.liveDiscordBridge?.active) {
+					await bridge.close().catch(() => {});
+					ctx.showError("Discord live bridge is already active (/discord stop first)");
+					return;
+				}
+				ctx.liveDiscordBridge = bridge;
+				void bridge.run().catch(error => {
+					if (ctx.liveDiscordBridge !== bridge || ctx.isShuttingDown) return;
+					ctx.liveDiscordBridge = undefined;
+					ctx.showError(`Discord live bridge stopped: ${errorMessage(error)}`);
+				});
+				const approvalMode = String(ctx.session.settings.get("tools.approvalMode"));
+				const activeTools = ctx.session.getActiveToolNames();
+				ctx.showStatus(
+					`Discord live bridge active with full host control acknowledged. Approval mode: ${approvalMode}; active tools: ${activeTools.length > 0 ? activeTools.join(", ") : "none"}. /discord stop revokes access.`,
+				);
+			} catch (error) {
+				ctx.showError(`Failed to start Discord live bridge: ${errorMessage(error)}`);
+			} finally {
+				resolveStart();
+				if (liveDiscordStarts.get(ctx)?.promise === startPromise) liveDiscordStarts.delete(ctx);
+			}
+		},
+	},
+
 	{
 		name: "collab",
 		description: "Share this session live via a relay",