@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/session/blob-store.ts

@@ -1,4 +1,5 @@
-import * as fs from "node:fs/promises";
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 
@@ -25,7 +26,7 @@ export class BlobStore {
 	 * @returns SHA-256 hex hash of the data
 	 */
 	async put(data: Buffer): Promise<BlobPutResult> {
-		const hash = new Bun.CryptoHasher("sha256").update(data).digest("hex");
+		const hash = new Bun.SHA256().update(data).digest("hex");
 		const blobPath = path.join(this.dir, hash);
 		const result = {
 			hash,
@@ -39,6 +40,26 @@ export class BlobStore {
 		return result;
 	}
 
+	/**
+	 * Synchronous variant of {@link put}. Use on persistence hot paths where the caller
+	 * cannot afford the microtask hops of the async version (e.g. OOM-safe session writes).
+	 * Returns once the bytes are in the kernel page cache.
+	 */
+	putSync(data: Buffer): BlobPutResult {
+		const hash = new Bun.SHA256().update(data).digest("hex");
+		const blobPath = path.join(this.dir, hash);
+		const result = {
+			hash,
+			path: blobPath,
+			get ref() {
+				return `${BLOB_PREFIX}${hash}`;
+			},
+		};
+		fs.mkdirSync(this.dir, { recursive: true });
+		fs.writeFileSync(blobPath, data);
+		return result;
+	}
+
 	/** Read blob by hash, returns Buffer or null if not found. */
 	async get(hash: string): Promise<Buffer | null> {
 		const blobPath = path.join(this.dir, hash);
@@ -55,7 +76,7 @@ export class BlobStore {
 	/** Check if a blob exists. */
 	async has(hash: string): Promise<boolean> {
 		try {
-			await fs.access(path.join(this.dir, hash));
+			await fsp.access(path.join(this.dir, hash));
 			return true;
 		} catch {
 			return false;
@@ -89,6 +110,12 @@ export async function externalizeImageDataUrl(blobStore: BlobStore, dataUrl: str
 	return ref;
 }
 
+/** Synchronous variant of {@link externalizeImageDataUrl}. */
+export function externalizeImageDataUrlSync(blobStore: BlobStore, dataUrl: string): string {
+	if (isBlobRef(dataUrl)) return dataUrl;
+	return blobStore.putSync(Buffer.from(dataUrl, "utf8")).ref;
+}
+
 /**
  * Externalize an image's base64 data to the blob store, returning a blob reference.
  * If the data is already a blob reference, returns it unchanged.
@@ -100,6 +127,12 @@ export async function externalizeImageData(blobStore: BlobStore, base64Data: str
 	return ref;
 }
 
+/** Synchronous variant of {@link externalizeImageData}. */
+export function externalizeImageDataSync(blobStore: BlobStore, base64Data: string): string {
+	if (isBlobRef(base64Data)) return base64Data;
+	return blobStore.putSync(Buffer.from(base64Data, "base64")).ref;
+}
+
 /**
  * Resolve an externalized provider image data URL back to its original string.
  * If the data is not a blob reference, returns it unchanged.

package/src/session/messages.ts

@@ -30,6 +30,72 @@ export interface SkillPromptDetails {
 	path: string;
 	args?: string;
 	lineCount: number;
+	/** Internal: tag used by AgentSession to remove the pending-display chip
+	 *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
+	 *  this message. Not surfaced to renderers; the `__` prefix signals
+	 *  "private". Optional — non-streaming skill prompts never set it. Stripped
+	 *  from persisted `details` by `SessionManager.appendCustomMessageEntry`
+	 *  via the `INTERNAL_DETAILS_FIELDS` allowlist below. */
+	__pendingDisplayTag?: string;
+}
+
+/** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
+ *  was an *expected internal transition* (plan-mode → execution compaction)
+ *  and must NOT surface as a red "Operation aborted" line. Distinct from
+ *  `undefined` (default) so user-cancel aborts with no errorMessage still
+ *  render normally. Persists through SessionManager so history replay
+ *  branches identically.
+ *
+ *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
+ *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
+ *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
+ *  (fallback error emission) read it via `isSilentAbort`. */
+export const SILENT_ABORT_MARKER = "__omp.silent_abort__";
+
+/** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
+ *  than string-comparing inline so refactors to the marker constant (e.g.,
+ *  namespacing changes) propagate through every consumer in lockstep. */
+export function isSilentAbort(errorMessage: string | undefined): boolean {
+	return errorMessage === SILENT_ABORT_MARKER;
+}
+
+/** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
+ *  `details` blob. Safe over `unknown`; returns undefined when the field is
+ *  absent or non-string. */
+export function readPendingDisplayTag(details: unknown): string | undefined {
+	if (typeof details !== "object" || details === null) return undefined;
+	const candidate = (details as { __pendingDisplayTag?: unknown }).__pendingDisplayTag;
+	return typeof candidate === "string" ? candidate : undefined;
+}
+
+/** Explicit allowlist of `details` field names that are AgentSession-internal
+ *  transient bookkeeping and MUST be removed before SessionManager persists
+ *  the CustomMessageEntry to disk. Scoped intentionally narrow: only fields
+ *  declared here are stripped. Adding a new entry is a deliberate, reviewed
+ *  change — unrelated future payload fields are never silently dropped. */
+export const INTERNAL_DETAILS_FIELDS = ["__pendingDisplayTag"] as const;
+
+/** Return a `details` copy with every key in `INTERNAL_DETAILS_FIELDS`
+ *  removed. Returns the input unchanged when there is nothing to strip
+ *  (null/non-object, or no listed fields present) so callers don't pay a
+ *  clone cost on the common path. */
+export function stripInternalDetailsFields<T>(details: T | undefined): T | undefined {
+	if (details == null || typeof details !== "object") return details;
+	const obj = details as Record<string, unknown>;
+	let hit = false;
+	for (const key of INTERNAL_DETAILS_FIELDS) {
+		if (key in obj) {
+			hit = true;
+			break;
+		}
+	}
+	if (!hit) return details;
+	const cleaned: Record<string, unknown> = { ...obj };
+	for (const key of INTERNAL_DETAILS_FIELDS) {
+		delete cleaned[key];
+	}
+	return cleaned as T;
 }
 
 function getPrunedToolResultContent(message: ToolResultMessage): (TextContent | ImageContent)[] {
@@ -364,8 +430,7 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						attribution: m.attribution ?? "agent",
 					};
 				default:
-					// biome-ignore lint/correctness/noSwitchDeclarations: fine
-					const _exhaustiveCheck: never = m;
+					m satisfies never;
 					return undefined;
 			}
 		})

package/src/session/session-manager.ts

@@ -31,7 +31,9 @@ import {
 	type BlobPutResult,
 	BlobStore,
 	externalizeImageData,
+	externalizeImageDataSync,
 	externalizeImageDataUrl,
+	externalizeImageDataUrlSync,
 	isBlobRef,
 	isImageDataUrl,
 	resolveImageData,
@@ -47,6 +49,7 @@ import {
 	type HookMessage,
 	type PythonExecutionMessage,
 	sanitizeRehydratedOpenAIResponsesAssistantMessage,
+	stripInternalDetailsFields,
 } from "./messages";
 import type { SessionStorage, SessionStorageWriter } from "./session-storage";
 import { FileSessionStorage, MemorySessionStorage } from "./session-storage";
@@ -1127,6 +1130,92 @@ async function prepareEntryForPersistence(entry: FileEntry, blobStore: BlobStore
 	return truncateForPersistence(entry, blobStore);
 }
 
+/**
+ * Synchronous variant of {@link truncateForPersistence}.
+ *
+ * The async version's overhead — `Promise.all` over `Object.entries`/`Array.prototype.map`,
+ * one microtask hop per nested node — is pure waste for entries without image blobs
+ * (the vast majority). The fast path runs in one synchronous tick so an OOM/SIGKILL
+ * landing right after `_persist` returns cannot lose the entry. Image externalization
+ * still happens, but via the synchronous blob-store path (`fs.writeFileSync`), so the
+ * blob bytes are in the kernel page cache before the JSONL line referencing them is
+ * written.
+ */
+function truncateForPersistenceSync(obj: unknown, blobStore: BlobStore, key?: string): unknown {
+	if (obj === null || obj === undefined) return obj;
+
+	if (typeof obj === "string") {
+		if (key === "image_url" && isImageDataUrl(obj)) {
+			return externalizeImageDataUrlSync(blobStore, obj);
+		}
+		if (obj.length > MAX_PERSIST_CHARS) {
+			if (key === "thinkingSignature" || key === "thoughtSignature" || key === "textSignature") {
+				return "";
+			}
+			const limit = Math.max(0, MAX_PERSIST_CHARS - TRUNCATION_NOTICE.length);
+			return `${truncateString(obj, limit)}${TRUNCATION_NOTICE}`;
+		}
+		return obj;
+	}
+
+	if (Array.isArray(obj)) {
+		let changed = false;
+		const result: unknown[] = new Array(obj.length);
+		for (let i = 0; i < obj.length; i++) {
+			const item = obj[i];
+			if (key === TEXT_CONTENT_KEY && isImageBlock(item)) {
+				if (!isBlobRef(item.data) && item.data.length >= BLOB_EXTERNALIZE_THRESHOLD) {
+					changed = true;
+					const blobRef = externalizeImageDataSync(blobStore, item.data);
+					result[i] = { ...item, data: blobRef };
+					continue;
+				}
+			}
+			const newItem = truncateForPersistenceSync(item, blobStore, key);
+			if (newItem !== item) changed = true;
+			result[i] = newItem;
+		}
+		return changed ? result : obj;
+	}
+
+	if (typeof obj === "object") {
+		let changed = false;
+		const entries: Array<readonly [string, unknown]> = [];
+		for (const [childKey, value] of Object.entries(obj)) {
+			if (childKey === "partialJson" || childKey === "jsonlEvents") {
+				changed = true;
+				continue;
+			}
+			const newValue = truncateForPersistenceSync(value, blobStore, childKey);
+			if (newValue !== value) changed = true;
+			entries.push([childKey, newValue]);
+		}
+		if (!changed) return obj;
+
+		const contentEntry = entries.find(([childKey]) => childKey === "content");
+		const lineCountEntry = entries.find(([childKey]) => childKey === "lineCount");
+		if (
+			contentEntry &&
+			typeof contentEntry[1] === "string" &&
+			lineCountEntry &&
+			typeof lineCountEntry[1] === "number"
+		) {
+			const content = contentEntry[1];
+			const updatedEntries = entries.map(([childKey, value]) =>
+				childKey === "lineCount" ? ([childKey, content.split("\n").length] as const) : ([childKey, value] as const),
+			);
+			return Object.fromEntries(updatedEntries);
+		}
+		return Object.fromEntries(entries);
+	}
+
+	return obj;
+}
+
+function prepareEntryForPersistenceSync(entry: FileEntry, blobStore: BlobStore): FileEntry {
+	return truncateForPersistenceSync(entry, blobStore) as FileEntry;
+}
+
 class NdjsonFileWriter {
 	#writer: SessionStorageWriter;
 	#closed = false;
@@ -1180,6 +1269,26 @@ class NdjsonFileWriter {
 		return this.#enqueue(() => this.#writeLine(line));
 	}
 
+	/**
+	 * Synchronously serialize and append the entry. Returns once `fs.writeSync` has handed
+	 * the bytes to the kernel page cache — durable across OOM/SIGKILL even before fsync.
+	 *
+	 * Callers MUST NOT mix this with pending async `write()` calls on the same writer:
+	 * the async path is queued through `#pendingWrites`, but this method bypasses the
+	 * queue. Use only when no concurrent async write is in flight (the session-manager
+	 * persist path enforces this via `#flushed`/`#needsFullRewriteOnNextPersist`).
+	 */
+	writeSync(entry: FileEntry): void {
+		if (this.#closed || this.#closing) throw new Error("Writer closed");
+		if (this.#error) throw this.#error;
+		const line = `${JSON.stringify(entry)}\n`;
+		try {
+			this.#writer.writeLineSync(line);
+		} catch (err) {
+			throw this.#recordError(err);
+		}
+	}
+
 	/** Flush all buffered data to disk. Waits for all queued writes. */
 	async flush(): Promise<void> {
 		if (this.#closed) return;
@@ -2332,20 +2441,27 @@ export class SessionManager {
 		}
 
 		if (this.#needsFullRewriteOnNextPersist || !this.#flushed) {
-			// Full flush: rewrite the entire file atomically to avoid
-			// duplicating entries if the file already exists (e.g. from ensureOnDisk).
-			// Errors are already surfaced through #persistChain/#persistError; the
-			// caller intentionally fires-and-forgets, so swallow the awaited rejection
+			// Cold path: rewrite the whole file atomically. Async — the writer is
+			// closed/reopened and every entry is re-prepared. Errors flow through
+			// `#persistChain` → `#recordPersistError`; we swallow the rejection
 			// here to avoid an unhandled rejection when the persist dir races with
 			// test-level tempDir cleanup.
 			this.#rewriteFile().catch(() => {});
-		} else {
-			this.#queuePersistTask(async () => {
-				const writer = this.#ensurePersistWriter();
-				if (!writer) return;
-				const persistedEntry = await prepareEntryForPersistence(entry, this.#blobStore);
-				await writer.write(persistedEntry);
-			}).catch(() => {});
+			return;
+		}
+
+		// Hot path: synchronously truncate + append. `fs.writeSync` returns once the
+		// bytes are in the kernel page cache, so the entry survives an OOM/SIGKILL
+		// landing immediately after this call. Image externalization (rare) runs via
+		// the synchronous blob-store path so blob bytes are durable before the JSONL
+		// line referencing them is written.
+		try {
+			const writer = this.#ensurePersistWriter();
+			if (!writer) return;
+			const persistedEntry = prepareEntryForPersistenceSync(entry, this.#blobStore);
+			writer.writeSync(persistedEntry);
+		} catch (err) {
+			this.#recordPersistError(err);
 		}
 	}
 
@@ -2544,7 +2660,10 @@ export class SessionManager {
 			customType,
 			content,
 			display,
-			details,
+			// Drop AgentSession-internal transient fields (allowlist in
+			// `INTERNAL_DETAILS_FIELDS`) before disk persistence. Single
+			// chokepoint covers every CustomMessage write path.
+			details: stripInternalDetailsFields(details),
 			attribution,
 			id: generateId(this.#byId),
 			parentId: this.#leafId,

package/src/session/session-storage.ts

@@ -13,6 +13,14 @@ export interface SessionStorageStat {
 
 export interface SessionStorageWriter {
 	writeLine(line: string): Promise<void>;
+	/**
+	 * Synchronously append a single line. Returns once the bytes are handed to the kernel
+	 * (page cache), so the data survives a non-graceful process death (OOM, SIGKILL, etc.)
+	 * even though it has not yet been fsynced to the underlying disk.
+	 *
+	 * `line` MUST already include the trailing newline. Throws synchronously on I/O error.
+	 */
+	writeLineSync(line: string): void;
 	flush(): Promise<void>;
 	fsync(): Promise<void>;
 	close(): Promise<void>;
@@ -23,6 +31,7 @@ export interface SessionStorage {
 	ensureDirSync(dir: string): void;
 	existsSync(path: string): boolean;
 	writeTextSync(path: string, content: string): void;
+	readTextSync(path: string): string;
 	statSync(path: string): SessionStorageStat;
 	listFilesSync(dir: string, pattern: string): string[];
 
@@ -72,7 +81,7 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 		return error;
 	}
 
-	async writeLine(line: string): Promise<void> {
+	writeLineSync(line: string): void {
 		if (this.#closed) throw new Error("Writer closed");
 		if (this.#error) throw this.#error;
 		try {
@@ -90,6 +99,10 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 		}
 	}
 
+	async writeLine(line: string): Promise<void> {
+		this.writeLineSync(line);
+	}
+
 	async flush(): Promise<void> {
 		if (this.#error) throw this.#error;
 		// OS buffers are flushed on fsync, nothing to do here
@@ -138,6 +151,10 @@ export class FileSessionStorage implements SessionStorage {
 		fs.writeFileSync(fpath, content);
 	}
 
+	readTextSync(fpath: string): string {
+		return fs.readFileSync(fpath, "utf-8");
+	}
+
 	statSync(path: string): SessionStorageStat {
 		const stats = fs.statSync(path);
 		return { size: stats.size, mtimeMs: stats.mtimeMs, mtime: stats.mtime };
@@ -230,7 +247,6 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 	#closed = false;
 	#error: Error | undefined;
 	#onError: ((err: Error) => void) | undefined;
-	#ready: Promise<void>;
 
 	constructor(
 		storage: MemorySessionStorage,
@@ -240,12 +256,8 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		this.#storage = storage;
 		this.#path = path;
 		this.#onError = options?.onError;
-		this.#ready = this.#initialize(options?.flags ?? "a");
-	}
-
-	async #initialize(flags: "a" | "w"): Promise<void> {
-		if (flags === "w") {
-			await this.#storage.writeText(this.#path, "");
+		if ((options?.flags ?? "a") === "w") {
+			this.#storage.writeTextSync(path, "");
 		}
 	}
 
@@ -256,32 +268,32 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		return error;
 	}
 
-	async writeLine(line: string): Promise<void> {
+	writeLineSync(line: string): void {
 		if (this.#closed) throw new Error("Writer closed");
-		await this.#ready;
 		if (this.#error) throw this.#error;
 		try {
-			const existing = this.#storage.existsSync(this.#path) ? await this.#storage.readText(this.#path) : "";
-			await this.#storage.writeText(this.#path, `${existing}${line}`);
+			const existing = this.#storage.existsSync(this.#path) ? this.#storage.readTextSync(this.#path) : "";
+			this.#storage.writeTextSync(this.#path, `${existing}${line}`);
 		} catch (err) {
 			throw this.#recordError(err);
 		}
 	}
 
+	async writeLine(line: string): Promise<void> {
+		this.writeLineSync(line);
+	}
+
 	async flush(): Promise<void> {
-		await this.#ready;
 		if (this.#error) throw this.#error;
 	}
 
 	async fsync(): Promise<void> {
 		// No-op for in-memory storage
-		await this.#ready;
 		if (this.#error) throw this.#error;
 	}
 
 	async close(): Promise<void> {
 		if (this.#closed) return;
-		await this.#ready;
 		this.#closed = true;
 	}
 
@@ -305,6 +317,12 @@ export class MemorySessionStorage implements SessionStorage {
 		this.#files.set(path, { content, mtimeMs: Date.now() });
 	}
 
+	readTextSync(path: string): string {
+		const entry = this.#files.get(path);
+		if (!entry) throw new Error(`File not found: ${path}`);
+		return entry.content;
+	}
+
 	statSync(path: string): SessionStorageStat {
 		const entry = this.#files.get(path);
 		if (!entry) throw new Error(`File not found: ${path}`);