@oh-my-pi/pi-coding-agent 8.1.0 → 8.2.0

package/src/session/session-manager.ts

@@ -1,10 +1,10 @@
-import { basename, join, resolve } from "node:path";
+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 { getAgentDir as getDefaultAgentDir } from "@oh-my-pi/pi-coding-agent/config";
-import { resizeImage } from "@oh-my-pi/pi-coding-agent/utils/image-resize";
-import { logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
+import { getAgentDir as getDefaultAgentDir } from "../config";
+import { resizeImage } from "../utils/image-resize";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -252,7 +252,7 @@ function migrateV2ToV3(entries: FileEntry[]): void {
  * Mutates entries in place. Returns true if any migration was applied.
  */
 function migrateToCurrentVersion(entries: FileEntry[]): boolean {
-	const header = entries.find((e) => e.type === "session") as SessionHeader | undefined;
+	const header = entries.find(e => e.type === "session") as SessionHeader | undefined;
 	const version = header?.version ?? 1;
 
 	if (version >= CURRENT_SESSION_VERSION) return false;
@@ -397,7 +397,7 @@ export function buildSessionContext(
 		messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
 
 		// Find compaction index in path
-		const compactionIdx = path.findIndex((e) => e.type === "compaction" && e.id === compaction.id);
+		const compactionIdx = path.findIndex(e => e.type === "compaction" && e.id === compaction.id);
 
 		// Emit kept messages (before compaction, starting from firstKeptEntryId)
 		let foundFirstKept = false;
@@ -432,16 +432,24 @@ export function buildSessionContext(
  */
 function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
 	const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-	const sessionDir = join(getDefaultAgentDir(), "sessions", safePath);
+	const sessionDir = path.join(getDefaultAgentDir(), "sessions", safePath);
 	storage.ensureDirSync(sessionDir);
 	return sessionDir;
 }
 
 /** Exported for testing */
-export function loadEntriesFromFile(filePath: string, storage: SessionStorage = new FileSessionStorage()): FileEntry[] {
-	if (!storage.existsSync(filePath)) return [];
+export async function loadEntriesFromFile(
+	filePath: string,
+	storage: SessionStorage = new FileSessionStorage(),
+): Promise<FileEntry[]> {
+	let content: string;
+	try {
+		content = await storage.readText(filePath);
+	} catch (err) {
+		if (isEnoent(err)) return [];
+		throw err;
+	}
 
-	const content = storage.readTextSync(filePath);
 	const entries: FileEntry[] = [];
 	const lines = content.trim().split("\n");
 
@@ -555,15 +563,13 @@ function extractFirstUserPrompt(lines: string[]): string | undefined {
  * Uses low-level file I/O to efficiently read only the first 4KB of each file
  * to extract the JSON header and first user message without loading entire session logs into memory.
  */
-function getSortedSessions(sessionDir: string, storage: SessionStorage): RecentSessionInfo[] {
+async function getSortedSessions(sessionDir: string, storage: SessionStorage): Promise<RecentSessionInfo[]> {
 	try {
-		const buf = Buffer.alloc(4096);
 		const files: string[] = storage.listFilesSync(sessionDir, "*.jsonl");
-		return files
-			.map((path: string) => {
+		const results = await Promise.all(
+			files.map(async (path: string) => {
 				try {
-					const length = storage.readTextPrefixSync(path, buf);
-					const content = buf.toString("utf-8", 0, length);
+					const content = await storage.readTextPrefix(path, 4096);
 					const lines = content.split("\n");
 					const firstLine = lines[0];
 					if (!firstLine || !firstLine.trim()) return null;
@@ -575,20 +581,20 @@ function getSortedSessions(sessionDir: string, storage: SessionStorage): RecentS
 				} catch {
 					return null;
 				}
-			})
-			.filter((item): item is RecentSessionInfo => item !== null)
-			.sort((a, b) => b.mtime - a.mtime);
+			}),
+		);
+		return results.filter((item): item is RecentSessionInfo => item !== null).sort((a, b) => b.mtime - a.mtime);
 	} catch {
 		return [];
 	}
 }
 
 /** Exported for testing */
-export function findMostRecentSession(
+export async function findMostRecentSession(
 	sessionDir: string,
 	storage: SessionStorage = new FileSessionStorage(),
-): string | null {
-	const sessions = getSortedSessions(sessionDir, storage);
+): Promise<string | null> {
+	const sessions = await getSortedSessions(sessionDir, storage);
 	return sessions[0]?.path || null;
 }
 
@@ -676,7 +682,7 @@ async function truncateForPersistence<T>(obj: T, key?: string): Promise<T> {
 	if (Array.isArray(obj)) {
 		let changed = false;
 		const result = await Promise.all(
-			obj.map(async (item) => {
+			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) {
@@ -843,12 +849,13 @@ class NdjsonFileWriter {
 }
 
 /** Get recent sessions for display in welcome screen */
-export function getRecentSessions(
+export async function getRecentSessions(
 	sessionDir: string,
 	limit = 3,
 	storage: SessionStorage = new FileSessionStorage(),
-): RecentSessionInfo[] {
-	return getSortedSessions(sessionDir, storage).slice(0, limit);
+): Promise<RecentSessionInfo[]> {
+	const sessions = await getSortedSessions(sessionDir, storage);
+	return sessions.slice(0, limit);
 }
 
 /**
@@ -882,16 +889,16 @@ function extractTextFromContent(content: Message["content"]): string {
 	if (typeof content === "string") return content;
 	return content
 		.filter((block): block is TextContent => block.type === "text")
-		.map((block) => block.text)
+		.map(block => block.text)
 		.join(" ");
 }
 
-function collectSessionsFromFiles(files: string[], storage: SessionStorage): SessionInfo[] {
+async function collectSessionsFromFiles(files: string[], storage: SessionStorage): Promise<SessionInfo[]> {
 	const sessions: SessionInfo[] = [];
 
 	for (const file of files) {
 		try {
-			const content = storage.readTextSync(file);
+			const content = await storage.readText(file);
 			const lines = content.trim().split("\n");
 			if (lines.length === 0) continue;
 
@@ -1003,10 +1010,10 @@ export class SessionManager {
 		await this._closePersistWriter();
 		this.persistError = undefined;
 		this.persistErrorReported = false;
-		this.sessionFile = resolve(sessionFile);
-		if (this.storage.existsSync(this.sessionFile)) {
-			this.fileEntries = loadEntriesFromFile(this.sessionFile!, this.storage);
-			const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
+		this.sessionFile = path.resolve(sessionFile);
+		this.fileEntries = await loadEntriesFromFile(this.sessionFile, this.storage);
+		if (this.fileEntries.length > 0) {
+			const header = this.fileEntries.find(e => e.type === "session") as SessionHeader | undefined;
 			this.sessionId = header?.id ?? nanoid();
 			this.sessionTitle = header?.title;
 
@@ -1053,7 +1060,7 @@ export class SessionManager {
 
 		if (this.persist) {
 			const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-			this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
+			this.sessionFile = path.join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
 		}
 		return this.sessionFile;
 	}
@@ -1115,7 +1122,7 @@ export class SessionManager {
 			if (this.persistError && !options?.ignoreError) throw this.persistError;
 			await task();
 		});
-		this.persistChain = next.catch((err) => {
+		this.persistChain = next.catch(err => {
 			this._recordPersistError(err);
 		});
 		return next;
@@ -1127,7 +1134,7 @@ export class SessionManager {
 		if (this.persistWriter && this.persistWriterPath === this.sessionFile) return this.persistWriter;
 		// Note: caller must await _closePersistWriter() before calling this if switching files
 		this.persistWriter = new NdjsonFileWriter(this.storage, this.sessionFile, {
-			onError: (err) => {
+			onError: err => {
 				this._recordPersistError(err);
 			},
 		});
@@ -1154,8 +1161,8 @@ export class SessionManager {
 
 	private async _writeEntriesAtomically(entries: FileEntry[]): Promise<void> {
 		if (!this.sessionFile) return;
-		const dir = resolve(this.sessionFile, "..");
-		const tempPath = join(dir, `.${basename(this.sessionFile)}.${nanoid(6)}.tmp`);
+		const dir = path.resolve(this.sessionFile, "..");
+		const tempPath = path.join(dir, `.${path.basename(this.sessionFile)}.${nanoid(6)}.tmp`);
 		const writer = new NdjsonFileWriter(this.storage, tempPath, { flags: "w" });
 		try {
 			for (const entry of entries) {
@@ -1185,7 +1192,7 @@ 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)));
 			await this._writeEntriesAtomically(entries);
 			this.flushed = true;
 		});
@@ -1236,7 +1243,7 @@ export class SessionManager {
 		this.sessionTitle = title;
 
 		// Update the in-memory header (so first flush includes title)
-		const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
+		const header = this.fileEntries.find(e => e.type === "session") as SessionHeader | undefined;
 		if (header) {
 			header.title = title;
 		}
@@ -1252,7 +1259,7 @@ export class SessionManager {
 		if (!this.persist || !this.sessionFile) return;
 		if (this.persistError) throw this.persistError;
 
-		const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
+		const hasAssistant = this.fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
 		if (!hasAssistant) return;
 
 		if (!this.flushed) {
@@ -1260,7 +1267,7 @@ export class SessionManager {
 			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)));
 				for (const persistedEntry of entries) {
 					await writer.write(persistedEntry);
 				}
@@ -1596,7 +1603,7 @@ export class SessionManager {
 	 * Get session header.
 	 */
 	getHeader(): SessionHeader | null {
-		const h = this.fileEntries.find((e) => e.type === "session");
+		const h = this.fileEntries.find(e => e.type === "session");
 		return h ? (h as SessionHeader) : null;
 	}
 
@@ -1709,18 +1716,18 @@ export class SessionManager {
 	 * Returns the new session file path, or undefined if not persisting.
 	 */
 	createBranchedSession(leafId: string): string | undefined {
-		const path = this.getBranch(leafId);
-		if (path.length === 0) {
+		const branchPath = this.getBranch(leafId);
+		if (branchPath.length === 0) {
 			throw new Error(`Entry ${leafId} not found`);
 		}
 
 		// Filter out LabelEntry from path - we'll recreate them from the resolved map
-		const pathWithoutLabels = path.filter((e) => e.type !== "label");
+		const pathWithoutLabels = branchPath.filter(e => e.type !== "label");
 
 		const newSessionId = nanoid();
 		const timestamp = new Date().toISOString();
 		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-		const newSessionFile = join(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);
+		const newSessionFile = path.join(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);
 
 		const header: SessionHeader = {
 			type: "session",
@@ -1732,7 +1739,7 @@ export class SessionManager {
 		};
 
 		// Collect labels for entries in the path
-		const pathEntryIds = new Set(pathWithoutLabels.map((e) => e.id));
+		const pathEntryIds = new Set(pathWithoutLabels.map(e => e.id));
 		const labelsToWrite: Array<{ targetId: string; label: string }> = [];
 		for (const [targetId, label] of this.labelsById) {
 			if (pathEntryIds.has(targetId)) {
@@ -1777,7 +1784,7 @@ export class SessionManager {
 		for (const { targetId, label } of labelsToWrite) {
 			const labelEntry: LabelEntry = {
 				type: "label",
-				id: generateId(new Set([...pathEntryIds, ...labelEntries.map((e) => e.id)])),
+				id: generateId(new Set([...pathEntryIds, ...labelEntries.map(e => e.id)])),
 				parentId,
 				timestamp: new Date().toISOString(),
 				targetId,
@@ -1816,10 +1823,10 @@ export class SessionManager {
 	): Promise<SessionManager> {
 		const dir = sessionDir ?? getDefaultSessionDir(cwd, storage);
 		const manager = new SessionManager(cwd, dir, true, storage);
-		const forkEntries = structuredClone(loadEntriesFromFile(sourcePath, storage)) as FileEntry[];
+		const forkEntries = structuredClone(await loadEntriesFromFile(sourcePath, storage)) as FileEntry[];
 		migrateToCurrentVersion(forkEntries);
-		const sourceHeader = forkEntries.find((e) => e.type === "session") as SessionHeader | undefined;
-		const historyEntries = forkEntries.filter((entry) => entry.type !== "session") as SessionEntry[];
+		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 });
 		const newHeader = manager.fileEntries[0] as SessionHeader;
 		newHeader.title = sourceHeader?.title;
@@ -1836,18 +1843,18 @@ export class SessionManager {
 	 * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
 	 */
 	static async open(
-		path: string,
+		filePath: string,
 		sessionDir?: string,
 		storage: SessionStorage = new FileSessionStorage(),
 	): Promise<SessionManager> {
 		// Extract cwd from session header if possible, otherwise use process.cwd()
-		const entries = loadEntriesFromFile(path, storage);
-		const header = entries.find((e) => e.type === "session") as SessionHeader | undefined;
+		const entries = await loadEntriesFromFile(filePath, storage);
+		const header = entries.find(e => e.type === "session") as SessionHeader | undefined;
 		const cwd = header?.cwd ?? process.cwd();
 		// If no sessionDir provided, derive from file's parent directory
-		const dir = sessionDir ?? resolve(path, "..");
+		const dir = sessionDir ?? path.resolve(filePath, "..");
 		const manager = new SessionManager(cwd, dir, true, storage);
-		await manager._initSessionFile(path);
+		await manager._initSessionFile(filePath);
 		return manager;
 	}
 
@@ -1862,7 +1869,7 @@ export class SessionManager {
 		storage: SessionStorage = new FileSessionStorage(),
 	): Promise<SessionManager> {
 		const dir = sessionDir ?? getDefaultSessionDir(cwd, storage);
-		const mostRecent = findMostRecentSession(dir, storage);
+		const mostRecent = await findMostRecentSession(dir, storage);
 		const manager = new SessionManager(cwd, dir, true, storage);
 		if (mostRecent) {
 			await manager._initSessionFile(mostRecent);
@@ -1884,11 +1891,15 @@ export class SessionManager {
 	 * @param cwd Working directory (used to compute default session directory)
 	 * @param sessionDir Optional session directory. If omitted, uses default (~/.omp/agent/sessions/<encoded-cwd>/).
 	 */
-	static list(cwd: string, sessionDir?: string, storage: SessionStorage = new FileSessionStorage()): SessionInfo[] {
+	static async list(
+		cwd: string,
+		sessionDir?: string,
+		storage: SessionStorage = new FileSessionStorage(),
+	): Promise<SessionInfo[]> {
 		const dir = sessionDir ?? getDefaultSessionDir(cwd, storage);
 		try {
 			const files = storage.listFilesSync(dir, "*.jsonl");
-			return collectSessionsFromFiles(files, storage);
+			return await collectSessionsFromFiles(files, storage);
 		} catch {
 			return [];
 		}
@@ -1897,13 +1908,13 @@ export class SessionManager {
 	/**
 	 * List all sessions across all project directories.
 	 */
-	static listAll(storage: SessionStorage = new FileSessionStorage()): SessionInfo[] {
-		const sessionsRoot = join(getDefaultAgentDir(), "sessions");
+	static async listAll(storage: SessionStorage = new FileSessionStorage()): Promise<SessionInfo[]> {
+		const sessionsRoot = path.join(getDefaultAgentDir(), "sessions");
 		try {
-			const files = Array.from(new Bun.Glob("**/*.jsonl").scanSync(sessionsRoot)).map((name) =>
-				join(sessionsRoot, name),
+			const files = Array.from(new Bun.Glob("**/*.jsonl").scanSync(sessionsRoot)).map(name =>
+				path.join(sessionsRoot, name),
 			);
-			return collectSessionsFromFiles(files, storage);
+			return await collectSessionsFromFiles(files, storage);
 		} catch {
 			return [];
 		}

package/src/session/session-storage.ts

@@ -1,17 +1,6 @@
-import {
-	closeSync,
-	existsSync,
-	fsyncSync,
-	mkdirSync,
-	openSync,
-	readFileSync,
-	readSync,
-	statSync,
-	writeFileSync,
-	writeSync,
-} from "node:fs";
-import { rename as renameAsync } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 
 export interface SessionStorageStat {
 	size: number;
@@ -30,14 +19,13 @@ export interface SessionStorageWriter {
 export interface SessionStorage {
 	ensureDirSync(dir: string): void;
 	existsSync(path: string): boolean;
-	readTextSync(path: string): string;
-	readTextPrefixSync(path: string, buf: Buffer): number;
 	writeTextSync(path: string, content: string): void;
 	statSync(path: string): SessionStorageStat;
 	listFilesSync(dir: string, pattern: string): string[];
 
 	exists(path: string): Promise<boolean>;
 	readText(path: string): Promise<string>;
+	readTextPrefix(path: string, maxBytes: number): Promise<string>;
 	writeText(path: string, content: string): Promise<void>;
 	rename(path: string, nextPath: string): Promise<void>;
 	unlink(path: string): Promise<void>;
@@ -50,9 +38,9 @@ function toError(value: unknown): Error {
 }
 
 // FinalizationRegistry to clean up leaked file descriptors
-const writerRegistry = new FinalizationRegistry<number>((fd) => {
+const writerRegistry = new FinalizationRegistry<number>(fd => {
 	try {
-		closeSync(fd);
+		fs.closeSync(fd);
 	} catch {
 		// Ignore - fd may already be closed or invalid
 	}
@@ -64,16 +52,16 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 	private error: Error | undefined;
 	private onError: ((err: Error) => void) | undefined;
 
-	constructor(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }) {
+	constructor(fpath: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }) {
 		this.onError = options?.onError;
 		const flags = options?.flags ?? "a";
 		// Ensure parent directory exists
-		const dir = dirname(path);
-		if (!existsSync(dir)) {
-			mkdirSync(dir, { recursive: true });
+		const dir = path.dirname(fpath);
+		if (!fs.existsSync(dir)) {
+			fs.mkdirSync(dir, { recursive: true });
 		}
 		// Open file once, keep fd for lifetime
-		this.fd = openSync(path, flags === "w" ? "w" : "a");
+		this.fd = fs.openSync(fpath, flags === "w" ? "w" : "a");
 		// Register for cleanup if abandoned without close()
 		writerRegistry.register(this, this.fd, this);
 	}
@@ -92,7 +80,7 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 			const buf = Buffer.from(line, "utf-8");
 			let offset = 0;
 			while (offset < buf.length) {
-				const written = writeSync(this.fd, buf, offset, buf.length - offset);
+				const written = fs.writeSync(this.fd, buf, offset, buf.length - offset);
 				if (written === 0) {
 					throw new Error("Short write");
 				}
@@ -112,7 +100,7 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 		if (this.closed) throw new Error("Writer closed");
 		if (this.error) throw this.error;
 		try {
-			fsyncSync(this.fd);
+			fs.fsyncSync(this.fd);
 		} catch (err) {
 			throw this.recordError(err);
 		}
@@ -124,7 +112,7 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 		// Unregister from finalization - we're closing properly
 		writerRegistry.unregister(this);
 		try {
-			closeSync(this.fd);
+			fs.closeSync(this.fd);
 		} catch {
 			// Ignore close errors
 		}
@@ -137,53 +125,56 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 
 export class FileSessionStorage implements SessionStorage {
 	ensureDirSync(dir: string): void {
-		if (!existsSync(dir)) {
-			mkdirSync(dir, { recursive: true });
+		if (!fs.existsSync(dir)) {
+			fs.mkdirSync(dir, { recursive: true });
 		}
 	}
 
 	existsSync(path: string): boolean {
-		return existsSync(path);
+		return fs.existsSync(path);
 	}
 
-	readTextSync(path: string): string {
-		return readFileSync(path, "utf-8");
-	}
-
-	readTextPrefixSync(path: string, buf: Buffer): number {
-		const fd = openSync(path, "r");
-		try {
-			const bytesRead = readSync(fd, buf, 0, buf.length, 0);
-			return bytesRead;
-		} finally {
-			closeSync(fd);
-		}
-	}
-
-	writeTextSync(path: string, content: string): void {
-		this.ensureDirSync(dirname(path));
-		writeFileSync(path, content);
+	writeTextSync(fpath: string, content: string): void {
+		this.ensureDirSync(path.dirname(fpath));
+		fs.writeFileSync(fpath, content);
 	}
 
 	statSync(path: string): SessionStorageStat {
-		const stats = statSync(path);
+		const stats = fs.statSync(path);
 		return { size: stats.size, mtimeMs: stats.mtimeMs, mtime: stats.mtime };
 	}
 
 	listFilesSync(dir: string, pattern: string): string[] {
 		try {
-			return Array.from(new Bun.Glob(pattern).scanSync(dir)).map((name) => join(dir, name));
+			return Array.from(new Bun.Glob(pattern).scanSync(dir)).map(name => path.join(dir, name));
 		} catch {
 			return [];
 		}
 	}
 
-	exists(path: string): Promise<boolean> {
-		return Bun.file(path).exists();
+	async exists(path: string): Promise<boolean> {
+		try {
+			await fs.promises.access(path);
+			return true;
+		} catch (err) {
+			if (isEnoent(err)) return false;
+			throw err;
+		}
 	}
 
 	readText(path: string): Promise<string> {
-		return Bun.file(path).text();
+		return fs.promises.readFile(path, "utf-8");
+	}
+
+	async readTextPrefix(path: string, maxBytes: number): Promise<string> {
+		const handle = await fs.promises.open(path, "r");
+		try {
+			const buffer = Buffer.alloc(maxBytes);
+			const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+			return buffer.subarray(0, bytesRead).toString("utf-8");
+		} finally {
+			await handle.close();
+		}
 	}
 
 	async writeText(path: string, content: string): Promise<void> {
@@ -192,23 +183,23 @@ export class FileSessionStorage implements SessionStorage {
 
 	async rename(path: string, nextPath: string): Promise<void> {
 		try {
-			await renameAsync(path, nextPath);
+			await fs.promises.rename(path, nextPath);
 		} catch (err) {
 			throw toError(err);
 		}
 	}
 
 	unlink(path: string): Promise<void> {
-		return Bun.file(path).unlink();
+		return fs.promises.unlink(path);
 	}
 
 	fsyncDirSync(dir: string): void {
 		try {
-			const fd = openSync(dir, "r");
+			const fd = fs.openSync(dir, "r");
 			try {
-				fsyncSync(fd);
+				fs.fsyncSync(fd);
 			} finally {
-				closeSync(fd);
+				fs.closeSync(fd);
 			}
 		} catch {
 			// Best-effort: some platforms/filesystems don't support fsync on directories.
@@ -265,7 +256,7 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		await this.ready;
 		if (this.error) throw this.error;
 		try {
-			const existing = this.storage.existsSync(this.path) ? this.storage.readTextSync(this.path) : "";
+			const existing = this.storage.existsSync(this.path) ? await this.storage.readText(this.path) : "";
 			await this.storage.writeText(this.path, `${existing}${line}`);
 		} catch (err) {
 			throw this.recordError(err);
@@ -305,17 +296,6 @@ export class MemorySessionStorage implements SessionStorage {
 		return this.files.has(path);
 	}
 
-	readTextSync(path: string): string {
-		const entry = this.files.get(path);
-		if (!entry) throw new Error(`File not found: ${path}`);
-		return entry.content;
-	}
-
-	readTextPrefixSync(path: string, buf: Buffer): number {
-		const content = this.readTextSync(path);
-		return buf.write(content, 0, buf.length, "utf-8");
-	}
-
 	writeTextSync(path: string, content: string): void {
 		this.files.set(path, { content, mtimeMs: Date.now() });
 	}
@@ -348,7 +328,15 @@ export class MemorySessionStorage implements SessionStorage {
 	}
 
 	readText(path: string): Promise<string> {
-		return Promise.resolve(this.readTextSync(path));
+		const entry = this.files.get(path);
+		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
+		return Promise.resolve(entry.content);
+	}
+
+	readTextPrefix(path: string, maxBytes: number): Promise<string> {
+		const entry = this.files.get(path);
+		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
+		return Promise.resolve(entry.content.slice(0, maxBytes));
 	}
 
 	writeText(path: string, content: string): Promise<void> {

package/src/session/storage-migration.ts

@@ -6,9 +6,8 @@
  * NOTE: Settings migration is now handled by SettingsManager.migrateToYaml(),
  * which migrates from both settings.json and agent.db to config.yaml.
  */
-
-import { getAgentDbPath } from "@oh-my-pi/pi-coding-agent/config";
 import { logger } from "@oh-my-pi/pi-utils";
+import { getAgentDbPath } from "../config";
 import { AgentStorage } from "./agent-storage";
 import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "./auth-storage";
 
@@ -128,7 +127,7 @@ async function migrateAuth(storage: AgentStorage, authPaths: string[], warnings:
 	for (const [provider, entry] of Object.entries(authJson.data)) {
 		const credentials = normalizeCredentialEntry(entry)
 			.filter(isValidCredential)
-			.map((credential) => credential);
+			.map(credential => credential);
 
 		if (credentials.length === 0) continue;
 		sawValid = true;

package/src/session/streaming-output.ts

@@ -1,5 +1,5 @@
-import { DEFAULT_MAX_BYTES } from "@oh-my-pi/pi-coding-agent/tools/truncate";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { DEFAULT_MAX_BYTES } from "../tools/truncate";
 
 export interface OutputSummary {
 	output: string;
@@ -141,7 +141,7 @@ export class OutputSink {
 		};
 
 		return new WritableStream<Uint8Array | string>({
-			write: async (chunk) => {
+			write: async chunk => {
 				if (typeof chunk === "string") {
 					await this.push(chunk);
 				} else {