@oh-my-pi/pi-coding-agent 17.3.2 → 17.3.4

package/dist/types/markit/converters/pdf/index.d.ts

@@ -1,6 +1,7 @@
 import type { ConversionResult, Converter, StreamInfo } from "../../types.js";
+/** Converts PDF buffers to Markdown through the native `pdf-inspector` bridge. */
 export declare class PdfConverter implements Converter {
     name: string;
     accepts(streamInfo: StreamInfo): boolean;
-    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
 }

package/dist/types/session/turn-recovery.d.ts

@@ -126,7 +126,7 @@ export declare class TurnRecovery {
     /** Persists an otherwise skipped terminal empty error turn. */
     persistTerminalEmptyErrorTurn(message: AssistantMessage): Promise<void>;
     /** Handles empty terminal assistant turns and schedules bounded recovery. */
-    handleEmptyAssistantStop(message: AssistantMessage): Promise<boolean>;
+    handleEmptyAssistantStop(message: AssistantMessage): Promise<"continue" | "terminal" | undefined>;
     /** Classifies suspicious terminal stops and schedules bounded recovery. */
     handleUnexpectedAssistantStop(message: AssistantMessage): Promise<boolean>;
     /** Removes a persisted failed assistant turn after its persistence slot settles. */

package/dist/types/tools/read-pdf.d.ts

@@ -0,0 +1,15 @@
+import type { ToolSession } from "../sdk.js";
+import type { ScreenshotResult } from "./browser/tab-protocol.js";
+/** A legacy PDF image-member path interpreted as a page screenshot request. */
+export interface PdfImageReadTarget {
+    /** PDF path before the member delimiter. */
+    pdfPath: string;
+    /** Original member text after the delimiter. */
+    member: string;
+    /** One-indexed page inferred from names such as `p2-img0.png`; defaults to page 1. */
+    page: number;
+}
+/** Parse a former PDF image-member path as a Chromium page screenshot request. */
+export declare function splitPdfImageReadPath(readPath: string): PdfImageReadTarget | null;
+/** Render one PDF page through the browser tool's shared headless Chromium. */
+export declare function renderPdfPageScreenshot(session: ToolSession, absolutePdfPath: string, page: number, signal?: AbortSignal): Promise<ScreenshotResult>;

package/dist/types/utils/external-editor.d.ts

@@ -18,6 +18,13 @@ export interface OpenInEditorOptions {
     /** Keep the file's trailing newline instead of trimming it from the returned text. */
     trimTrailingNewline?: boolean;
 }
+/** Subprocess argv and Windows quoting mode used to launch an external editor. */
+export interface EditorSpawnCommand {
+    cmd: string[];
+    windowsVerbatimArguments: boolean;
+}
+/** Resolves shell argv without letting the host runtime re-quote the editor command. */
+export declare function resolveEditorSpawnCommand(editorCmd: string, tmpFile: string, platform?: NodeJS.Platform): EditorSpawnCommand;
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.

package/dist/types/utils/markit.d.ts

@@ -18,10 +18,9 @@ export interface MarkitConversionResult {
 }
 export interface MarkitFileConversionOptions {
     /**
-     * Directory the PDF converter writes extracted images/diagrams into. When
-     * set, each embedded image is rendered to `<id>.png` and referenced by path
-     * in the markdown; when unset, markit emits an `<!-- image: <id> ... -->`
-     * placeholder comment instead.
+     * Directory converters may use for extracted image or diagram files. Since
+     * those files are conversion side effects, conversions using this option
+     * bypass the markdown cache.
      */
     imageDir?: string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.3.2",
+	"version": "17.3.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -41,8 +41,6 @@
 		"format-prompts": "bun scripts/format-prompts.ts",
 		"gen:tool-views": "bun --cwd=../collab-web run gen:tool-views",
 		"gen:bundle": "bun scripts/bundle-dist.ts",
-		"gen:mupdf": "bun scripts/embed-mupdf-wasm.ts --generate",
-		"gen:mupdf:reset": "bun scripts/embed-mupdf-wasm.ts --reset",
 		"gen:native": "bun --cwd=../natives run gen:native",
 		"gen:native:reset": "bun --cwd=../natives run gen:native:reset",
 		"prepack": "bun run gen:tool-views && bun run gen:bundle",
@@ -50,18 +48,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.3.2",
-		"@oh-my-pi/omp-stats": "17.3.2",
-		"@oh-my-pi/omptype": "17.3.2",
-		"@oh-my-pi/pi-agent-core": "17.3.2",
-		"@oh-my-pi/pi-ai": "17.3.2",
-		"@oh-my-pi/pi-catalog": "17.3.2",
-		"@oh-my-pi/pi-mnemopi": "17.3.2",
-		"@oh-my-pi/pi-natives": "17.3.2",
-		"@oh-my-pi/pi-tui": "17.3.2",
-		"@oh-my-pi/pi-utils": "17.3.2",
-		"@oh-my-pi/pi-wire": "17.3.2",
-		"@oh-my-pi/snapcompact": "17.3.2",
+		"@oh-my-pi/hashline": "17.3.4",
+		"@oh-my-pi/omp-stats": "17.3.4",
+		"@oh-my-pi/omptype": "17.3.4",
+		"@oh-my-pi/pi-agent-core": "17.3.4",
+		"@oh-my-pi/pi-ai": "17.3.4",
+		"@oh-my-pi/pi-catalog": "17.3.4",
+		"@oh-my-pi/pi-mnemopi": "17.3.4",
+		"@oh-my-pi/pi-natives": "17.3.4",
+		"@oh-my-pi/pi-tui": "17.3.4",
+		"@oh-my-pi/pi-utils": "17.3.4",
+		"@oh-my-pi/pi-wire": "17.3.4",
+		"@oh-my-pi/snapcompact": "17.3.4",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
@@ -73,7 +71,6 @@
 		"@opentelemetry/sdk-metrics": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@opentelemetry/sdk-trace-node": "^2.9.0",
-		"mupdf": "^1.28.0",
 		"puppeteer-core": "25.3.0"
 	},
 	"optionalDependencies": {

package/scripts/build-binary.ts

@@ -88,7 +88,6 @@ async function main(): Promise<void> {
 			["bun", "--cwd=../natives", "run", "gen:native"],
 			crossBuild ? { ...Bun.env, TARGET_PLATFORM: crossBuild.platform, TARGET_ARCH: crossBuild.arch } : Bun.env,
 		);
-		await runCommand(["bun", "run", "gen:mupdf"]);
 		try {
 			await compileCodingAgent({
 				repoRoot,
@@ -104,7 +103,6 @@ async function main(): Promise<void> {
 				await runCommand(["codesign", "--force", "--sign", "-", outputPath]);
 			}
 		} finally {
-			await runCommand(["bun", "run", "gen:mupdf:reset"]);
 			await runCommand(["bun", "--cwd=../natives", "run", "gen:native:reset"]);
 		}
 	} finally {

package/scripts/bundle-dist.ts

@@ -15,7 +15,6 @@ const legacyHtmlExportAssetPattern = /^(?:template-[^.]+\.(?:css|html|js)|tool-v
 // `omp-legacy-pi-modules` exists only in compiled binaries via the build plugin;
 // the npm bundle never executes that `isCompiledBinary()` branch.
 const ALWAYS_EXTERNAL = [
-	"mupdf",
 	"@oh-my-pi/pi-natives",
 	"@huggingface/transformers",
 	"fastembed",

package/src/cli/read-cli.ts

@@ -10,6 +10,7 @@ import chalk from "@oh-my-pi/pi-utils/chalk";
 import { Settings } from "../config/settings";
 import { extractUriScheme } from "../internal-urls/parse";
 import { InternalUrlRouter } from "../internal-urls/router";
+import { closeDaemonClients } from "../launch/client";
 import { discoverAndLoadMCPTools } from "../mcp/loader";
 import { MCPManager } from "../mcp/manager";
 import { discoverAuthStorage } from "../session/auth-broker-config";
@@ -93,6 +94,7 @@ export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
 			if (MCPManager.instance() === mcpManager) MCPManager.setInstance(undefined);
 		}
 		authStorage?.close();
+		await closeDaemonClients();
 	}
 
 	if (failed) process.exit(1);

package/src/markit/NOTICE

@@ -1,15 +1,15 @@
-This directory contains an in-house document-to-markdown engine adapted from
+Portions of this in-house document-to-markdown engine are adapted from
 markit-ai (https://github.com/Michaelliv/markit), used under the MIT License.
+This attribution covers the shared registry/types and the DOCX, PPTX, XLSX,
+and EPUB converters. The PDF converter is implemented separately and is not
+derived from markit-ai.
 
   Copyright (c) 2026 Michael Liv
 
-Only the converters for the document formats omp supports are ported (pdf,
-docx, pptx, xlsx, epub); the CLI, plugin/provider, and unused converters
-(html, image, audio, plain-text, rss, github, wikipedia, csv, json, yaml,
-ipynb, iwork, zip, xml) were dropped. Legacy binary `.doc`/`.ppt`/`.xls` and
-`.rtf` are routed by the read/fetch tools but have no converter — they surface
-a conversion error, exactly as upstream markit did. Logic is ported faithfully
-so conversion output matches the upstream package.
+The CLI, plugin/provider, and unused converters (html, image, audio,
+plain-text, rss, github, wikipedia, csv, json, yaml, ipynb, iwork, zip, xml)
+were dropped. Legacy binary `.doc`/`.ppt`/`.xls` and `.rtf` have no converter
+and surface a conversion error.
 
 MIT License
 

package/src/markit/converters/pdf/index.ts

@@ -1,48 +1,10 @@
-// Adapted from markit-ai (MIT). See ../../NOTICE.
-
-/**
- * PDF to Markdown converter.
- *
- * Uses mupdf (native WASM) for fast PDF parsing and a custom pipeline for
- * table detection via vector line extraction + raycasting.
- *
- * Pipeline:
- *   1. Extract text boxes + vector segments + image regions per page (mupdf)
- *   2. Detect column layout (single vs multi-column)
- *   3. Per column: detect table grids from segments (grid detection + raycasting)
- *   4. Render diagrams as PNG files (if output directory provided)
- *   5. Render tables as markdown tables, free text as paragraphs/headings
- */
-import * as path from "node:path";
+import { pdfToMarkdown } from "@oh-my-pi/pi-natives";
 import type { ConversionResult, Converter, StreamInfo } from "../../types";
-import { detectColumns } from "./columns";
-import { extractPages, renderImageRegion } from "./extract";
-import { resolveTableGrids } from "./grid";
-import { stripHeadersFooters } from "./headers";
-import { renderPageContent } from "./render";
-import type { Segment, TextBox } from "./types";
 
 const EXTENSIONS = [".pdf"];
 const MIMETYPES = ["application/pdf", "application/x-pdf"];
 
-type ImageBlock = { topY: number; markdown: string };
-
-/**
- * Process a set of text boxes (one column or full page): run table detection,
- * separate free text, and render to markdown.
- */
-function processColumn(
-	pageNumber: number,
-	textBoxes: TextBox[],
-	segments: Segment[],
-	imageBlocks: ImageBlock[],
-): string {
-	const { grids, consumedIds } = resolveTableGrids(pageNumber, textBoxes, segments);
-	const consumedSet = new Set(consumedIds);
-	const freeTextBoxes = textBoxes.filter(tb => !consumedSet.has(tb.id));
-	return renderPageContent(freeTextBoxes, grids, imageBlocks, textBoxes);
-}
-
+/** Converts PDF buffers to Markdown through the native `pdf-inspector` bridge. */
 export class PdfConverter implements Converter {
 	name = "pdf";
 
@@ -56,91 +18,17 @@ export class PdfConverter implements Converter {
 		return false;
 	}
 
-	async convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult> {
-		const pdfBytes = new Uint8Array(input);
-		const pages = await extractPages(pdfBytes);
-		// Remove running headers/footers before processing.
-		stripHeadersFooters(pages);
-		const imageDir = streamInfo.imageDir;
-
-		const pageMarkdowns: string[] = [];
-		for (const page of pages) {
-			// Build image blocks for this page.
-			const imageBlocks: ImageBlock[] = [];
-			if (imageDir && page.images.length > 0) {
-				for (const img of page.images) {
-					const filename = `${img.id}.png`;
-					const filepath = path.join(imageDir, filename);
-					try {
-						const png = await renderImageRegion(pdfBytes, img);
-						await Bun.write(filepath, png);
-						imageBlocks.push({ topY: img.topY, markdown: `![${img.id}](${filepath})` });
-					} catch {
-						// Image rendering failed — skip.
-					}
-				}
-			} else if (page.images.length > 0) {
-				for (const img of page.images) {
-					imageBlocks.push({
-						topY: img.topY,
-						markdown: `<!-- image: ${img.id} (page ${img.pageNumber}, ${img.bbox.w}x${img.bbox.h}pt) -->`,
-					});
-				}
-			}
-
-			// Detect column layout.
-			// If the page has vertical segments (tables), suppress column detection
-			// when one detected column is very narrow — that's a table's first column,
-			// not a page layout column.
-			const layout = detectColumns(page.textBoxes);
-			if (layout.columnCount > 1 && page.segments.some(s => Math.abs(s.x1 - s.x2) <= 0.8)) {
-				const pageXMin = Math.min(...page.textBoxes.map(tb => tb.bounds.left));
-				const pageXMax = Math.max(...page.textBoxes.map(tb => tb.bounds.right));
-				const pageWidth = pageXMax - pageXMin;
-				const minColFraction = 0.3;
-				const tooNarrow = layout.columns.some(col => {
-					const colXMin = Math.min(...col.map(tb => tb.bounds.left));
-					const colXMax = Math.max(...col.map(tb => tb.bounds.right));
-					return (colXMax - colXMin) / pageWidth < minColFraction;
-				});
-				if (tooNarrow) {
-					layout.columnCount = 1;
-					layout.columns = [page.textBoxes];
-					layout.boundaries = [];
-				}
-			}
-
-			if (layout.columnCount === 1) {
-				// Single column — process normally.
-				const md = processColumn(page.pageNumber, page.textBoxes, page.segments, imageBlocks);
-				if (md.length > 0) pageMarkdowns.push(md);
-			} else {
-				// Multi-column — process each column independently, then join.
-				const columnMarkdowns: string[] = [];
-				for (const colBoxes of layout.columns) {
-					// Filter segments to those within this column's X range.
-					const colXMin = Math.min(...colBoxes.map(tb => tb.bounds.left));
-					const colXMax = Math.max(...colBoxes.map(tb => tb.bounds.right));
-					const margin = 10;
-					const colSegments = page.segments.filter(seg => {
-						const segXMin = Math.min(seg.x1, seg.x2);
-						const segXMax = Math.max(seg.x1, seg.x2);
-						return segXMax >= colXMin - margin && segXMin <= colXMax + margin;
-					});
-					// Images go with the first column only (no X info to split by).
-					const md = processColumn(
-						page.pageNumber,
-						colBoxes,
-						colSegments,
-						columnMarkdowns.length === 0 ? imageBlocks : [],
-					);
-					if (md.length > 0) columnMarkdowns.push(md);
-				}
-				const joined = columnMarkdowns.join("\n\n");
-				if (joined.length > 0) pageMarkdowns.push(joined);
-			}
-		}
-
-		return { markdown: pageMarkdowns.join("\n\n") };
+	async convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult> {
+		const result = await pdfToMarkdown(input);
+		const notice =
+			result.pagesNeedingOcr.length > 0
+				? `Text extraction is incomplete for PDF pages ${result.pagesNeedingOcr.join(", ")}. Use the browser tool to render those pages or OCR them.`
+				: undefined;
+
+		const conversion: ConversionResult = {
+			markdown: notice ? [result.markdown, notice].filter(Boolean).join("\n\n") : result.markdown,
+		};
+		if (result.title !== undefined) conversion.title = result.title;
+		return conversion;
 	}
 }

package/src/mcp/client.ts

@@ -92,7 +92,7 @@ async function initializeConnection(
 	transport: MCPTransport,
 	options?: {
 		signal?: AbortSignal;
-		/** Called after the initialize response (which sets the session ID) but before notifications/initialized. */
+		/** Called after notifications/initialized succeeds. */
 		onInitialized?: () => void | Promise<void>;
 	},
 ): Promise<MCPInitializeResult> {
@@ -119,14 +119,13 @@ async function initializeConnection(
 	// initialize; transports that don't need it ignore this.
 	transport.setProtocolVersion?.(result.protocolVersion);
 
-	// Hook point: the transport now has the session ID from the initialize response.
-	// For HTTP, this is the moment to open the SSE stream so server-to-client requests
-	// triggered by notifications/initialized (e.g. roots/list) can be delivered.
-	await options?.onInitialized?.();
-
-	// Send initialized notification
+	// Send initialized before opening the optional GET SSE stream. Servers may
+	// reject or terminate sessions that receive session traffic before this
+	// notification; POST response streams already carry messages during setup.
 	await transport.notify("notifications/initialized");
 
+	await options?.onInitialized?.();
+
 	return result;
 }
 
@@ -162,8 +161,8 @@ export async function connectToServer(
 			const initResult = await initializeConnection(transport, {
 				signal: options?.signal,
 				async onInitialized() {
-					// Open the SSE stream before sending initialized, so server-to-client
-					// requests triggered by on_initialized (e.g. roots/list) are delivered.
+					// Open the optional GET SSE stream only after the initialized
+					// notification makes the session ready for further traffic.
 					if ("startSSEListener" in transport! && typeof transport!.startSSEListener === "function") {
 						await (transport as { startSSEListener(): Promise<void> }).startSSEListener();
 					}

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

@@ -141,6 +141,8 @@ export class EventController {
 	// restored when the banner clears at the next `agent_start` (see
 	// #handleMessageEnd / #handleAgentStart).
 	#pinnedErrorComponent: AssistantMessageComponent | undefined = undefined;
+	#pinnedErrorMessage: AssistantMessage | undefined = undefined;
+	#restorePinnedErrorInline = true;
 	#retrySupersededAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#retrySupersededAssistantQueue: AssistantMessageComponent[] = [];
 	// Set when `auto_retry_start` fires and cleared by `auto_retry_end` (both
@@ -650,6 +652,8 @@ export class EventController {
 		this.#readToolCallAssistantComponents.clear();
 		this.#lastAssistantComponent = undefined;
 		this.#pinnedErrorComponent = undefined;
+		this.#pinnedErrorMessage = undefined;
+		this.#restorePinnedErrorInline = true;
 		this.#retryPending = this.ctx.viewSession.isRetrying;
 		this.#cancelIdleCompaction();
 		this.#cancelIdleRecap();
@@ -743,10 +747,13 @@ export class EventController {
 		this.#resetReadGroup();
 		this.#resolveDisplaceableTodo();
 		this.#lastAssistantComponent = undefined;
-		// Restore the previous turn's inline error in the transcript before dropping
-		// the banner, so the error stays in history once the banner is gone.
-		this.#pinnedErrorComponent?.setErrorPinned(false);
+		// Restore terminal errors in transcript history when their banner clears.
+		// Recoverable empty-output attempts are discarded by session recovery and
+		// must stay hidden rather than resurfacing as a stale inline error.
+		if (this.#restorePinnedErrorInline) this.#pinnedErrorComponent?.setErrorPinned(false);
 		this.#pinnedErrorComponent = undefined;
+		this.#pinnedErrorMessage = undefined;
+		this.#restorePinnedErrorInline = true;
 		this.ctx.clearPinnedError();
 		if (this.ctx.retryLoader) {
 			this.ctx.retryLoader.stop();
@@ -1320,14 +1327,20 @@ export class EventController {
 			}
 			this.ctx.streamingComponent = undefined;
 			this.ctx.streamingMessage = undefined;
-			// Pin a turn-ending provider error (e.g. Anthropic content-filter block)
-			// above the editor so it survives transcript scroll. Cleared at the next
-			// turn's agent_start. Suppress the transcript's inline `Error: …` line for
-			// the same message while pinned so the error isn't rendered twice.
+			// Pin a turn-ending provider error above the editor so it survives
+			// transcript scroll and suppress its duplicate inline row. Empty-output
+			// errors are known intermediate attempts: hide them entirely while
+			// session recovery continues, but retain the component so a terminal
+			// retry-cap event can promote its final error into the one banner.
 			if (event.message.stopReason === "error" && event.message.errorMessage && !isSilentAbort(event.message)) {
+				const recoverableEmptyOutput =
+					!event.message.errorMessage.startsWith("Retry budget exhausted") &&
+					AIError.is(AIError.classifyMessage(event.message), AIError.Flag.EmptyResponse);
 				this.#lastAssistantComponent?.setErrorPinned(true);
 				this.#pinnedErrorComponent = this.#lastAssistantComponent;
-				this.ctx.showPinnedError(event.message.errorMessage);
+				this.#pinnedErrorMessage = event.message;
+				this.#restorePinnedErrorInline = !recoverableEmptyOutput;
+				if (!recoverableEmptyOutput) this.ctx.showPinnedError(event.message.errorMessage);
 			}
 			this.ctx.statusLine.invalidate();
 			this.ctx.ui.requestRender();
@@ -1947,6 +1960,8 @@ export class EventController {
 			// restore its inline Error row; just unpin the fixed-region banner so the
 			// retry UI is the visible state.
 			this.#pinnedErrorComponent = undefined;
+			this.#pinnedErrorMessage = undefined;
+			this.#restorePinnedErrorInline = true;
 			this.ctx.clearPinnedError();
 		}
 		const delaySeconds = Math.round(event.delayMs / 1000);
@@ -1968,20 +1983,51 @@ export class EventController {
 			this.ctx.retryLoader = undefined;
 			this.ctx.statusContainer.disposeChildren();
 		}
+		const pinnedError = this.#pinnedErrorMessage?.errorMessage;
+		const terminalFailurePinned =
+			!event.success &&
+			this.#pinnedErrorComponent !== undefined &&
+			pinnedError !== undefined &&
+			pinnedError === event.finalError;
+		let stalePinnedErrorCleared = false;
+		if (!event.success && this.#pinnedErrorComponent && !terminalFailurePinned) {
+			this.#pinnedErrorComponent.setErrorPinned(false);
+			this.#pinnedErrorComponent = undefined;
+			this.#pinnedErrorMessage = undefined;
+			this.#restorePinnedErrorInline = true;
+			this.ctx.clearPinnedError();
+			stalePinnedErrorCleared = true;
+		}
 		let appliedRetryUpdate = false;
 		for (const retryError of event.retryErrors ?? []) {
 			const component = this.#takeRetrySupersededAssistantComponent(retryError.persistenceKey);
 			if (!component) continue;
 			component.applyRetryRecovery(retryError.retryRecovery);
-			if (this.#pinnedErrorComponent === component) this.#pinnedErrorComponent = undefined;
+			if (!terminalFailurePinned && this.#pinnedErrorComponent === component) {
+				this.#pinnedErrorComponent = undefined;
+				this.#pinnedErrorMessage = undefined;
+				this.#restorePinnedErrorInline = true;
+			}
 			appliedRetryUpdate = true;
 		}
-		if (appliedRetryUpdate || (event.retryErrors?.length ?? 0) > 0) {
+		if (
+			!terminalFailurePinned &&
+			!stalePinnedErrorCleared &&
+			(appliedRetryUpdate || (event.retryErrors?.length ?? 0) > 0)
+		) {
 			this.ctx.clearPinnedError();
 		}
 		this.#clearRetrySupersededAssistantComponents();
 		if (!event.success) {
-			this.ctx.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
+			if (terminalFailurePinned) {
+				const terminalError = this.#restorePinnedErrorInline
+					? `Retry failed after ${event.attempt} attempts: ${event.finalError || pinnedError || "Unknown error"}`
+					: (pinnedError ?? event.finalError);
+				if (terminalError) this.ctx.showPinnedError(terminalError);
+				this.#restorePinnedErrorInline = true;
+			} else {
+				this.ctx.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
+			}
 		}
 		this.#ensureWorkingLoaderWhileStreaming();
 		this.ctx.ui.requestRender();

package/src/modes/rpc/rpc-client.ts

@@ -353,6 +353,13 @@ export class RpcClient {
 			// failures are reaped by the readyPromise catch below; established
 			// workers are reaped here so pending requests cannot hang indefinitely.
 			if (!readySettled) {
+				// Stdout can close before the exit reaper finishes draining stderr.
+				// child.exited settles only after the stderr tail is complete (for
+				// nonzero exits), so give it a bounded head start: the exit watcher
+				// below was registered first and rejects with the real stderr text
+				// instead of an empty "Stderr:" (flaked under full-suite load).
+				await Promise.race([child.exited.catch(() => {}), Bun.sleep(250)]);
+				if (readySettled) return;
 				readySettled = true;
 				readyReject(new Error(`Agent output stream ended before ready. Stderr: ${child.peekStderr()}`));
 				return;

package/src/modes/utils/hotkeys-markdown.ts

@@ -39,7 +39,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		"| `Tab` | Path completion / accept autocomplete |",
 		`| \`${appKey(bindings, "app.interrupt")}\` | Cancel autocomplete / interrupt active work |`,
 		`| \`${appKey(bindings, "app.clear")}\` | Clear editor (first) / exit (second) |`,
-		`| \`${appKey(bindings, "app.exit")}\` | Exit (when editor is empty) |`,
+		`| \`${appKey(bindings, "app.exit")}\` | Exit (saves current prompt as draft) |`,
 		`| \`${appKey(bindings, "app.suspend")}\` | Suspend to background |`,
 		`| \`${appKey(bindings, "app.display.reset")}\` | Reset terminal display |`,
 		`| \`${appKey(bindings, "app.thinking.cycle")}\` | Cycle thinking level |`,

package/src/prompts/system/empty-stop-retry.md

@@ -1,4 +1,4 @@
 <system-injection>
-Stopped; task incomplete. Continue.
+Stopped without actionable output; task incomplete. Continue with a user-visible final answer or the next required tool call.
 Attempt #{{retryCount}}/{{maxRetries}}
 </system-injection>

package/src/session/agent-session.ts

@@ -2854,11 +2854,18 @@ export class AgentSession {
 			// tool_result and corrupts message history. The handler also
 			// schedules its own retry, so a real empty stop never needs the
 			// active-goal threshold pre-empt below.
-			if (await this.#recovery.handleEmptyAssistantStop(msg)) {
+			const emptyOutputRecovery = await this.#recovery.handleEmptyAssistantStop(msg);
+			if (emptyOutputRecovery === "continue") {
 				maintenanceRoute("empty-stop-handled");
 				await emitAgentEndNotification({ willContinue: true });
 				return;
 			}
+			if (emptyOutputRecovery === "terminal") {
+				// The cap already closed retry state and made provider-empty errors
+				// non-retryable. Continue through terminal maintenance so session_stop
+				// hooks and queued follow-up handling retain their normal contract.
+				maintenanceRoute("empty-stop-retry-cap");
+			}
 
 			// Record quota exhaustion before deciding whether this failed turn may be
 			// replayed. Visible/side-effecting output then remains terminal while its