@yusukeshib/pi-babysit 0.6.17 → 0.6.18

package/README.md

@@ -106,9 +106,17 @@ first content line; streamed updates and duplicate results keep that time. This
 is the time babysit received the first byte of the event or line, not an
 application event time. Narrow views place the date above the text. Old logs and
 lines without capture metadata remain readable without invented timestamps.
-Only the selected log is loaded, bounded to the latest 1 MiB / 2,000 display
-lines with an omission notice; the full log file is unchanged. Empty logs show
-a placeholder. Works in the released Pi 1.0 widget host. Mouse interaction
+Only the selected log is loaded: the viewer starts at the tail and lazily reads
+older/newer pages as you scroll to the loaded window's edges. The scrollbar
+represents that window, not the entire file; the footer shows its byte range.
+Normally a small sliding window of roughly 64 KiB pages is retained. Page limits
+are soft for oversized records and individual assistant-response/tool-result
+groups (streaming snapshots and duplicate results stay together), and for pages
+intersecting the viewport. Agent tasks are split at assistant-message boundaries,
+not loaded as a whole; older logs lacking those events can form larger groups.
+All saved history remains reachable, with no log records discarded or modified.
+Capture-time sidecars are sought by byte range rather than read in full. Empty
+logs show a placeholder. Works in the released Pi 1.0 widget host. Mouse interaction
 requires fullscreen mode; `/babysit view` opens the viewer using a keyboard
 picker, and `/babysit` still provides a snapshot. The displayed `age` is total
 session age, not time spent in the current state. Transcript details

package/index.ts

