@gavin-hu/my-pi-agent 0.13.1 → 0.15.0

package/extensions/watch/child.ts

@@ -0,0 +1,150 @@
+/**
+ * A command watcher's process lifecycle: spawn, tree-kill, escalate, and drain.
+ *
+ * A command source is a spawned process whose merged stdout and stderr feed the
+ * matcher. This module owns the process side only — the spawn, the SIGTERM →
+ * SIGKILL grace, and the shutdown drain — over the injected `SpawnFn` and
+ * `KillTreeFn` seams, so the runtime keeps the watcher's status, its repaint,
+ * and its clock.
+ *
+ * Value-only: the child handle and its escalation timer live on the caller's
+ * slot, never here, because Pi loads each extension with its own module cache.
+ */
+
+import { defaultKillTree, defaultSpawn, type KillTreeFn, type SpawnFn, type SpawnedProcess } from "../../lib/spawn.ts";
+
+/** Grace period before a stopped command is escalated to SIGKILL. */
+export const KILL_GRACE_MS = 2000;
+
+/**
+ * The process fields a watcher record carries. The supervisor mutates them in
+ * place, so the runtime's record and the module's handle cannot disagree about
+ * whether a child is still live.
+ */
+export interface ChildSlot {
+	pid?: number;
+	child?: SpawnedProcess;
+	killTimer?: ReturnType<typeof setTimeout>;
+}
+
+/** How a child settled, for the sink that owns the watcher's status transition. */
+export type ChildOutcome =
+	| { kind: "closed"; code: number | null; signal: string | null }
+	| { kind: "failed"; message: string };
+
+export interface ChildSink {
+	/** One chunk of merged stdout/stderr. */
+	onData(chunk: Buffer): void;
+	/**
+	 * The child closed or failed to spawn. The sink owns the status, because only
+	 * it knows whether the watcher was still running when that happened.
+	 */
+	onSettled(outcome: ChildOutcome): void;
+}
+
+export interface ChildSupervisorOptions {
+	spawn?: SpawnFn;
+	killTree?: KillTreeFn;
+	/** Grace before SIGTERM escalates to SIGKILL; default {@link KILL_GRACE_MS}. */
+	graceMs?: number;
+}
+
+export interface ChildSupervisor {
+	/** Spawn `command`, or return the spawn error and leave the slot's child unset. */
+	start(slot: ChildSlot, command: string, cwd: string, sink: ChildSink): string | undefined;
+	/** SIGTERM a command, escalating to SIGKILL when it has not closed in time. */
+	terminate(slot: ChildSlot): void;
+	/** Kill immediately, without arming an escalation. */
+	kill(slot: ChildSlot, signal: "SIGTERM" | "SIGKILL"): void;
+	/** Cancel a pending escalation. */
+	clearTimer(slot: ChildSlot): void;
+	/** Resolve when every slot's child has closed, or after `ms`, whichever comes first. */
+	wait(slots: readonly ChildSlot[], ms: number): Promise<void>;
+}
+
+export function createChildSupervisor(options: ChildSupervisorOptions = {}): ChildSupervisor {
+	const spawnFn = options.spawn ?? defaultSpawn;
+	const killTree = options.killTree ?? defaultKillTree;
+	const graceMs = options.graceMs ?? KILL_GRACE_MS;
+
+	const clearTimer = (slot: ChildSlot): void => {
+		if (slot.killTimer) {
+			clearTimeout(slot.killTimer);
+			slot.killTimer = undefined;
+		}
+	};
+
+	const kill = (slot: ChildSlot, signal: "SIGTERM" | "SIGKILL"): void => {
+		const pid = slot.pid;
+		try {
+			if (pid !== undefined) killTree(pid, signal, signal === "SIGKILL");
+			else slot.child?.kill(signal);
+		} catch {
+			// Best-effort: the child may already be gone.
+		}
+	};
+
+	const terminate = (slot: ChildSlot): void => {
+		clearTimer(slot);
+		kill(slot, "SIGTERM");
+		if (slot.pid === undefined && !slot.child) return;
+		slot.killTimer = setTimeout(() => {
+			slot.killTimer = undefined;
+			if (slot.child) kill(slot, "SIGKILL");
+		}, graceMs);
+		slot.killTimer.unref?.();
+	};
+
+	const start = (slot: ChildSlot, command: string, cwd: string, sink: ChildSink): string | undefined => {
+		let child: SpawnedProcess;
+		try {
+			child = spawnFn(command, { cwd });
+		} catch (error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+		slot.child = child;
+		slot.pid = child.pid;
+		const onData = (chunk: Buffer): void => sink.onData(chunk);
+		child.stdout?.on("data", onData);
+		child.stderr?.on("data", onData);
+		child.on("close", (code, signal) => {
+			clearTimer(slot);
+			slot.child = undefined;
+			sink.onSettled({ kind: "closed", code, signal });
+		});
+		child.on("error", (error) => {
+			clearTimer(slot);
+			slot.child = undefined;
+			sink.onSettled({ kind: "failed", message: error.message });
+		});
+		return undefined;
+	};
+
+	const wait = (slots: readonly ChildSlot[], ms: number): Promise<void> => {
+		const alive = slots.filter((slot) => slot.child !== undefined);
+		if (alive.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			let remaining = alive.length;
+			let timer: ReturnType<typeof setTimeout> | undefined;
+			const settle = (): void => {
+				if (--remaining > 0) return;
+				if (timer !== undefined) clearTimeout(timer);
+				resolve();
+			};
+			for (const slot of alive) {
+				let done = false;
+				const once = (): void => {
+					if (done) return;
+					done = true;
+					settle();
+				};
+				slot.child?.on("close", once);
+				slot.child?.on("error", once);
+			}
+			timer = setTimeout(resolve, ms);
+			timer.unref?.();
+		});
+	};
+
+	return { start, terminate, kill, clearTimer, wait };
+}

