@yusukeshib/pi-babysit 0.6.17 → 0.6.19

package/README.md

@@ -71,6 +71,47 @@ calls if another extension or preset re-enables `bash`, including shell
 backgrounding (`… &`, `nohup`, `setsid`, `disown`). Set
 `PI_BABYSIT_ALLOW_BASH=1` to retain direct `bash` explicitly.
 
+## Remote processes over SSH
+
+Install a `babysit` CLI with `--host` support on both machines (tested with
+local 0.14.5 and remote 0.14.6), and configure non-interactive SSH access.
+SSH aliases, keys, known hosts, and ProxyJump are handled by babysit/SSH;
+pi-babysit does not install remote software or copy credentials.
+
+```text
+babysit_run { host: "yusuke-t4", cwd: "/home/yusuke/project", command: "bun test", foreground: true, returnLines: 30 }
+babysit_run { host: "user@server", command: "python3 -i", name: "remote-repl", continueAfterStart: true }
+babysit_check { id: "remote-repl", screen: true }
+babysit_send { id: "remote-repl", text: "print(42)" }
+babysit_kill { id: "remote-repl" }
+```
+
+`host` omitted (or `"local"`) preserves local behavior. `cwd` is process-only:
+local default is Pi's cwd; remote default is the remote login home, **never**
+the local checkout. Remote commands use POSIX `sh`, with quoted cwd and Pi
+metadata environment values; the local `PI_SESSION_FILE` and shell path are
+not forwarded. Remote subagents and `retryOnWorkerDeath` are explicitly unsupported.
+
+The returned Pi id persists a host and unique, Pi-namespaced remote worker id.
+Check/send/wait/kill, PTY screens/keys, completion notifications, and mixed-host
+waits use this mapping; manual remote sessions are never adopted or killed.
+Resume the same Pi session to reconnect. Remote logs stay remote: results show
+an executable `babysit --host … log -s …` locator instead of a local file path.
+Remote output is a bounded tail (200 lines by default) or CLI `--grep` search
+(no local line numbers). The widget shows host/state and a small tail; its
+remote full-history viewer is unavailable and instead shows log/attach hints.
+
+An SSH failure is **unknown status**, not process exit. Remote workers may
+survive disconnects. An uncertain launch keeps its identity and reports the
+tracked id: reconcile it with check/kill rather than blindly retrying. Attached
+foreground interruption explicitly kills the remote worker and claims cleanup
+only after terminal-state confirmation; unreachable cleanup is reported as
+unverified. Detached waits do not own the worker. Pi quit attempts cleanup of
+tracked workers, reporting unverified remote cleanup to stderr. Local GC retains
+roots with unresolved remote identities; it never deletes/prunes remote logs.
+After reconnecting, check or kill tracked workers to establish terminal status
+before local retention can collect their metadata.
+
 ## Commands (human)
 
 | Command | What it does |
@@ -106,9 +147,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
@@ -118,7 +167,8 @@ with Pi's tool-output toggle (`Ctrl+O` by default).
 ## Logs without context flooding
 
 `babysit_run`, `babysit_wait`, and automatic completion notifications always
-return lifecycle metadata and the absolute path to the complete `output.log`.
+return lifecycle metadata and the absolute path to the complete local `output.log`
+(or a remote CLI log locator for SSH processes).
 Explicit run/wait results inline complete output up to 8 KB; unsolicited
 completion notifications use a stricter 2 KB per-process output cap and an 8 KB
 aggregate message cap. Process exits observed in one poll share one message and

package/index.ts

@@ -33,6 +33,7 @@
 
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -45,6 +46,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";
@@ -185,6 +187,8 @@ interface BsSession {
 	note?: string | null;
 	output_bytes?: number;
 	screen_seq?: number | null;
+	host?: string;
+	transportError?: string;
 }
 
 // A worker whose PTY process is gone (alive:false) can still report state
