@oh-my-pi/pi-coding-agent 14.6.5 → 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.5",
+	"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.5",
-		"@oh-my-pi/pi-agent-core": "14.6.5",
-		"@oh-my-pi/pi-ai": "14.6.5",
-		"@oh-my-pi/pi-natives": "14.6.5",
-		"@oh-my-pi/pi-tui": "14.6.5",
-		"@oh-my-pi/pi-utils": "14.6.5",
+		"@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

@@ -403,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();
 	}
 

package/src/modes/interactive-mode.ts

@@ -445,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();
 
@@ -1189,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

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,