@gajae-code/coding-agent 0.11.2 → 0.11.4

package/src/modes/components/custom-editor.ts

@@ -59,9 +59,22 @@ const DEFAULT_ACTION_KEYS = Object.fromEntries(
 
 const PASTE_DECISION_TIMEOUT_MS = 5_000;
 const PENDING_PASTE_INPUT_MAX = 64;
+const PENDING_PASTE_INPUT_MAX_BYTES = 256 * 1024;
 
 type PastePendingClearReason = "timeout" | "queue-limit";
 
+export interface PasteTextContext {
+	readonly signal: AbortSignal;
+	/** Run one synchronous composer mutation only while this paste transaction is current. */
+	commit(commit: () => boolean): boolean;
+}
+
+interface PendingPasteDecision {
+	readonly controller: AbortController;
+	readonly pasteContent: string;
+	readonly remaining: string;
+}
+
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -94,9 +107,9 @@ export class CustomEditor extends Editor {
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
 	/** Called before bracketed paste content is inserted. Return true to consume it. */
-	onPasteText?: (text: string) => boolean | Promise<boolean>;
-	/** Called when async paste handling drops queued input instead of replaying it. */
-	onPastePendingInputCleared?: (reason: PastePendingClearReason, droppedInputCount: number) => void;
+	onPasteText?: (text: string, context: PasteTextContext) => boolean | Promise<boolean>;
+	/** Called when pending paste handling is cancelled after restoring queued input. */
+	onPastePendingInputCleared?: (reason: PastePendingClearReason, restoredInputCount: number) => void;
 	/** Called when the configured dequeue shortcut is pressed. */
 	onDequeue?: () => void;
 	/** Called when the configured queue shortcut is pressed. */
@@ -117,7 +130,9 @@ export class CustomEditor extends Editor {
 	#pasteDecisionPending = false;
 	#pasteDecisionToken = 0;
 	#pasteDecisionTimeout: NodeJS.Timeout | undefined;
+	#pendingPasteDecision: PendingPasteDecision | undefined;
 	#pendingPasteInput: string[] = [];
+	#pendingPasteInputBytes = 0;
 
 	setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void {
 		this.#actionKeys.set(action, [...keys]);
@@ -165,75 +180,127 @@ export class CustomEditor extends Editor {
 		}
 	}
 
-	#clearPendingPasteState(): number {
+	#resetPendingPasteState(abortReason?: Error): string[] {
 		this.#clearPasteDecisionTimeout();
+		if (abortReason) this.#pendingPasteDecision?.controller.abort(abortReason);
 		this.#pasteDecisionPending = false;
 		this.#pasteDecisionToken += 1;
-		const droppedInputCount = this.#pendingPasteInput.length;
+		this.#pendingPasteDecision = undefined;
+		const queuedInput = this.#pendingPasteInput;
 		this.#pendingPasteInput = [];
-		return droppedInputCount;
+		this.#pendingPasteInputBytes = 0;
+		return queuedInput;
+	}
+
+	#pendingPasteEventCount(): number {
+		return this.#pendingPasteInput.length + (this.#pendingPasteDecision?.remaining ? 1 : 0);
+	}
+
+	#restoreCancelledPaste(reason: PastePendingClearReason, overflowInput?: string): void {
+		const decision = this.#pendingPasteDecision;
+		const queuedInput = this.#resetPendingPasteState(new Error(`Paste handling cancelled: ${reason}`));
+		if (decision) {
+			super.handleInput(`\x1b[200~${decision.pasteContent}\x1b[201~`);
+			this.#drainPendingPasteInput(decision.remaining, queuedInput);
+			if (overflowInput !== undefined) this.handleInput(overflowInput);
+		}
+		this.onPastePendingInputCleared?.(
+			reason,
+			queuedInput.length + (decision?.remaining ? 1 : 0) + (overflowInput === undefined ? 0 : 1),
+		);
 	}
 
 	#startPasteDecisionTimeout(token: number): void {
 		this.#clearPasteDecisionTimeout();
 		this.#pasteDecisionTimeout = setTimeout(() => {
 			if (token !== this.#pasteDecisionToken) return;
-			const droppedInputCount = this.#clearPendingPasteState();
-			this.onPastePendingInputCleared?.("timeout", droppedInputCount);
+			this.#restoreCancelledPaste("timeout");
 		}, PASTE_DECISION_TIMEOUT_MS);
 		this.#pasteDecisionTimeout.unref?.();
 	}
 
 	dispose(): void {
-		this.#clearPendingPasteState();
+		this.#resetPendingPasteState(new Error("Editor disposed during paste handling"));
 		this.#pasteHandler = new BracketedPasteHandler();
 		super.dispose();
 	}
 
