@oh-my-pi/pi-coding-agent 11.2.3 → 11.3.0

package/src/session/blob-store.ts

@@ -0,0 +1,105 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+
+const BLOB_PREFIX = "blob:sha256:";
+
+/**
+ * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
+ *
+ * Files are stored at `<dir>/<sha256-hex>` with no extension. The SHA-256 hash is computed
+ * over the raw binary data (not base64). Content-addressing makes writes idempotent and
+ * provides automatic deduplication across sessions.
+ */
+export class BlobStore {
+	constructor(readonly dir: string) {}
+
+	/**
+	 * Write binary data to the blob store.
+	 * @returns SHA-256 hex hash of the data
+	 */
+	async put(data: Buffer): Promise<string> {
+		const hasher = new Bun.CryptoHasher("sha256");
+		hasher.update(data);
+		const hash = hasher.digest("hex");
+		const blobPath = path.join(this.dir, hash);
+
+		// Content-addressed: skip write if blob already exists
+		try {
+			await fs.access(blobPath);
+			return hash;
+		} catch {
+			// Does not exist, write it
+		}
+
+		await Bun.write(blobPath, data);
+		return hash;
+	}
+
+	/** 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);
+		try {
+			const file = Bun.file(blobPath);
+			const ab = await file.arrayBuffer();
+			return Buffer.from(ab);
+		} catch (err) {
+			if (isEnoent(err)) return null;
+			throw err;
+		}
+	}
+
+	/** Check if a blob exists. */
+	async has(hash: string): Promise<boolean> {
+		try {
+			await fs.access(path.join(this.dir, hash));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+}
+
+/** Check if a data string is a blob reference. */
+export function isBlobRef(data: string): boolean {
+	return data.startsWith(BLOB_PREFIX);
+}
+
+/** Extract the SHA-256 hash from a blob reference string. */
+export function parseBlobRef(data: string): string | null {
+	if (!data.startsWith(BLOB_PREFIX)) return null;
+	return data.slice(BLOB_PREFIX.length);
+}
+
+/** Create a blob reference string from a SHA-256 hash. */
+export function makeBlobRef(hash: string): string {
+	return `${BLOB_PREFIX}${hash}`;
+}
+
+/**
+ * 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.
+ */
+export async function externalizeImageData(blobStore: BlobStore, base64Data: string): Promise<string> {
+	if (isBlobRef(base64Data)) return base64Data;
+	const buffer = Buffer.from(base64Data, "base64");
+	const hash = await blobStore.put(buffer);
+	return makeBlobRef(hash);
+}
+
+/**
+ * Resolve a blob reference back to base64 data.
+ * If the data is not a blob reference, returns it unchanged.
+ * If the blob is missing, logs a warning and returns a placeholder.
+ */
+export async function resolveImageData(blobStore: BlobStore, data: string): Promise<string> {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+
+	const buffer = await blobStore.get(hash);
+	if (!buffer) {
+		logger.warn("Blob not found for image reference", { hash });
+		return data; // Return the ref as-is; downstream will see invalid base64 but won't crash
+	}
+	return buffer.toString("base64");
+}

package/src/session/session-manager.ts

@@ -2,8 +2,8 @@ import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent, Usage } from "@oh-my-pi/pi-ai";
 import { isEnoent, logger, parseJsonlLenient, Snowflake } from "@oh-my-pi/pi-utils";
-import { getAgentDir as getDefaultAgentDir } from "../config";
-import { resizeImage } from "../utils/image-resize";
+import { getBlobsDir, getAgentDir as getDefaultAgentDir } from "../config";
+import { BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -125,6 +125,15 @@ export interface SessionInitEntry extends SessionEntryBase {
 	outputSchema?: unknown;
 }
 
+/** Mode change entry - tracks agent mode transitions (e.g. plan mode). */
+export interface ModeChangeEntry extends SessionEntryBase {
+	type: "mode_change";
+	/** Current mode name, or "none" when exiting a mode */
+	mode: string;
+	/** Optional mode-specific data (e.g. plan file path) */
+	data?: Record<string, unknown>;
+}
+
 /**
  * Custom message entry for extensions to inject messages into LLM context.
  * Use customType to identify your extension's entries.
@@ -156,7 +165,8 @@ export type SessionEntry =
 	| CustomMessageEntry
 	| LabelEntry
 	| TtsrInjectionEntry
-	| SessionInitEntry;
+	| SessionInitEntry
+	| ModeChangeEntry;
 
 /** Raw file entry (includes header) */
 export type FileEntry = SessionHeader | SessionEntry;
@@ -176,6 +186,10 @@ export interface SessionContext {
 	models: Record<string, string>;
 	/** Names of TTSR rules that have been injected this session */
 	injectedTtsrRules: string[];
+	/** Active mode (e.g. "plan") or "none" if no special mode is active */
+	mode: string;
+	/** Mode-specific data from the last mode_change entry */
+	modeData?: Record<string, unknown>;
 }
 
 export interface SessionInfo {
@@ -184,6 +198,8 @@ export interface SessionInfo {
 	/** Working directory where the session was started. Empty string for old sessions. */
 	cwd: string;
 	title?: string;
+	/** Path to the parent session (if this session was forked). */
+	parentSessionPath?: string;
 	created: Date;
 	modified: Date;
 	messageCount: number;
@@ -324,7 +340,7 @@ export function buildSessionContext(
 	let leaf: SessionEntry | undefined;
 	if (leafId === null) {
 		// Explicitly null - return no messages (navigated to before first entry)
-		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [] };
+		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [], mode: "none" };
 	}
 	if (leafId) {
 		leaf = byId.get(leafId);
@@ -335,7 +351,7 @@ export function buildSessionContext(
 	}
 
 	if (!leaf) {
-		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [] };
+		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [], mode: "none" };
 	}
 
 	// Walk from leaf to root, collecting path
@@ -351,6 +367,8 @@ export function buildSessionContext(
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 	const injectedTtsrRulesSet = new Set<string>();
+	let mode = "none";
+	let modeData: Record<string, unknown> | undefined;
 
 	for (const entry of path) {
 		if (entry.type === "thinking_level_change") {
@@ -371,6 +389,9 @@ export function buildSessionContext(
 			for (const ruleName of entry.injectedRules) {
 				injectedTtsrRulesSet.add(ruleName);
 			}
+		} else if (entry.type === "mode_change") {
+			mode = entry.mode;
+			modeData = entry.data;
 		}
 	}
 
@@ -433,7 +454,7 @@ export function buildSessionContext(
 		}
 	}
 
-	return { messages, thinkingLevel, models, injectedTtsrRules };
+	return { messages, thinkingLevel, models, injectedTtsrRules, mode, modeData };
 }
 
 /**
@@ -471,6 +492,41 @@ export async function loadEntriesFromFile(
 	return entries;
 }
 
+/**
+ * Resolve blob references in loaded entries, replacing `blob:sha256:<hash>` data fields
+ * with the actual base64 content from the blob store. Mutates entries in place.
+ */
+async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void> {
+	const promises: Promise<void>[] = [];
+
+	for (const entry of entries) {
+		if (entry.type === "session") continue;
+
+		// Resolve image blocks in message content arrays
+		let contentArray: unknown[] | undefined;
+		if (entry.type === "message") {
+			const content = (entry.message as { content?: unknown }).content;
+			if (Array.isArray(content)) contentArray = content;
+		} else if (entry.type === "custom_message" && Array.isArray(entry.content)) {
+			contentArray = entry.content;
+		}
+
+		if (!contentArray) continue;
+
+		for (const block of contentArray) {
+			if (isImageBlock(block) && isBlobRef(block.data)) {
+				promises.push(
+					resolveImageData(blobStore, block.data).then(resolved => {
+						(block as { data: string }).data = resolved;
+					}),
+				);
+			}
+		}
+	}
+
+	await Promise.all(promises);
+}
+
 /**
  * Lightweight metadata for a session file, used in session picker UI.
  * Uses lazy getters to defer string formatting until actually displayed.
@@ -513,7 +569,7 @@ class RecentSessionInfo {
 	get name(): string {
 		if (this.#name) return this.#name;
 		const fullName = this.fullName;
-		this.#name = fullName.length <= 40 ? fullName : `${fullName.slice(0, 37)}...`;
+		this.#name = fullName.length <= 40 ? fullName : `${fullName.slice(0, 39)}…`;
 		return this.#name;
 	}
 
@@ -603,9 +659,8 @@ function formatTimeAgo(date: Date): string {
 
 const MAX_PERSIST_CHARS = 500_000;
 const TRUNCATION_NOTICE = "\n\n[Session persistence truncated large content]";
-const PLACEHOLDER_IMAGE_DATA =
-	"/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////2wBDAf//////////////////////////////////////////////////////////////////////////////////////wAARCAAQABADASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAgP/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCkA//Z";
-
+/** Minimum base64 length to externalize to blob store (skip tiny inline images) */
+const BLOB_EXTERNALIZE_THRESHOLD = 1024;
 const TEXT_CONTENT_KEY = "content";
 
 /**
@@ -638,25 +693,7 @@ function isImageBlock(value: unknown): value is { type: "image"; data: string; m
 	);
 }
 
-async function compressImageForPersistence(image: ImageContent): Promise<ImageContent> {
-	try {
-		const maxBytes = Math.floor((MAX_PERSIST_CHARS * 3) / 4);
-		const resized = await resizeImage(image, {
-			maxWidth: 512,
-			maxHeight: 512,
-			maxBytes,
-			jpegQuality: 70,
-		});
-		if (resized.data.length > MAX_PERSIST_CHARS) {
-			return { type: "image", data: PLACEHOLDER_IMAGE_DATA, mimeType: "image/jpeg" };
-		}
-		return { type: "image", data: resized.data, mimeType: resized.mimeType };
-	} catch {
-		return { type: "image", data: PLACEHOLDER_IMAGE_DATA, mimeType: "image/jpeg" };
-	}
-}
-
-async function truncateForPersistence<T>(obj: T, key?: string): Promise<T> {
+async function truncateForPersistence<T>(obj: T, blobStore: BlobStore, key?: string): Promise<T> {
 	if (obj === null || obj === undefined) return obj;
 
 	if (typeof obj === "string") {
@@ -673,16 +710,13 @@ async function truncateForPersistence<T>(obj: T, key?: string): Promise<T> {
 			obj.map(async item => {
 				// Special handling: compress oversized images while preserving shape
 				if (key === TEXT_CONTENT_KEY && isImageBlock(item)) {
-					if (item.data.length > MAX_PERSIST_CHARS) {
+					if (!isBlobRef(item.data) && item.data.length >= BLOB_EXTERNALIZE_THRESHOLD) {
 						changed = true;
-						return compressImageForPersistence({
-							type: "image",
-							data: item.data,
-							mimeType: item.mimeType ?? "image/jpeg",
-						});
+						const blobRef = await externalizeImageData(blobStore, item.data);
+						return { ...item, data: blobRef };
 					}
 				}
-				const newItem = await truncateForPersistence(item, key);
+				const newItem = await truncateForPersistence(item, blobStore, key);
 				if (newItem !== item) changed = true;
 				return newItem;
 			}),
@@ -701,7 +735,7 @@ async function truncateForPersistence<T>(obj: T, key?: string): Promise<T> {
 				changed = true;
 				continue;
 			}
-			const newV = await truncateForPersistence(v, k);
+			const newV = await truncateForPersistence(v, blobStore, k);
 			result[k] = newV;
 			if (newV !== v) changed = true;
 		}
@@ -715,8 +749,8 @@ async function truncateForPersistence<T>(obj: T, key?: string): Promise<T> {
 	return obj;
 }
 
-async function prepareEntryForPersistence(entry: FileEntry): Promise<FileEntry> {
-	return truncateForPersistence(entry);
+async function prepareEntryForPersistence(entry: FileEntry, blobStore: BlobStore): Promise<FileEntry> {
+	return truncateForPersistence(entry, blobStore);
 }
 
 class NdjsonFileWriter {
@@ -933,6 +967,7 @@ async function collectSessionsFromFiles(files: string[], storage: SessionStorage
 						id: header.id,
 						cwd: typeof header.cwd === "string" ? header.cwd : "",
 						title: header.title ?? shortSummary,
+						parentSessionPath: (header as SessionHeader).parentSession,
 						created: new Date(header.timestamp),
 						modified: stats.mtime,
 						messageCount,
@@ -963,6 +998,7 @@ export class SessionManager {
 	private persistChain: Promise<void> = Promise.resolve();
 	private persistError: Error | undefined;
 	private persistErrorReported = false;
+	private readonly blobStore: BlobStore;
 
 	private constructor(
 		private readonly cwd: string,
@@ -970,6 +1006,7 @@ export class SessionManager {
 		private readonly persist: boolean,
 		private readonly storage: SessionStorage,
 	) {
+		this.blobStore = new BlobStore(getBlobsDir());
 		if (persist && sessionDir) {
 			this.storage.ensureDirSync(sessionDir);
 		}
@@ -1002,6 +1039,8 @@ export class SessionManager {
 				await this._rewriteFile();
 			}
 
+			await resolveBlobRefsInEntries(this.fileEntries, this.blobStore);
+
 			this._buildIndex();
 			this.flushed = true;
 		} else {
@@ -1226,7 +1265,9 @@ export class SessionManager {
 		if (!this.persist || !this.sessionFile) return;
 		await this._queuePersistTask(async () => {
 			await this._closePersistWriterInternal();
-			const entries = await Promise.all(this.fileEntries.map(entry => prepareEntryForPersistence(entry)));
+			const entries = await Promise.all(
+				this.fileEntries.map(entry => prepareEntryForPersistence(entry, this.blobStore)),
+			);
 			await this._writeEntriesAtomically(entries);
 			this.flushed = true;
 		});
@@ -1294,14 +1335,18 @@ export class SessionManager {
 		if (this.persistError) throw this.persistError;
 
 		const hasAssistant = this.fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
-		if (!hasAssistant && !this.flushed) return;
+		if (!hasAssistant) {
+			// Mark as not flushed so when assistant arrives, all entries get written
+			this.flushed = false;
+			return;
+		}
 
 		if (!this.flushed) {
 			this.flushed = true;
 			void this._queuePersistTask(async () => {
 				const writer = this._ensurePersistWriter();
 				if (!writer) return;
-				const entries = await Promise.all(this.fileEntries.map(e => prepareEntryForPersistence(e)));
+				const entries = await Promise.all(this.fileEntries.map(e => prepareEntryForPersistence(e, this.blobStore)));
 				for (const persistedEntry of entries) {
 					await writer.write(persistedEntry);
 				}
@@ -1310,7 +1355,7 @@ export class SessionManager {
 			void this._queuePersistTask(async () => {
 				const writer = this._ensurePersistWriter();
 				if (!writer) return;
-				const persistedEntry = await prepareEntryForPersistence(entry);
+				const persistedEntry = await prepareEntryForPersistence(entry, this.blobStore);
 				await writer.write(persistedEntry);
 			});
 		}
@@ -1381,6 +1426,20 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	/** Append a mode change as child of current leaf, then advance leaf. Returns entry id. */
+	appendModeChange(mode: string, data?: Record<string, unknown>): string {
+		const entry: ModeChangeEntry = {
+			type: "mode_change",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: new Date().toISOString(),
+			mode,
+			data,
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+
 	/**
 	 * Append a model change as child of current leaf, then advance leaf. Returns entry id.
 	 * @param model Model in "provider/modelId" format
@@ -1776,6 +1835,7 @@ export class SessionManager {
 	 * Returns the new session file path, or undefined if not persisting.
 	 */
 	createBranchedSession(leafId: string): string | undefined {
+		const previousSessionFile = this.sessionFile;
 		const branchPath = this.getBranch(leafId);
 		if (branchPath.length === 0) {
 			throw new Error(`Entry ${leafId} not found`);
@@ -1795,7 +1855,7 @@ export class SessionManager {
 			id: newSessionId,
 			timestamp,
 			cwd: this.cwd,
-			parentSession: this.persist ? this.sessionFile : undefined,
+			parentSession: this.persist ? previousSessionFile : undefined,
 		};
 
 		// Collect labels for entries in the path
@@ -1834,6 +1894,8 @@ export class SessionManager {
 			this.storage.writeTextSync(newSessionFile, `${lines.join("\n")}\n`);
 			this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries];
 			this.sessionId = newSessionId;
+			this.sessionFile = newSessionFile;
+			this.flushed = true;
 			this._buildIndex();
 			return newSessionFile;
 		}
@@ -1885,6 +1947,7 @@ export class SessionManager {
 		const manager = new SessionManager(cwd, dir, true, storage);
 		const forkEntries = structuredClone(await loadEntriesFromFile(sourcePath, storage)) as FileEntry[];
 		migrateToCurrentVersion(forkEntries);
+		await resolveBlobRefsInEntries(forkEntries, manager.blobStore);
 		const sourceHeader = forkEntries.find(e => e.type === "session") as SessionHeader | undefined;
 		const historyEntries = forkEntries.filter(entry => entry.type !== "session") as SessionEntry[];
 		manager._newSessionSync({ parentSession: sourceHeader?.id });

package/src/task/executor.ts

@@ -270,7 +270,7 @@ function extractToolArgsPreview(args: Record<string, unknown>): string {
 	for (const key of previewKeys) {
 		if (args[key] && typeof args[key] === "string") {
 			const value = args[key] as string;
-			return value.length > 60 ? `${value.slice(0, 57)}...` : value;
+			return value.length > 60 ? `${value.slice(0, 59)}…` : value;
 		}
 	}
 
@@ -940,6 +940,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						getActiveTools: () => session.getActiveToolNames(),
 						getAllTools: () => session.getAllToolNames(),
 						setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+						getCommands: () => [],
 						setModel: async model => {
 							const key = await session.modelRegistry.getApiKey(model);
 							if (!key) return false;
@@ -956,6 +957,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						hasPendingMessages: () => session.queuedMessageCount > 0,
 						shutdown: () => {},
 						getContextUsage: () => session.getContextUsage(),
+						getSystemPrompt: () => session.systemPrompt,
 						compact: async instructionsOrOptions => {
 							const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 							const options =
@@ -1100,15 +1102,23 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 		} else {
 			// Normal successful completion
-			const completeData = normalizeCompleteData(lastSubmitResult?.data ?? null, reportFindings);
-			try {
-				rawOutput = JSON.stringify(completeData, null, 2) ?? "null";
-			} catch (err) {
-				const errorMessage = err instanceof Error ? err.message : String(err);
-				rawOutput = `{"error":"Failed to serialize submit_result data: ${errorMessage}"}`;
+			const submitData = lastSubmitResult?.data;
+			if (submitData === null || submitData === undefined) {
+				// Agent called submit_result but with null/undefined data — treat as missing
+				// so the fallback path can try to extract output from conversation text
+				const warning = "SYSTEM WARNING: Subagent called submit_result with null data.";
+				rawOutput = rawOutput ? `${warning}\n\n${rawOutput}` : warning;
+			} else {
+				const completeData = normalizeCompleteData(submitData, reportFindings);
+				try {
+					rawOutput = JSON.stringify(completeData, null, 2) ?? "null";
+				} catch (err) {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					rawOutput = `{"error":"Failed to serialize submit_result data: ${errorMessage}"}`;
+				}
+				exitCode = 0;
+				stderr = "";
 			}
-			exitCode = 0;
-			stderr = "";
 		}
 	} else {
 		const allowFallback = exitCode === 0 && !done.aborted && !signal?.aborted;