@gajae-code/coding-agent 0.11.10 → 0.12.0

package/src/modes/components/queue-pane.ts

@@ -1,11 +1,12 @@
 import { Container, matchesKey, type SelectItem, SelectList, Spacer, Text } from "@gajae-code/tui";
+import { formatKeyHint } from "../../config/keybindings";
 import type { QueuedMessageEditEntry } from "../../session/agent-session";
 import { getSelectListTheme, theme } from "../theme/theme";
 import { DynamicBorder } from "./dynamic-border";
 
 const MAX_VISIBLE_QUEUE_MESSAGES = 8;
-const RAW_UP = "\x1b[A";
-const RAW_DOWN = "\x1b[B";
+type QueueSelectorAction = "tui.select.confirm" | "tui.select.cancel";
+type QueueSelectorNavigationAction = "tui.select.up" | "tui.select.down" | "tui.select.pageUp" | "tui.select.pageDown";
 
 export class QueuePaneComponent extends Container {
 	#selectList: SelectList;
@@ -13,11 +14,20 @@ export class QueuePaneComponent extends Container {
 	#selectedIndex: number;
 	#onDelete: (entry: QueuedMessageEditEntry, index: number) => void;
 	#onMove: (entry: QueuedMessageEditEntry, index: number, direction: "up" | "down") => void;
-
+	#onSelect: (entry: QueuedMessageEditEntry) => void;
+	#onClose: () => void;
+	#entries: QueuedMessageEditEntry[];
+	#matchesSelectAction: (keyData: string, action: QueueSelectorAction) => boolean;
+	#resolveSelectNavigation: (keyData: string) => QueueSelectorNavigationAction | undefined;
 	constructor(
 		entries: QueuedMessageEditEntry[],
 		options: {
 			selectedIndex?: number;
+			formatKeyHint?: (key: string) => string;
+			formatSelectAction?: (action: QueueSelectorAction) => string;
+			matchesSelectAction?: (keyData: string, action: QueueSelectorAction) => boolean;
+			resolveSelectNavigation?: (keyData: string) => QueueSelectorNavigationAction | undefined;
+			onSelect: (entry: QueuedMessageEditEntry) => void;
 			onDelete: (entry: QueuedMessageEditEntry, index: number) => void;
 			onMove: (entry: QueuedMessageEditEntry, index: number, direction: "up" | "down") => void;
 			onClose: () => void;
@@ -25,23 +35,46 @@ export class QueuePaneComponent extends Container {
 	) {
 		super();
 		this.#onDelete = options.onDelete;
+		this.#onSelect = options.onSelect;
 		this.#onMove = options.onMove;
+		this.#onClose = options.onClose;
+		this.#entries = entries;
+		this.#matchesSelectAction =
+			options.matchesSelectAction ??
+			((keyData, action) => matchesKey(keyData, action === "tui.select.confirm" ? "enter" : "escape"));
+		this.#resolveSelectNavigation = options.resolveSelectNavigation ?? (() => undefined);
 		this.#selectedIndex = Math.max(0, Math.min(options.selectedIndex ?? 0, entries.length - 1));
 		this.#selectedEntry = entries[this.#selectedIndex];
 		const byId = new Map(entries.map(entry => [entry.id, entry]));
+		const displayKey = options.formatKeyHint ?? formatKeyHint;
+		const selectKeys = `${displayKey("alt+up")}/${displayKey("alt+down")}`;
+		const editKey = options.formatSelectAction
+			? options.formatSelectAction("tui.select.confirm") || "Disabled"
+			: displayKey("enter");
+		const deleteKey = displayKey("delete");
+		const moveKeys = `${displayKey("ctrl+up")}/${displayKey("ctrl+down")}`;
+		const closeKey = options.formatSelectAction
+			? options.formatSelectAction("tui.select.cancel") || "Disabled"
+			: displayKey("escape");
+		const itemHint = `${editKey} edit · ${deleteKey} remove · ${moveKeys} move`;
+		const controlsHint = `${selectKeys} select · ${itemHint} · ${closeKey} close`;
 		const items: SelectItem[] = entries.map((entry, index) => ({
 			value: entry.id,
 			label: `${entry.label} ${index + 1}`,
 			description: entry.text,
-			hint: "Del remove · Ctrl+↑/↓ move",
+			hint: itemHint,
 		}));
 
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(theme.bold("Message queue"), 1, 0));
-		this.addChild(new Text(theme.fg("muted", "Del remove · Ctrl+↑/↓ move · Esc close"), 1, 0));
+		this.addChild(new Text(theme.fg("muted", controlsHint), 1, 0));
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
 		this.#selectList = new SelectList(items, MAX_VISIBLE_QUEUE_MESSAGES, getSelectListTheme());
+		this.#selectList.onSelect = item => {
+			const entry = byId.get(item.value);
+			if (entry) this.#onSelect(entry);
+		};
 		this.#selectList.onSelectionChange = item => {
 			const index = entries.findIndex(entry => entry.id === item.value);
 			this.#selectedIndex = index === -1 ? this.#selectedIndex : index;
@@ -54,12 +87,25 @@ export class QueuePaneComponent extends Container {
 	}
 
 	handleInput(keyData: string): void {
-		if (matchesKey(keyData, "alt+up")) {
-			this.#selectList.handleInput(RAW_UP);
+		if (this.#matchesSelectAction(keyData, "tui.select.confirm")) {
+			if (this.#selectedEntry) this.#onSelect(this.#selectedEntry);
+			return;
+		}
+		if (this.#matchesSelectAction(keyData, "tui.select.cancel")) {
+			this.#onClose();
+			return;
+		}
+		const navigation = this.#resolveSelectNavigation(keyData);
+		if (navigation) {
+			this.#selectList.handleNavigation(navigation);
 			return;
 		}
-		if (matchesKey(keyData, "alt+down")) {
-			this.#selectList.handleInput(RAW_DOWN);
+		if (matchesKey(keyData, "enter") || matchesKey(keyData, "escape")) return;
+		if (matchesKey(keyData, "alt+up") || matchesKey(keyData, "alt+down")) {
+			const direction = matchesKey(keyData, "alt+up") ? -1 : 1;
+			this.#selectedIndex = (this.#selectedIndex + direction + this.#entries.length) % this.#entries.length;
+			this.#selectedEntry = this.#entries[this.#selectedIndex];
+			this.#selectList.setSelectedIndex(this.#selectedIndex);
 			return;
 		}
 		if (matchesKey(keyData, "ctrl+up") || matchesKey(keyData, "ctrl+shift+up")) {

package/src/modes/components/queued-message-selector.ts

@@ -1,12 +1,13 @@
 import { Container, matchesKey, type SelectItem, SelectList, Spacer, Text } from "@gajae-code/tui";
+import { formatKeyHint } from "../../config/keybindings";
 import type { QueuedMessageEditEntry } from "../../session/agent-session";
 import { getSelectListTheme, theme } from "../theme/theme";
 import { DynamicBorder } from "./dynamic-border";
 
 const MAX_VISIBLE_QUEUED_MESSAGES = 8;
-const RAW_UP = "\x1b[A";
-const RAW_DOWN = "\x1b[B";
 type QueuedMessageMoveDirection = "up" | "down";
+type QueueSelectorAction = "tui.select.confirm" | "tui.select.cancel";
+type QueueSelectorNavigationAction = "tui.select.up" | "tui.select.down" | "tui.select.pageUp" | "tui.select.pageDown";
 
 export type { QueuedMessageMoveDirection };
 
@@ -16,32 +17,61 @@ export class QueuedMessageSelectorComponent extends Container {
 	#selectedIndex = 0;
 	#onDelete: (entry: QueuedMessageEditEntry, selectedIndex: number) => void;
 	#onMove: (entry: QueuedMessageEditEntry, selectedIndex: number, direction: QueuedMessageMoveDirection) => void;
-
+	#onSelect: (entry: QueuedMessageEditEntry) => void;
+	#onCancel: () => void;
+	#entries: QueuedMessageEditEntry[];
+	#matchesSelectAction: (keyData: string, action: QueueSelectorAction) => boolean;
+	#resolveSelectNavigation: (keyData: string) => QueueSelectorNavigationAction | undefined;
 	constructor(
 		entries: QueuedMessageEditEntry[],
 		onSelect: (entry: QueuedMessageEditEntry) => void,
 		onDelete: (entry: QueuedMessageEditEntry, selectedIndex: number) => void,
 		onMove: (entry: QueuedMessageEditEntry, selectedIndex: number, direction: QueuedMessageMoveDirection) => void,
 		onCancel: () => void,
-		options?: { selectedIndex?: number },
+		options?: {
+			selectedIndex?: number;
+			formatKeyHint?: (key: string) => string;
+			formatSelectAction?: (action: QueueSelectorAction) => string;
+			matchesSelectAction?: (keyData: string, action: QueueSelectorAction) => boolean;
+			resolveSelectNavigation?: (keyData: string) => QueueSelectorNavigationAction | undefined;
+		},
 	) {
 		super();
 
 		this.#onDelete = onDelete;
 		this.#onMove = onMove;
+		this.#onSelect = onSelect;
+		this.#onCancel = onCancel;
+		this.#entries = entries;
+		this.#matchesSelectAction =
+			options?.matchesSelectAction ??
+			((keyData, action) => matchesKey(keyData, action === "tui.select.confirm" ? "enter" : "escape"));
+		this.#resolveSelectNavigation = options?.resolveSelectNavigation ?? (() => undefined);
 		const byId = new Map(entries.map(entry => [entry.id, entry]));
 		this.#selectedIndex = Math.max(0, Math.min(options?.selectedIndex ?? 0, entries.length - 1));
 		this.#selectedEntry = entries[this.#selectedIndex];
+		const displayKey = options?.formatKeyHint ?? formatKeyHint;
+		const selectKeys = `${displayKey("alt+up")}/${displayKey("alt+down")}`;
+		const editKey = options?.formatSelectAction
+			? options.formatSelectAction("tui.select.confirm") || "Disabled"
+			: displayKey("enter");
+		const deleteKey = displayKey("delete");
+		const moveKeys = `${displayKey("ctrl+up")}/${displayKey("ctrl+down")}`;
+		const cancelKey = options?.formatSelectAction
+			? options.formatSelectAction("tui.select.cancel") || "Disabled"
+			: displayKey("escape");
+		const itemHint = `${editKey} edit · ${deleteKey} remove · ${moveKeys} move`;
+		const controlsHint = `${selectKeys} select · ${itemHint} · ${cancelKey} cancel`;
 		const items: SelectItem[] = entries.map((entry, index) => ({
 			value: entry.id,
 			label: `${entry.label} ${index + 1}`,
 			description: entry.text,
-			hint: "Enter edit · Del remove · Ctrl+↑/↓ move",
+			hint: itemHint,
 		}));
 
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(theme.bold("Queued messages"), 1, 0));
-		this.addChild(new Text(theme.fg("muted", "Enter edit · Del remove · Ctrl+↑/↓ move · Esc cancel"), 1, 0));
+		this.addChild(new Text(theme.fg("muted", controlsHint), 1, 0));
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
 
@@ -63,12 +93,25 @@ export class QueuedMessageSelectorComponent extends Container {
 	}
 
 	handleInput(keyData: string): void {
-		if (matchesKey(keyData, "alt+up")) {
-			this.#selectList.handleInput(RAW_UP);
+		if (this.#matchesSelectAction(keyData, "tui.select.confirm")) {
+			if (this.#selectedEntry) this.#onSelect(this.#selectedEntry);
+			return;
+		}
+		if (this.#matchesSelectAction(keyData, "tui.select.cancel")) {
+			this.#onCancel();
+			return;
+		}
+		const navigation = this.#resolveSelectNavigation(keyData);
+		if (navigation) {
+			this.#selectList.handleNavigation(navigation);
 			return;
 		}
-		if (matchesKey(keyData, "alt+down")) {
-			this.#selectList.handleInput(RAW_DOWN);
+		if (matchesKey(keyData, "enter") || matchesKey(keyData, "escape")) return;
+		if (matchesKey(keyData, "alt+up") || matchesKey(keyData, "alt+down")) {
+			const direction = matchesKey(keyData, "alt+up") ? -1 : 1;
+			this.#selectedIndex = (this.#selectedIndex + direction + this.#entries.length) % this.#entries.length;
+			this.#selectedEntry = this.#entries[this.#selectedIndex];
+			this.#selectList.setSelectedIndex(this.#selectedIndex);
 			return;
 		}
 		if (matchesKey(keyData, "ctrl+up") || matchesKey(keyData, "ctrl+shift+up")) {

package/src/modes/components/read-tool-group.ts

@@ -3,7 +3,7 @@ import { Container, Text } from "@gajae-code/tui";
 import { InternalUrlRouter } from "../../internal-urls";
 import { getLanguageFromPath, theme } from "../../modes/theme/theme";
 import { splitPathAndSel } from "../../tools/path-utils";
-import { PREVIEW_LIMITS, shortenPath } from "../../tools/render-utils";
+import { PREVIEW_LIMITS, replaceTabs, shortenPath } from "../../tools/render-utils";
 import { renderCodeCell } from "../../tui";
 import type { ToolExecutionHandle } from "./tool-execution";
 
@@ -53,9 +53,16 @@ type ReadToolResultDetails = {
 	conflictCount?: number;
 };
 
-type ReadToolGroupOptions = {
-	showContentPreview?: boolean;
-};
+type ReadToolVisibleProjection = ReadonlyArray<{
+	path: string;
+	status: ReadEntry["status"];
+	correctedFrom?: string;
+	conflictCount?: number;
+	preview?: {
+		lines: readonly string[];
+		hiddenLineCount: number;
+	};
+}>;
 
 function getSuffixResolution(details: ReadToolResultDetails | undefined): ReadToolSuffixResolution | undefined {
 	if (typeof details?.suffixResolution?.from !== "string" || typeof details.suffixResolution.to !== "string") {
@@ -82,13 +89,16 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	#expanded = false;
 	#manuallyExpanded: boolean | undefined;
 	#showContentPreview: boolean;
+	#visibleTranscriptChanged = false;
+	#lastVisibleProjection: ReadToolVisibleProjection = [];
 
-	constructor(options: ReadToolGroupOptions = {}) {
+	constructor(options: { showContentPreview?: boolean } = {}) {
 		super();
 		this.#showContentPreview = options.showContentPreview ?? false;
 		this.#text = new Text("", 0, 0);
 		this.addChild(this.#text);
 		this.#updateDisplay();
+		this.#lastVisibleProjection = this.#visibleProjection();
 	}
 
 	updateArgs(args: ReadRenderArgs, toolCallId?: string): void {
@@ -102,7 +112,7 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		};
 		entry.path = rawPath;
 		this.#entries.set(toolCallId, entry);
-		this.#updateDisplay();
+		this.#updateDisplayAndNotify();
 	}
 
 	updateResult(
@@ -126,23 +136,20 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 			typeof details?.conflictCount === "number" && details.conflictCount > 0 ? details.conflictCount : undefined;
 		entry.conflictCount = conflictCount;
 		entry.status = result.isError ? "error" : suffixResolution ? "warning" : "success";
-		// Store the text content for preview/expanded display
 		const textContent = result.content?.find(c => c.type === "text")?.text;
-		if (textContent !== undefined) {
-			entry.contentText = textContent;
-		}
-		this.#updateDisplay();
+		entry.contentText = textContent;
+		this.#updateDisplayAndNotify();
 	}
 
 	setArgsComplete(_toolCallId?: string): void {
-		this.#updateDisplay();
+		this.#updateDisplayAndNotify();
 	}
 
 	/** Applies automatic expansion unless this renderer instance has an explicit fold choice. */
 	setExpanded(expanded: boolean): void {
 		if (this.#manuallyExpanded !== undefined) return;
 		this.#expanded = expanded;
-		this.#updateDisplay();
+		this.#updateDisplayAndNotify();
 	}
 
 	/**
@@ -152,13 +159,74 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	setManuallyExpanded(expanded: boolean): void {
 		this.#manuallyExpanded = expanded;
 		this.#expanded = expanded;
-		this.#updateDisplay();
+		this.#updateDisplayAndNotify();
 	}
 
 	getComponent(): Component {
 		return this;
 	}
 
+	consumeVisibleTranscriptChange(): boolean {
+		const changed = this.#visibleTranscriptChanged;
+		this.#visibleTranscriptChanged = false;
+		return changed;
+	}
+
+	#visibleProjection(): ReadToolVisibleProjection {
+		return [...this.#entries.values()].map(entry => {
+			if (!this.#shouldRenderPreview(entry)) {
+				return {
+					path: entry.path,
+					status: entry.status,
+					correctedFrom: entry.correctedFrom,
+					conflictCount: entry.conflictCount,
+				};
+			}
+			const lines = replaceTabs(entry.contentText ?? "")
+				.split(/\r?\n/)
+				.map(line => line.slice(line.lastIndexOf("\r") + 1));
+			const visibleLineCount = this.#expanded ? lines.length : Math.min(lines.length, COLLAPSED_PREVIEW_LINES);
+			return {
+				path: entry.path,
+				status: entry.status,
+				correctedFrom: entry.correctedFrom,
+				preview: {
+					lines: lines.slice(0, visibleLineCount),
+					hiddenLineCount: lines.length - visibleLineCount,
+				},
+			};
+		});
+	}
+
+	#sameVisibleProjection(left: ReadToolVisibleProjection, right: ReadToolVisibleProjection): boolean {
+		if (left.length !== right.length) return false;
+		return left.every((entry, index) => {
+			const other = right[index];
+			if (
+				!other ||
+				entry.path !== other.path ||
+				entry.status !== other.status ||
+				entry.correctedFrom !== other.correctedFrom ||
+				(!entry.preview && entry.conflictCount !== other.conflictCount)
+			)
+				return false;
+			if (!entry.preview || !other.preview) return entry.preview === other.preview;
+			return (
+				entry.preview.hiddenLineCount === other.preview.hiddenLineCount &&
+				entry.preview.lines.length === other.preview.lines.length &&
+				entry.preview.lines.every((line, lineIndex) => line === other.preview!.lines[lineIndex])
+			);
+		});
+	}
+
+	#updateDisplayAndNotify(): void {
+		this.#updateDisplay();
+		const after = this.#visibleProjection();
+		if (this.#sameVisibleProjection(after, this.#lastVisibleProjection)) return;
+		this.#lastVisibleProjection = after;
+		this.#visibleTranscriptChanged = true;
+	}
+
 	#updateDisplay(): void {
 		const entries = [...this.#entries.values()];
 

package/src/modes/components/session-observer-overlay.ts

@@ -1,10 +1,11 @@
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import type { ToolResultMessage } from "@gajae-code/ai";
 import { matchesKey } from "@gajae-code/tui";
 import { formatDuration, formatNumber } from "@gajae-code/utils";
 import type { KeyId } from "../../config/keybindings";
 import { isSilentAbort } from "../../session/messages";
-import type { SessionMessageEntry } from "../../session/session-manager";
+import type { FileEntry, SessionMessageEntry } from "../../session/session-manager";
 import { parseSessionEntries } from "../../session/session-manager";
 import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
 import { theme } from "../theme/theme";
@@ -15,13 +16,26 @@ import {
 } from "./tool-transcript-format";
 import { type TranscriptViewerEntry, TranscriptViewerOverlay } from "./transcript-viewer-overlay";
 
+const FATAL_UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+
+type FileIdentity = { dev: bigint; ino: bigint };
+type StableSnapshot = { identity: FileIdentity; size: number; prefix: Buffer; tail: Buffer };
+type ObserverCache = {
+	path: string;
+	identity: FileIdentity;
+	completeOffset: number;
+	prefixDigest: string;
+	entries: SessionMessageEntry[];
+	model?: string;
+};
+
 /** Session-observer adapter. The shared viewer owns navigation and fold state. */
 export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 	#registry: SessionObserverRegistry;
 	#onDone: () => void;
 	#observeKeys: readonly KeyId[];
 	#selectedSessionId?: string;
-	#cache?: { path: string; bytesRead: number; entries: SessionMessageEntry[]; model?: string };
+	#cache?: ObserverCache;
 
 	constructor(registry: SessionObserverRegistry, onDone: () => void, observeKeys: KeyId[]) {
 		// The option closures run during the base constructor's initial refresh,
@@ -126,32 +140,81 @@ export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 		return stats.length ? [theme.fg("dim", stats.join(theme.sep.dot))] : [];
 	}
 	#load(filePath: string): SessionMessageEntry[] {
-		if (this.#cache?.path !== filePath) this.#cache = undefined;
-		const fromByte = this.#cache?.bytesRead ?? 0;
-		const result = readFileIncremental(filePath, fromByte);
-		if (!result) return this.#cache?.entries ?? [];
-		if (result.newSize < fromByte) {
+		if (this.#cache && this.#cache.path !== filePath) {
 			this.#cache = undefined;
-			return this.#load(filePath);
+			this.resetSourceState();
 		}
-		if (!this.#cache) this.#cache = { path: filePath, bytesRead: 0, entries: [] };
-		if (result.text) {
-			const lastNewline = result.text.lastIndexOf("\n");
-			if (lastNewline >= 0) {
-				const complete = result.text.slice(0, lastNewline + 1);
-				for (const entry of parseSessionEntries(complete)) {
-					if (entry.type === "message") {
-						this.#cache.entries.push(entry);
-						if (!this.#cache.model && entry.message.role === "assistant") this.#cache.model = entry.message.model;
-					} else if (entry.type === "model_change") this.#cache.model = entry.model;
-				}
-				this.#cache.bytesRead = fromByte + Buffer.byteLength(complete, "utf-8");
+
+		const cache = this.#cache;
+		const snapshot = readStableSnapshot(filePath, cache?.completeOffset ?? 0);
+		if (!snapshot) {
+			// An unreadable source is never allowed to keep presenting a prior file as current.
+			if (cache) this.#clearSource();
+			return [];
+		}
+
+		const canAppend =
+			cache &&
+			sameIdentity(cache.identity, snapshot.identity) &&
+			snapshot.size >= cache.completeOffset &&
+			digest(snapshot.prefix) === cache.prefixDigest;
+		if (canAppend) return this.#appendStable(cache, snapshot);
+
+		// A changed fd identity, changed committed bytes, or a shrink is a replacement.
+		// Validate the entire candidate before it replaces the visible transcript.
+		const replacement = readStableSnapshot(filePath, 0);
+		if (!replacement) {
+			this.#clearSource();
+			return [];
+		}
+		const candidate = cacheEntries(filePath, replacement);
+		if (!candidate) {
+			this.#clearSource();
+			return [];
+		}
+		this.#cache = candidate;
+		if (cache) this.resetSourceState();
+		return candidate.entries;
+	}
+	#appendStable(cache: ObserverCache, snapshot: StableSnapshot): SessionMessageEntry[] {
+		const complete = completePrefix(snapshot.tail);
+		if (!complete) {
+			if (!isValidUtf8Prefix(snapshot.tail)) {
+				this.#clearSource();
+				return [];
 			}
+			return cache.entries;
+		}
+		const remainder = snapshot.tail.subarray(complete.bytes.length);
+		if (!isValidUtf8Prefix(remainder)) {
+			this.#clearSource();
+			return [];
 		}
-		return this.#cache.entries;
+		const parsed = parseCompleteEntries(complete.bytes);
+		if (!parsed) {
+			this.#clearSource();
+			return [];
+		}
+		const entries = [...cache.entries, ...parsed.entries];
+		this.#cache = {
+			...cache,
+			completeOffset: cache.completeOffset + complete.bytes.length,
+			prefixDigest: digest(Buffer.concat([snapshot.prefix, complete.bytes])),
+			entries,
+			model: parsed.model ?? cache.model,
+		};
+		return entries;
+	}
+	#clearSource(): void {
+		if (this.#cache) this.resetSourceState();
+		this.#cache = undefined;
 	}
 }
 
+/**
+ * This deliberately remains the eager full-history projection. PR2 owns projection
+ * virtualization/incrementalization; source acquisition above only controls snapshot safety.
+ */
 export function entriesFromMessages(entries: readonly SessionMessageEntry[]): TranscriptViewerEntry[] {
 	const results = new Map<string, ToolResultMessage>();
 	for (const entry of entries)
@@ -259,19 +322,111 @@ function truncateThinking(text: string, expanded: boolean): string {
 	return text.length > limit ? `${text.slice(0, limit)}...` : text;
 }
 
-function readFileIncremental(filePath: string, fromByte: number): { text: string; newSize: number } | null {
+function readStableSnapshot(filePath: string, completeOffset: number): StableSnapshot | null {
+	let fd: number | undefined;
 	try {
-		const stat = fs.statSync(filePath);
-		if (stat.size <= fromByte) return { text: "", newSize: stat.size };
-		const buffer = Buffer.alloc(stat.size - fromByte);
-		const fd = fs.openSync(filePath, "r");
-		try {
-			fs.readSync(fd, buffer, 0, buffer.length, fromByte);
-		} finally {
-			fs.closeSync(fd);
-		}
-		return { text: buffer.toString("utf-8"), newSize: stat.size };
+		fd = fs.openSync(filePath, "r");
+		const before = fs.fstatSync(fd, { bigint: true });
+		if (before.size > BigInt(Number.MAX_SAFE_INTEGER) || completeOffset > Number(before.size)) return null;
+		const size = Number(before.size);
+		const prefix = readExactly(fd, 0, completeOffset);
+		const tail = readExactly(fd, completeOffset, size - completeOffset);
+		const after = fs.fstatSync(fd, { bigint: true });
+		if (
+			before.dev !== after.dev ||
+			before.ino !== after.ino ||
+			before.size !== after.size ||
+			before.mtimeNs !== after.mtimeNs ||
+			before.ctimeNs !== after.ctimeNs
+		)
+			return null;
+		return { identity: { dev: before.dev, ino: before.ino }, size, prefix, tail };
+	} catch {
+		return null;
+	} finally {
+		if (fd !== undefined) fs.closeSync(fd);
+	}
+}
+
+function readExactly(fd: number, position: number, length: number): Buffer {
+	const buffer = Buffer.alloc(length);
+	let offset = 0;
+	while (offset < length) {
+		const bytesRead = fs.readSync(fd, buffer, offset, length - offset, position + offset);
+		if (bytesRead === 0) throw new Error("Short session file read");
+		offset += bytesRead;
+	}
+	return buffer;
+}
+
+function sameIdentity(left: FileIdentity, right: FileIdentity): boolean {
+	return left.dev === right.dev && left.ino === right.ino;
+}
+
+function digest(bytes: Buffer): string {
+	return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+function completePrefix(bytes: Buffer): { bytes: Buffer } | undefined {
+	const newline = bytes.lastIndexOf(0x0a);
+	return newline < 0 ? undefined : { bytes: bytes.subarray(0, newline + 1) };
+}
+
+function parseCompleteEntries(bytes: Buffer): { entries: SessionMessageEntry[]; model?: string } | null {
+	try {
+		const text = FATAL_UTF8_DECODER.decode(bytes);
+		for (const line of text.split("\n")) if (line.trim()) JSON.parse(line);
+		const parsed = parseSessionEntries(text);
+		return {
+			entries: parsed.filter((entry): entry is SessionMessageEntry => entry.type === "message"),
+			model: modelFromEntries(parsed),
+		};
 	} catch {
 		return null;
 	}
 }
+
+function modelFromEntries(entries: readonly FileEntry[]): string | undefined {
+	let model: string | undefined;
+	for (const entry of entries) {
+		if (entry.type === "model_change") model = entry.model;
+		else if (entry.type === "message" && entry.message.role === "assistant" && entry.message.model)
+			model = entry.message.model;
+	}
+	return model;
+}
+
+function isValidUtf8Prefix(bytes: Buffer): boolean {
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function cacheEntries(filePath: string, snapshot: StableSnapshot): ObserverCache | null {
+	const complete = completePrefix(snapshot.tail);
+	if (!complete) {
+		if (!isValidUtf8Prefix(snapshot.tail)) return null;
+		return {
+			path: filePath,
+			identity: snapshot.identity,
+			completeOffset: 0,
+			prefixDigest: digest(Buffer.alloc(0)),
+			entries: [],
+		};
+	}
+	const remainder = snapshot.tail.subarray(complete.bytes.length);
+	if (!isValidUtf8Prefix(remainder)) return null;
+	const parsed = parseCompleteEntries(complete.bytes);
+	if (!parsed) return null;
+	return {
+		path: filePath,
+		identity: snapshot.identity,
+		completeOffset: complete.bytes.length,
+		prefixDigest: digest(complete.bytes),
+		entries: parsed.entries,
+		model: parsed.model,
+	};
+}