@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.3

package/src/session/redis-session-storage.ts

@@ -4,6 +4,7 @@ import {
 	type SessionStorageBackend,
 	type SessionStorageIndexEntry,
 } from "./indexed-session-storage";
+import type { SessionTitleUpdate } from "./session-title-slot";
 
 /**
  * Minimal subset of the `bun:redis` `RedisClient` surface used by
@@ -44,6 +45,28 @@ export interface RedisSessionStorageOptions {
 const DEFAULT_PREFIX = "omp:sessions:";
 const DEFAULT_SCAN_COUNT = 500;
 
+function encodeTitleMeta(title: SessionTitleUpdate): string {
+	return JSON.stringify(title);
+}
+
+function decodeTitleMeta(raw: string | undefined): SessionTitleUpdate | undefined {
+	if (!raw) return undefined;
+	try {
+		const parsed = JSON.parse(raw) as unknown;
+		if (typeof parsed !== "object" || parsed === null) return undefined;
+		const record = parsed as Record<string, unknown>;
+		if (typeof record.updatedAt !== "string") return undefined;
+		const source = record.source === "auto" || record.source === "user" ? record.source : undefined;
+		return {
+			title: typeof record.title === "string" ? record.title : undefined,
+			source,
+			updatedAt: record.updatedAt,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
 /**
  * Redis-backed implementation of {@link SessionStorage}. Each session JSONL
  * file maps to a Redis STRING key, with per-key metadata (mtime) tracked in a
@@ -83,8 +106,9 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 	async loadIndex(): Promise<SessionStorageIndexEntry[]> {
 		const filePrefix = this.#fileKey("");
 		const metaRaw = await this.#client.hgetall(this.#metaKey());
+		const titleRaw = await this.#client.hgetall(this.#titleMetaKey());
 		const meta: Record<string, string> = metaRaw ?? {};
-
+		const titles: Record<string, string> = titleRaw ?? {};
 		const seen = new Set<string>();
 		let cursor = "0";
 		do {
@@ -106,10 +130,14 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 				const size = await this.#client.strlen(key);
 				const rawMtime = meta[path];
 				const parsedMtime = rawMtime === undefined ? Number.NaN : Number(rawMtime);
+				const title = decodeTitleMeta(titles[path]);
 				return {
 					path,
 					size,
 					mtimeMs: Number.isFinite(parsedMtime) ? parsedMtime : fallbackMtimeMs,
+					title: title?.title,
+					titleSource: title?.source,
+					titleUpdatedAt: title?.updatedAt,
 				};
 			}),
 		);
@@ -126,9 +154,14 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 		return Promise.all([head, tail]);
 	}
 
-	async writeFull(path: string, content: string, mtimeMs: number): Promise<void> {
+	async writeFull(path: string, content: string, mtimeMs: number, title?: SessionTitleUpdate): Promise<void> {
 		await this.#client.set(this.#fileKey(path), content);
 		await this.#client.hset(this.#metaKey(), path, String(mtimeMs));
+		if (title) {
+			await this.#client.hset(this.#titleMetaKey(), path, encodeTitleMeta(title));
+		} else {
+			await this.#client.hdel(this.#titleMetaKey(), path);
+		}
 	}
 
 	async append(path: string, line: string, mtimeMs: number): Promise<void> {
@@ -136,6 +169,11 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 		await this.#client.hset(this.#metaKey(), path, String(mtimeMs));
 	}
 
+	async updateSessionTitle(path: string, title: SessionTitleUpdate, mtimeMs: number): Promise<void> {
+		await this.#client.hset(this.#metaKey(), path, String(mtimeMs));
+		await this.#client.hset(this.#titleMetaKey(), path, encodeTitleMeta(title));
+	}
+
 	async truncate(path: string, mtimeMs: number): Promise<void> {
 		await this.writeFull(path, "", mtimeMs);
 	}
@@ -144,13 +182,18 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 		if (paths.length === 0) return;
 		await this.#client.del(...paths.map(path => this.#fileKey(path)));
 		await this.#client.hdel(this.#metaKey(), ...paths);
+		await this.#client.hdel(this.#titleMetaKey(), ...paths);
 	}
 
 	async move(src: string, dst: string, mtimeMs: number): Promise<void> {
 		await this.#client.rename(this.#fileKey(src), this.#fileKey(dst));
 		try {
+			const titleMeta = await this.#client.hgetall(this.#titleMetaKey());
 			await this.#client.hdel(this.#metaKey(), src);
 			await this.#client.hset(this.#metaKey(), dst, String(mtimeMs));
+			await this.#client.hdel(this.#titleMetaKey(), src);
+			const title = titleMeta[src];
+			if (title !== undefined) await this.#client.hset(this.#titleMetaKey(), dst, title);
 		} catch (err) {
 			logger.warn("Redis session storage meta rename failed", {
 				src,
@@ -167,4 +210,8 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 	#metaKey(): string {
 		return `${this.#prefix}meta`;
 	}
+
+	#titleMetaKey(): string {
+		return `${this.#prefix}title`;
+	}
 }

package/src/session/session-entries.ts

@@ -3,6 +3,24 @@ import type { ImageContent, MessageAttribution, ServiceTier, TextContent } from
 
 export const CURRENT_SESSION_VERSION = 3;
 
+export const SESSION_TITLE_SLOT_BYTES = 256;
+
+export const SESSION_TITLE_SLOT_ENTRY_TYPE = "title";
+
+export const TITLE_CHANGE_ENTRY_TYPE = "title_change";
+
+export type SessionTitleSource = "auto" | "user";
+
+/** Fixed-width first-line slot carrying the mutable current session title. */
+export interface SessionTitleSlotEntry {
+	type: typeof SESSION_TITLE_SLOT_ENTRY_TYPE;
+	v: 1;
+	title: string;
+	source?: SessionTitleSource;
+	updatedAt: string;
+	pad: string;
+}
+
 export const EPHEMERAL_MODEL_CHANGE_ROLE = "fallback";
 
 export interface SessionHeader {
@@ -10,7 +28,7 @@ export interface SessionHeader {
 	version?: number; // v1 sessions don't have this
 	id: string;
 	title?: string; // Auto-generated title from first message
-	titleSource?: "auto" | "user";
+	titleSource?: SessionTitleSource;
 	timestamp: string;
 	cwd: string;
 	parentSession?: string;
@@ -105,6 +123,21 @@ export interface LabelEntry extends SessionEntryBase {
 	label: string | undefined;
 }
 
+/** Append-only audit entry recording a session title change. */
+export interface TitleChangeEntry extends SessionEntryBase {
+	type: typeof TITLE_CHANGE_ENTRY_TYPE;
+	title: string;
+	previousTitle?: string;
+	source: SessionTitleSource;
+	trigger?: string;
+}
+
+declare module "@oh-my-pi/pi-agent-core/compaction/entries" {
+	interface CustomCompactionSessionEntries {
+		titleChange: TitleChangeEntry;
+	}
+}
+
 /** TTSR injection entry - tracks which time-traveling rules have been injected this session. */
 export interface TtsrInjectionEntry extends SessionEntryBase {
 	type: "ttsr_injection";
@@ -178,14 +211,18 @@ export type SessionEntry =
 	| CustomEntry
 	| CustomMessageEntry
 	| LabelEntry
+	| TitleChangeEntry
 	| TtsrInjectionEntry
 	| MCPToolSelectionEntry
 	| SessionInitEntry
 	| ModeChangeEntry;
 
-/** Raw file entry (includes header) */
+/** Raw logical file entry after loaders strip any fixed-width title slot. */
 export type FileEntry = SessionHeader | SessionEntry;
 
+/** Physical JSONL entry before slot-aware loaders fold the title slot. */
+export type RawFileEntry = SessionTitleSlotEntry | FileEntry;
+
 /** Tree node for getTree() - defensive copy of session structure */
 export interface SessionTreeNode {
 	entry: SessionEntry;

package/src/session/session-history-format.ts

@@ -40,6 +40,12 @@ export interface HistoryFormatOptions {
 	 * still collapse to a one-liner.
 	 */
 	expandPrimaryContext?: boolean;
+	/**
+	 * Append the full unified diff (from a tool result's `details.diff`) below
+	 * edit/apply_patch tool lines, instead of just the path. The advisor sets
+	 * this so it sees what changed without re-reading the file.
+	 */
+	expandEditDiffs?: boolean;
 }
 
 /** Max length of the primary-arg summary inside `→ tool(...)` lines. */
@@ -139,12 +145,24 @@ function primaryArg(name: string, args: Record<string, unknown> | undefined): st
 	}
 }
 
+/**
+ * Wrap a diff body in a backtick fence sized to outlast the longest backtick
+ * run inside it, so a diff that touches markdown (triple backticks) can't break
+ * out of the fence. Info string `diff` for syntax highlighting.
+ */
+function fenceDiff(diff: string): string {
+	const longest = diff.match(/`+/g)?.reduce((m, run) => Math.max(m, run.length), 0) ?? 0;
+	const fence = "`".repeat(Math.max(3, longest + 1));
+	return `${fence}diff\n${diff}\n${fence}`;
+}
+
 /** One line per tool call: `→ read(src/foo.ts:50-80) ⇒ ok · 31 lines`. */
 function toolCallLine(
 	name: string,
 	args: Record<string, unknown> | undefined,
 	result: ToolResultMessage | undefined,
 	includeToolIntent?: boolean,
+	expandEditDiffs?: boolean,
 ): string {
 	const head = `→ ${name}(${primaryArg(name, args)})`;
 	let base: string;
@@ -162,6 +180,13 @@ function toolCallLine(
 		}
 	}
 
+	if (expandEditDiffs) {
+		const diff = (result?.details as { diff?: unknown } | undefined)?.diff;
+		if (typeof diff === "string" && diff.trim()) {
+			base = `${base}\n${fenceDiff(diff)}`;
+		}
+	}
+
 	const intent = includeToolIntent ? args?.[INTENT_FIELD] : undefined;
 	if (typeof intent === "string" && intent.trim()) {
 		const formattedIntent = oneLine(intent, 80);
@@ -280,7 +305,9 @@ export function formatSessionHistoryMarkdown(messages: unknown[], opts?: History
 					} else if (block.type === "toolCall") {
 						const result = resultsByCallId.get(block.id);
 						if (result) consumed.add(block.id);
-						body.push(toolCallLine(block.name, block.arguments, result, opts?.includeToolIntent));
+						body.push(
+							toolCallLine(block.name, block.arguments, result, opts?.includeToolIntent, opts?.expandEditDiffs),
+						);
 					} else if (opts?.includeThinking && block.type === "thinking" && block.thinking.trim()) {
 						body.push(`_thinking:_ ${block.thinking}`);
 					}
@@ -303,7 +330,7 @@ export function formatSessionHistoryMarkdown(messages: unknown[], opts?: History
 			case "toolResult": {
 				// Normally consumed by its toolCall; orphans (e.g. truncated history) get their own line.
 				if (consumed.has(msg.toolCallId)) break;
-				lines.push(toolCallLine(msg.toolName, undefined, msg, opts?.includeToolIntent), "");
+				lines.push(toolCallLine(msg.toolName, undefined, msg, opts?.includeToolIntent, opts?.expandEditDiffs), "");
 				lastWatchedLabel = undefined;
 				break;
 			}

package/src/session/session-listing.ts

@@ -270,39 +270,69 @@ interface SessionListHeader {
 	timestamp?: string;
 }
 
-function parseSessionListHeader(
-	content: string,
-	entries: Array<Record<string, unknown>>,
-): SessionListHeader | undefined {
-	const parsedHeader = entries[0];
-	if (parsedHeader?.type === "session" && typeof parsedHeader.id === "string") {
-		return {
-			type: "session",
-			id: parsedHeader.id,
-			cwd: typeof parsedHeader.cwd === "string" ? parsedHeader.cwd : undefined,
-			title: typeof parsedHeader.title === "string" ? parsedHeader.title : undefined,
-			parentSession: typeof parsedHeader.parentSession === "string" ? parsedHeader.parentSession : undefined,
-			timestamp: typeof parsedHeader.timestamp === "string" ? parsedHeader.timestamp : undefined,
-		};
-	}
+function normalizeTitleOverride(title: string | undefined): string | null | undefined {
+	if (title === undefined) return undefined;
+	return title.trim() ? title : null;
+}
 
-	const firstLineEnd = content.indexOf("\n");
-	const firstLine = firstLineEnd === -1 ? content : content.slice(0, firstLineEnd);
-	if (extractStringProperty(firstLine, "type") !== "session") return undefined;
+function sessionListHeaderFromRecord(
+	record: Record<string, unknown> | undefined,
+	titleOverride?: string | null,
+): SessionListHeader | undefined {
+	if (record?.type !== "session" || typeof record.id !== "string") return undefined;
+	return {
+		type: "session",
+		id: record.id,
+		cwd: typeof record.cwd === "string" ? record.cwd : undefined,
+		title:
+			titleOverride === null
+				? undefined
+				: (titleOverride ?? (typeof record.title === "string" ? record.title : undefined)),
+		parentSession: typeof record.parentSession === "string" ? record.parentSession : undefined,
+		timestamp: typeof record.timestamp === "string" ? record.timestamp : undefined,
+	};
+}
 
-	const id = extractStringProperty(firstLine, "id");
+function parseSessionListHeaderLine(line: string, titleOverride?: string | null): SessionListHeader | undefined {
+	if (extractStringProperty(line, "type") !== "session") return undefined;
+	const id = extractStringProperty(line, "id");
 	if (!id) return undefined;
-
 	return {
 		type: "session",
 		id,
-		cwd: extractStringProperty(firstLine, "cwd"),
-		title: extractStringProperty(firstLine, "title"),
-		parentSession: extractStringProperty(firstLine, "parentSession"),
-		timestamp: extractStringProperty(firstLine, "timestamp"),
+		cwd: extractStringProperty(line, "cwd"),
+		title: titleOverride === null ? undefined : (titleOverride ?? extractStringProperty(line, "title")),
+		parentSession: extractStringProperty(line, "parentSession"),
+		timestamp: extractStringProperty(line, "timestamp"),
 	};
 }
 
+function parseSessionListHeader(
+	content: string,
+	entries: Array<Record<string, unknown>>,
+): SessionListHeader | undefined {
+	const firstEntry = entries[0];
+	const parsedSlotTitle = normalizeTitleOverride(
+		firstEntry?.type === "title" && typeof firstEntry.title === "string" ? firstEntry.title : undefined,
+	);
+	const parsedHeader = sessionListHeaderFromRecord(entries[firstEntry?.type === "title" ? 1 : 0], parsedSlotTitle);
+	if (parsedHeader) return parsedHeader;
+
+	let slotTitle: string | null | undefined;
+	let firstNonEmpty = true;
+	for (const rawLine of content.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		if (firstNonEmpty && extractStringProperty(line, "type") === "title") {
+			slotTitle = normalizeTitleOverride(extractStringProperty(line, "title"));
+			firstNonEmpty = false;
+			continue;
+		}
+		return parseSessionListHeaderLine(line, slotTitle);
+	}
+	return undefined;
+}
+
 function getSessionListWorkerCount(fileCount: number): number {
 	if (fileCount <= SESSION_LIST_PARALLEL_THRESHOLD) return 1;
 	return Math.min(

package/src/session/session-loader.ts

@@ -2,14 +2,77 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { getBlobsDir, isEnoent, parseJsonlLenient } from "@oh-my-pi/pi-utils";
 import { BlobStore, isBlobRef, resolveImageData, resolveImageDataUrl } from "./blob-store";
 import { buildSessionContext } from "./session-context";
-import type { FileEntry, SessionEntry, SessionHeader } from "./session-entries";
+import {
+	type FileEntry,
+	type RawFileEntry,
+	SESSION_TITLE_SLOT_BYTES,
+	type SessionEntry,
+	type SessionHeader,
+	type SessionTitleSlotEntry,
+} from "./session-entries";
 import { migrateToCurrentVersion } from "./session-migrations";
 import { isImageBlock, isImageDataPayload } from "./session-persistence";
 import { FileSessionStorage, type SessionStorage } from "./session-storage";
+import {
+	parseTitleSlotFromContent,
+	parseTitleSlotLine,
+	type SessionTitleUpdate,
+	titleUpdateFromSlot,
+} from "./session-title-slot";
 
+function splitTitleSlot(content: string): { body: string; slot: SessionTitleUpdate | undefined } {
+	const slot = titleUpdateFromSlot(parseTitleSlotFromContent(content));
+	if (!slot) return { body: content, slot: undefined };
+	const newlineIndex = content.indexOf("\n");
+	return { body: content.slice(newlineIndex + 1), slot };
+}
+
+function foldTitleSlot(entries: FileEntry[], slot: SessionTitleUpdate | undefined): FileEntry[] {
+	if (!slot || entries.length === 0) return entries;
+	const header = entries[0] as SessionHeader;
+	if (header.type !== "session" || typeof header.id !== "string") return entries;
+	if (slot.title && slot.title.length > 0) {
+		header.title = slot.title;
+	} else {
+		delete header.title;
+	}
+	if (slot.source) {
+		header.titleSource = slot.source;
+	} else {
+		delete header.titleSource;
+	}
+	return entries;
+}
+
+/** Parse session JSONL while stripping and folding the optional fixed title slot. */
+export function parseSessionContent(content: string): {
+	entries: FileEntry[];
+	titleSlot: SessionTitleUpdate | undefined;
+} {
+	const { body, slot } = splitTitleSlot(content);
+	const entries = parseJsonlLenient<RawFileEntry>(body) as FileEntry[];
+	return { entries: foldTitleSlot(entries, slot), titleSlot: slot };
+}
+
+/** Read only the fixed-size head window to detect a physical title slot. */
+export async function readTitleSlotFromFile(
+	filePath: string,
+	storage: SessionStorage = new FileSessionStorage(),
+): Promise<SessionTitleSlotEntry | undefined> {
+	let head: string;
+	try {
+		[head] = await storage.readTextSlices(filePath, SESSION_TITLE_SLOT_BYTES, 0);
+	} catch (err) {
+		if (isEnoent(err)) return undefined;
+		throw err;
+	}
+	const newlineIndex = head.indexOf("\n");
+	if (newlineIndex < 0) return undefined;
+	return parseTitleSlotLine(head.slice(0, newlineIndex));
+}
 /** Exported for compaction.test.ts */
 export function parseSessionEntries(content: string): FileEntry[] {
-	return parseJsonlLenient<FileEntry>(content);
+	return parseSessionContent(content).entries;
 }
 
 /** Exported for testing */
@@ -24,7 +87,7 @@ export async function loadEntriesFromFile(
 		if (isEnoent(err)) return [];
 		throw err;
 	}
-	const entries = parseJsonlLenient<FileEntry>(content);
+	const { entries } = parseSessionContent(content);
 
 	// Validate session header
 	if (entries.length === 0) return entries;