-	#drainPendingPasteInput(initialInput?: string): void {
+	#drainPendingPasteInput(initialInput: string | undefined, queuedInput: readonly string[]): void {
 		if (initialInput && initialInput.length > 0) {
 			this.handleInput(initialInput);
 		}
-		while (!this.#pasteDecisionPending) {
-			const nextInput = this.#pendingPasteInput.shift();
-			if (nextInput === undefined) break;
-			this.handleInput(nextInput);
+		for (const input of queuedInput) {
+			this.handleInput(input);
 		}
 	}
 
 	#handleBracketedPaste(pasteContent: string, remaining: string): void {
-		const applyPasteResult = (token: number, handled: boolean | undefined) => {
+		const remainingBytes = Buffer.byteLength(remaining);
+		if (remainingBytes > PENDING_PASTE_INPUT_MAX_BYTES) {
+			super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
+			if (remaining.length > 0) this.handleInput(remaining);
+			this.onPastePendingInputCleared?.("queue-limit", 1);
+			return;
+		}
+		const token = this.#pasteDecisionToken + 1;
+		const controller = new AbortController();
+		this.#pasteDecisionToken = token;
+		this.#pasteDecisionPending = true;
+		this.#pendingPasteDecision = { controller, pasteContent, remaining };
+		this.#pendingPasteInputBytes = remainingBytes;
+		let commitUsed = false;
+
+		const applyPasteResult = (handled: boolean | undefined) => {
 			if (token !== this.#pasteDecisionToken) return;
-			this.#clearPasteDecisionTimeout();
+			const queuedInput = this.#resetPendingPasteState();
 			if (!handled) {
 				super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
 			}
-			this.#pasteDecisionPending = false;
-			this.#drainPendingPasteInput(remaining);
+			this.#drainPendingPasteInput(remaining, queuedInput);
 		};
-		const pasteResult = this.onPasteText?.(pasteContent);
+
+		let pasteResult: boolean | Promise<boolean> | undefined;
+		try {
+			pasteResult = this.onPasteText?.(pasteContent, {
+				signal: controller.signal,
+				commit: commit => {
+					if (
+						commitUsed ||
+						token !== this.#pasteDecisionToken ||
+						!this.#pasteDecisionPending ||
+						controller.signal.aborted
+					) {
+						return false;
+					}
+					commitUsed = true;
+					return commit();
+				},
+			});
+		} catch {
+			applyPasteResult(false);
+			return;
+		}
 
 		if (pasteResult instanceof Promise) {
-			const token = this.#pasteDecisionToken + 1;
-			this.#pasteDecisionToken = token;
-			this.#pasteDecisionPending = true;
 			this.#startPasteDecisionTimeout(token);
-			void pasteResult.then(
-				handled => applyPasteResult(token, handled),
-				() => applyPasteResult(token, false),
-			);
+			void pasteResult.then(applyPasteResult, () => applyPasteResult(false));
 		} else {
-			applyPasteResult(this.#pasteDecisionToken, pasteResult);
+			applyPasteResult(pasteResult);
 		}
 	}
 
 	handleInput(data: string): void {
 		if (this.#pasteDecisionPending) {
-			this.#pendingPasteInput.push(data);
-			if (this.#pendingPasteInput.length > PENDING_PASTE_INPUT_MAX) {
-				const droppedInputCount = this.#clearPendingPasteState();
-				this.onPastePendingInputCleared?.("queue-limit", droppedInputCount);
+			const inputBytes = Buffer.byteLength(data);
+			if (
+				this.#pendingPasteEventCount() >= PENDING_PASTE_INPUT_MAX ||
+				this.#pendingPasteInputBytes + inputBytes > PENDING_PASTE_INPUT_MAX_BYTES
+			) {
+				this.#restoreCancelledPaste("queue-limit", data);
+				return;
 			}
+			this.#pendingPasteInput.push(data);
+			this.#pendingPasteInputBytes += inputBytes;
 			return;
 		}
 
@@ -245,8 +312,12 @@ export class CustomEditor extends Editor {
 		}
 
 		if (this.onPasteText) {
-			const paste = this.#pasteHandler.process(data);
+			const paste =
+				data === "\x1b" && !this.#pasteHandler.hasPendingFrame
+					? ({ handled: false } as const)
+					: this.#pasteHandler.process(data);
 			if (paste.handled) {
+				if (paste.leading.length > 0) this.handleInput(paste.leading);
 				if (paste.pasteContent !== undefined) {
 					this.onViewportFollowLive?.();
 					this.#handleBracketedPaste(paste.pasteContent, paste.remaining);

package/src/modes/components/custom-provider-wizard.ts

@@ -41,6 +41,7 @@ export class CustomProviderWizardComponent extends Container {
 		credential: "",
 		models: "",
 	};
+	#submitInFlight = false;
 	#onSubmit: (input: CustomProviderWizardSubmit) => void;
 	#onCancel: () => void;
 	#onRender: () => void;
@@ -294,7 +295,7 @@ export class CustomProviderWizardComponent extends Container {
 			this.#step = "credential";
 		} else if (this.#step === "confirm" || this.#step === "force-confirm") {
 			if (this.#selectedIndex === 0) {
-				this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+				this.#submit();
 				return;
 			}
 			this.#step = "models";
@@ -303,6 +304,30 @@ export class CustomProviderWizardComponent extends Container {
 		this.#onRender();
 	}
 
+	#submit(): void {
+		if (this.#submitInFlight) return;
+		this.#submitInFlight = true;
+		let submission: unknown;
+		try {
+			submission = this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+		} catch (error) {
+			this.#submitInFlight = false;
+			throw error;
+		}
+		if (!(submission instanceof Promise)) {
+			this.#submitInFlight = false;
+			return;
+		}
+		void submission.then(
+			() => {
+				this.#submitInFlight = false;
+			},
+			() => {
+				this.#submitInFlight = false;
+			},
+		);
+	}
+
 	#buildInput(force: boolean): CustomProviderWizardSubmit {
 		const input = {
 			compatibility: this.#state.compatibility,

package/src/modes/components/session-observer-overlay.ts

@@ -8,10 +8,9 @@ import type { SessionMessageEntry } from "../../session/session-manager";
 import { parseSessionEntries } from "../../session/session-manager";
 import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
 import { theme } from "../theme/theme";
+import { composeToolText } from "./tool-transcript-format";
 import { type TranscriptViewerEntry, TranscriptViewerOverlay } from "./transcript-viewer-overlay";
 
-const MAX_TOOL_ARGS_CHARS = 500;
-
 /** Session-observer adapter. The shared viewer owns navigation and fold state. */
 export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 	#registry: SessionObserverRegistry;
@@ -191,15 +190,20 @@ function entriesFromMessages(entries: readonly SessionMessageEntry[]): Transcrip
 							.map(part => part.text)
 							.join("\n")
 							.trim() ?? "";
-					const summary = formatToolArgs(content.name, content.arguments);
-					const callText = [summary, content.intent].filter(Boolean).join("\n");
-					const resultDisplay = result?.isError ? `✗ ${resultText || "Error"}` : resultText || "✓ done";
+					const text = composeToolText({
+						name: content.name,
+						args: content.arguments,
+						intent: content.intent,
+						resultText,
+						isError: result?.isError ?? false,
+						hasResult: results.has(content.id),
+					});
 					output.push({
 						id: `tool:${content.id}`,
 						kind: "tool",
 						label: content.name,
 						payload: {
-							text: [callText, resultDisplay].filter(Boolean).join("\n"),
+							text,
 							metadata: {
 								name: content.name,
 								arguments: content.arguments,
@@ -234,23 +238,6 @@ function entriesFromMessages(entries: readonly SessionMessageEntry[]): Transcrip
 	return output;
 }
 
-function formatToolArgs(name: string, args: Record<string, unknown>): string {
-	if (name === "read" || name === "write" || name === "edit") return args.path ? `path: ${args.path}` : "";
-	if (name === "bash") return typeof args.command === "string" ? args.command.replaceAll("\t", "    ") : "";
-	if (name === "search")
-		return [
-			args.pattern ? `pattern: ${args.pattern}` : "",
-			Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "",
-		]
-			.filter(Boolean)
-			.join(", ");
-	return Object.entries(args)
-		.filter(([key]) => !key.startsWith("_"))
-		.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`)
-		.join(", ")
-		.slice(0, MAX_TOOL_ARGS_CHARS);
-}
-
 function truncateThinking(text: string, expanded: boolean): string {
 	const limit = expanded ? 4_000 : 200;
 	return text.length > limit ? `${text.slice(0, limit)}...` : text;

package/src/modes/components/tool-transcript-format.ts

@@ -0,0 +1,72 @@
+export const MAX_TOOL_ARGS_CHARS = 500;
+export const TOOL_RESULT_MAX_EXPANDED_LINES = 100;
+
+type ToolCallFields = {
+	name: string;
+	args: Record<string, unknown>;
+	intent?: string;
+};
+
+type ToolResultFields = {
+	resultText: string;
+	isError: boolean;
+	hasResult: boolean;
+};
+
+export type ToolTranscriptFields = ToolCallFields & ToolResultFields;
+
+export function formatToolArgs(name: string, args: Record<string, unknown>): string {
+	if (name === "read" || name === "write" || name === "edit") return args.path ? `path: ${args.path}` : "";
+	if (name === "bash") return typeof args.command === "string" ? args.command.replaceAll("\t", "    ") : "";
+	if (name === "search")
+		return [
+			args.pattern ? `pattern: ${args.pattern}` : "",
+			Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "",
+		]
+			.filter(Boolean)
+			.join(", ");
+	return Object.entries(args)
+		.filter(([key]) => !key.startsWith("_"))
+		.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`)
+		.join(", ")
+		.slice(0, MAX_TOOL_ARGS_CHARS);
+}
+
+export function composeToolCall({ name, args, intent }: ToolCallFields): string {
+	return [formatToolArgs(name, args), intent].filter(Boolean).join("\n");
+}
+
+export function composeToolResult({ resultText, isError, hasResult }: ToolResultFields): string {
+	const text = resultText.trim();
+	if (!hasResult) return "⏳ pending";
+	if (isError) return `✗ ${text || "Error"}`;
+	return text || "✓ done";
+}
+
+export function composeToolText(fields: ToolTranscriptFields): string {
+	return [composeToolCall(fields), composeToolResult(fields)].filter(Boolean).join("\n");
+}
+
+/**
+ * Caps result output without allocating an array for every source line. The final
+ * line count still requires scanning the result so the omitted-line count is exact.
+ */
+function expandedToolResult(result: string): string {
+	let lineCount = 1;
+	let prefixEnd = result.length;
+	for (let index = 0; index < result.length; index++) {
+		if (result[index] !== "\n") continue;
+		if (lineCount === TOOL_RESULT_MAX_EXPANDED_LINES) prefixEnd = index;
+		lineCount += 1;
+	}
+	const prefix = result.slice(0, prefixEnd);
+	return lineCount > TOOL_RESULT_MAX_EXPANDED_LINES
+		? `${prefix}\n... ${lineCount - TOOL_RESULT_MAX_EXPANDED_LINES} more lines`
+		: prefix;
+}
+
+export function toolDisplayText(fields: ToolTranscriptFields, expanded: boolean): string {
+	const call = composeToolCall(fields);
+	if (!expanded) return call;
+	return [call, expandedToolResult(composeToolResult(fields))].filter(Boolean).join("\n");
+}

package/src/modes/components/transcript-viewer-overlay.ts

@@ -11,6 +11,7 @@ import { sanitizeText } from "@gajae-code/utils";
 import { getMarkdownTheme, theme } from "../theme/theme";
 import type { TranscriptItemRegistry, TranscriptSourcePayload } from "../transcript-item-registry";
 import { DynamicBorder } from "./dynamic-border";
+import { toolDisplayText } from "./tool-transcript-format";
 
 const INDENT = "    ";
 const PAGE_SIZE = 15;
@@ -363,6 +364,29 @@ export class TranscriptViewerOverlay extends Container {
 	}
 }
 
+type ToolTranscriptMetadata = {
+	name: string;
+	arguments: Record<string, unknown>;
+	intent?: unknown;
+	resultText: string;
+	isError: boolean;
+	hasResult: boolean;
+};
+
+function hasToolTranscriptMetadata(
+	metadata: Readonly<Record<string, unknown>>,
+): metadata is Readonly<ToolTranscriptMetadata> {
+	return (
+		typeof metadata.name === "string" &&
+		metadata.arguments !== null &&
+		typeof metadata.arguments === "object" &&
+		!Array.isArray(metadata.arguments) &&
+		typeof metadata.resultText === "string" &&
+		typeof metadata.isError === "boolean" &&
+		typeof metadata.hasResult === "boolean"
+	);
+}
+
 /** Main-session adapter over the registry's canonical payload resolver. */
 export function transcriptViewerEntries(registry: TranscriptItemRegistry): TranscriptViewerEntry[] {
 	return registry.items().flatMap(item => {
@@ -375,10 +399,26 @@ export function transcriptViewerEntries(registry: TranscriptItemRegistry): Trans
 				: item.kind === "assistant-thinking"
 					? "Thinking"
 					: item.kind === "tool"
-						? "Tool"
+						? String(payload.metadata.name ?? "Tool")
 						: item.kind === "user"
 							? "User"
 							: item.kind;
-		return [{ id: item.id, kind: item.kind, label, payload, ...capabilities }];
+		const toolMetadata = hasToolTranscriptMetadata(payload.metadata) ? payload.metadata : undefined;
+		const getDisplayText =
+			item.kind === "tool" && toolMetadata
+				? (expanded: boolean) =>
+						toolDisplayText(
+							{
+								name: toolMetadata.name,
+								args: toolMetadata.arguments,
+								intent: typeof toolMetadata.intent === "string" ? toolMetadata.intent : undefined,
+								resultText: toolMetadata.resultText,
+								isError: toolMetadata.isError,
+								hasResult: toolMetadata.hasResult,
+							},
+							expanded,
+						)
+				: undefined;
+		return [{ id: item.id, kind: item.kind, label, payload, ...capabilities, getDisplayText }];
 	});
 }

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

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
 import { type AutocompleteProvider, matchesKey, type SlashCommand } from "@gajae-code/tui";
-import { $env, sanitizeText } from "@gajae-code/utils";
+import { $env, logger, sanitizeText } from "@gajae-code/utils";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 import { isSettingsInitialized, settings } from "../../config/settings";
 import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/gjc-plugins";
@@ -22,12 +22,14 @@ import { getUserMessageViewportAnchorIds } from "../../session/session-manager";
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
-import { ensureSupportedImageInput, ImageInputTooLargeError, loadImageInput } from "../../utils/image-loading";
+import { ensureSupportedImageInput, ImageInputTooLargeError } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
-import { formatPastedImageReference, resolvePastedImagePath } from "../../utils/pasted-image-path";
+import { loadPastedImageBatch, PastedImageBatchError } from "../../utils/pasted-image-loading";
+import { formatPastedImageReference, parsePastedImagePaths } from "../../utils/pasted-image-path";
 import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
 import { ActionRegistry, APP_ACTION_METADATA } from "../action-registry";
 import { CommandPalette, type CommandPaletteAction, type CommandPaletteEntry } from "../components/command-palette";
+import type { PasteTextContext } from "../components/custom-editor";
 import { QueuePaneComponent } from "../components/queue-pane";
 import { type QueuedMessageMoveDirection, QueuedMessageSelectorComponent } from "../components/queued-message-selector";
 
@@ -44,14 +46,23 @@ const EMPTY_EDITOR_DOUBLE_ESCAPE_WINDOW_MS = 500;
 const IMAGE_PLACEHOLDER_PATTERN = /\[image ([1-9]\d*)\]/g;
 const IMAGE_PLACEHOLDER_PRESENT_PATTERN = /\[image [1-9]\d*\]/;
 
+interface InputControllerDependencies {
+	loadPastedImageBatch?: typeof loadPastedImageBatch;
+}
+
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 
 export class InputController {
 	readonly actionRegistry: ActionRegistry<void>;
+	readonly #loadPastedImageBatch: typeof loadPastedImageBatch;
 
-	constructor(private ctx: InteractiveModeContext) {
+	constructor(
+		private ctx: InteractiveModeContext,
+		dependencies: InputControllerDependencies = {},
+	) {
+		this.#loadPastedImageBatch = dependencies.loadPastedImageBatch ?? loadPastedImageBatch;
 		this.actionRegistry = new ActionRegistry({
 			context: undefined,
 			showError: actionId => this.ctx.showError(actionId),
@@ -585,11 +596,11 @@ export class InputController {
 		);
 		this.ctx.editor.onCopyPrompt = () => this.#executeAction("app.clipboard.copyPrompt");
 		this.#registerCommandPaletteAction("app.clipboard.copyPrompt", copyPrompt);
-		this.ctx.editor.onPasteText = text => this.handleTextPaste(text);
-		this.ctx.editor.onPastePendingInputCleared = (reason, droppedInputCount) => {
+		this.ctx.editor.onPasteText = (text, context) => this.handleTextPaste(text, context);
+		this.ctx.editor.onPastePendingInputCleared = (reason, restoredInputCount) => {
 			const reasonText = reason === "timeout" ? "timed out" : "exceeded the input queue limit";
 			this.ctx.showWarning(
-				`Paste handling ${reasonText}; discarded ${droppedInputCount} buffered input event${droppedInputCount === 1 ? "" : "s"}.`,
+				`Paste handling ${reasonText}; restored the original paste and ${restoredInputCount} buffered input event${restoredInputCount === 1 ? "" : "s"}.`,
 			);
 		};
 		const expandTools = () => this.toggleToolOutputExpansion();
@@ -1522,46 +1533,96 @@ export class InputController {
 		return true;
 	}
 
-	handleTextPaste(text: string): boolean | Promise<boolean> {
-		const imagePath = resolvePastedImagePath(text, { cwd: this.ctx.sessionManager.getCwd() });
-		return imagePath ? this.#attachPastedImagePath(imagePath) : false;
+	handleTextPaste(text: string, context: PasteTextContext): boolean | Promise<boolean> {
+		if (this.ctx.isBashMode || this.ctx.isPythonMode) return false;
+		const parsed = parsePastedImagePaths(text, { cwd: this.ctx.sessionManager.getCwd() });
+		if (!parsed) return false;
+		if (parsed.kind === "too-many") {
+			this.ctx.showStatus(`Cannot attach more than ${parsed.maxCandidates} pasted images.`);
+			return false;
+		}
+		return this.#attachPastedImagePaths(parsed.paths, parsed.requiresConfirmation, context);
 	}
 
-	/**
-	 * Returns `false` on every failure path so the editor replays the original
-	 * bracketed paste — the raw path text must never be lost when attachment
-	 * is impossible (unsupported content, oversized image, load error).
-	 */
-	async #attachPastedImagePath(imagePath: string): Promise<boolean> {
+	/** Return false on every failure so CustomEditor restores the exact paste. */
+	async #attachPastedImagePaths(
+		imagePaths: readonly string[],
+		requiresConfirmation: boolean,
+		context: PasteTextContext,
+	): Promise<boolean> {
+		const signal = context.signal;
+		const editor = this.ctx.editor;
+		const editorText = editor.getText();
+		const pendingImages = this.ctx.pendingImages;
+		const pendingImageCount = pendingImages.length;
 		try {
-			const image = await loadImageInput({
-				path: imagePath,
-				cwd: this.ctx.sessionManager.getCwd(),
+			if (requiresConfirmation) {
+				const selection = await this.ctx.showHookSelector(
+					`Attach ${imagePaths.length} pasted images?\nOnly attach files you intend to send to the model.`,
+					["Attach images", "Paste paths literally"],
+					{ signal, helpText: "Enter: choose · Esc: paste paths literally" },
+				);
+				signal.throwIfAborted();
+				if (selection !== "Attach images") return false;
+			}
+
+			const loaded = await this.#loadPastedImageBatch({
+				paths: imagePaths,
 				autoResize: this.ctx.settings.get("images.autoResize"),
+				sourcePolicy: requiresConfirmation ? "confirmed" : "automatic-temp",
+				signal,
 			});
-			if (!image) {
-				this.ctx.showStatus("Unsupported pasted image file");
-				return false;
-			}
+			signal.throwIfAborted();
+			return context.commit(() => {
+				if (
+					this.ctx.editor !== editor ||
+					editor.getText() !== editorText ||
+					this.ctx.pendingImages !== pendingImages ||
+					pendingImages.length !== pendingImageCount
+				) {
+					return false;
+				}
 
-			this.ctx.pendingImages = [
-				...this.ctx.pendingImages,
-				{
-					type: "image",
-					data: image.data,
-					mimeType: image.mimeType,
-				},
-			];
-			this.ctx.editor.insertText(`${formatPastedImageReference(this.#nextImagePlaceholder(), image.resolvedPath)} `);
-			this.ctx.showStatus(`Attached image: ${path.basename(image.resolvedPath)}`, { dim: true });
-			this.ctx.ui.requestRender();
-			return true;
+				const firstImageNumber = pendingImages.length + 1;
+				const references = loaded.sourcePaths.map((sourcePath, index) =>
+					formatPastedImageReference(`[image ${firstImageNumber + index}]`, sourcePath),
+				);
+				try {
+					editor.insertText(`${references.join(" ")} `);
+					this.ctx.pendingImages = [...pendingImages, ...loaded.images];
+				} catch (error) {
+					try {
+						editor.setText(editorText);
+					} catch {
+						// Preserve the original mutation error when rollback itself fails.
+					} finally {
+						this.ctx.pendingImages = pendingImages;
+					}
+					throw error;
+				}
+
+				try {
+					this.ctx.showStatus(
+						loaded.images.length === 1
+							? `Attached image: ${path.basename(loaded.sourcePaths[0] ?? "")}`
+							: `Attached ${loaded.images.length} images`,
+						{ dim: true },
+					);
+					this.ctx.ui.requestRender();
+				} catch (error) {
+					logger.warn("Pasted images attached but status rendering failed", { error: String(error) });
+				}
+				return true;
+			});
 		} catch (error) {
-			if (error instanceof ImageInputTooLargeError) {
+			if (signal.aborted) return false;
+			if (error instanceof ImageInputTooLargeError || error instanceof PastedImageBatchError) {
 				this.ctx.showStatus(error.message);
 				return false;
 			}
-			this.ctx.showStatus("Failed to attach pasted image");
+			this.ctx.showStatus(
+				imagePaths.length === 1 ? "Failed to attach pasted image" : "Failed to attach pasted images",
+			);
 			return false;
 		}
 	}

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

@@ -1060,7 +1060,7 @@ export class SelectorController {
 			};
 			wizard = new CustomProviderWizardComponent(
 				input => {
-					void submit(input);
+					return submit(input);
 				},
 				() => {
 					done();