package/extensions/watch/format.ts

@@ -6,50 +6,23 @@
  * status chip, the `/watch` screen, the transcript, and the model.
  *
  * File and command output is untrusted, so every line that reaches a widget or
- * the model goes through `sanitizeLine` at the boundary.
+ * the model goes through `sanitizeUntrustedLine` from `lib/format.ts` at the
+ * boundary; `sanitizeLine` covers the extension's own trusted text.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { sanitizeLine } from "../../lib/format.ts";
-import { clip, labelLine } from "../../lib/tui/columns.ts";
+import { boundedTail, sanitizeLine } from "../../lib/format.ts";
+import { clip, clipLabel, labelLine } from "../../lib/tui/columns.ts";
 import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
+import { byRunningFirst } from "../../lib/tui/rows.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import type { PendingMatch, WatchRecord, WatchStatus } from "./types.ts";
 
-/** Longest sanitized watched line kept for display; longer lines are clipped. */
-const MAX_WATCH_LINE = 200;
-
-/** ESC-introduced sequences: OSC, CSI, and single-character escapes. */
-const OSC = /\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
-const CSI = /\u001b\[[0-?]*[ -/]*[@-~]/g;
-const OTHER_ESC = /\u001b[@-Z\\-_]/g;
-const CONTROL = /[\u0000-\u001f\u007f-\u009f]/g;
-
-/**
- * Make one line of untrusted file/command output safe to render.
- *
- * Resolves carriage returns the way a terminal would (keep the text after the
- * last `\r`, so progress rewrites collapse to their final state), strips ANSI
- * escapes and control characters, collapses whitespace, and clips the result.
- * `sanitizeLine` alone would leave the printable tail of an ANSI sequence.
- */
-export function sanitizeWatchLine(raw: string): string {
-	const withoutAnsi = raw.replace(OSC, "").replace(CSI, "").replace(OTHER_ESC, "");
-	const afterCr = withoutAnsi.slice(withoutAnsi.lastIndexOf("\r") + 1);
-	const cleaned = afterCr.replace(CONTROL, " ").replace(/\s+/g, " ").trim();
-	return cleaned.length > MAX_WATCH_LINE ? `${cleaned.slice(0, MAX_WATCH_LINE - 1)}…` : cleaned;
-}
-
 /** Compile a pattern; case-insensitive unless `caseSensitive`. */
 export function compileRegex(pattern: string, caseSensitive: boolean): RegExp {
 	return new RegExp(pattern, caseSensitive ? "" : "i");
 }
 
-/** A label clipped to one safe display line. */
-export function clipLabel(text: string): string {
-	return labelLine(text, sanitizeWatchLine);
-}
-
 /** What a watcher reads: a path or a command, clipped for display. */
 export function sourceLabel(watch: WatchRecord): string {
 	if (watch.source.kind === "file") return clipLabel(watch.source.path ?? "");
@@ -89,11 +62,6 @@ export function statusGlyphChar(status: WatchStatus): string {
 	}
 }
 
-/** Width-1 themed glyph for a watcher status. */
-export function statusGlyph(status: WatchStatus, theme: Theme): string {
-	return paint(theme, statusRole(status), statusGlyphChar(status));
-}
-
 /** Short status word, including an exit code or error when present. */
 export function statusWord(watch: WatchRecord): string {
 	if (watch.status === "error" && watch.error) return `error (${watch.error})`;
@@ -104,10 +72,7 @@ export function statusWord(watch: WatchRecord): string {
 }
 
 /** Order watchers for display: running first, then by most recent start. */
-export function compareWatches(a: WatchRecord, b: WatchRecord): number {
-	const rank = (watch: WatchRecord): number => (watch.status === "running" ? 0 : 1);
-	return rank(a) - rank(b) || b.startedAt - a.startedAt;
-}
+export const compareWatches = byRunningFirst<WatchRecord>((watch) => watch.status === "running");
 
 /** One-line watcher summary shared by model output and the `/watch` screen. */
 function watchSummary(watch: WatchRecord, now: number): string {
@@ -155,12 +120,7 @@ export function formatTail(
 			truncated: false,
 		};
 	}
-	let body = lines.join("\n");
-	let truncated = false;
-	if (body.length > maxChars) {
-		body = body.slice(body.length - maxChars);
-		truncated = true;
-	}
+	const { text: body, truncated } = boundedTail(lines, maxChars);
 	const suffix = truncated ? `\n… truncated (${lines.length} lines total)` : "";
 	return { text: `${watch.id} (${statusWord(watch)}) ${label}:\n${body}${suffix}`, truncated };
 }
@@ -199,7 +159,7 @@ export function formatWatchOutcomeLine(watch: WatchRecord, theme: Theme, now = D
 			? paint(theme, "bad", statusWord(watch))
 			: paint(theme, "faint", `${watch.matchCount} match${watch.matchCount === 1 ? "" : "es"}`);
 	return (
-		statusGlyph(watch.status, theme) +
+		paint(theme, statusRole(watch.status), statusGlyphChar(watch.status)) +
 		" " +
 		paint(theme, "accent", watch.id) +
 		" " +

package/extensions/watch/index.ts

@@ -14,10 +14,11 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { WATCH_MATCH_CHANNEL, type WatchMatchEvent } from "../../lib/events.ts";
 import { sanitizeLine } from "../../lib/format.ts";
-import { noticeMessage, type NoticeMessage, pruneStaleNotices } from "../../lib/notice.ts";
-import { STATUS_KEYS } from "../../lib/tui/glyphs.ts";
+import { noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
+import { createPendingReporter } from "../../lib/report.ts";
 import { registerCommands } from "./commands.ts";
-import { clipLabel, formatPendingMatch } from "./format.ts";
+import { clipLabel } from "../../lib/tui/columns.ts";
+import { formatPendingMatch } from "./format.ts";
 import { createWatchRuntime, type WatchRuntime } from "./runtime.ts";
 import { registerTools } from "./tools.ts";
 import type { PendingMatch } from "./types.ts";
@@ -62,53 +63,46 @@ export interface WatchDeps {
 export default function watch(pi: ExtensionAPI, deps: WatchDeps = {}): void {
 	if (!isExtensionEnabled("watch")) return;
 	const runtime = deps.runtime ?? createWatchRuntime();
-	let busy = false;
-	let waking = false;
 
-	registerTools(pi, runtime);
-	registerCommands(pi, runtime);
-
-	// Opt-in wake: a `wake` watcher matched while the agent is idle. Report *all*
-	// pending matches, not just the waking one, so a non-wake match is not
-	// silently dropped. `waking` guards the window before `agent_start` fires.
-	const handleMatch = (): void => {
-		if (busy || waking) return;
-		const pending = runtime.pendingMatches();
-		if (pending.length === 0) return;
-		try {
-			pi.sendMessage(watchNotice(pending), { triggerTurn: true });
-			runtime.markReported(pending);
-			waking = true;
-		} catch {
-			// Waking is best-effort; the next turn still reports the matches.
-			return;
-		}
+	// Opt-in wake: a `wake` watcher matched while the agent is idle. The reporter
+	// reports *all* pending matches, not just the waking one, so a non-wake match
+	// is not silently dropped.
+	const reporter = createPendingReporter<PendingMatch>({
+		wake: (notice) => pi.sendMessage(notice, { triggerTurn: true }),
+		pending: () => runtime.pendingMatches(),
+		markReported: (matches) => runtime.markReported(matches),
+		buildNotice: watchNotice,
+		source: "watch",
 		// A wake means the user is away from the terminal, so the alert also leaves
 		// the process. bytefly's notify capability owns delivery; this publishes the
 		// fact and never learns how it is sent. The newest match is the one an alert
 		// is about, while the count covers the whole cycle.
-		const newest = pending[pending.length - 1];
-		if (!newest) return;
-		try {
-			const event: WatchMatchEvent = {
-				count: pending.length,
-				watcherId: newest.watcherId,
-				label: newest.label,
-				line: newest.line,
-			};
-			pi.events.emit(WATCH_MATCH_CHANNEL, event);
-		} catch {
-			// A throwing listener must not cost the wake that already happened.
-		}
-	};
+		onWoke: (matches) => {
+			const newest = matches[matches.length - 1];
+			if (!newest) return;
+			try {
+				const event: WatchMatchEvent = {
+					count: matches.length,
+					watcherId: newest.watcherId,
+					label: newest.label,
+					line: newest.line,
+				};
+				pi.events.emit(WATCH_MATCH_CHANNEL, event);
+			} catch {
+				// A throwing listener must not cost the wake that already happened.
+			}
+		},
+	});
+
+	registerTools(pi, runtime);
+	registerCommands(pi, runtime);
 
 	pi.on("session_start", (_event, ctx) => {
-		busy = false;
-		waking = false;
+		reporter.sessionStart();
 		runtime.load(ctx);
 		// `shutdown` clears this; a reload or session replacement reuses the
 		// runtime, so re-arm it on every session start.
-		runtime.onMatch = handleMatch;
+		runtime.onMatch = () => reporter.report();
 	});
 
 	// Tree navigation does not change the watcher table; only repaint.
@@ -117,37 +111,27 @@ export default function watch(pi: ExtensionAPI, deps: WatchDeps = {}): void {
 	});
 
 	pi.on("agent_start", () => {
-		busy = true;
+		reporter.agentStart();
 	});
 	pi.on("agent_settled", () => {
-		busy = false;
-		waking = false;
+		reporter.agentSettled();
 	});
 
 	// Report matches to the model at the start of the next turn.
 	pi.on("before_agent_start", (_event, ctx) => {
-		const pending = runtime.pendingMatches();
-		if (pending.length === 0) return undefined;
-		runtime.markReported(pending);
+		const reported = reporter.beforeAgentStart();
+		if (!reported) return undefined;
 		runtime.setStatus(ctx);
-		return { message: watchNotice(pending) };
+		return reported;
 	});
 
 	// Keep stale match notices out of later turns. Only this extension's notices
 	// are pruned; another source's are left for its own handler.
-	pi.on("context", (event) => {
-		const pruned = pruneStaleNotices(event.messages, "watch");
-		return pruned ? { messages: pruned } : undefined;
-	});
+	pi.on("context", (event) => reporter.filterContext(event.messages));
 
-	pi.on("session_shutdown", async (_event, ctx) => {
+	// `shutdown` detaches the UI controller, which clears both chips.
+	pi.on("session_shutdown", async () => {
 		runtime.onMatch = undefined;
 		await runtime.shutdown();
-		try {
-			ctx.ui.setStatus(STATUS_KEYS.watch, undefined);
-			ctx.ui.setStatus(STATUS_KEYS.watchMatches, undefined);
-		} catch {
-			// UI may already be gone.
-		}
 	});
 }

package/extensions/watch/runtime.ts

@@ -12,17 +12,18 @@ import { closeSync, openSync, readSync, statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { resolveEffectiveCwd } from "../../lib/env.ts";
+import { LineSplitter } from "../../lib/lines.ts";
+import type { KillTreeFn, SpawnFn, SpawnedProcess } from "../../lib/spawn.ts";
+import { createChildSupervisor } from "./child.ts";
 import { DEFAULT_CONFIG, loadConfig, type WatchConfig } from "./config.ts";
-import { compileRegex, sanitizeWatchLine, sourceLabel } from "./format.ts";
-import { defaultKillTree, defaultSpawn, type KillTreeFn, type SpawnFn, type SpawnedProcess } from "./process.ts";
+import { sanitizeUntrustedLine } from "../../lib/format.ts";
+import { compileRegex, sourceLabel } from "./format.ts";
 import { createUiController, type UiController } from "./ui.ts";
 import type { PendingMatch, WatchMatch, WatchRecord, WatchSource } from "./types.ts";
 
 /** Largest slice read from a file per tick. */
 const MAX_CHUNK = 1024 * 1024;
-/** A line without a newline is flushed once it grows past this. */
-const MAX_LINE_BYTES = 1024 * 1024;
-/** Grace period before a stopped command is escalated to SIGKILL. */
+/** Grace before a stopped command escalates to SIGKILL; `child.ts` defaults the same. */
 const KILL_GRACE_MS = 2000;
 
 /** Internal watcher state: the public record plus non-serializable fields. */
@@ -48,7 +49,7 @@ interface Internal {
 	regex: RegExp;
 	excludes: RegExp[];
 	offset: number;
-	pending: Buffer;
+	lines: LineSplitter;
 	rawLines: string[];
 	matches: WatchMatch[];
 	child?: SpawnedProcess;
@@ -103,8 +104,11 @@ export interface WatchRuntimeOptions {
 }
 
 export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRuntime {
-	const spawnFn = options.spawn ?? defaultSpawn;
-	const killTree = options.killTree ?? defaultKillTree;
+	const children = createChildSupervisor({
+		spawn: options.spawn,
+		killTree: options.killTree,
+		graceMs: options.killGraceMs,
+	});
 	const now = options.now ?? (() => Date.now());
 	const fixedConfig = options.config;
 	const autoClock = options.autoClock ?? true;
@@ -208,7 +212,7 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 		for (const exclude of w.excludes) if (exclude.test(line)) return false;
 		if (!w.regex.test(line)) return false;
 
-		const clean = sanitizeWatchLine(line);
+		const clean = sanitizeUntrustedLine(line);
 		w.matches.push({ seq: ++w.seq, line: clean, at: time, seen: false });
 		if (w.matches.length > config.maxMatches) {
 			w.matches.splice(0, w.matches.length - config.maxMatches);
@@ -224,85 +228,16 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 	};
 
 	const consume = (w: Internal, chunk: Buffer, time: number): void => {
-		const combined = w.pending.length > 0 ? Buffer.concat([w.pending, chunk]) : chunk;
-		let start = 0;
 		let matched = false;
-		while (true) {
-			const newline = combined.indexOf(0x0a, start);
-			if (newline < 0) break;
-			if (emit(w, combined.subarray(start, newline).toString("utf-8"), time)) matched = true;
-			start = newline + 1;
-		}
-		let rest = combined.subarray(start);
-		if (rest.length > MAX_LINE_BYTES) {
-			if (emit(w, rest.toString("utf-8"), time)) matched = true;
-			rest = Buffer.alloc(0);
+		for (const line of w.lines.push(chunk)) {
+			if (emit(w, line, time)) matched = true;
 		}
-		w.pending = Buffer.from(rest);
 		if (matched && w.wake) fireOnMatch();
 	};
 
+	/** A source that ended mid-line still reports that line. */
 	const flushPending = (w: Internal, time: number): void => {
-		if (w.pending.length === 0) return;
-		const rest = w.pending.toString("utf-8");
-		w.pending = Buffer.alloc(0);
-		emit(w, rest, time);
-	};
-
-	const clearKillTimer = (w: Internal): void => {
-		if (w.killTimer) {
-			clearTimeout(w.killTimer);
-			w.killTimer = undefined;
-		}
-	};
-
-	const killChild = (w: Internal, signal: "SIGTERM" | "SIGKILL"): void => {
-		const pid = w.pid;
-		try {
-			if (pid !== undefined) killTree(pid, signal, signal === "SIGKILL");
-			else w.child?.kill(signal);
-		} catch {
-			// Best-effort: the child may already be gone.
-		}
-	};
-
-	/** SIGTERM a command, escalating to SIGKILL when it has not closed in time. */
-	const terminateChild = (w: Internal): void => {
-		clearKillTimer(w);
-		killChild(w, "SIGTERM");
-		if (w.pid === undefined && !w.child) return;
-		w.killTimer = setTimeout(() => {
-			w.killTimer = undefined;
-			if (w.child) killChild(w, "SIGKILL");
-		}, killGraceMs);
-		w.killTimer.unref?.();
-	};
-
-	/** Resolve when every command has closed, or after `ms`, whichever comes first. */
-	const waitForChildren = (watches: Internal[], ms: number): Promise<void> => {
-		const alive = watches.filter((w) => w.child !== undefined);
-		if (alive.length === 0) return Promise.resolve();
-		return new Promise((resolve) => {
-			let remaining = alive.length;
-			let timer: ReturnType<typeof setTimeout> | undefined;
-			const settle = (): void => {
-				if (--remaining > 0) return;
-				if (timer !== undefined) clearTimeout(timer);
-				resolve();
-			};
-			for (const w of alive) {
-				let done = false;
-				const once = (): void => {
-					if (done) return;
-					done = true;
-					settle();
-				};
-				w.child?.on("close", once);
-				w.child?.on("error", once);
-			}
-			timer = setTimeout(resolve, ms);
-			timer.unref?.();
-		});
+		for (const line of w.lines.flush()) emit(w, line, time);
 	};
 
 	const pollFile = (w: Internal, time: number): void => {
@@ -317,7 +252,7 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 		}
 		if (size < w.offset) {
 			w.offset = 0;
-			w.pending = Buffer.alloc(0);
+			w.lines.reset();
 		}
 		if (w.offset >= size) return;
 
@@ -344,42 +279,28 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 	};
 
 	const startCommand = (w: Internal): void => {
-		let child: SpawnedProcess;
-		try {
-			child = spawnFn(w.source.command ?? "", { cwd: w.source.cwd ?? process.cwd() });
-		} catch (error) {
-			w.status = "error";
-			w.error = (error as Error).message;
-			w.endedAt = now();
-			return;
-		}
-		w.child = child;
-		w.pid = child.pid;
-		const onData = (chunk: Buffer): void => consume(w, chunk, now());
-		child.stdout?.on("data", onData);
-		child.stderr?.on("data", onData);
-		child.on("close", (code, signal) => {
-			clearKillTimer(w);
-			w.child = undefined;
-			if (w.status !== "running") return;
-			flushPending(w, now());
-			w.status = "exited";
-			w.exitCode = code;
-			w.signal = signal;
-			w.endedAt = now();
-			ui.paint();
-			if (runningCount() === 0) stopClock();
-		});
-		child.on("error", (error) => {
-			clearKillTimer(w);
-			w.child = undefined;
-			if (w.status !== "running") return;
-			w.status = "error";
-			w.error = error.message;
-			w.endedAt = now();
-			ui.paint();
-			if (runningCount() === 0) stopClock();
+		const error = children.start(w, w.source.command ?? "", w.source.cwd ?? process.cwd(), {
+			onData: (chunk) => consume(w, chunk, now()),
+			onSettled: (outcome) => {
+				if (w.status !== "running") return;
+				if (outcome.kind === "closed") {
+					flushPending(w, now());
+					w.status = "exited";
+					w.exitCode = outcome.code;
+					w.signal = outcome.signal;
+				} else {
+					w.status = "error";
+					w.error = outcome.message;
+				}
+				w.endedAt = now();
+				ui.paint();
+				if (runningCount() === 0) stopClock();
+			},
 		});
+		if (error === undefined) return;
+		w.status = "error";
+		w.error = error;
+		w.endedAt = now();
 	};
 
 	const tick = (): void => {
@@ -443,7 +364,7 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 			regex,
 			excludes,
 			offset,
-			pending: Buffer.alloc(0),
+			lines: new LineSplitter(),
 			rawLines: [],
 			matches: [],
 			notified: false,
@@ -476,13 +397,13 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 
 	const matches = (id: string, lines?: number) => tail(id, lines, (w) => w.matches.map((m) => m.line));
 	const logs = (id: string, lines?: number) =>
-		tail(id, lines, (w) => w.rawLines.map((line) => sanitizeWatchLine(line)));
+		tail(id, lines, (w) => w.rawLines.map((line) => sanitizeUntrustedLine(line)));
 
 	const stop = (id: string): boolean => {
 		const w = watches.get(id);
 		if (!w || w.status !== "running") return false;
 		flushPending(w, now());
-		terminateChild(w);
+		children.terminate(w);
 		w.status = "stopped";
 		w.endedAt = now();
 		ui.paint();
@@ -535,8 +456,8 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 		for (const w of watches.values()) {
 			if (w.status !== "running") continue;
 			w.status = "stopped";
-			clearKillTimer(w);
-			killChild(w, "SIGKILL");
+			children.clearTimer(w);
+			children.kill(w, "SIGKILL");
 			w.child = undefined;
 		}
 		watches.clear();
@@ -554,13 +475,13 @@ export function createWatchRuntime(options: WatchRuntimeOptions = {}): WatchRunt
 			flushPending(w, now());
 			w.status = "stopped";
 			w.endedAt = now();
-			clearKillTimer(w);
-			killChild(w, "SIGTERM");
+			children.clearTimer(w);
+			children.kill(w, "SIGTERM");
 		}
-		await waitForChildren(running, killGraceMs);
+		await children.wait(running, killGraceMs);
 		for (const w of running) {
-			clearKillTimer(w);
-			if (w.child) killChild(w, "SIGKILL");
+			children.clearTimer(w);
+			if (w.child) children.kill(w, "SIGKILL");
 		}
 		watches.clear();
 		ui.detach();