@@ -214,8 +218,17 @@ function bs(
 		cwd?: string;
 		signal?: AbortSignal;
 		env?: Record<string, string | undefined>;
+		host?: string;
 	} = {},
 ): Promise<{ stdout: string; stderr: string; code: number }> {
+	const sessionIndex = args.indexOf("-s");
+	const meta = sessionIndex >= 0 ? readMeta(args[sessionIndex + 1]) : null;
+	const host = opts.host ?? meta?.host;
+	if (host && host !== "local") {
+		args = [...args];
+		if (meta?.remoteId) args[sessionIndex + 1] = meta.remoteId;
+		args.unshift("--host", host);
+	}
 	return new Promise((resolve) => {
 		if (opts.signal?.aborted) {
 			resolve({ stdout: "", stderr: "aborted", code: 130 });
@@ -237,6 +250,8 @@ function bs(
 		opts.signal?.addEventListener("abort", onAbort, { once: true });
 		child.stdout?.on("data", (d) => {
 			stdout += d.toString();
+			// Drain output but bound remote log/screen memory even for a huge single line.
+			if (host && host !== "local" && (args.includes("log") || args.includes("screenshot")) && Buffer.byteLength(stdout) > 32_000) stdout = Buffer.from(stdout).subarray(-32_000).toString("utf8");
 		});
 		child.stderr?.on("data", (d) => {
 			stderr += d.toString();
@@ -320,8 +335,8 @@ async function requireBabysit(): Promise<void> {
 // Error-aware: `babysit list` failing is NOT the same as "no sessions" —
 // callers that show state to the agent must surface the error instead of
 // silently reporting an empty registry (which reads like lost sessions).
-async function listSessions(): Promise<{ sessions: BsSession[]; error?: string }> {
-	const r = await bs(["list", "--json"]);
+async function localSessions(host?: string): Promise<{ sessions: BsSession[]; error?: string }> {
+	const r = await bs(["list", "--json"], { host });
 	if (r.code !== 0) {
 		return {
 			sessions: [],
@@ -337,6 +352,28 @@ async function listSessions(): Promise<{ sessions: BsSession[]; error?: string }
 	}
 }
 
+async function listSessions(): Promise<{ sessions: BsSession[]; error?: string }> {
+	const local = await localSessions();
+	const known = remoteMetadata();
+	await Promise.all([...new Set(known.map(({ meta }) => meta.host!))].map(async (host) => {
+		const remote = await localSessions(host);
+		for (const { id, meta } of known.filter((entry) => entry.meta.host === host)) {
+			const found = remote.sessions.find((session) => session.id === meta.remoteId);
+			if (found && !remote.error) {
+				local.sessions.push({ ...found, id, host });
+				const terminalState = isConfirmedTerminalState(found.state) ? found.state : undefined;
+				if (meta.remoteTerminalState !== terminalState) {
+					writeMeta(id, { ...readMeta(id)!, remoteTerminalState: terminalState });
+				}
+			} else {
+				// Keep unresolved references active for polling/group delivery, never fabricate exit.
+				local.sessions.push({ id, host, state: "running", transportError: remote.error ?? "tracked remote session not found", note: `status unknown on ${host}: ${remote.error ?? "session not found"}` });
+			}
+		}
+	}));
+	return local;
+}
+
 async function lookupStatus(
 	id: string,
 ): Promise<{ session: BsSession | null; error?: string }> {
@@ -345,8 +382,10 @@ async function lookupStatus(
 	// status-then-list pair (two CLI subprocesses for every status lookup).
 	try {
 		const listed = await listSessions();
-		if (listed.error) return { session: null, error: listed.error };
-		return { session: listed.sessions.find((session) => session.id === id) ?? null };
+		const session = listed.sessions.find((session) => session.id === id) ?? null;
+		if (session?.transportError) return { session: null, error: `${session.host}: ${session.transportError}` };
+		if (listed.error && !readMeta(id)?.host) return { session: null, error: listed.error };
+		return { session };
 	} catch (error) {
 		return { session: null, error: error instanceof Error ? error.message : String(error) };
 	}
@@ -408,10 +447,11 @@ async function terminateRunningSessions(): Promise<void> {
 	let listed: Awaited<ReturnType<typeof listSessions>>;
 	try {
 		listed = await listSessions();
-	} catch {
+	} catch (error) {
+		console.error(`Babysit shutdown cleanup unknown: ${error instanceof Error ? error.message : String(error)}`);
 		return;
 	}
-	if (listed.error) return;
+	if (listed.error) console.error(`Local babysit shutdown cleanup unknown: ${listed.error}`);
 
 	// A namespace may contain many independent commands and agents. Terminate
 	// them concurrently so quitting Pi does not wait for serial kill timeouts.
@@ -421,7 +461,13 @@ async function terminateRunningSessions(): Promise<void> {
 			.filter((session) => session.state === "running")
 			.map(async (session) => {
 				const result = await bs(["kill", "-s", session.id, "--json"]);
-				if (result.code !== 0 || validateKillResponse(result.stdout)) return;
+				if (session.host) {
+					const terminal = await awaitConfirmedTermination(session.id);
+					if (!terminal || !isConfirmedTerminalState(terminal.state)) {
+						console.error(`Remote cleanup unverified for ${session.id} on ${session.host}: ${result.stderr || "terminal state unavailable"}`);
+						return;
+					}
+				} else if (result.code !== 0 || validateKillResponse(result.stdout)) return;
 				// A later resume of this Pi session must not turn intentional shutdown
 				// cleanup into a process-completion notification.
 				suppressNotify(session.id, "kill");
@@ -444,6 +490,9 @@ export interface SubagentBudget {
 }
 
 interface Meta {
+	host?: string;
+	remoteId?: string;
+	remoteTerminalState?: string;
 	kind: "process" | "subagent";
 	// process
 	name?: string;
@@ -492,7 +541,21 @@ interface Meta {
 }
 
 const metaDir = () => path.join(ROOT, "meta");
-const logPath = (id: string) => path.join(ROOT, "sessions", id, "output.log");
+const localLogPath = (id: string) => path.join(ROOT, "sessions", id, "output.log");
+const logPath = (id: string) => {
+	const meta = readMeta(id);
+	return meta?.host ? `${shq(BABYSIT_BIN)} --host ${shq(meta.host)} log -s ${shq(meta.remoteId!)}` : localLogPath(id);
+};
+
+function remoteMetadata(): Array<{ id: string; meta: Meta }> {
+	try {
+		return fs.readdirSync(metaDir()).filter((file) => file.endsWith(".json")).flatMap((file) => {
+			const id = file.slice(0, -5);
+			const meta = readMeta(id);
+			return meta?.host && meta.remoteId ? [{ id, meta }] : [];
+		});
+	} catch { return []; }
+}
 
 function writeMeta(id: string, m: Meta): boolean {
 	const target = path.join(metaDir(), `${id}.json`);
@@ -574,9 +637,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;
@@ -622,6 +692,17 @@ function gcRootIsSafe(root: string): boolean {
 		}
 	}
 
+	// Remote PIDs are meaningless locally. Retain unresolved remote references;
+	// terminal observations are persisted by listSessions, never prune remote data.
+	try {
+		for (const file of fs.readdirSync(path.join(root, "meta"))) {
+			if (!file.endsWith(".json")) continue;
+			const meta = JSON.parse(fs.readFileSync(path.join(root, "meta", file), "utf8")) as Meta;
+			if (meta.host && (!meta.remoteTerminalState || !isConfirmedTerminalState(meta.remoteTerminalState))) return false;
+		}
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") return false;
+	}
 	const sessionsDir = path.join(root, "sessions");
 	let sessionDirs: fs.Dirent[];
 	try {
@@ -748,7 +829,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,
@@ -1116,6 +1197,10 @@ async function searchLog(
 	signal?: AbortSignal,
 	maxBytes = TAIL_MAX_BYTES,
 ): Promise<{ text: string; error?: string }> {
+	if (readMeta(id)?.host) {
+		const result = await bs(["log", "-s", id, "--grep", pattern, "--tail", String(maxLines)], { signal });
+		return result.code === 0 ? { text: clip(result.stdout.trimEnd(), maxBytes) } : { text: "", error: result.stderr || result.stdout || "Remote log search failed" };
+	}
 	const file = logPath(id);
 	if (!fs.existsSync(file)) return { text: "", error: `Log file is missing: ${file}` };
 	if (signal?.aborted) return { text: "", error: "Log search was interrupted." };
@@ -1188,6 +1273,12 @@ async function inlineOutput(
 	status: BsSession,
 	maxBytes = INLINE_OUTPUT_MAX_BYTES,
 ): Promise<string> {
+	if (readMeta(id)?.host) {
+		const result = await bs(["log", "-s", id, "--tail", "200"]);
+		if (result.code !== 0) return `\nRemote output unavailable: ${clip(result.stderr || result.stdout, maxBytes)}`;
+		const output = clip(result.stdout.trimEnd(), maxBytes);
+		return output ? `\n\nRemote output (200 lines max):\n${output}` : "";
+	}
 	let bytes = status.output_bytes;
 	if (bytes == null) {
 		try {
@@ -1200,7 +1291,9 @@ async function inlineOutput(
 		const size = Number.isFinite(bytes) ? `${bytes} bytes` : "size unavailable";
 		return `\nOutput omitted (${size}; inline limit ${maxBytes}).`;
 	}
-	const output = (await bs(["log", "-s", id])).stdout.trimEnd();
+	const result = await bs(["log", "-s", id]);
+	if (result.code !== 0) return `\nOutput unavailable: ${clip(result.stderr || result.stdout, maxBytes)}`;
+	const output = result.stdout.trimEnd();
 	if (Buffer.byteLength(output) > maxBytes) {
 		return `\nOutput omitted (exceeds inline limit ${maxBytes} bytes).`;
 	}
@@ -1230,7 +1323,9 @@ async function selectedProcessOutput(
 		const body = result.text || `(no output matching /${selection.pattern}/)`;
 		return `\n\nSelected output /${selection.pattern}/:\n${clip(body, maxBytes)}`;
 	}
-	const tail = (await bs(["log", "-s", id, "--tail", String(lines)])).stdout.trimEnd();
+	const result = await bs(["log", "-s", id, "--tail", String(lines)], { signal });
+	if (result.code !== 0) return `\nOutput unavailable: ${clip(result.stderr || result.stdout, maxBytes)}`;
+	const tail = result.stdout.trimEnd();
 	return tail ? `\n\nSelected tail (${lines} lines max):\n${clip(tail, maxBytes)}` : "";
 }
 
@@ -1978,6 +2073,7 @@ const reservedSessionIds = new Set<string>();
 async function reserveUniqueSessionId(name: string): Promise<string> {
 	const base = name.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "proc";
 	const taken = new Set((await listSessions()).sessions.map((s) => s.id));
+	for (const { id } of remoteMetadata()) taken.add(id);
 	for (const id of reservedSessionIds) taken.add(id);
 	let id = base;
 	for (let i = 2; taken.has(id); i++) id = `${base}-${i}`;
@@ -1988,7 +2084,8 @@ async function reserveUniqueSessionId(name: string): Promise<string> {
 interface ProcOpts {
 	name?: string;
 	command: string;
-	cwd: string;
+	cwd?: string;
+	host?: string;
 	env?: Record<string, string | undefined>;
 	timeout?: string; // default: none — dev servers may run indefinitely
 	idleTimeout?: string;
@@ -2009,22 +2106,53 @@ export function processSessionEnvironment(
 	};
 }
 
+// babysit session ids are limited to 64 ASCII characters. Names stay in local
+// metadata; a fixed namespace hash plus full UUID keeps remote ids at 52 bytes.
+export function remoteProcessId(namespace: string): string {
+	return `pi-${createHash("sha256").update(namespace).digest("hex").slice(0, 12)}-${randomUUID()}`;
+}
+
+export function validateProcessHost(host?: string): void {
+	if (host && host !== "local" && (!/^[A-Za-z0-9][A-Za-z0-9_.@:\[\]-]*$/.test(host) || host.startsWith("-"))) {
+		throw new Error("Invalid host: use an SSH destination or config alias, not options or whitespace.");
+	}
+}
+
+export function remoteProcessCommand(command: string, cwd?: string, env: Record<string, string | undefined> = {}): string {
+	const assignments = Object.entries(env).filter(([key, value]) => value !== undefined && key !== "PI_SESSION_FILE" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${shq(value!)}`);
+	return `${cwd !== undefined ? `cd ${shq(cwd)} && ` : ""}exec env ${assignments.join(" ")} sh -c ${shq(command)}`;
+}
+
 async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: string }> {
+	validateProcessHost(opts.host);
+	const remote = !!opts.host && opts.host !== "local";
 	const bsArgs = ["run", "-d", "--json", "--size", "120x40"];
 	if (!opts.pty) bsArgs.push("--no-tty");
 	if (opts.timeout && opts.timeout !== "none") bsArgs.push("--timeout", opts.timeout);
 	if (opts.idleTimeout && opts.idleTimeout !== "none")
 		bsArgs.push("--idle-timeout", opts.idleTimeout);
-	const reservedId = opts.name ? await reserveUniqueSessionId(opts.name) : undefined;
-	if (reservedId) bsArgs.push("--id", reservedId);
-	bsArgs.push("--", SHELL, "-c", opts.command);
+	const reservedId = remote ? await reserveUniqueSessionId(opts.name ?? "remote-proc") : opts.name ? await reserveUniqueSessionId(opts.name) : undefined;
+	const remoteId = remote ? remoteProcessId(ROOT) : undefined;
+	if (reservedId) bsArgs.push("--id", remoteId ?? reservedId);
+	if (remote && !writeMeta(reservedId!, { kind: "process", host: opts.host, remoteId, name: opts.name ?? reservedId, command: opts.command, notificationGroup: opts.notificationGroup, notified: false, startedAt: Date.now() })) {
+		reservedSessionIds.delete(reservedId!);
+		return { error: "Cannot persist remote identity; process was not started." };
+	}
+	bsArgs.push("--", remote ? "sh" : SHELL, "-c", remote ? remoteProcessCommand(opts.command, opts.cwd, opts.env) : opts.command);
 
 	let r: Awaited<ReturnType<typeof bs>>;
 	try {
-		r = await bs(bsArgs, { cwd: opts.cwd, env: opts.env });
+		r = await bs(bsArgs, { cwd: remote ? undefined : opts.cwd, env: remote ? undefined : opts.env, host: opts.host });
 	} finally {
 		if (reservedId) reservedSessionIds.delete(reservedId);
 	}
+	if (remote) {
+		if (r.code !== 0) return { error: `Remote launch on ${opts.host} is unverified: ${r.stderr || r.stdout}. Tracked id: ${reservedId}; use check/kill to reconcile. Do not blindly retry.` };
+		try {
+			if (JSON.parse(r.stdout).id !== remoteId) throw new Error("unexpected remote id");
+		} catch { return { error: `Remote launch response is unverified on ${opts.host}; tracked id: ${reservedId}. Use check/kill to reconcile; do not retry.` }; }
+		return { id: reservedId! };
+	}
 	if (r.code !== 0) {
 		return {
 			error:
@@ -2521,12 +2649,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 +2663,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();
@@ -2675,6 +2810,10 @@ function readTailLines(file: string, lines: number, maxBytes = 64_000): string[]
 	}
 }
 
+const remoteTails = new Map<string, string[]>();
+// Running previews are not final. Only a successful post-terminal fetch is reusable.
+const remoteTerminalTails = new Set<string>();
+
 // Trailing lines to show for a session (sanitized, unprefixed).
 // Process tails are read directly from the bounded end of output.log, avoiding
 // one `babysit log` subprocess per visible process.
@@ -2685,6 +2824,7 @@ export function widgetTail(
 	lines = WIDGET_COLLAPSED_TAIL_LINES,
 ): string[] {
 	let raw: string[];
+	if (readMeta(id)?.host) return remoteTails.get(id) ?? ["Remote output unavailable; use babysit_check."];
 	if (!isSub) {
 		raw = readTailLines(logPath(id), lines);
 	} else {
@@ -2714,6 +2854,8 @@ export function widgetTail(
 // process interactively (detach with Ctrl-\ Ctrl-\). `/babysit` shows this as a
 // hint alongside an inline snapshot instead of spawning a tmux window itself.
 function attachCmd(id: string): string {
+	const meta = readMeta(id);
+	if (meta?.host) return `${shq(BABYSIT_BIN)} --host ${shq(meta.host)} attach -s ${shq(meta.remoteId!)}`;
 	return `BABYSIT_DIR=${shq(ROOT)} ${shq(BABYSIT_BIN)} attach -s ${shq(id)}`;
 }
 
@@ -3511,6 +3653,8 @@ export default function (pi: ExtensionAPI) {
 		const notices = prepared.flatMap((notice) => {
 			const current = readMeta(notice.id);
 			if (!shouldDeliverProcessCompletion(current)) return [];
+			const latest = finalSessions.find((session) => session.id === notice.id);
+			if (!latest || latest.transportError || latest.state === "running") return [];
 			if (!isNotificationGroupReady(current, finalSessions, readMeta)) return [];
 			metadataById.set(notice.id, current);
 			return [{ ...notice, command: current.command }];
@@ -3610,6 +3754,12 @@ export default function (pi: ExtensionAPI) {
 
 		const theme = ctx.ui.theme;
 		const summaryLines = renderWidgetLines(procs, subs.length - idle, idle, theme);
+		await Promise.all(ordered.filter((session) => session.host && (session.state === "running" || !remoteTerminalTails.has(session.id))).map(async (session) => {
+			remoteTerminalTails.delete(session.id);
+			const result = await bs(["log", "-s", session.id, "--tail", String(WIDGET_COLLAPSED_TAIL_LINES)]);
+			remoteTails.set(session.id, result.code === 0 ? clip(result.stdout, TAIL_MAX_BYTES).trimEnd().split("\n").map(sanitizeTailLine) : [`Remote output unavailable on ${session.host}: ${clip(result.stderr, 200)}`]);
+			if (result.code === 0 && !session.transportError && (isConfirmedTerminalState(session.state) || session.state === "dead")) remoteTerminalTails.add(session.id);
+		}));
 		const tails = await Promise.all(
 			active.map((session) => {
 				const isSubagent = kindOf(session.id) === "subagent";
@@ -3632,11 +3782,12 @@ export default function (pi: ExtensionAPI) {
 					...(meta?.launchCommand ? [theme.bold(escapeCommandForDisplay(readableLaunchCommand(meta.launchCommand)))] : []),
 				]
 				: meta?.command ? [theme.bold(escapeCommandForDisplay(meta.command))] : [];
+			if (meta?.host) details.unshift(`host: ${meta.host}${session.transportError ? " (status unknown)" : ""} · ${attachCmd(id)}`);
 			if (session.state === "running") {
 				const state: WidgetSessionState = isSubagent && progressById.get(id)?.done ? "idle" : "running";
 				return {
 					id,
-					header: renderWidgetSessionHeader(id, isSubagent ? "agent" : "process", state, elapsedOf(id), theme),
+					header: renderWidgetSessionHeader(id, isSubagent ? "agent" : "process", state, elapsedOf(id), theme) + (session.transportError ? " · status unknown" : ""),
 					tail: activeTails.get(id) ?? [],
 					viewable: true,
 					active: true,
@@ -3674,8 +3825,9 @@ export default function (pi: ExtensionAPI) {
 						requestRender: () => tui.requestRender(),
 						getTheme: () => ctx.ui.theme,
 						readLog: (id) => {
+							if (readMeta(id)?.host) return { text: `Remote full-history viewer is unavailable.\nLog: ${logPath(id)}\nTake over: ${attachCmd(id)}\n\n${(remoteTails.get(id) ?? []).join("\n")}`, isAgent: false };
 							const isAgent = kindOf(id) === "subagent";
-							return { ...readViewerLog(logPath(id), true), isAgent };
+							return { file: logPath(id), isAgent };
 						},
 					});
 					return sessionWidget;
@@ -3806,6 +3958,8 @@ export default function (pi: ExtensionAPI) {
 		}
 		taskProgressCache.clear();
 		searchLogCache.clear();
+		remoteTails.clear();
+		remoteTerminalTails.clear();
 		pollNeeded = true;
 		const retentionDays = Number(process.env.PI_BABYSIT_RETENTION_DAYS ?? "3");
 		if (
@@ -3946,6 +4100,8 @@ export default function (pi: ExtensionAPI) {
 			return prepareBabysitRunArguments(args) as never;
 		},
 		parameters: Type.Object({
+			host: Type.Optional(Type.String({ description: "Process SSH destination/config alias (default local). Remote subagents are unsupported." })),
+			cwd: Type.Optional(Type.String({ description: "Process working directory. Remote default is login home; never inferred from local cwd." })),
 			command: Type.Optional(
 				Type.String({
 					description: "Shell command to run (process mode). Mutually exclusive with profile/task.",
@@ -4076,6 +4232,9 @@ export default function (pi: ExtensionAPI) {
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			await requireBabysit();
 			const isSubagent = params.profile === "subagent";
+			validateProcessHost(params.host);
+			if (isSubagent && (params.cwd !== undefined || (params.host && params.host !== "local"))) throw new Error("host/cwd are process-only options; remote subagents are not supported.");
+			if (params.host && params.host !== "local" && params.retryOnWorkerDeath) throw new Error("Remote automatic launch retries are unsupported; reconcile the tracked session explicitly.");
 			if (isSubagent && !params.task) {
 				return {
 					content: [{ type: "text", text: "profile 'subagent' requires `task`." }],
@@ -4180,7 +4339,8 @@ export default function (pi: ExtensionAPI) {
 				const spawnOpts: ProcOpts = {
 					name: params.name,
 					command: params.command as string,
-					cwd: ctx.cwd,
+					host: params.host,
+					cwd: params.cwd ?? (params.host && params.host !== "local" ? undefined : ctx.cwd),
 					timeout: params.timeout,
 					idleTimeout: params.idleTimeout,
 					pty: params.pty ?? true,
@@ -4556,7 +4716,7 @@ export default function (pi: ExtensionAPI) {
 							: "";
 					const what = (kind === "subagent" ? meta?.task : meta?.command) ?? "";
 					const preview = what.length > 60 ? `${what.slice(0, 57)}…` : what;
-					return `${s.id}  [${kind}] ${s.state}${ec}${depth}${flag}${preview ? `  — ${preview}` : ""}`;
+					return `${s.id}  [${kind}${s.host ? ` host=${s.host}` : ""}] ${s.transportError ? "unknown" : s.state}${ec}${depth}${flag}${preview ? `  — ${preview}` : ""}`;
 				});
 				const hidden = sessions.length - selected.length;
 				const suffix = hidden > 0 ? `\n… ${hidden} session(s) hidden${revealHint}.` : "";
@@ -4566,7 +4726,9 @@ export default function (pi: ExtensionAPI) {
 				};
 			}
 
-			const st = await statusOf(params.id);
+			const lookup = await lookupStatus(params.id);
+			if (lookup.error) throw new Error(`Status unknown for ${params.id}: ${lookup.error}`);
+			const st = lookup.session;
 			if (!st) {
 				return {
 					content: [{ type: "text", text: `No such session: ${params.id}` }],
@@ -4601,7 +4763,7 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 				const kind = meta?.kind ?? "process";
-				const header = `[${kind}] state=${st.state}\nlog: ${logPath(params.id)}`;
+				const header = `[${kind}${meta?.host ? ` host=${meta.host}` : ""}] state=${st.state}\nlog: ${logPath(params.id)}`;
 				const body = result.text
 					? `--- latest matches /${params.pattern}/ ---\n${result.text}`
 					: `(no output matching /${params.pattern}/)`;
@@ -4614,7 +4776,7 @@ export default function (pi: ExtensionAPI) {
 			// --- process ---
 			if (meta?.kind !== "subagent") {
 				const parts: string[] = [];
-				let header = `[process] state=${st.state}`;
+				let header = `[process${meta?.host ? ` host=${meta.host}` : ""}] state=${st.state}`;
 				if (st.state === "running") {
 					const el = elapsedOf(params.id);
 					if (el) header += ` elapsed=${el}`;
@@ -4626,10 +4788,13 @@ export default function (pi: ExtensionAPI) {
 				parts.push(header);
 				if (params.screen) {
 					const sc = await bs(["screenshot", "-s", params.id, "--trim"]);
+					if (sc.code !== 0) throw new Error(sc.stderr || sc.stdout || "Screenshot unavailable");
 					parts.push(`--- screen ---\n${clip(sc.stdout.trimEnd(), checkMaxBytes) || "(blank screen)"}`);
 				} else {
+					const result = await bs(["log", "-s", params.id, "--tail", String(nLines)]);
+					if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Log unavailable");
 					const tail = clip(
-						(await bs(["log", "-s", params.id, "--tail", String(nLines)])).stdout.trimEnd(),
+						result.stdout.trimEnd(),
 						checkMaxBytes,
 					);
 					parts.push(tail ? `--- recent output ---\n${tail}` : "(no output yet)");
@@ -4724,7 +4889,9 @@ export default function (pi: ExtensionAPI) {
 		}),
 		async execute(_id, params) {
 			await requireBabysit();
-			const st = await statusOf(params.id);
+			const lookup = await lookupStatus(params.id);
+			if (lookup.error) throw new Error(`Status unknown for ${params.id}: ${lookup.error}`);
+			const st = lookup.session;
 			if (!st || st.state !== "running") {
 				return {
 					content: [
@@ -5281,12 +5448,12 @@ export default function (pi: ExtensionAPI) {
 				// For a LIVE process show the CURRENT rendered screen (TUIs redraw in
 				// place, so the raw stream isn't representative); for a finished one
 				// the recorded tail is enough.
-				const screen = running
-					? (await bs(["screenshot", "-s", picked.id, "--trim"])).stdout.trimEnd()
-					: "";
-				const tail = (await bs(["log", "-s", picked.id, "--tail", "30"])).stdout.trimEnd();
+				const screenResult = running ? await bs(["screenshot", "-s", picked.id, "--trim"]) : undefined;
+				const screen = screenResult ? screenResult.code === 0 ? screenResult.stdout.trimEnd() : `Screen unavailable: ${screenResult.stderr || screenResult.stdout}` : "";
+				const tailResult = await bs(["log", "-s", picked.id, "--tail", "30"]);
+				const tail = tailResult.code === 0 ? tailResult.stdout.trimEnd() : `Output unavailable: ${tailResult.stderr || tailResult.stdout}`;
 				const title =
-					`${picked.id} ${picked.state}${elapsedSuffix}` +
+					`${picked.id}${meta?.host ? ` @${meta.host}` : ""} ${picked.transportError ? "unknown" : picked.state}${elapsedSuffix}` +
 					(picked.exit_code != null ? ` (exit=${picked.exit_code})` : "");
 				const body =
 					(meta?.command ? `\`${meta.command}\`\n\n` : "") +

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.19",
   "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",