@oh-my-pi/pi-coding-agent 17.1.3 → 17.1.4

package/src/eval/js/worker-core.ts

@@ -25,6 +25,8 @@ interface ActiveRun {
 
 type RunResult = Extract<WorkerOutbound, { type: "result" }>;
 
+export type RejectionInterceptor = (handler: (reason: unknown) => boolean) => () => void;
+
 export type WorkerCoreOptions =
 	| {
 			mode: "isolated";
@@ -36,10 +38,12 @@ export type WorkerCoreOptions =
 			 * mutate the host's own cwd on the inline fallback.
 			 */
 			chdir?: (cwd: string) => void;
+			/** Share the subprocess host's fatal-rejection guard when one is installed. */
+			interceptUnhandledRejections?: RejectionInterceptor;
 	  }
 	| {
 			mode: "inline";
-			interceptUnhandledRejections(handler: (reason: unknown) => boolean): () => void;
+			interceptUnhandledRejections: RejectionInterceptor;
 	  };
 
 /** Finished-cell filenames retained for attributing rejections that surface after the run settled. */
@@ -115,7 +119,7 @@ export class WorkerCore {
 	 * without a usable stack, while anything else keeps its default fatality.
 	 */
 	#installRejectionGuard(): () => void {
-		if (this.#options.mode === "inline") {
+		if (this.#options.interceptUnhandledRejections) {
 			return this.#options.interceptUnhandledRejections(reason => this.#consumeRejection(reason));
 		}
 		const onRejection = (reason: unknown): void => {

package/src/exec/bash-executor.ts

@@ -5,7 +5,7 @@
  */
 import { ExponentialYield } from "@oh-my-pi/pi-agent-core/utils/yield";
 import { type MinimizerOptions, Shell, type ShellRunResult } from "@oh-my-pi/pi-natives";
-import { isExecutable, type ShellConfig } from "@oh-my-pi/pi-utils/procmgr";
+import { isCmdShell, isExecutable, type ShellConfig } from "@oh-my-pi/pi-utils/procmgr";
 import { Settings, type ShellMinimizerSettings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
@@ -367,8 +367,10 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	});
 	const commandEnv = buildNonInteractiveEnv(preflight.env);
 	const runCdInPersistentShell = options?.useUserShell === true && !prefix && isPersistentShellCdCommand(command);
+	// Never wrap in cmd.exe: it is only the Windows no-bash fallback for spawn
+	// paths, and the embedded brush shell runs the POSIX line better directly.
 	const finalCommand =
-		options?.useUserShell === true && !bashShell && !runCdInPersistentShell
+		options?.useUserShell === true && !bashShell && !isCmdShell(shell) && !runCdInPersistentShell
 			? buildUserShellCommand(shell, args, preflight.command)
 			: preflight.command;
 

package/src/extensibility/extensions/runner.ts

@@ -103,10 +103,11 @@ function handlerTimeoutForEvent(eventType: string): number {
 }
 
 const EXTENSION_HANDLER_TIMEOUT = Symbol("extensionHandlerTimeout");
+const EXTENSION_HANDLER_ABORTED = Symbol("extensionHandlerAborted");
 
 /**
- * Race `work` against a `timeoutMs` budget, clearing the pending timer the
- * instant the work settles.
+ * Race `work` against a `timeoutMs` budget and optional cancellation signal,
+ * clearing the timer and abort listener as soon as one branch settles.
  *
  * We deliberately avoid `Bun.sleep(timeoutMs).then(...)` here: that leaves an
  * uncancellable timer registered with the event loop, so every successful
@@ -119,14 +120,20 @@ const EXTENSION_HANDLER_TIMEOUT = Symbol("extensionHandlerTimeout");
 async function raceHandlerWithTimeout<T>(
 	work: Promise<T>,
 	timeoutMs: number,
-): Promise<T | typeof EXTENSION_HANDLER_TIMEOUT> {
-	const { promise: timeoutPromise, resolve: resolveTimeout } =
-		Promise.withResolvers<typeof EXTENSION_HANDLER_TIMEOUT>();
-	const timer = setTimeout(() => resolveTimeout(EXTENSION_HANDLER_TIMEOUT), timeoutMs);
+	signal?: AbortSignal,
+): Promise<T | typeof EXTENSION_HANDLER_TIMEOUT | typeof EXTENSION_HANDLER_ABORTED> {
+	if (signal?.aborted) return EXTENSION_HANDLER_ABORTED;
+	const { promise: interruptPromise, resolve: resolveInterrupt } = Promise.withResolvers<
+		typeof EXTENSION_HANDLER_TIMEOUT | typeof EXTENSION_HANDLER_ABORTED
+	>();
+	const timer = setTimeout(() => resolveInterrupt(EXTENSION_HANDLER_TIMEOUT), timeoutMs);
+	const onAbort = () => resolveInterrupt(EXTENSION_HANDLER_ABORTED);
+	signal?.addEventListener("abort", onAbort, { once: true });
 	try {
-		return await Promise.race([work, timeoutPromise]);
+		return await Promise.race([work, interruptPromise]);
 	} finally {
 		clearTimeout(timer);
+		signal?.removeEventListener("abort", onAbort);
 	}
 }
 
@@ -372,7 +379,9 @@ export class ExtensionRunner {
 		await this.emit({ type: "credential_disabled", ...event });
 	}
 
+	/** Emits a session stop pass that can be cancelled with the active settle signal. */
 	async emitSessionStop(event: Omit<SessionStopEvent, "type">): Promise<SessionStopEventResult | undefined> {
+		if (event.signal.aborted) return undefined;
 		return await this.emit({ type: "session_stop", ...event });
 	}
 
@@ -622,8 +631,14 @@ export class ExtensionRunner {
 		ext: Extension,
 		timeoutMs: number,
 	): Promise<TResult | undefined> {
+		const signal =
+			event.type === "session_stop" && "signal" in event && event.signal instanceof AbortSignal
+				? event.signal
+				: undefined;
+		if (signal?.aborted) return undefined;
 		try {
-			const handlerResult = await raceHandlerWithTimeout(Promise.resolve(handler(event, ctx)), timeoutMs);
+			const handlerResult = await raceHandlerWithTimeout(Promise.resolve(handler(event, ctx)), timeoutMs, signal);
+			if (handlerResult === EXTENSION_HANDLER_ABORTED) return undefined;
 			if (handlerResult === EXTENSION_HANDLER_TIMEOUT) {
 				const error = `handler timed out after ${timeoutMs}ms`;
 				logger.warn("Extension handler timed out", {

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -19,6 +19,9 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Effort } from "@oh-my-pi/pi-catalog/effort";
+import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import {
 	calculateCost,
 	getBundledModel,
@@ -71,6 +74,12 @@ export function StringEnum<T extends string | number>(
 	return schema;
 }
 
+/** Clamp a historical Pi thinking level against OMP's model metadata. */
+export function clampThinkingLevel<TApi extends Api>(model: Model<TApi>, level: Effort | "off"): Effort | "off" {
+	if (level === "off") return "off";
+	return clampThinkingLevelForModel(model, level) ?? "off";
+}
+
 export * from "@oh-my-pi/pi-ai";
 /**
  * Compatibility re-exports for catalog symbols that pi-ai historically exposed

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -861,6 +861,11 @@ export interface ResourceLoader {
 	readonly __ompLegacyPiLoader?: true;
 }
 
+/** Create a pre-initialization runtime for legacy extension resource loaders. */
+export function createExtensionRuntime(): ExtensionRuntime {
+	return new ExtensionRuntime();
+}
+
 /**
  * Loader-owned inputs that {@link createAgentSession} needs regardless of
  * whether the caller provided extra options. `cwd`/`agentDir` fall back to
@@ -894,7 +899,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 	readonly __ompLegacyPiLoader = true as const;
 	#state: ResolvedLoaderState;
 	#options: DefaultResourceLoaderOptions;
-	#extensionsResult: LoadExtensionsResult = { extensions: [], errors: [], runtime: new ExtensionRuntime() };
+	#extensionsResult: LoadExtensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
 	#skills: Skill[] = [];
 	#skillDiagnostics: ResourceDiagnostic[] = [];
 	#prompts: PromptTemplate[] = [];
@@ -1043,7 +1048,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 		const { cwd, noExtensions, additionalExtensionPaths, extensionFactories, eventBus } = this.#state;
 
 		if (noExtensions && additionalExtensionPaths.length === 0 && extensionFactories.length === 0) {
-			return { extensions: [], errors: [], runtime: new ExtensionRuntime() };
+			return { extensions: [], errors: [], runtime: createExtensionRuntime() };
 		}
 
 		const paths = await discoverSessionExtensionPaths(
@@ -1366,6 +1371,13 @@ export function getPackageDir(): string {
 	return getOmpPackageDir() ?? (isCompiledBinary() ? path.dirname(process.execPath) : process.cwd());
 }
 
+// Legacy pi's `@earendil-works/pi-coding-agent` re-exported `estimateTokens`
+// from its package root (via `./core/compaction/index.ts`). In omp it lives in
+// `@oh-my-pi/pi-agent-core/compaction`, and the coding-agent barrel below does
+// not forward it, so legacy extensions importing it fail Bun's static export
+// check during validation (issue #6583).
+export { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+
 export * from "../index";
 export { formatBytes as formatSize } from "../tools/render-utils";
 export { copyToClipboard } from "../utils/clipboard";

package/src/extensibility/legacy-pi-tui-shim.ts

@@ -6,5 +6,38 @@
  * exposes the equivalent, broader `decodePrintableKey` helper. Keep the legacy
  * name available without reintroducing it into the canonical package surface.
  */
+import { ImageProtocol, TERMINAL } from "@oh-my-pi/pi-tui";
+
 export * from "@oh-my-pi/pi-tui";
 export { decodePrintableKey as decodeKittyPrintable } from "@oh-my-pi/pi-tui";
+
+/** Report canonical terminal capabilities through the legacy Pi TUI shape. */
+export function getCapabilities(): {
+	images: "kitty" | "iterm2" | null;
+	trueColor: boolean;
+	hyperlinks: boolean;
+} {
+	const images =
+		TERMINAL.imageProtocol === ImageProtocol.Kitty
+			? "kitty"
+			: TERMINAL.imageProtocol === ImageProtocol.Iterm2
+				? "iterm2"
+				: null;
+	return { images, trueColor: TERMINAL.trueColor, hyperlinks: TERMINAL.hyperlinks };
+}
+
+/**
+ * Delete one Kitty graphics image by id, matching the legacy Pi TUI helper.
+ *
+ * Returns the bare control sequence exactly like upstream Pi: legacy callers
+ * (e.g. pi-sprite) apply their own tmux passthrough wrapping, so wrapping here
+ * would double-wrap under tmux and the outer terminal would drop the command.
+ */
+export function deleteKittyImage(imageId: number): string {
+	return `\x1b_Ga=d,d=I,i=${imageId},q=2\x1b\\`;
+}
+
+/** Delete every Kitty graphics image using the legacy Pi TUI bare sequence. */
+export function deleteAllKittyImages(): string {
+	return "\x1b_Ga=d,d=A,q=2\x1b\\";
+}

package/src/extensibility/shared-events.ts

@@ -102,6 +102,8 @@ export interface SessionStopEvent {
 	session_id: string;
 	session_file?: string;
 	stop_hook_active: boolean;
+	/** Cancels handler waiting when the active settle pass is aborted. */
+	signal: AbortSignal;
 }
 
 /** Preparation data for tree navigation (used by session_before_tree event) */

package/src/main.ts

@@ -885,6 +885,10 @@ export async function buildSessionOptions(
 	// - supports --provider <name> --model <pattern>
 	// - supports --model <provider>/<pattern>
 	const modelMatchPreferences = getModelMatchPreferences(activeSettings);
+	// True when a configured `default` role was deliberately left unresolved for
+	// createAgentSession's post-extension re-resolution (issue #6694); the
+	// scoped thinking-level seed below must be deferred along with the model.
+	let deferredDefaultRole = false;
 	if (parsed.model) {
 		const resolved = resolveCliModel({
 			cliProvider: parsed.provider,
@@ -946,7 +950,20 @@ export async function buildSessionOptions(
 				}
 			}
 		}
-		if (!options.model) options.model = scopedModels[0].model;
+		// A configured `default` role that doesn't resolve within the startup
+		// scope is deferred, NOT silently pinned to `scopedModels[0]`: the scope
+		// is resolved before extensions register their providers, so a role naming
+		// an extension-registered model (listed in `enabledModels`) would drop out
+		// here and the session would run on an unrelated in-scope provider without
+		// any error. Leaving `options.model` unset lets createAgentSession's
+		// post-extension default-role resolution reclaim it against the fully
+		// registered, still enabledModels-scoped catalog (issue #6694).
+		// Defer ONLY for a settings-derived scope: createAgentSession re-resolves
+		// against `settings.enabledModels` and never sees CLI `--models`, so
+		// deferring under an explicit CLI scope would let the saved default
+		// escape it — keep pinning the first scoped model there.
+		deferredDefaultRole = !options.model && Boolean(remembered) && !((parsed.models?.length ?? 0) > 0);
+		if (!options.model && !deferredDefaultRole) options.model = scopedModels[0].model;
 	}
 
 	if (parsed.noPrewalk && (parsed.prewalk || parsed.prewalkInto !== undefined)) {
@@ -1005,6 +1022,10 @@ export async function buildSessionOptions(
 	} else if (
 		scopedModels.length > 0 &&
 		scopedModels[0].explicitThinkingLevel === true &&
+		// A deferred default role resolves its own model (and any explicit
+		// thinking suffix) after extensions register; seeding the fallback
+		// scoped model's level here would override it in createAgentSession.
+		!deferredDefaultRole &&
 		!parsed.continue &&
 		!parsed.resume
 	) {

package/src/modes/acp/acp-agent.ts

@@ -1691,6 +1691,12 @@ export class AcpAgent implements Agent {
 			planExists: true,
 		};
 		if (!approved) {
+			// Rejection keeps plan mode active for another planning turn. Promote the
+			// reviewed path into plan-mode state so the next `#buildPlanModeMessage()`
+			// targets the plan just reviewed, not the stale state path.
+			if (state.planFilePath !== planFilePath) {
+				session.setPlanModeState({ ...state, planFilePath });
+			}
 			const normalizedTitle = normalizePlanTitle(resolvedTitle).title;
 			return {
 				content: [

package/src/modes/components/assistant-message.ts

@@ -1,10 +1,20 @@
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
-import { Container, Image, type ImageBudget, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
+import {
+	Container,
+	Image,
+	type ImageBudget,
+	ImageProtocol,
+	Markdown,
+	replaceTabs,
+	Spacer,
+	TERMINAL,
+	Text,
+} from "@oh-my-pi/pi-tui";
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
-import { getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
+import { expandKeyHint, getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import { canonicalizeMessage, formatThinkingForDisplay, hasDisplayableThinking } from "../../utils/thinking-display";
 import { resolveAssistantErrorPresentation } from "../utils/transcript-render-helpers";
 import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cache-invalidation-marker";
@@ -196,6 +206,22 @@ export class AssistantMessageComponent extends Container {
 	 * transcript keeps the error in history.
 	 */
 	#errorPinned = false;
+	/**
+	 * Whether the inline turn-ending error block renders its full body instead of
+	 * the {@link MAX_TRANSCRIPT_ERROR_LINES}-capped preview. Toggled by
+	 * {@link setExpanded} so Ctrl+O (tool-output expansion) reveals a long
+	 * provider error whose tail would otherwise be unreachable in the live TUI.
+	 */
+	#errorExpanded = false;
+	/**
+	 * True when the current {@link updateContent} message carries a truncatable
+	 * inline provider error (the `#appendErrorBlock` path) — set whether or not
+	 * the inline block was actually drawn, so it stays true even while the error
+	 * is suppressed under a pinned banner. Gates {@link setExpanded} so toggling
+	 * expansion only re-renders assistant turns that carry such an error, not
+	 * every message in the transcript.
+	 */
+	#hasTruncatableError = false;
 	/**
 	 * Monotonic content version reported to the transcript container via
 	 * {@link getTranscriptBlockVersion}. Bumped by {@link updateContent} — the
@@ -408,6 +434,22 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	/**
+	 * Expand or collapse the inline turn-ending error block so Ctrl+O
+	 * (tool-output expansion) can reveal a long provider error's hidden tail.
+	 * Only re-renders when the current message carries a truncatable error, so
+	 * toggling expansion across the transcript skips ordinary turns. Works even
+	 * while the error is pinned in the banner: the inline block is drawn (in full)
+	 * when expanded so the complete body is reachable without sending a message.
+	 */
+	setExpanded(expanded: boolean): void {
+		if (this.#errorExpanded === expanded) return;
+		this.#errorExpanded = expanded;
+		if (this.#hasTruncatableError && this.#lastMessage) {
+			this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
+		}
+	}
+
 	isTranscriptBlockFinalized(): boolean {
 		return this.#transcriptBlockFinalized;
 	}
@@ -488,12 +530,25 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	/**
-	 * Render a turn-ending provider error inline. Drops blank lines, clamps the
-	 * line count to {@link MAX_TRANSCRIPT_ERROR_LINES}, and width-truncates each
-	 * line so a pathological body — e.g. the HTML page a proxy returns on a 502 —
-	 * can't flood the transcript. Mirrors {@link ErrorBannerComponent}.
+	 * Render a turn-ending provider error inline. Collapsed (default), it drops
+	 * blank lines, clamps the line count to {@link MAX_TRANSCRIPT_ERROR_LINES},
+	 * and width-truncates each line so a pathological body — e.g. the HTML page a
+	 * proxy returns on a 502 — can't flood the transcript, appending a dim
+	 * `ctrl+o`/expand hint when lines were hidden. Expanded (via
+	 * {@link setExpanded}), it renders the full body — tabs replaced, blank lines
+	 * preserved — letting {@link Text} word-wrap each line to the render width so
+	 * the complete message is reachable. Mirrors {@link ErrorBannerComponent}.
 	 */
 	#appendErrorBlock(message: string): void {
+		if (this.#errorExpanded) {
+			const [first = "Unknown error", ...rest] = replaceTabs(message.replace(/\s+$/, "")).split("\n");
+			this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${first}`), 1, 0));
+			for (const line of rest) {
+				this.#contentContainer.addChild(new Text(theme.fg("error", `  ${line}`), 1, 0));
+			}
+			return;
+		}
+		const total = message.split("\n").filter(l => l.trim()).length;
 		const lines = getPreviewLines(message, MAX_TRANSCRIPT_ERROR_LINES, TRUNCATE_LENGTHS.LINE);
 		if (lines.length === 0) lines.push("Unknown error");
 		// The caller owns the separating Spacer; adding one here doubled the gap.
@@ -501,6 +556,16 @@ export class AssistantMessageComponent extends Container {
 		for (const line of lines.slice(1)) {
 			this.#contentContainer.addChild(new Text(theme.fg("error", `  ${line}`), 1, 0));
 		}
+		if (total > lines.length) {
+			const hidden = total - lines.length;
+			this.#contentContainer.addChild(
+				new Text(
+					theme.fg("dim", `  … +${hidden} more line${hidden === 1 ? "" : "s"} (${expandKeyHint()} to expand)`),
+					1,
+					0,
+				),
+			);
+		}
 	}
 
 	/** Toggle rendering for assistant-native and tool-result images. */
@@ -643,7 +708,10 @@ export class AssistantMessageComponent extends Container {
 		if (this.#toolImagesByCallId.size > 0) return false;
 		const errorPresentation = resolveAssistantErrorPresentation(message);
 		if (errorPresentation.kind === "compact-recovered") return false;
-		if (errorPresentation.kind === "full" && !(message.stopReason === "error" && this.#errorPinned)) {
+		if (
+			errorPresentation.kind === "full" &&
+			!(message.stopReason === "error" && this.#errorPinned && !this.#errorExpanded)
+		) {
 			return false;
 		}
 		// Extension stability: if thinking renderers exist and any tracked thinking
@@ -777,6 +845,7 @@ export class AssistantMessageComponent extends Container {
 		// Clear content container
 		this.#contentContainer.clear();
 		this.#thinkingDots = undefined;
+		this.#hasTruncatableError = false;
 
 		// Determine if we should capture Markdown instances for next fast path
 		const shouldCapture = this.#canFastPath(message);
@@ -859,11 +928,19 @@ export class AssistantMessageComponent extends Container {
 			this.#contentContainer.addChild(new Spacer(1));
 			this.#contentContainer.addChild(new Text(theme.fg("dim", errorPresentation.text), 1, 0));
 		} else if (!hasToolCalls && errorPresentation.kind === "full") {
-			if (!(message.stopReason === "error" && this.#errorPinned)) {
+			if (message.stopReason === "aborted") {
 				this.#contentContainer.addChild(new Spacer(1));
-				if (message.stopReason === "aborted") {
-					this.#contentContainer.addChild(new Text(theme.fg("error", errorPresentation.text), 1, 0));
-				} else {
+				this.#contentContainer.addChild(new Text(theme.fg("error", errorPresentation.text), 1, 0));
+			} else {
+				// Non-aborted provider error: a truncatable inline block. Mark it so
+				// setExpanded re-renders even while the same error is pinned above.
+				this.#hasTruncatableError = true;
+				// Suppress the inline block only while pinned AND collapsed — the
+				// banner already shows the capped error there. When expanded, draw
+				// the inline block in full so the complete body is reachable without
+				// sending a message; the pinned banner stays a short reminder.
+				if (!(message.stopReason === "error" && this.#errorPinned) || this.#errorExpanded) {
+					this.#contentContainer.addChild(new Spacer(1));
 					this.#appendErrorBlock(errorPresentation.text);
 				}
 			}

package/src/modes/components/chat-transcript-builder.ts

@@ -303,6 +303,7 @@ export class ChatTranscriptBuilder {
 			proseOnlyThinking,
 		);
 		assistantComponent.setImagesVisible(settings.get("terminal.showImages"));
+		this.#trackExpandable(assistantComponent);
 		this.container.addChild(assistantComponent);
 
 		if (settings.get("display.cacheMissMarker")) {
@@ -334,6 +335,7 @@ export class ChatTranscriptBuilder {
 				proseOnlyThinking,
 			);
 			component.setImagesVisible(settings.get("terminal.showImages"));
+			this.#trackExpandable(component);
 			this.container.addChild(component);
 		};
 

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

@@ -8,6 +8,7 @@ import {
 	CustomEditor,
 	extractBracketedImagePastePaths,
 	extractBracketedPastePaths,
+	extractImagePastePathsFromText,
 	extractImagePathFromText,
 	extractPastePathsFromText,
 	SPACE_HOLD_MECHANICAL_RUN,
@@ -182,6 +183,43 @@ describe("CustomEditor bracketed path paste", () => {
 		expect(editor.getText()).toBe("/tmp/report.csv");
 		expect(imagePathCalls).toBe(0);
 	});
+
+	it("attaches a spaced screenshot path as an image instead of inserting it as literal text", () => {
+		// #6578: the raw macOS "copy screenshot path" payload has unescaped
+		// spaces, which defeats the segment splitter. Before the whole-text
+		// fallback the paste degraded to literal text in the prompt.
+		const { editor } = makeEditor();
+		const screenshot = "/Users/me/Desktop/Screenshot 2026-07-24 at 1.55.12 PM.png";
+		const pasted: string[] = [];
+		editor.onPasteImagePath = path => {
+			pasted.push(path);
+		};
+
+		editor.handleInput(bracketedPaste(screenshot));
+
+		expect(pasted).toEqual([screenshot]);
+		expect(editor.getText()).toBe("");
+	});
+
+	it("keeps a two-file drag with unescaped spaces as text instead of attaching one fused path", () => {
+		// PR #6582 review: selecting two screenshots and dropping them together
+		// emits a single space-separated payload the splitter also refuses
+		// (`PM.png` carries no directory). Fusing it into one path attaches
+		// nothing — `handleImagePathPaste` hits ENOENT and only shows a status,
+		// never restoring the text — so the drop must degrade to a text paste.
+		const { editor } = makeEditor();
+		const dropped =
+			"/Users/me/Desktop/Screenshot 2026-07-24 at 1.55.12 PM.png /Users/me/Desktop/Screenshot 2026-07-24 at 1.56.00 PM.png";
+		const pasted: string[] = [];
+		editor.onPasteImagePath = path => {
+			pasted.push(path);
+		};
+
+		editor.handleInput(bracketedPaste(dropped));
+
+		expect(pasted).toEqual([]);
+		expect(editor.getText()).toBe(dropped);
+	});
 });
 describe("CustomEditor configured paste image keys", () => {
 	it("routes Ghostty Cmd+V kitty key events through the macOS image-paste default", () => {
@@ -250,6 +288,12 @@ describe("extractImagePathFromText (issue #3506)", () => {
 		);
 	});
 
+	it("returns undefined for two spaced paths the splitter could not separate", () => {
+		// Only the whole-text pass survives the splitter here, and it must not
+		// fuse the pair into one path the loader can never resolve.
+		expect(extractImagePathFromText("/tmp/a.png /tmp/b shot.png")).toBeUndefined();
+	});
+
 	it("does not hijack prose that happens to contain a path-shaped fragment", () => {
 		// The whole-text branch is gated on ABSOLUTE_PATH_PREFIX_REGEX, so a
 		// non-anchored prefix ("see ...") never triggers it.
@@ -264,6 +308,132 @@ describe("extractPastePathsFromText", () => {
 	});
 });
 
+describe("extractImagePastePathsFromText (issue #6578)", () => {
+	const MAC_SCREENSHOT =
+		"/var/folders/xx/T/TemporaryItems/NSIRD_screencaptureui_ab/Screenshot 2026-07-24 at 1.55.12 PM.png";
+	const WINDOWS_SPACED = "C:\\Users\\me\\My Pictures\\shot 1.png";
+
+	// Every case must resolve identically on the stripped-marker route
+	// (assembled pastes) and the bracketed route, since the latter now
+	// delegates to the former.
+	const cases: { name: string; text: string; expected: string[] | undefined }[] = [
+		{ name: "a macOS screenshot path with unescaped spaces", text: MAC_SCREENSHOT, expected: [MAC_SCREENSHOT] },
+		{ name: "a Windows drive path with unescaped spaces", text: WINDOWS_SPACED, expected: [WINDOWS_SPACED] },
+		{
+			name: "a home-anchored path with unescaped spaces",
+			text: "~/Pictures/Cleanshot 2026-07-24 at 12.00.png",
+			expected: ["~/Pictures/Cleanshot 2026-07-24 at 12.00.png"],
+		},
+		{
+			name: "a shell-escaped spaced path",
+			text: "/tmp/My\\ Photos/shot\\ 1.png",
+			expected: ["/tmp/My Photos/shot 1.png"],
+		},
+		{
+			name: "a double-quoted spaced path",
+			text: '"/tmp/My Photos/shot 1.png"',
+			expected: ["/tmp/My Photos/shot 1.png"],
+		},
+		{ name: "a spaced path with a non-image extension", text: "/tmp/my report 2026.csv", expected: undefined },
+		{
+			// Ends in a real image extension, so only the absolute-prefix
+			// anchor keeps the whole-text fallback from swallowing the prose.
+			name: "prose ending in a path-shaped fragment",
+			text: "see /Users/me/Desktop/Screen Shot 1.png",
+			expected: undefined,
+		},
+		{
+			name: "two spaced image paths on separate lines",
+			text: "/tmp/a shot.png\n/tmp/b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "a bare spaced filename with no leading separator",
+			text: "Screenshot 2026-07-24 at 1.55.12 PM.png",
+			expected: undefined,
+		},
+		{
+			name: "two POSIX paths dragged together when one has unescaped spaces",
+			text: "/tmp/a.png /tmp/b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "two macOS screenshots dragged together",
+			text: `${MAC_SCREENSHOT} /var/folders/xx/T/TemporaryItems/NSIRD_screencaptureui_ab/Screenshot 2026-07-24 at 1.56.00 PM.png`,
+			expected: undefined,
+		},
+		{
+			name: "two home-anchored paths with unescaped spaces",
+			text: "~/a.png ~/Pictures/b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "two Windows drive paths with unescaped spaces",
+			text: `C:\\Users\\me\\a.png ${WINDOWS_SPACED}`,
+			expected: undefined,
+		},
+		{
+			name: "two `file://` URLs with unescaped spaces",
+			text: "file:///tmp/a.png file:///tmp/b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "two UNC paths with unescaped spaces",
+			text: "\\\\srv\\share\\a.png \\\\srv\\share\\b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "a tab-separated pair of dragged paths",
+			text: "/tmp/a.png\t/tmp/b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "an absolute path followed by a dot-relative path with unescaped spaces",
+			text: "/tmp/a.png ./b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "an absolute path followed by a parent-relative path with unescaped spaces",
+			text: "/tmp/a.png ../pics/b shot.png",
+			expected: undefined,
+		},
+		{
+			name: "a Windows drive path followed by a dot-relative path with unescaped spaces",
+			text: "C:\\Users\\me\\a.png .\\b shot.png",
+			expected: undefined,
+		},
+		{
+			// The interior `Photos/shot` token after an unescaped space is the
+			// shape of a spaced directory name, not of a second dragged path —
+			// this is why bare relatives are not multi-path anchors.
+			name: "a single path with an unescaped spaced directory name",
+			text: "/Users/me/My Photos/shot 1.png",
+			expected: ["/Users/me/My Photos/shot 1.png"],
+		},
+		{
+			// The escape asserts the space belongs to the path, so the `/sub`
+			// that follows is a component rather than a second drag payload.
+			name: "a path whose escaped space precedes a slash-led component",
+			text: "/tmp/odd dir\\ /sub/a b.png",
+			expected: ["/tmp/odd dir /sub/a b.png"],
+		},
+		{
+			// Splitter-success path: both segments are explicit, so the
+			// whole-text pass never runs and the pair still attaches as two.
+			name: "two explicit image paths the splitter can separate",
+			text: "/tmp/a.png /tmp/b.png",
+			expected: ["/tmp/a.png", "/tmp/b.png"],
+		},
+	];
+
+	for (const { name, text, expected } of cases) {
+		it(`${expected ? "recovers" : "rejects"} ${name} on both paste routes`, () => {
+			expect(extractImagePastePathsFromText(text)).toEqual(expected);
+			expect(extractBracketedImagePastePaths(bracketedPaste(text))).toEqual(expected);
+		});
+	}
+});
+
 describe("CustomEditor space-hold push-to-talk", () => {
 	beforeAll(async () => {
 		await initTheme();