@@ -45,6 +45,7 @@ import type {
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
 import { Box, Markdown, Text, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { createLogViewer } from "./log-viewer";
+import { FileLogSource } from "./log-source";
 import { Type, type TSchema } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents";
@@ -574,9 +575,16 @@ function markAutomaticGc(now = new Date()): void {
 	}
 }
 
-function scanTreeStats(root: string): { bytes: number; newestMtimeMs: number } {
+function scanTreeStats(root: string, rootMtimeMs?: number): { bytes: number; newestMtimeMs: number } {
 	let bytes = 0;
-	let newestMtimeMs = 0;
+	let newestMtimeMs: number;
+	try {
+		// The collector's own lock file updates the root mtime; use the
+		// pre-lock age when rescanning, but still include fresh descendants.
+		newestMtimeMs = rootMtimeMs ?? fs.lstatSync(root).mtimeMs;
+	} catch {
+		return { bytes: 0, newestMtimeMs: Infinity };
+	}
 	const pending = [root];
 	while (pending.length > 0) {
 		const current = pending.pop() as string;
@@ -748,7 +756,7 @@ export function gcBabysitRoots(options: {
 				result.skippedLive.push(entry.name);
 				continue;
 			}
-			const refreshedStats = scanTreeStats(root);
+			const refreshedStats = scanTreeStats(root, stats.newestMtimeMs);
 			if (now - refreshedStats.newestMtimeMs < options.olderThanMs) continue;
 			tombstone = path.join(
 				options.rootBase,
@@ -2521,12 +2529,13 @@ export function createSessionWidget(options: {
 	getHeight: () => number;
 	requestRender: () => void;
 	getTheme: () => Theme;
-	readLog: (id: string) => { text: string; isAgent: boolean; clipped?: boolean; lineTimestamps?: (number | undefined)[] };
+	readLog: (id: string) => { text?: string; file?: string; isAgent: boolean; clipped?: boolean; lineTimestamps?: (number | undefined)[] };
 }) {
 	const listState: WidgetSessionListState = { mode: "running", page: 0 };
 	let selectedId: string | undefined;
 	let displays: WidgetSessionDisplay[] = [];
 	let viewer: ReturnType<typeof createLogViewer> | undefined;
+	let source: FileLogSource | undefined;
 	let list = createWidgetComponent([], [], open, listState);
 	function refreshViewer() {
 		if (!selectedId || !viewer) return;
@@ -2534,20 +2543,26 @@ export function createSessionWidget(options: {
 		const session = displays.find((session) => session.id === selectedId);
 		const header = session?.header ?? selectedId;
 		const detail = session?.details?.[0] ?? "";
-		viewer.update(
-			`${log.clipped ? "[older log omitted: 1 MiB limit] " : ""}${header}`,
-			log.text,
-			log.isAgent,
-			detail.startsWith("task: ") ? detail.slice(6) : detail,
-			log.lineTimestamps,
-		);
+		const context = detail.startsWith("task: ") ? detail.slice(6) : detail;
+		if (log.file) {
+			if (!source || source.file !== log.file || source.isAgent !== log.isAgent)
+				source = new FileLogSource(log.file, log.isAgent);
+			viewer.updateSource(header, source, context);
+		} else {
+			viewer.update(header, log.text ?? "", log.isAgent, context, log.lineTimestamps);
+			source = undefined;
+		}
 	}
 	function close() {
 		selectedId = undefined;
+		viewer?.dispose();
 		viewer = undefined;
+		source = undefined;
 		options.requestRender();
 	}
 	function open(id: string) {
+		viewer?.dispose();
+		source = undefined;
 		selectedId = id;
 		viewer = createLogViewer({ ...options, onClose: close });
 		refreshViewer();
@@ -3675,7 +3690,7 @@ export default function (pi: ExtensionAPI) {
 						getTheme: () => ctx.ui.theme,
 						readLog: (id) => {
 							const isAgent = kindOf(id) === "subagent";
-							return { ...readViewerLog(logPath(id), true), isAgent };
+							return { file: logPath(id), isAgent };
 						},
 					});
 					return sessionWidget;

package/log-source.ts

@@ -0,0 +1,232 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface LogPage {
+	start: number;
+	end: number;
+	text: string;
+	lineTimestamps: (number | undefined)[];
+}
+
+/** Byte cursors, not an index: only the selected sliding window is retained. */
+export class FileLogSource {
+	readonly pageBytes: number;
+	size = 0;
+	metadataVersion = "";
+	private identity = "";
+	private modified = 0;
+	constructor(readonly file: string, readonly isAgent = false, pageBytes = 64 * 1024) {
+		this.pageBytes = Math.max(1, pageBytes);
+	}
+	/** A changed identity or shrinking file invalidates every cursor. */
+	refresh(): boolean {
+		try {
+			const stat = fs.statSync(path.join(path.dirname(this.file), "output.timestamps.jsonl"));
+			this.metadataVersion = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+		} catch { this.metadataVersion = ""; }
+		try {
+			const stat = fs.statSync(this.file);
+			const identity = `${stat.dev}:${stat.ino}`;
+			const reset = identity !== this.identity || stat.size < this.size ||
+				(stat.size === this.size && stat.mtimeMs !== this.modified);
+			this.identity = identity;
+			this.modified = stat.mtimeMs;
+			this.size = stat.size;
+			return reset;
+		} catch {
+			const reset = this.identity !== "";
+			this.identity = "";
+			this.size = 0;
+			return reset;
+		}
+	}
+	private bytes(fd: number, start: number, end: number): Buffer {
+		const data = Buffer.alloc(Math.max(0, end - start));
+		let read = 0;
+		while (read < data.length) {
+			const n = fs.readSync(fd, data, read, data.length - read, start + read);
+			if (!n) break;
+			read += n;
+		}
+		return data.subarray(0, read);
+	}
+	/** Find record boundaries in fixed-size reads. Keep assistant snapshots and
+	 * subsequent tool results together, but never require a whole agent task:
+	 * each new assistant message is another safe page boundary. Limits are soft
+	 * for a single response/result group or oversized individual record. */
+	private boundary(fd: number, position: number, direction: -1 | 1): number {
+		const chunk = 8192;
+		let cursor = Math.max(0, Math.min(position, this.size));
+		if (!this.isAgent) {
+			while (direction < 0 ? cursor > 0 : cursor < this.size) {
+				const start = direction < 0 ? Math.max(0, cursor - chunk) : cursor;
+				const end = direction < 0 ? cursor : Math.min(this.size, cursor + chunk);
+				const data = this.bytes(fd, start, Math.min(this.size, end + 1));
+				for (let i = direction < 0 ? end - start - 1 : 0;
+					direction < 0 ? i >= 0 : i < end - start; i += direction) {
+					if (data[i] !== 10 && data[i] !== 13) continue;
+					const boundary = start + i + (data[i] === 13 && data[i + 1] === 10 ? 2 : 1);
+					if (direction < 0 ? boundary <= position : boundary >= position) return boundary;
+				}
+				cursor = direction < 0 ? start : end;
+			}
+			return direction < 0 ? 0 : this.size;
+		}
+		// Scan records in non-overlapping chunks. Carry only the record crossing
+		// the chunk edge, so normal pages do not reread 8 KiB for every event.
+		cursor = this.recordBoundary(fd, position, direction < 0 ? 1 : -1);
+		let parts: Buffer[] = [];
+		let recordStart = cursor;
+		const isStart = (start: number, segments: Buffer[]) => {
+			if (!(direction < 0 ? start <= position : start >= position)) return false;
+			try {
+				const event = JSON.parse(Buffer.concat(segments).toString("utf8"));
+				return event?.type === "agent_start" ||
+					(event?.type === "message_start" && event.message?.role === "assistant");
+			} catch { return false; }
+		};
+		while (direction < 0 ? cursor > 0 : cursor < this.size) {
+			const start = direction < 0 ? Math.max(0, cursor - chunk) : cursor;
+			const end = direction < 0 ? cursor : Math.min(this.size, cursor + chunk);
+			const data = this.bytes(fd, start, Math.min(this.size, end + 1));
+			let edge = direction < 0 ? end - start : 0;
+			for (let i = direction < 0 ? end - start - 1 : 0;
+				direction < 0 ? i >= 0 : i < end - start; i += direction) {
+				if (data[i] !== 10 && data[i] !== 13) continue;
+				if (data[i] === 13 && data[i + 1] === 10) continue;
+				if (direction < 0) {
+					const segments = [data.subarray(i + 1, edge), ...parts];
+					if (isStart(start + i + 1, segments)) return start + i + 1;
+					parts = []; edge = i + 1;
+				} else {
+					parts.push(data.subarray(edge, i + 1));
+					if (isStart(recordStart, parts)) return recordStart;
+					parts = []; edge = i + 1; recordStart = start + edge;
+				}
+			}
+			if (direction < 0) parts.unshift(data.subarray(0, edge));
+			else parts.push(data.subarray(edge, end - start));
+			cursor = direction < 0 ? start : end;
+		}
+		if (isStart(direction < 0 ? 0 : recordStart, parts)) return direction < 0 ? 0 : recordStart;
+		return direction < 0 ? 0 : this.size;
+	}
+	private recordBoundary(fd: number, position: number, direction: -1 | 1): number {
+		// Same byte scanner, without interpreting agent events.
+		const processSource = new FileLogSource(this.file, false, this.pageBytes);
+		processSource.size = this.size;
+		return processSource.boundary(fd, position, direction);
+	}
+	private empty(): LogPage { return { start: 0, end: 0, text: "", lineTimestamps: [] }; }
+	private page(fd: number, start: number, end: number): LogPage {
+		const data = this.bytes(fd, start, end);
+		return { start, end: start + data.length, text: data.toString("utf8"), lineTimestamps: this.timestamps(data, start) };
+	}
+	before(end = this.size): LogPage {
+		if (!this.size) return this.empty();
+		let fd: number | undefined;
+		try {
+			fd = fs.openSync(this.file, "r");
+			return this.page(fd, this.boundary(fd, Math.max(0, end - this.pageBytes), -1), end);
+		} catch { this.dispose(); return this.empty(); }
+		finally { if (fd !== undefined) fs.closeSync(fd); }
+	}
+	after(start: number): LogPage {
+		if (!this.size) return this.empty();
+		let fd: number | undefined;
+		try {
+			fd = fs.openSync(this.file, "r");
+			return this.page(fd, start, this.boundary(fd, Math.min(this.size, start + this.pageBytes), 1));
+		} catch { this.dispose(); return this.empty(); }
+		finally { if (fd !== undefined) fs.closeSync(fd); }
+	}
+	/** Sorted sidecar byte ranges permit a binary seek without a persistent index.
+	 * Capture metadata is optional; malformed records have no trusted timestamp. */
+	private timestamps(data: Buffer, offset: number): (number | undefined)[] {
+		const times: (number | undefined)[] = [];
+		const positions = [offset];
+		for (let i = 0; i < data.length; i++) {
+			if (data[i] !== 10 && data[i] !== 13) continue;
+			if (data[i] === 13 && data[i + 1] === 10) i++;
+			positions.push(offset + i + 1);
+		}
+		let fd: number | undefined;
+		try {
+			fd = fs.openSync(path.join(path.dirname(this.file), "output.timestamps.jsonl"), "r");
+			const size = fs.fstatSync(fd).size;
+			const record = (at: number) => {
+				let start = at;
+				if (at > 0) {
+					while (start > 0) {
+						const begin = Math.max(0, start - 1024);
+						const b = this.bytes(fd!, begin, start);
+						const newline = b.lastIndexOf(10);
+						if (newline >= 0) { start = begin + newline + 1; break; }
+						start = begin;
+					}
+				}
+				let end = start;
+				const chunks: Buffer[] = [];
+				while (end < size) {
+					const b = this.bytes(fd!, end, Math.min(size, end + 1024));
+					if (!b.length) break;
+					const newline = b.indexOf(10);
+					const n = newline < 0 ? b.length : newline + 1;
+					chunks.push(b.subarray(0, n)); end += n;
+					if (newline >= 0) break;
+				}
+				let value: number[] | undefined;
+				try {
+					const r = JSON.parse(Buffer.concat(chunks).toString());
+					if (Array.isArray(r) && r.length === 3 && r.every(Number.isSafeInteger) && r[0] >= 0 && r[1] > 0 && Number.isSafeInteger(r[0] + r[1]) && r[2] >= 0 && r[2] <= 8640000000000000) value = r;
+				} catch { /* Optional malformed metadata. */ }
+				return { start, end, value };
+			};
+			let low = 0, high = size;
+			while (low < high) {
+				const r = record(Math.floor((low + high) / 2));
+				// An invalid seek pivot gives no ordering evidence. Do not fall back
+				// to a full sidecar scan; metadata is optional, raw history is not.
+				if (!r.value) return positions.map(() => undefined);
+				if (r.value[0] + r.value[1] <= offset) low = Math.max(low + 1, r.end);
+				else high = r.start;
+			}
+			let position = 0, cursor = low;
+			let pending: Buffer[] = [];
+			let previousEnd = 0;
+			while (cursor < size && position < positions.length) {
+				let chunk = this.bytes(fd, cursor, Math.min(size, cursor + 8192));
+				if (!chunk.length) break;
+				cursor += chunk.length;
+				if (cursor === size && chunk.at(-1) !== 10) chunk = Buffer.concat([chunk, Buffer.from("\n")]);
+				let edge = 0;
+				for (let i = 0; i < chunk.length && position < positions.length; i++) {
+					if (chunk[i] !== 10) continue;
+					pending.push(chunk.subarray(edge, i)); edge = i + 1;
+					const text = Buffer.concat(pending).toString(); pending = [];
+					let value: number[];
+					try {
+						value = JSON.parse(text);
+						if (!Array.isArray(value) || value.length !== 3 || !value.every(Number.isSafeInteger) ||
+							value[0] < previousEnd || value[1] <= 0 || !Number.isSafeInteger(value[0] + value[1]) ||
+							value[2] < 0 || value[2] > 8640000000000000) continue;
+					} catch { continue; }
+					const [start, length, time] = value;
+					previousEnd = start + length;
+					while (position < positions.length && positions[position] < start) times[position++] = undefined;
+					while (position < positions.length && positions[position] < start + length) {
+						times[position] = positions[position] < offset + data.length ? time : undefined;
+						position++;
+					}
+				}
+				pending.push(chunk.subarray(edge));
+			}
+		} catch { /* Missing sidecars are normal for old logs. */ }
+		finally { if (fd !== undefined) fs.closeSync(fd); }
+		return positions.map((_, i) => times[i]);
+	}
+	retime(page: LogPage): LogPage {
+		return { ...page, lineTimestamps: this.timestamps(Buffer.from(page.text), page.start) };
+	}
+	dispose() { this.identity = ""; this.size = 0; this.metadataVersion = ""; }
+}

package/log-viewer.ts

@@ -11,6 +11,8 @@ import {
 	type TuiMouseEvent,
 } from "@earendil-works/pi-tui";
 
+import { FileLogSource, type LogPage } from "./log-source";
+
 export interface LogViewerOptions {
 	getHeight: () => number;
 	requestRender: () => void;
@@ -59,6 +61,7 @@ function agentBlocks(raw: string, timestamps?: (number | undefined)[]): Block[]
 			continue;
 		}
 		if (!e || typeof e !== "object") continue;
+		if (e.type === "agent_start") { current = undefined; toolResults.clear(); }
 		if (e.type === "message_start" && e.message?.role === "assistant")
 			current = undefined;
 		if (["message_start", "message_update", "message_end"].includes(e.type)) {
@@ -137,6 +140,19 @@ export function createLogViewer(options: LogViewerOptions) {
 		description = "",
 		isAgent = false;
 	let lineTimestamps: (number | undefined)[] | undefined;
+	let source: FileLogSource | undefined;
+	let pages: LogPage[] = [];
+	let sourceSize = 0;
+	let tailDirty = false;
+	let metadataVersion = "";
+	let adjacentPageStart: number | undefined;
+	const setPages = () => {
+		raw = pages.map((page) => page.text).join("");
+		lineTimestamps = pages.flatMap((page, i) =>
+			i < pages.length - 1 && /[\r\n]$/.test(page.text)
+				? page.lineTimestamps.slice(0, -1) : page.lineTimestamps);
+		body.invalidate();
+	};
 	let cache: string[] | undefined,
 		cacheWidth = -1,
 		cacheTheme: Theme | undefined;
@@ -150,7 +166,7 @@ export function createLogViewer(options: LogViewerOptions) {
 			const blocks = isAgent
 				? agentBlocks(raw, lineTimestamps)
 				: [{ kind: "result" as const, text: sanitize(raw, true) }];
-			const lines: string[] = description
+			const lines: string[] = description && (!source || pages[0]?.start === 0)
 				? [
 						theme.fg("muted", isAgent ? "[task]" : "[command]"),
 						...new Text(sanitize(description), 0, 0).render(width),
@@ -212,13 +228,7 @@ export function createLogViewer(options: LogViewerOptions) {
 			}
 			if (!blocks.some((block) => block.text.trim()))
 				lines.push(theme.fg("muted", "(no output available)"));
-			cache =
-				lines.length > 2000
-					? [
-							theme.fg("warning", "[Earlier log lines clipped]"),
-							...lines.slice(-1999),
-						]
-					: lines;
+			cache = lines;
 			cacheWidth = width;
 			cacheTheme = theme;
 			return cache;
@@ -262,7 +272,7 @@ export function createLogViewer(options: LogViewerOptions) {
 	const footer: Component = {
 		invalidate() {},
 		render: (width) => [
-			options.getTheme().fg("dim", truncateToWidth("↑↓ · Esc close", width)),
+			options.getTheme().fg("dim", truncateToWidth(source ? `↑↓ · bytes ${pages[0]?.start ?? 0}–${pages.at(-1)?.end ?? 0}/${source.size} (window) · Esc close` : "↑↓ · Esc close", width)),
 		],
 	};
 	let geometry = {
@@ -281,8 +291,74 @@ export function createLogViewer(options: LogViewerOptions) {
 			width = Math.max(0, Math.floor(width));
 			const height = Math.max(0, Math.floor(options.getHeight()) - 2);
 			const contentWidth = Math.max(0, width - 1);
-			const lines = body.render(Math.max(1, contentWidth));
+			const renderWidth = Math.max(1, contentWidth);
+			let lines = body.render(renderWidth);
 			scrollView.updateLayout(lines.length, height, options.requestRender);
+			const followAtEof = source && pages.at(-1)?.end === source.size && scrollView.isFollowingEnd;
+			if (source && tailDirty && scrollView.scrollTop + height >= lines.length) {
+				const anchor = scrollView.scrollTop;
+				pages[pages.length - 1] = source.after(pages.at(-1)!.start);
+				tailDirty = false; setPages(); lines = body.render(renderWidth);
+				scrollView.updateLayout(lines.length, height, options.requestRender);
+				scrollView.scrollTo(anchor, { disableFollow: true });
+			}
+			if (source && pages.length && height > 0) {
+				const top = scrollView.scrollTop;
+				const first = pages[0], last = pages[pages.length - 1];
+				if (top === 0 && first.start > 0) {
+					const page = source.before(first.start);
+					if (page.start < first.start) {
+						adjacentPageStart = page.start;
+						pages.unshift(page); setPages();
+						const anchor = top + body.render(renderWidth).length - lines.length;
+						lines = body.render(renderWidth);
+						scrollView.updateLayout(lines.length, height, options.requestRender);
+						if (followAtEof) scrollView.scrollToEnd();
+						else scrollView.scrollTo(anchor, { disableFollow: true });
+					}
+				} else if (top + height >= lines.length && last.end < source.size) {
+					const page = source.after(last.end);
+					if (page.end > last.end) {
+						adjacentPageStart = page.start;
+						pages.push(page); setPages();
+						const anchor = top;
+						lines = body.render(renderWidth);
+						scrollView.updateLayout(lines.length, height, options.requestRender);
+						scrollView.scrollTo(anchor, { disableFollow: true });
+					}
+				}
+			}
+			// A resize may make formerly visible pages evictable. Keep only the
+			// small window plus pages that actually intersect the viewport.
+			while (source && pages.length > 3) {
+				const top = scrollView.scrollTop;
+				const first = pages.shift()!; setPages();
+				let next = body.render(renderWidth);
+				const delta = lines.length - next.length;
+				if (top >= delta && first.start !== adjacentPageStart) {
+					lines = next;
+					scrollView.updateLayout(lines.length, height, options.requestRender);
+					if (followAtEof) scrollView.scrollToEnd();
+					else scrollView.scrollTo(top - delta, { disableFollow: true });
+					continue;
+				}
+				pages.unshift(first);
+				const last = pages.pop()!; setPages(); next = body.render(renderWidth);
+				if (top + height <= next.length && last.start !== adjacentPageStart) {
+					lines = next;
+					scrollView.updateLayout(lines.length, height, options.requestRender);
+					if (followAtEof) scrollView.scrollToEnd();
+					else scrollView.scrollTo(top, { disableFollow: true });
+					continue;
+				}
+				pages.push(last); setPages(); lines = body.render(renderWidth);
+				break;
+			}
+			if (source && source.size === 0 && raw) {
+				pages = [source.before()]; tailDirty = false; setPages();
+				lines = body.render(renderWidth);
+				scrollView.updateLayout(lines.length, height, options.requestRender);
+			}
 			const visible = lines.slice(
 				scrollView.scrollTop,
 				scrollView.scrollTop + height,
@@ -370,7 +446,37 @@ export function createLogViewer(options: LogViewerOptions) {
 		invalidate() {
 			body.invalidate();
 		},
+		dispose() { source?.dispose(); source = undefined; pages = []; raw = ""; body.invalidate(); },
+		updateSource(nextHeader: string, nextSource: FileLogSource, context = "") {
+			header = nextHeader;
+			const changed = source !== nextSource;
+			if (changed) { source?.dispose(); pages = []; }
+			source = nextSource;
+			const reset = source.refresh();
+			isAgent = source.isAgent;
+			if (description !== context) body.invalidate();
+			description = context;
+			if (changed || reset || !pages.length) {
+				adjacentPageStart = undefined;
+				tailDirty = false;
+				pages = [source.before()]; setPages(); scrollView.scrollToEnd();
+			} else if (source.size !== sourceSize) {
+				if (scrollView.isFollowingEnd && pages.at(-1)?.end === sourceSize) {
+					tailDirty = false;
+					pages = [source.before()]; setPages(); scrollView.scrollToEnd();
+				} else if (pages.at(-1)?.end === sourceSize) {
+					tailDirty = true;
+				}
+			}
+			if (metadataVersion !== source.metadataVersion && !changed && !reset) {
+				pages = pages.map(page => source!.retime(page)); setPages();
+			}
+			metadataVersion = source.metadataVersion;
+			sourceSize = source.size;
+			options.requestRender();
+		},
 		update(nextHeader: string, logText: string, agent: boolean, context = "", timestamps?: (number | undefined)[]) {
+			if (source) { source.dispose(); source = undefined; pages = []; }
 			header = nextHeader;
 			if (raw !== logText || isAgent !== agent || description !== context ||
 				JSON.stringify(lineTimestamps) !== JSON.stringify(timestamps)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.6.17",
+  "version": "0.6.18",
   "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",
@@ -21,6 +21,7 @@
   "files": [
     "index.ts",
     "log-viewer.ts",
+    "log-source.ts",
     "agents.ts",
     "self-reap.ts",
     "format-stream.mjs",