@oh-my-pi/pi-coding-agent 14.6.4 → 14.6.6

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [14.6.6] - 2026-05-04
+
+### Added
+
+- Added Ctrl+D draft persistence: pressing Ctrl+D with text in the editor now exits the app and saves the unsent text as a per-session draft. Resuming the same session (e.g. via `--resume`) restores the draft into the editor (one-shot, removed after restore).
+
 ## [14.6.4] - 2026-05-03
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.6.4",
+	"version": "14.6.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.6.4",
-		"@oh-my-pi/pi-agent-core": "14.6.4",
-		"@oh-my-pi/pi-ai": "14.6.4",
-		"@oh-my-pi/pi-natives": "14.6.4",
-		"@oh-my-pi/pi-tui": "14.6.4",
-		"@oh-my-pi/pi-utils": "14.6.4",
+		"@oh-my-pi/omp-stats": "14.6.6",
+		"@oh-my-pi/pi-agent-core": "14.6.6",
+		"@oh-my-pi/pi-ai": "14.6.6",
+		"@oh-my-pi/pi-natives": "14.6.6",
+		"@oh-my-pi/pi-tui": "14.6.6",
+		"@oh-my-pi/pi-utils": "14.6.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",

package/src/edit/modes/hashline.ts

@@ -1486,7 +1486,9 @@ async function executeHashlineSection(
 export async function executeHashlineSingle(
 	options: ExecuteHashlineSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
-	const sections = splitHashlineInputs(options.input, { cwd: options.session.cwd, path: options.path });
+	const sections = mergeSamePathSections(
+		splitHashlineInputs(options.input, { cwd: options.session.cwd, path: options.path }),
+	);
 
 	// Fast path: a single section needs no preflight pass.
 	if (sections.length === 1) return executeHashlineSection({ ...options, ...sections[0] });
@@ -1518,3 +1520,20 @@ export async function executeHashlineSingle(
 		},
 	};
 }
+
+/**
+ * Collapse consecutive or interleaved sections targeting the same path into a
+ * single section with concatenated diffs. Anchors authored against the same
+ * file snapshot must be applied as one batch; otherwise the first sub-edit
+ * shifts line numbers out from under the second's anchors and rebase fails.
+ * Path order is preserved by first occurrence.
+ */
+function mergeSamePathSections(sections: HashlineInputSection[]): HashlineInputSection[] {
+	const byPath = new Map<string, string[]>();
+	for (const section of sections) {
+		const existing = byPath.get(section.path);
+		if (existing) existing.push(section.diff);
+		else byPath.set(section.path, [section.diff]);
+	}
+	return Array.from(byPath, ([path, diffs]) => ({ path, diff: diffs.join("\n") }));
+}

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

@@ -197,12 +197,11 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		// Intercept configured exit shortcut (only when editor is empty)
+		// Intercept configured exit shortcut. Always consume the shortcut so it
+		// never reaches the parent handler; firing onExit is the controller's
+		// chance to snapshot the current text as a draft before shutting down.
 		if (this.#matchesAction(data, "app.exit")) {
-			if (this.getText().length === 0 && this.onExit) {
-				this.onExit();
-			}
-			// Always consume exit shortcut (don't pass to parent)
+			this.onExit?.();
 			return;
 		}
 

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

