@oh-my-pi/pi-coding-agent 15.8.2 → 15.9.0

package/src/session/session-manager.ts

@@ -270,6 +270,22 @@ export function getRestorableSessionModels(
 	return [roleModel, defaultModel];
 }
 
+/**
+ * Coarse lifecycle status of a session, derived from its last persisted message.
+ *
+ * - `complete` — the last assistant turn ended with no unanswered tool calls, i.e.
+ *   the agent yielded control back to the user.
+ * - `interrupted` — work was cut off mid-flight: a trailing assistant turn with
+ *   pending tool calls, a trailing tool result the agent never continued from, or
+ *   a length-truncated turn.
+ * - `aborted` — the last assistant turn was cancelled by the user.
+ * - `error` — the last assistant turn ended in an error.
+ * - `pending` — a trailing user message with no assistant reply persisted after it.
+ * - `unknown` — status could not be determined (empty/header-only session, or the
+ *   final message was larger than the tail window that was read).
+ */
+export type SessionStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
+
 export interface SessionInfo {
 	path: string;
 	id: string;
@@ -285,6 +301,11 @@ export interface SessionInfo {
 	size: number;
 	firstMessage: string;
 	allMessagesText: string;
+	/**
+	 * Coarse lifecycle status from the session's last persisted message. Optional:
+	 * synthesized {@link SessionInfo}s (cross-project stubs, tests) leave it unset.
+	 */
+	status?: SessionStatus;
 }
 
 export type ReadonlySessionManager = Pick<
@@ -1076,7 +1097,7 @@ async function getSortedSessions(sessionDir: string, storage: SessionStorage): P
 		await Promise.all(
 			files.map(async (path: string) => {
 				try {
-					const content = await storage.readTextPrefix(path, 4096);
+					const [content] = await storage.readTextSlices(path, 4096, 0);
 					const entries = parseJsonlLenient<Record<string, unknown>>(content);
 					if (entries.length === 0) return;
 					const header = entries[0] as Record<string, unknown>;
@@ -1528,21 +1549,79 @@ function extractTextFromContent(content: Message["content"]): string {
 }
 
 const SESSION_LIST_PREFIX_BYTES = 4096;
+/**
+ * Tail window read to derive {@link SessionStatus}. Large enough to capture a
+ * typical final assistant turn (thinking + text); when the final message exceeds
+ * it the status falls back to `unknown` rather than misreporting.
+ */
+const SESSION_LIST_SUFFIX_BYTES = 32_768;
 const SESSION_LIST_PARALLEL_THRESHOLD = 64;
 const SESSION_LIST_MAX_WORKERS = 16;
-const sessionListPrefixDecoder = new TextDecoder("utf-8", { fatal: false });
 
-async function readSessionListPrefix(file: string, storage: SessionStorage, buffer: Buffer): Promise<string> {
-	if (!(storage instanceof FileSessionStorage)) {
-		return storage.readTextPrefix(file, buffer.byteLength);
+/**
+ * Derive a {@link SessionStatus} from a tail window of a session file. Entries are
+ * newline-terminated on write, so within the window only the first line can be a
+ * partial fragment — it simply fails to parse and is skipped. We walk backwards to
+ * the last `message` entry and classify by its role / stop reason.
+ */
+function deriveSessionStatus(suffix: string): SessionStatus {
+	if (!suffix) return "unknown";
+	const lines = suffix.split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const line = lines[i];
+		// Every persisted entry is `JSON.stringify(obj)` → starts with `{`. This
+		// cheaply rejects blank lines and the leading partial fragment without
+		// attempting to parse a multi-KB tail of a truncated line.
+		if (line.charCodeAt(0) !== 123) continue;
+		let entry: { type?: string; message?: TailMessage };
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry.type === "message" && entry.message) {
+			return statusFromTailMessage(entry.message);
+		}
 	}
+	return "unknown";
+}
 
-	const handle = await fs.promises.open(file, "r");
-	try {
-		const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, 0);
-		return sessionListPrefixDecoder.decode(buffer.subarray(0, bytesRead));
-	} finally {
-		await handle.close();
+interface TailMessage {
+	role?: string;
+	stopReason?: string;
+	content?: unknown;
+}
+
+function isToolCallBlock(block: unknown): boolean {
+	return typeof block === "object" && block !== null && (block as { type?: unknown }).type === "toolCall";
+}
+
+function statusFromTailMessage(message: TailMessage): SessionStatus {
+	switch (message.role) {
+		case "assistant": {
+			switch (message.stopReason) {
+				case "error":
+					return "error";
+				case "aborted":
+					return "aborted";
+				case "length":
+					return "interrupted";
+			}
+			// A turn that ends without unanswered tool calls means the agent yielded
+			// control back to the user — complete. Trailing tool calls (no tool
+			// results after) mean the loop was cut off before running them.
+			const content = message.content;
+			if (Array.isArray(content) && content.some(isToolCallBlock)) return "interrupted";
+			return "complete";
+		}
+		case "toolResult":
+			// Tools ran but the agent never produced the following assistant turn.
+			return "interrupted";
+		case "user":
+			// User message with no assistant reply persisted after it.
+			return "pending";
+		default:
+			return "unknown";
 	}
 }
 
@@ -1677,13 +1756,15 @@ function getSessionListWorkerCount(fileCount: number): number {
 	);
 }
 
-async function collectSessionFromFile(
-	file: string,
-	storage: SessionStorage,
-	buffer: Buffer,
-): Promise<SessionInfo | undefined> {
+async function collectSessionFromFile(file: string, storage: SessionStorage): Promise<SessionInfo | undefined> {
 	try {
-		const content = await readSessionListPrefix(file, storage, buffer);
+		const stat = storage.statSync(file);
+		const [content, suffix] = await storage.readTextSlices(
+			file,
+			SESSION_LIST_PREFIX_BYTES,
+			SESSION_LIST_SUFFIX_BYTES,
+		);
+		const { size, mtime } = stat;
 		const entries = parseJsonlLenient<Record<string, unknown>>(content);
 		const header = parseSessionListHeader(content, entries);
 		if (!header) return undefined;
@@ -1719,7 +1800,6 @@ async function collectSessionFromFile(
 
 		firstMessage ||= extractFirstUserMessageFromPrefix(content) ?? "";
 		const messageCount = Math.max(parsedMessageCount, countMessageMarkers(content));
-		const stats = storage.statSync(file);
 		return {
 			path: file,
 			id: header.id,
@@ -1727,11 +1807,12 @@ async function collectSessionFromFile(
 			title: header.title ?? shortSummary,
 			parentSessionPath: header.parentSession,
 			created: new Date(header.timestamp ?? ""),
-			modified: stats.mtime,
+			modified: mtime,
 			messageCount,
-			size: stats.size,
+			size,
 			firstMessage: firstMessage || "(no messages)",
 			allMessagesText: allMessages.length > 0 ? allMessages.join(" ") : firstMessage,
+			status: deriveSessionStatus(suffix),
 		};
 	} catch {
 		return undefined;
@@ -1745,10 +1826,9 @@ async function collectSessionsFromFileStride(
 	stride: number,
 ): Promise<SessionInfo[]> {
 	const sessions: SessionInfo[] = [];
-	const buffer = Buffer.allocUnsafe(SESSION_LIST_PREFIX_BYTES);
 
 	for (let i = startIndex; i < files.length; i += stride) {
-		const session = await collectSessionFromFile(files[i], storage, buffer);
+		const session = await collectSessionFromFile(files[i], storage);
 		if (session) sessions.push(session);
 	}
 

package/src/session/session-storage.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-import { isEnoent, peekFile, toError } from "@oh-my-pi/pi-utils";
+import { isEnoent, peekFileEnds, toError } from "@oh-my-pi/pi-utils";
 
 const utf8Decoder = new TextDecoder("utf-8");
 
@@ -31,13 +31,13 @@ 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[];
 
 	exists(path: string): Promise<boolean>;
 	readText(path: string): Promise<string>;
-	readTextPrefix(path: string, maxBytes: number): Promise<string>;
+	/** Read the requested UTF-8 byte windows from the head and tail of the file. */
+	readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
 	writeText(path: string, content: string): Promise<void>;
 	rename(path: string, nextPath: string): Promise<void>;
 	unlink(path: string): Promise<void>;
@@ -151,10 +151,6 @@ 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 };
@@ -182,8 +178,11 @@ export class FileSessionStorage implements SessionStorage {
 		return Bun.file(path).text();
 	}
 
-	async readTextPrefix(path: string, maxBytes: number): Promise<string> {
-		return peekFile(path, maxBytes, header => utf8Decoder.decode(header));
+	async readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]> {
+		return peekFileEnds(path, prefixBytes, suffixBytes, (head, tail) => [
+			utf8Decoder.decode(head),
+			utf8Decoder.decode(tail),
+		]);
 	}
 
 	async writeText(path: string, content: string): Promise<void> {
@@ -272,8 +271,8 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		if (this.#closed) throw new Error("Writer closed");
 		if (this.#error) throw this.#error;
 		try {
-			// O(1) chunked append — see MemorySessionStorage.appendChunkSync.
-			this.#storage.appendChunkSync(this.#path, line);
+			// O(1) append — push onto the path's indexed in-memory entry.
+			this.#storage.appendSync(this.#path, line);
 		} catch (err) {
 			throw this.#recordError(err);
 		}
@@ -302,26 +301,140 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 	}
 }
 
-/**
- * Mirror entry stored per path. Chunks accumulate via O(1) `push` on
- * `appendChunkSync`; readers materialise into a single string lazily.
- * `byteLen` is kept in sync so `statSync` is O(1) (and returns true UTF-8
- * bytes, not character count).
- */
-interface MirrorEntry {
+interface MemoryFileEntry {
 	chunks: string[];
-	byteLen: number;
+	cumulativeBytes: number[];
+	size: number;
 	mtimeMs: number;
 }
 
-function materialiseMirror(entry: MirrorEntry): string {
-	if (entry.chunks.length === 0) return "";
-	if (entry.chunks.length === 1) return entry.chunks[0];
-	return entry.chunks.join("");
+function createMemoryFileEntry(content: string, mtimeMs: number): MemoryFileEntry {
+	const size = Buffer.byteLength(content, "utf-8");
+	return {
+		chunks: size === 0 ? [] : [content],
+		cumulativeBytes: size === 0 ? [] : [size],
+		size,
+		mtimeMs,
+	};
+}
+
+function appendMemoryChunk(entry: MemoryFileEntry, chunk: string): void {
+	const chunkSize = Buffer.byteLength(chunk, "utf-8");
+	if (chunkSize === 0) return;
+	entry.size += chunkSize;
+	entry.chunks.push(chunk);
+	entry.cumulativeBytes.push(entry.size);
+}
+
+function normalizeByteLimit(maxBytes: number, size: number): number {
+	if (!(maxBytes > 0) || size === 0) return 0;
+	return Math.min(Math.trunc(maxBytes), size);
+}
+
+function lowerBound(values: readonly number[], target: number): number {
+	let lo = 0;
+	let hi = values.length;
+	while (lo < hi) {
+		const mid = (lo + hi) >>> 1;
+		if (values[mid] < target) {
+			lo = mid + 1;
+		} else {
+			hi = mid;
+		}
+	}
+	return lo;
+}
+
+function upperBound(values: readonly number[], target: number): number {
+	let lo = 0;
+	let hi = values.length;
+	while (lo < hi) {
+		const mid = (lo + hi) >>> 1;
+		if (values[mid] <= target) {
+			lo = mid + 1;
+		} else {
+			hi = mid;
+		}
+	}
+	return lo;
+}
+
+function joinChunkRange(chunks: readonly string[], start: number, end: number): string {
+	const count = end - start;
+	if (count <= 0) return "";
+	if (count === 1) return chunks[start] ?? "";
+
+	let content = "";
+	for (let i = start; i < end; i++) {
+		content += chunks[i];
+	}
+	return content;
+}
+
+function decodeChunkByteRange(chunk: string, startByte: number, endByte: number, chunkSize: number): string {
+	if (startByte >= endByte) return "";
+	if (startByte === 0 && endByte === chunkSize) return chunk;
+	if (chunk.length === chunkSize) return chunk.slice(startByte, endByte);
+	const bytes = Buffer.from(chunk, "utf-8");
+	return utf8Decoder.decode(bytes.subarray(startByte, endByte));
+}
+
+function materializeMemoryEntry(entry: MemoryFileEntry): string {
+	const { chunks } = entry;
+	if (chunks.length === 0) return "";
+	if (chunks.length === 1) return chunks[0];
+
+	const content = chunks.join("");
+	entry.chunks = [content];
+	entry.cumulativeBytes = [entry.size];
+	return content;
+}
+
+function sliceChunksHead(entry: MemoryFileEntry, maxBytes: number): string {
+	const limit = normalizeByteLimit(maxBytes, entry.size);
+	if (limit === 0) return "";
+	if (limit >= entry.size) return materializeMemoryEntry(entry);
+
+	const boundaryIndex = lowerBound(entry.cumulativeBytes, limit);
+	const chunkStart = boundaryIndex === 0 ? 0 : entry.cumulativeBytes[boundaryIndex - 1];
+	const chunkEnd = entry.cumulativeBytes[boundaryIndex];
+	if (chunkEnd === limit) return joinChunkRange(entry.chunks, 0, boundaryIndex + 1);
+
+	const chunk = entry.chunks[boundaryIndex];
+	const chunkPrefix = decodeChunkByteRange(chunk, 0, limit - chunkStart, chunkEnd - chunkStart);
+	return joinChunkRange(entry.chunks, 0, boundaryIndex) + chunkPrefix;
+}
+
+function sliceChunksTail(entry: MemoryFileEntry, maxBytes: number): string {
+	const limit = normalizeByteLimit(maxBytes, entry.size);
+	if (limit === 0) return "";
+	if (limit >= entry.size) return materializeMemoryEntry(entry);
+
+	const startByte = entry.size - limit;
+	const boundaryIndex = upperBound(entry.cumulativeBytes, startByte);
+	const chunkStart = boundaryIndex === 0 ? 0 : entry.cumulativeBytes[boundaryIndex - 1];
+	const chunkEnd = entry.cumulativeBytes[boundaryIndex];
+	const chunkOffset = startByte - chunkStart;
+	if (chunkOffset === 0) return joinChunkRange(entry.chunks, boundaryIndex, entry.chunks.length);
+
+	const chunk = entry.chunks[boundaryIndex];
+	const chunkSuffix = decodeChunkByteRange(chunk, chunkOffset, chunkEnd - chunkStart, chunkEnd - chunkStart);
+	return chunkSuffix + joinChunkRange(entry.chunks, boundaryIndex + 1, entry.chunks.length);
 }
 
 export class MemorySessionStorage implements SessionStorage {
-	#files = new Map<string, MirrorEntry>();
+	// Each path keeps appended string chunks plus cumulative UTF-8 byte offsets.
+	// Full reads materialize the chunks into one string chunk, so repeated reads
+	// do not re-join stale history. Later appends still stay O(1) by pushing
+	// after that materialized chunk. Prefix/suffix reads binary-search byte
+	// offsets and join only the requested window.
+	#files = new Map<string, MemoryFileEntry>();
+
+	#requireEntry(path: string): MemoryFileEntry {
+		const entry = this.#files.get(path);
+		if (!entry) throw new Error(`File not found: ${path}`);
+		return entry;
+	}
 
 	ensureDirSync(_dir: string): void {
 		// No-op for in-memory storage.
@@ -332,11 +445,7 @@ export class MemorySessionStorage implements SessionStorage {
 	}
 
 	writeTextSync(path: string, content: string): void {
-		this.#files.set(path, {
-			chunks: content.length === 0 ? [] : [content],
-			byteLen: Buffer.byteLength(content, "utf-8"),
-			mtimeMs: Date.now(),
-		});
+		this.#files.set(path, createMemoryFileEntry(content, Date.now()));
 	}
 
 	/**
@@ -344,28 +453,21 @@ export class MemorySessionStorage implements SessionStorage {
 	 * creates the entry. External callers should go through `openWriter()`
 	 * rather than touching the mirror directly.
 	 */
-	appendChunkSync(path: string, chunk: string): void {
+	appendSync(path: string, chunk: string): void {
+		const mtimeMs = Date.now();
 		let entry = this.#files.get(path);
 		if (!entry) {
-			entry = { chunks: [], byteLen: 0, mtimeMs: Date.now() };
+			entry = createMemoryFileEntry("", mtimeMs);
 			this.#files.set(path, entry);
 		}
-		entry.chunks.push(chunk);
-		entry.byteLen += Buffer.byteLength(chunk, "utf-8");
-		entry.mtimeMs = Date.now();
-	}
-
-	readTextSync(path: string): string {
-		const entry = this.#files.get(path);
-		if (!entry) throw new Error(`File not found: ${path}`);
-		return materialiseMirror(entry);
+		appendMemoryChunk(entry, chunk);
+		entry.mtimeMs = mtimeMs;
 	}
 
 	statSync(path: string): SessionStorageStat {
-		const entry = this.#files.get(path);
-		if (!entry) throw new Error(`File not found: ${path}`);
+		const entry = this.#requireEntry(path);
 		return {
-			size: entry.byteLen,
+			size: entry.size,
 			mtimeMs: entry.mtimeMs,
 			mtime: new Date(entry.mtimeMs),
 		};
@@ -391,35 +493,13 @@ export class MemorySessionStorage implements SessionStorage {
 	readText(path: string): Promise<string> {
 		const entry = this.#files.get(path);
 		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
-		return Promise.resolve(materialiseMirror(entry));
+		return Promise.resolve(materializeMemoryEntry(entry));
 	}
 
-	readTextPrefix(path: string, maxBytes: number): Promise<string> {
+	readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]> {
 		const entry = this.#files.get(path);
 		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
-		if (entry.chunks.length === 0 || maxBytes <= 0) return Promise.resolve("");
-
-		// Walk chunks until the byte budget is exhausted. Avoids materialising
-		// the full mirror just to slice a prefix — bounded work for big files.
-		let accumulatedBytes = 0;
-		const out: string[] = [];
-		for (const chunk of entry.chunks) {
-			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
-			if (accumulatedBytes + chunkBytes <= maxBytes) {
-				out.push(chunk);
-				accumulatedBytes += chunkBytes;
-				if (accumulatedBytes === maxBytes) break;
-				continue;
-			}
-			// Boundary chunk: slice in byte space and decode. Result MAY be
-			// shorter than the budget if a multi-byte codepoint straddles the
-			// boundary — matches `peekFile` semantics (partial decode at cap).
-			const remainingBytes = maxBytes - accumulatedBytes;
-			const utf8 = Buffer.from(chunk, "utf-8");
-			out.push(utf8Decoder.decode(utf8.subarray(0, remainingBytes)));
-			break;
-		}
-		return Promise.resolve(out.join(""));
+		return Promise.resolve([sliceChunksHead(entry, prefixBytes), sliceChunksTail(entry, suffixBytes)]);
 	}
 
 	writeText(path: string, content: string): Promise<void> {