@@ -344,8 +344,11 @@ export class InputController {
 				// (a user-role `message_start` event) leaves any draft the user has
 				// typed since queuing intact. Same protection as #783, applied to
 				// the streaming/queue path.
-				this.ctx.locallySubmittedUserSignatures.add(`${text}\u0000${images?.length ?? 0}`);
-				await this.ctx.session.prompt(text, { streamingBehavior: "steer", images });
+				await this.ctx.withLocalSubmission(
+					text,
+					() => this.ctx.session.prompt(text, { streamingBehavior: "steer", images }),
+					{ imageCount: images?.length ?? 0 },
+				);
 				this.ctx.updatePendingMessagesDisplay();
 				this.ctx.ui.requestRender();
 				return;
@@ -400,7 +403,9 @@ export class InputController {
 	}
 
 	handleCtrlD(): void {
-		// Only called when editor is empty (enforced by CustomEditor)
+		// Editor text (if any) is snapshotted at the start of shutdown() and
+		// persisted as a draft for the next resume. Empty text is also fine —
+		// shutdown clears any stale sidecar in that case.
 		void this.ctx.shutdown();
 	}
 
@@ -440,7 +445,9 @@ export class InputController {
 		if (this.ctx.session.isStreaming) {
 			this.ctx.editor.addToHistory(text);
 			this.ctx.editor.setText("");
-			await this.ctx.session.prompt(text, { streamingBehavior: "followUp" });
+			await this.ctx.withLocalSubmission(text, () =>
+				this.ctx.session.prompt(text, { streamingBehavior: "followUp" }),
+			);
 			this.ctx.updatePendingMessagesDisplay();
 			this.ctx.ui.requestRender();
 			return;
@@ -449,7 +456,7 @@ export class InputController {
 		// Not streaming — just submit normally
 		this.ctx.editor.addToHistory(text);
 		this.ctx.editor.setText("");
-		await this.ctx.session.prompt(text);
+		await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text));
 	}
 
 	restoreQueuedMessagesToEditor(options?: { abort?: boolean; currentText?: string }): number {

package/src/modes/interactive-mode.ts

@@ -183,6 +183,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	optimisticUserMessageSignature: string | undefined = undefined;
 	locallySubmittedUserSignatures: Set<string> = new Set();
 	#pendingSubmittedInput: SubmittedUserInput | undefined;
+	#pendingSubmissionDispose: (() => void) | undefined;
 	lastSigintTime = 0;
 	lastEscapeTime = 0;
 	shutdownRequested = false;
@@ -444,6 +445,20 @@ export class InteractiveMode implements InteractiveModeContext {
 		// Restore mode from session (e.g. plan mode on resume)
 		await this.#restoreModeFromSession();
 
+		// Restore unsent editor draft from previous session shutdown (Ctrl+D).
+		// One-shot: consumeDraft removes the sidecar after read so the next
+		// resume does not re-restore the same text.
+		try {
+			const draft = await this.sessionManager.consumeDraft();
+			if (draft && !this.editor.getText()) {
+				this.editor.setText(draft);
+				this.updateEditorBorderColor();
+				this.ui.requestRender();
+			}
+		} catch (err) {
+			logger.warn("Failed to restore session draft", { error: String(err) });
+		}
+
 		// Subscribe to agent events
 		this.#subscribeToAgent();
 
@@ -567,6 +582,30 @@ export class InteractiveMode implements InteractiveModeContext {
 		);
 	}
 
+	recordLocalSubmission(text: string, imageCount = 0): () => void {
+		if (this.isKnownSlashCommand(text)) {
+			return () => {};
+		}
+		const signature = `${text}\u0000${imageCount}`;
+		this.locallySubmittedUserSignatures.add(signature);
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			this.locallySubmittedUserSignatures.delete(signature);
+		};
+	}
+
+	async withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: { imageCount?: number }): Promise<T> {
+		const dispose = this.recordLocalSubmission(text, options?.imageCount ?? 0);
+		try {
+			return await fn();
+		} catch (err) {
+			dispose();
+			throw err;
+		}
+	}
+
 	startPendingSubmission(input: { text: string; images?: ImageContent[] }): SubmittedUserInput {
 		const submission: SubmittedUserInput = {
 			text: input.text,
@@ -575,8 +614,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			started: false,
 		};
 		this.#pendingSubmittedInput = submission;
-		this.optimisticUserMessageSignature = `${submission.text}\u0000${submission.images?.length ?? 0}`;
-		this.locallySubmittedUserSignatures.add(this.optimisticUserMessageSignature);
+		const imageCount = submission.images?.length ?? 0;
+		this.optimisticUserMessageSignature = `${submission.text}\u0000${imageCount}`;
+		this.#pendingSubmissionDispose = this.recordLocalSubmission(submission.text, imageCount);
 		this.addMessageToChat({
 			role: "user",
 			content: [{ type: "text", text: submission.text }, ...(submission.images ?? [])],
@@ -598,7 +638,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		submission.cancelled = true;
 		this.#pendingSubmittedInput = undefined;
 		this.optimisticUserMessageSignature = undefined;
-		this.locallySubmittedUserSignatures.delete(`${submission.text}\u0000${submission.images?.length ?? 0}`);
+		this.#pendingSubmissionDispose?.();
+		this.#pendingSubmissionDispose = undefined;
 		this.#pendingWorkingMessage = undefined;
 		if (this.loadingAnimation) {
 			this.loadingAnimation.stop();
@@ -624,6 +665,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	finishPendingSubmission(input: SubmittedUserInput): void {
 		if (this.#pendingSubmittedInput === input) {
 			this.#pendingSubmittedInput = undefined;
+			this.#pendingSubmissionDispose = undefined;
 		}
 	}
 
@@ -1161,8 +1203,18 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (this.#isShuttingDown) return;
 		this.#isShuttingDown = true;
 
+		// Snapshot the editor before any teardown empties it. Persisting the draft
+		// here covers Ctrl+D shutdown with non-empty text; for /exit the editor is
+		// already cleared so saveDraft("") just removes any stale sidecar.
+		const draftText = this.editor.getText();
+
 		// Flush pending session writes before shutdown
 		await this.sessionManager.flush();
+		try {
+			await this.sessionManager.saveDraft(draftText);
+		} catch (err) {
+			logger.warn("Failed to save session draft", { error: String(err) });
+		}
 		this.#btwController.dispose();
 
 		// Emit shutdown event to hooks
@@ -1223,6 +1275,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	showError(message: string): void {
 		this.#pendingSubmittedInput = undefined;
 		this.optimisticUserMessageSignature = undefined;
+		this.#pendingSubmissionDispose?.();
+		this.#pendingSubmissionDispose = undefined;
 		this.#pendingWorkingMessage = undefined;
 		if (this.loadingAnimation) {
 			this.loadingAnimation.stop();

package/src/modes/types.ts

@@ -151,6 +151,19 @@ export interface InteractiveModeContext {
 	cancelPendingSubmission(): boolean;
 	markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
 	finishPendingSubmission(input: SubmittedUserInput): void;
+	/**
+	 * Marks a locally-initiated user submission so the eventual `message_start`
+	 * event for that user message does not clobber the editor draft (see #783).
+	 * Returns a dispose function that removes the signature; call it on
+	 * delivery failure so a retry can be re-marked cleanly.
+	 */
+	recordLocalSubmission(text: string, imageCount?: number): () => void;
+	/**
+	 * Wraps `fn` in a `recordLocalSubmission` marker that is automatically
+	 * removed if `fn` rejects. Use this for the common case where a thrown
+	 * delivery error should leave the signature set untouched.
+	 */
+	withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: { imageCount?: number }): Promise<T>;
 	isKnownSlashCommand(text: string): boolean;
 	addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): void;
 	renderSessionContext(

package/src/modes/utils/ui-helpers.ts

@@ -534,6 +534,16 @@ export class UiHelpers {
 		this.ctx.showStatus("Queued message for after compaction");
 	}
 
+	async #deliverQueuedMessage(message: CompactionQueuedMessage): Promise<void> {
+		if (this.ctx.isKnownSlashCommand(message.text)) {
+			await this.ctx.session.prompt(message.text);
+			return;
+		}
+		await this.ctx.withLocalSubmission(message.text, () =>
+			message.mode === "followUp" ? this.ctx.session.followUp(message.text) : this.ctx.session.steer(message.text),
+		);
+	}
+
 	isKnownSlashCommand(text: string): boolean {
 		if (!text.startsWith("/")) return false;
 		const spaceIndex = text.indexOf(" ");
@@ -576,13 +586,7 @@ export class UiHelpers {
 		try {
 			if (options?.willRetry) {
 				for (const message of queuedMessages) {
-					if (this.ctx.isKnownSlashCommand(message.text)) {
-						await this.ctx.session.prompt(message.text);
-					} else if (message.mode === "followUp") {
-						await this.ctx.session.followUp(message.text);
-					} else {
-						await this.ctx.session.steer(message.text);
-					}
+					await this.#deliverQueuedMessage(message);
 				}
 				this.ctx.updatePendingMessagesDisplay();
 				return;
@@ -607,7 +611,10 @@ export class UiHelpers {
 			const rest = queuedMessages.slice(firstPromptIndex + 1);
 
 			for (const message of preCommands) {
-				await this.ctx.session.prompt(message.text);
+				// preCommands are all slash commands; #deliverQueuedMessage handles
+				// that branch (no local-submission marking needed since slash
+				// commands don't generate a matching user message_start).
+				await this.#deliverQueuedMessage(message);
 			}
 
 			// Pass streamingBehavior so that if the session is still streaming when
@@ -619,22 +626,22 @@ export class UiHelpers {
 			// deferred, the message lands in the same queue every other consumer
 			// (Alt+Up dequeue, post-stream drain) already drains, instead of being
 			// stranded in compactionQueuedMessages with no drainer.
+			//
+			// firstPrompt is fire-and-forget — its rejection is funneled through
+			// `restoreQueue` rather than rethrown, so we use the primitive
+			// recordLocalSubmission and dispose manually in the catch.
+			const disposeFirstPrompt = this.ctx.recordLocalSubmission(firstPrompt.text);
 			const promptPromise = this.ctx.session
 				.prompt(firstPrompt.text, {
 					streamingBehavior: firstPrompt.mode === "followUp" ? "followUp" : "steer",
 				})
 				.catch((error: unknown) => {
+					disposeFirstPrompt();
 					restoreQueue(error);
 				});
 
 			for (const message of rest) {
-				if (this.ctx.isKnownSlashCommand(message.text)) {
-					await this.ctx.session.prompt(message.text);
-				} else if (message.mode === "followUp") {
-					await this.ctx.session.followUp(message.text);
-				} else {
-					await this.ctx.session.steer(message.text);
-				}
+				await this.#deliverQueuedMessage(message);
 			}
 			this.ctx.updatePendingMessagesDisplay();
 			void promptPromise;

package/src/prompts/tools/hashline.md

@@ -8,8 +8,8 @@ This format is purely textual. The tool has NO awareness of language, indentatio
 
 <ops>
 @PATH            header: subsequent ops apply to PATH
-< ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows as `{{hsep}}TEXT` lines
 + ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows as `{{hsep}}TEXT` lines
+< ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows as `{{hsep}}TEXT` lines
 - A..B           delete the line range (inclusive); `- A` for one line
 = A..B           replace the range with payload `{{hsep}}TEXT` lines, or with one blank line if no payload follows
 </ops>
@@ -20,6 +20,7 @@ This format is purely textual. The tool has NO awareness of language, indentatio
 - `< A` inserts before line A; `+ A` inserts after line A. `< BOF` / `+ BOF` both prepend; `< EOF` / `+ EOF` both append.
 - `= A..B` replaces the inclusive range with the following payload lines. `= A` (or `= A..B`) with no payload blanks the range to a single empty line.
 - `- A..B` deletes the inclusive range; omit `..B` for one line.
+- Pick the smallest op for the change: pure addition → `+`/`<`; pure deletion → `-`; `= A..B` ONLY when content inside `A..B` is actually being modified or removed.
 </rules>
 
 <case file="a.ts">
@@ -39,11 +40,9 @@ This format is purely textual. The tool has NO awareness of language, indentatio
 
 # Replace a contiguous range with multiple lines
 @a.ts
-= {{hrefr 3}}..{{hrefr 6}}
-{{hsep}}export function label(name: string): string {
+= {{hrefr 4}}..{{hrefr 5}}
 {{hsep}}	const clean = (name || DEF).trim();
 {{hsep}}	return clean.length === 0 ? DEF : clean.toUpperCase();
-{{hsep}}}
 
 # Insert BEFORE a line
 @a.ts
@@ -73,11 +72,30 @@ This format is purely textual. The tool has NO awareness of language, indentatio
 = {{hrefr 2}}
 </examples>
 
+<anti-pattern>
+# WRONG — replaces 6 lines just to add one. Use `+` at the boundary instead.
+@a.ts
+= {{hrefr 1}}..{{hrefr 6}}
+{{hsep}}const DEF = "guest";
+{{hsep}}const DEBUG = false;
+{{hsep}}
+{{hsep}}export function label(name) {
+{{hsep}}	const clean = name || DEF;
+{{hsep}}	return clean.trim();
+{{hsep}}}
+
+# RIGHT — same effect, one-line insert
+@a.ts
++ {{hrefr 1}}
+{{hsep}}const DEBUG = false;
+
+If your replacement payload would render with even one unchanged line in the diff, you have the wrong op or the wrong range. Stop and rewrite as `+`/`<`/`-` plus a narrower `=`.
+</anti-pattern>
+
 <critical>
 - Always copy anchors exactly from tool output, but **NEVER** include line content after the `{{hsep}}` separator in the op line.
-- Only emit changed lines. Do not restate unchanged context as payload.
 - Every inserted/replacement content line **MUST** start with `{{hsep}}`; raw content lines are invalid.
 - Do not write unified diff syntax (`@@`, `-OLD`, `+NEW`).
-- To replace a block, use one `= A..B` op followed by all replacement `{{hsep}}TEXT` payload lines.
 - `= A..B` deletes the range; payload is what's written. If a payload edge line already exists immediately outside `A..B`, widen the range to cover it — otherwise it duplicates.
+- Multiple ops in one patch are cheap. Prefer two narrow ops over one wide `=`.
 </critical>

package/src/session/session-manager.ts

@@ -2182,6 +2182,63 @@ export class SessionManager {
 		return manager.getPath(id);
 	}
 
+	/**
+	 * Path to the unsent-input draft sidecar for the current session. Lives inside
+	 * the artifacts directory so it is removed together with the session on
+	 * `dropSession`. Returns null when the session has no on-disk identity.
+	 */
+	#getDraftPath(): string | null {
+		const dir = this.getArtifactsDir();
+		return dir ? path.join(dir, "draft.txt") : null;
+	}
+
+	/**
+	 * Persist (or clear) the current editor draft so the next resume of this
+	 * session can restore it. Empty text deletes any stale draft. No-op when the
+	 * session is not persisted.
+	 */
+	async saveDraft(text: string): Promise<void> {
+		const draftPath = this.#getDraftPath();
+		if (!draftPath || !this.persist) return;
+		if (text.length === 0) {
+			try {
+				await this.storage.unlink(draftPath);
+			} catch (err) {
+				if (!isEnoent(err)) throw err;
+			}
+			return;
+		}
+		// Force the session header onto disk so resume can find the file we are
+		// attaching this draft to. Without this, a session whose first message
+		// never produced an assistant reply would persist a draft next to a
+		// session file that does not exist on disk.
+		await this.ensureOnDisk();
+		await this.storage.writeText(draftPath, text);
+	}
+
+	/**
+	 * Read and remove the saved draft. Returns the previously-saved text, or
+	 * null when no draft is pending. Single-shot: a successful read removes the
+	 * sidecar so a subsequent resume does not re-restore the same text.
+	 */
+	async consumeDraft(): Promise<string | null> {
+		const draftPath = this.#getDraftPath();
+		if (!draftPath) return null;
+		let text: string;
+		try {
+			text = await this.storage.readText(draftPath);
+		} catch (err) {
+			if (isEnoent(err)) return null;
+			throw err;
+		}
+		try {
+			await this.storage.unlink(draftPath);
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+		return text;
+	}
+
 	/** The source that set the session name: "user" (manual /rename or RPC) or "auto" (generated title). */
 	get titleSource(): "auto" | "user" | undefined {
 		return this.#titleSource;

package/src/tools/image-gen.ts

@@ -1125,7 +1125,9 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					headers: {
 						"Content-Type": "application/json",
 						Authorization: `Bearer ${apiKey.apiKey}`,
-						"X-Title": "Oh-My-Pi",
+						"HTTP-Referer": "https://github.com/can1357/oh-my-pi",
+						"X-OpenRouter-Title": "Oh-My-Pi",
+						"X-OpenRouter-Categories": "cli-agent",
 					},
 					body: JSON.stringify(requestBody),
 					signal: requestSignal,