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

package/extensions/job/format.ts

@@ -7,51 +7,19 @@
  *
  * Raw log output is untrusted: it can contain ANSI escapes, carriage-return
  * progress rewrites, and control characters. Every boundary that surfaces log
- * text goes through `sanitizeLogLine`/`sanitizeLogText`, which strip those so a
- * background process cannot restyle or corrupt the terminal. The raw log file
- * is never modified.
+ * text goes through `sanitizeUntrustedLine`/`sanitizeUntrustedText` from
+ * `lib/format.ts`, so a background process cannot restyle or corrupt the
+ * terminal. The raw log file is never modified.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { formatDuration } from "../../lib/format.ts";
-import { clip, LABEL_WIDTH, labelLine } from "../../lib/tui/columns.ts";
+import { boundedTail, formatDuration, sanitizeUntrustedLine } from "../../lib/format.ts";
+import { clip, clipLabel, LABEL_WIDTH } 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 { JobRecord, JobStatus } from "./types.ts";
 
-/** Longest sanitized log line kept for display; longer lines are clipped. */
-const MAX_LOG_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;
-
-/** Remove ANSI/OSC escape sequences and control characters from one line. */
-function stripEscapes(raw: string): string {
-	return raw.replace(OSC, "").replace(CSI, "").replace(OTHER_ESC, "");
-}
-
-/**
- * Make one line of untrusted log 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
- * escapes and control characters, collapses whitespace, and clips the result.
- */
-export function sanitizeLogLine(raw: string): string {
-	const withoutAnsi = stripEscapes(raw);
-	const afterCr = withoutAnsi.slice(withoutAnsi.lastIndexOf("\r") + 1);
-	const cleaned = afterCr.replace(CONTROL, " ").replace(/\s+/g, " ").trim();
-	return cleaned.length > MAX_LOG_LINE ? `${cleaned.slice(0, MAX_LOG_LINE - 1)}…` : cleaned;
-}
-
-/** Sanitize a block of log text line by line. */
-export function sanitizeLogText(raw: string): string[] {
-	return raw.split("\n").map(sanitizeLogLine);
-}
-
 /** The last `count` entries of `lines`. */
 export function tailLines(lines: string[], count: number): string[] {
 	if (count <= 0) return [];
@@ -95,22 +63,12 @@ export function statusGlyphChar(status: JobStatus): string {
 	}
 }
 
-/** Width-1 themed glyph for a status. */
-export function statusGlyph(status: JobStatus, theme: Theme): string {
-	return paint(theme, statusRole(status), statusGlyphChar(status));
-}
-
 /** Short status word for text output. */
 function statusWord(job: JobRecord): string {
 	if (job.status === "failed" && job.exitCode !== null) return `failed (exit ${job.exitCode})`;
 	return job.status;
 }
 
-/** A label clipped to one safe display line. */
-export function clipLabel(text: string): string {
-	return labelLine(text, sanitizeLogLine);
-}
-
 /** A job's label (falling back to its command) clipped to one safe display line. */
 export function shortLabel(job: JobRecord): string {
 	return clipLabel(job.label || job.command);
@@ -138,12 +96,12 @@ export function formatJobList(jobs: JobRecord[], now = Date.now(), ownSessionId?
 export function formatJobStatus(job: JobRecord, now = Date.now(), ownSessionId?: string): string {
 	const lines = [
 		`${job.id}: ${statusWord(job)}`,
-		`command: ${sanitizeLogLine(job.command)}`,
-		`cwd: ${sanitizeLogLine(job.cwd)}`,
+		`command: ${sanitizeUntrustedLine(job.command)}`,
+		`cwd: ${sanitizeUntrustedLine(job.cwd)}`,
 		`elapsed: ${formatDuration(elapsedMs(job, now))}`,
 	];
 	if (job.pid) lines.push(`pid: ${job.pid}`);
-	if (job.logPath) lines.push(`log: ${sanitizeLogLine(job.logPath)}`);
+	if (job.logPath) lines.push(`log: ${sanitizeUntrustedLine(job.logPath)}`);
 	if (ownSessionId !== undefined && job.sessionId !== ownSessionId) lines.push("session: another session");
 	if (job.lastLine) lines.push(`last: ${job.lastLine}`);
 	return lines.join("\n");
@@ -154,12 +112,7 @@ export function formatLogs(job: JobRecord, lines: string[], maxChars: number): {
 	if (lines.length === 0) {
 		return { text: `${job.id}: no output yet${job.logPath ? ` (log: ${job.logPath})` : ""}.`, 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; full log: ${job.logPath}` : "";
 	return { text: `${job.id} (${statusWord(job)}) output:\n${body}${suffix}`, truncated };
 }
@@ -172,10 +125,10 @@ export function formatCompletion(job: JobRecord, now = Date.now()): string {
 
 /** Transcript call text for the `job` tool. */
 export function formatCallText(action: string, args: Record<string, unknown>, argsComplete = true): string {
-	const target = typeof args.id === "string" && args.id ? sanitizeLogLine(args.id) : undefined;
+	const target = typeof args.id === "string" && args.id ? sanitizeUntrustedLine(args.id) : undefined;
 	switch (action) {
 		case "start": {
-			const command = typeof args.command === "string" ? sanitizeLogLine(args.command.trim()) : "";
+			const command = typeof args.command === "string" ? sanitizeUntrustedLine(args.command.trim()) : "";
 			if (!command) return argsComplete ? "start" : "start …";
 			const preview = clip(command, LABEL_WIDTH);
 			return `start → ${preview}`;
@@ -184,7 +137,7 @@ export function formatCallText(action: string, args: Record<string, unknown>, ar
 			return `kill ${target ?? ""}`.trim();
 		case "send": {
 			if (!target) return "send";
-			const input = typeof args.input === "string" ? sanitizeLogLine(args.input) : "";
+			const input = typeof args.input === "string" ? sanitizeUntrustedLine(args.input) : "";
 			const preview = input ? clip(input, LABEL_WIDTH) : "";
 			const parts = [preview, args.eof === true ? "EOF" : ""].filter(Boolean).join(" + ");
 			return parts ? `send ${target} → ${parts}` : `send ${target}`;
@@ -201,10 +154,7 @@ export function formatCallText(action: string, args: Record<string, unknown>, ar
 }
 
 /** Order jobs for display: running first, then by most recent start. */
-export function compareJobs(a: JobRecord, b: JobRecord): number {
-	const rank = (job: JobRecord): number => (job.status === "running" ? 0 : 1);
-	return rank(a) - rank(b) || b.startedAt - a.startedAt;
-}
+export const compareJobs = byRunningFirst<JobRecord>((job) => job.status === "running");
 
 export interface JobCounts {
 	total: number;
@@ -252,7 +202,7 @@ export function formatJobOutcomeLine(job: JobRecord, theme: Theme, now = Date.no
 	const outcome =
 		job.status === "failed" ? paint(theme, "bad", jobOutcome(job)) : paint(theme, "faint", jobOutcome(job));
 	return (
-		statusGlyph(job.status, theme) +
+		paint(theme, statusRole(job.status), statusGlyphChar(job.status)) +
 		" " +
 		paint(theme, "accent", job.id) +
 		" " +
@@ -267,11 +217,11 @@ export function formatJobOutcomeLine(job: JobRecord, theme: Theme, now = Date.no
 /** Unstyled, sanitized detail lines for the `/jobs` focus pane. */
 export function formatJobDetail(job: JobRecord, now = Date.now(), ownSessionId?: string): string[] {
 	const lines = [
-		sanitizeLogLine(`command: ${job.command}`),
-		sanitizeLogLine(`cwd: ${job.cwd} · ${jobOutcome(job)} · ${formatDuration(elapsedMs(job, now))}`),
+		sanitizeUntrustedLine(`command: ${job.command}`),
+		sanitizeUntrustedLine(`cwd: ${job.cwd} · ${jobOutcome(job)} · ${formatDuration(elapsedMs(job, now))}`),
 	];
 	if (ownSessionId !== undefined && job.sessionId !== ownSessionId) lines.push("owner: another session");
-	const last = sanitizeLogLine(job.lastLine);
+	const last = sanitizeUntrustedLine(job.lastLine);
 	if (last) lines.push(`last: ${last}`);
 	return lines;
 }

package/extensions/job/index.ts

@@ -13,13 +13,13 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { JOB_FINISHED_CHANNEL, type JobFinishedEvent } from "../../lib/events.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 { formatCompletion, jobOutcome, shortLabel } from "./format.ts";
 import { createJobsRuntime, type JobsRuntime } from "./runtime.ts";
 import { registerTools } from "./tools.ts";
-import type { Job, JobRecord } from "./types.ts";
+import type { JobRecord } from "./types.ts";
 
 /** Marker embedded in the injected completion context. */
 const JOB_CONTEXT_MARKER = "[BACKGROUND JOBS]";
@@ -65,33 +65,27 @@ export interface JobsDeps {
 export default function jobs(pi: ExtensionAPI, deps: JobsDeps = {}): void {
 	if (!isExtensionEnabled("job")) return;
 	const runtime = deps.runtime ?? createJobsRuntime();
-	let busy = false;
+
+	// Opt-in wake: a `wake` job finished while the agent is idle. The reporter
+	// reports *all* pending completions, not just the waking one, so a job that
+	// finished earlier is not silently marked seen and dropped.
+	const reporter = createPendingReporter<JobRecord>({
+		wake: (notice) => pi.sendMessage(notice, { triggerTurn: true }),
+		pending: () => runtime.pendingCompletions(),
+		markReported: (records) => runtime.markReported(records.map((job) => job.id)),
+		buildNotice: jobNotice,
+		source: "job",
+	});
 
 	registerTools(pi, runtime);
 	registerCommands(pi, runtime);
 
-	// Opt-in wake: a `wake` job finished while the agent is idle. Report *all*
-	// pending completions, not just the waking one, so a non-wake job that
-	// finished earlier is not silently marked seen and dropped.
-	const handleFinish = (_job: Job): void => {
-		if (busy) return;
-		const pending = runtime.pendingCompletions();
-		if (pending.length === 0) return;
-		try {
-			pi.sendMessage(jobNotice(pending), { triggerTurn: true });
-			// Mark only once the send succeeded; a throw leaves them for the next turn.
-			runtime.markReported(pending.map((job) => job.id));
-		} catch {
-			// Waking is best-effort; the next turn still reports the completion.
-		}
-	};
-
 	pi.on("session_start", (_event, ctx) => {
-		busy = 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.onFinish = handleFinish;
+		// `shutdown` clears these; a reload or session replacement reuses the
+		// runtime, so re-arm them on every session start.
+		runtime.onFinish = () => reporter.report();
 		// Notify-listening extensions follow completions on the shared bus; the
 		// runtime only knows the callback, never the channel.
 		runtime.onComplete = (job) => {
@@ -109,37 +103,28 @@ export default function jobs(pi: ExtensionAPI, deps: JobsDeps = {}): void {
 	});
 
 	pi.on("agent_start", () => {
-		busy = true;
+		reporter.agentStart();
 	});
 	pi.on("agent_settled", () => {
-		busy = false;
+		reporter.agentSettled();
 	});
 
 	// Report completions to the model at the start of the next turn.
 	pi.on("before_agent_start", (_event, ctx) => {
-		const pending = runtime.pendingCompletions();
-		if (pending.length === 0) return undefined;
-		runtime.markReported(pending.map((job) => job.id));
+		const reported = reporter.beforeAgentStart();
+		if (!reported) return undefined;
 		runtime.setStatus(ctx);
-		return { message: jobNotice(pending) };
+		return reported;
 	});
 
 	// Keep stale completion 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, "job");
-		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.onFinish = undefined;
 		runtime.onComplete = undefined;
 		await runtime.shutdown();
-		try {
-			ctx.ui.setStatus(STATUS_KEYS.jobs, undefined);
-			ctx.ui.setStatus(STATUS_KEYS.jobsFailure, undefined);
-		} catch {
-			// UI may already be gone.
-		}
 	});
 }

package/extensions/job/log-writer.ts

@@ -0,0 +1,208 @@
+/**
+ * The per-job log sink: a write stream, the line splitter that feeds the job's
+ * `lastLine`, and rotation when the segment reaches its cap.
+ *
+ * Extracted from the job runtime so the process/table lifecycle and the log
+ * plumbing can be read separately. The writer owns no job state: every path and
+ * limit is a callback over the runtime's live config, and a buffered line is
+ * handed back through `onLine`.
+ */
+
+import { createWriteStream, existsSync, renameSync, unlinkSync, type WriteStream } from "node:fs";
+import { LineSplitter } from "../../lib/lines.ts";
+import type { Job, JobRecord } from "./types.ts";
+
+/** Bytes held while a rotation swaps the log stream before writes resume. */
+const MAX_ROTATION_QUEUE_BYTES = 2 * 1024 * 1024;
+
+/** One job's log state: the live segment, the queue, and the counters. */
+export interface LogHandle {
+	stream?: WriteStream;
+	lines: LineSplitter;
+	/** Chunks that arrived while the log stream was being swapped. */
+	queue: Buffer[];
+	/** Bytes currently in `queue`. */
+	queuedBytes: number;
+	/** True between ending the old stream and reopening the log. */
+	rotating: boolean;
+	/** Bytes dropped because a rotation could not keep up; reported by `logs`. */
+	droppedBytes: number;
+	/** Bytes written to the live segment, counted exactly as chunks arrive. */
+	logBytes: number;
+	/** True once the handle is disposed; a rotation in flight never reopens. */
+	disposed: boolean;
+}
+
+export interface LogWriterOptions {
+	/** The clock the repaint window is measured on. */
+	now(): number;
+	/** The live segment for a job, or undefined when it cannot be used. */
+	logPath(job: JobRecord): string | undefined;
+	/** The rotated segment for a job, or undefined when it cannot be used. */
+	rotatedPath(job: JobRecord): string | undefined;
+	/** Bytes a segment may reach before it rotates; 0 disables rotation. */
+	maxBytes(): number;
+	/** The repaint window for output-driven painting. */
+	repaintMs(): number;
+	/** Record one output line; the runtime sanitizes it onto the job. */
+	onLine(job: Job, line: string): void;
+	/** Repaint, at most once per repaint window while output arrives. */
+	onPaint(): void;
+}
+
+export interface LogWriter {
+	/** A handle for one job's log; `logPath` is undefined for a detached job. */
+	create(logPath: string | undefined): LogHandle;
+	/** Append child output, splitting lines and rotating at the cap. */
+	write(handle: LogHandle, job: Job, chunk: Buffer): void;
+	/** The buffered final lines, including a final line without a newline. */
+	flush(handle: LogHandle): string[];
+	/** Close the stream and mark the handle dead; idempotent. */
+	dispose(handle: LogHandle, options: { endStream: boolean }): void;
+}
+
+export function createLogWriter(options: LogWriterOptions): LogWriter {
+	/** Last output-driven repaint, so a busy child cannot repaint per chunk. */
+	let lastPaint = 0;
+
+	const writeLog = (handle: LogHandle, chunk: Buffer): void => {
+		try {
+			handle.stream?.write(chunk);
+		} catch {
+			// A closed stream must not break output handling.
+		}
+		// Count what we handed the stream: `WriteStream.bytesWritten` only updates on
+		// its completion callback, which can lag a tick behind the file on disk.
+		if (handle.stream) handle.logBytes += chunk.length;
+	};
+
+	/** Buffer a chunk while the log stream is being swapped, dropping the oldest past the cap. */
+	const enqueue = (handle: LogHandle, chunk: Buffer, front = false): void => {
+		if (front) handle.queue.unshift(chunk);
+		else handle.queue.push(chunk);
+		handle.queuedBytes += chunk.length;
+		while (handle.queuedBytes > MAX_ROTATION_QUEUE_BYTES && handle.queue.length > 1) {
+			const dropped = handle.queue.shift();
+			if (!dropped) break;
+			handle.queuedBytes -= dropped.length;
+			handle.droppedBytes += dropped.length;
+		}
+	};
+
+	/**
+	 * Move the live segment aside, queueing `chunk` ahead of the backlog, and reopen.
+	 *
+	 * Returns false when no rotation can start (no stream, or a record whose log
+	 * paths do not validate), so the caller writes the chunk instead of stranding it
+	 * in a queue nothing will drain.
+	 *
+	 * The old stream is ended and its `close` awaited before the rename, because
+	 * Windows refuses to rename an open file; chunks that arrive in that window
+	 * are queued rather than written, so nothing lands in the renamed inode.
+	 */
+	const rotateLog = (handle: LogHandle, job: Job, chunk: Buffer): boolean => {
+		const stream = handle.stream;
+		const logPath = options.logPath(job);
+		const rotated = options.rotatedPath(job);
+		if (!stream || !logPath || !rotated || handle.rotating) return false;
+		// This chunk precedes whatever queued while the previous segment was closing.
+		enqueue(handle, chunk, true);
+		handle.rotating = true;
+		stream.once("close", () => {
+			// A killed or cleared job disposes its handle; never reopen for it.
+			if (handle.disposed) return;
+			try {
+				if (existsSync(rotated)) unlinkSync(rotated);
+				renameSync(logPath, rotated);
+			} catch {
+				// A failed rename leaves the oversized segment in place; keep appending.
+			}
+			const reopened = createWriteStream(logPath, { flags: "a" });
+			reopened.on("error", () => {});
+			handle.stream = reopened;
+			handle.rotating = false;
+			handle.logBytes = 0;
+			drain(handle, job);
+		});
+		try {
+			stream.end();
+		} catch {
+			// Already ended.
+		}
+		return true;
+	};
+
+	/** Write one output chunk, rotating the segment first when it reached the cap. */
+	const writeChunk = (handle: LogHandle, job: Job, chunk: Buffer): void => {
+		if (handle.rotating) {
+			// Later than everything already queued.
+			enqueue(handle, chunk);
+			return;
+		}
+		const cap = options.maxBytes();
+		if (handle.stream && cap > 0 && handle.logBytes >= cap && rotateLog(handle, job, chunk)) return;
+		writeLog(handle, chunk);
+	};
+
+	/**
+	 * Replay the queue through `writeChunk` after a rotation, so a backlog that is
+	 * itself larger than the cap rotates again instead of filling one segment.
+	 */
+	const drain = (handle: LogHandle, job: Job): void => {
+		while (!handle.rotating && handle.queue.length > 0) {
+			const chunk = handle.queue.shift();
+			if (!chunk) break;
+			handle.queuedBytes -= chunk.length;
+			writeChunk(handle, job, chunk);
+		}
+	};
+
+	return {
+		create(logPath) {
+			const stream = logPath === undefined ? undefined : createWriteStream(logPath, { flags: "a" });
+			stream?.on("error", () => {});
+			return {
+				stream,
+				lines: new LineSplitter(),
+				queue: [],
+				queuedBytes: 0,
+				rotating: false,
+				droppedBytes: 0,
+				logBytes: 0,
+				disposed: false,
+			};
+		},
+
+		write(handle, job, chunk) {
+			if (handle.disposed) return;
+			writeChunk(handle, job, chunk);
+			for (const line of handle.lines.push(chunk)) options.onLine(job, line);
+			const time = options.now();
+			if (time - lastPaint >= options.repaintMs()) {
+				lastPaint = time;
+				options.onPaint();
+			}
+		},
+
+		flush(handle) {
+			return handle.lines.flush();
+		},
+
+		dispose(handle, { endStream }) {
+			if (handle.disposed) return;
+			handle.disposed = true;
+			// A rotation in flight checks `disposed` before reopening, so dropping the
+			// queue here cannot leak a stream for a dead job.
+			handle.queue = [];
+			handle.queuedBytes = 0;
+			if (endStream) {
+				try {
+					handle.stream?.end();
+				} catch {
+					// Already closed.
+				}
+			}
+			handle.stream = undefined;
+		},
+	};
+}

package/extensions/job/logs.ts

@@ -7,7 +7,8 @@
  */
 
 import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
-import { sanitizeLogText, tailLines } from "./format.ts";
+import { sanitizeUntrustedText } from "../../lib/format.ts";
+import { tailLines } from "./format.ts";
 
 /** Bytes of log read for a `logs` call. */
 const LOG_READ_BYTES = 64 * 1024;
@@ -50,7 +51,7 @@ export function readLogTail(path: string | undefined, lines: number): LogTail {
 	} catch {
 		// A missing/unreadable log yields an empty tail.
 	}
-	const all = dropTrailingBlank(sanitizeLogText(text));
+	const all = dropTrailingBlank(sanitizeUntrustedText(text));
 	const more = start > 0 || all.length > lines;
 	return { lines: tailLines(all, lines), truncated, more };
 }

package/extensions/job/process.ts

@@ -1,64 +1,17 @@
 /**
- * Process plumbing for the jobs extension.
+ * Process plumbing that only `job` needs.
  *
- * Background jobs must outlive a single tool call, so they are spawned with
- * Node's `child_process` rather than `pi.exec` (which resolves only when the
- * command finishes). Every function here is injectable, so tests can drive a
- * scripted child without launching a real process.
- *
- * On POSIX the child is started detached, making it a process-group leader;
- * signals go to the whole group (`-pid`) so a shell and its descendants die
- * together. On Windows the tree is killed with `taskkill /T`.
+ * The shared spawn, tree-kill, and liveness seams live in `lib/spawn.ts`, so
+ * what stays here is the job-specific remainder: the pid liveness and start-time
+ * seams the runtime injects, and the `ps` token that guards against pid reuse
+ * when a reattached job is settled.
  */
 
-import { execFileSync, spawn as nodeSpawn, spawnSync } from "node:child_process";
-import type { Readable } from "node:stream";
-
-/**
- * The writable end of a child's stdin pipe.
- *
- * Only the operations `send` needs, so tests can hand the runtime a recording
- * double instead of a real socket.
- */
-export interface StdinSink {
-	write(chunk: string): boolean;
-	end(): void;
-	destroy?(): void;
-	on(event: "error" | "close", listener: (error?: Error) => void): unknown;
-}
-
-/** The subset of a spawned child the runtime uses. */
-export interface SpawnedProcess {
-	pid?: number;
-	stdout: Readable | null;
-	stderr: Readable | null;
-	/** Present only when spawned with `stdin: true`. */
-	stdin?: StdinSink | null;
-	on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
-	on(event: "error", listener: (error: Error) => void): unknown;
-	kill(signal?: NodeJS.Signals): boolean;
-	/** Detach from the parent's event loop, so a background job cannot hold Pi open. */
-	unref?(): void;
-}
-
-export type SpawnFn = (
-	command: string,
-	options: {
-		cwd: string;
-		env?: NodeJS.ProcessEnv;
-		/** The command writes its own output to the log; keep no parent pipe. */
-		detachOutput?: boolean;
-		/** Give the child a stdin pipe instead of `/dev/null` (no immediate EOF). */
-		stdin?: boolean;
-	},
-) => SpawnedProcess;
+import { execFileSync } from "node:child_process";
 
 /** Whether a pid is still alive. */
 export type LivenessFn = (pid: number) => boolean;
 
-/** Send `signal` to a pid's process tree, escalating to SIGKILL when `force`. */
-export type KillTreeFn = (pid: number, signal: NodeJS.Signals, force?: boolean) => void;
-
 /**
  * Best-effort OS start-time token for a pid, used to detect pid reuse.
  * Returns undefined when the platform cannot provide one (for example Windows,
@@ -67,32 +20,6 @@ export type KillTreeFn = (pid: number, signal: NodeJS.Signals, force?: boolean)
  */
 export type StartTokenFn = (pid: number) => string | undefined;
 
-/** Default spawn: a shell command in its own process group. A detached job
- * redirects its own output to the log, so it needs no pipe to this process.
- * Stdin stays closed unless the job asked for it: a closed stdin gives the
- * child EOF, so `read` exits instead of blocking forever. */
-export const defaultSpawn: SpawnFn = (command, options) =>
-	nodeSpawn(command, {
-		cwd: options.cwd,
-		shell: true,
-		detached: process.platform !== "win32",
-		stdio: [
-			options.stdin ? "pipe" : "ignore",
-			...(options.detachOutput ? (["ignore", "ignore"] as const) : (["pipe", "pipe"] as const)),
-		],
-		env: options.env,
-	});
-
-/** Default liveness check. EPERM means the pid exists but is owned by someone else. */
-export const defaultLiveness: LivenessFn = (pid) => {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return (error as NodeJS.ErrnoException).code === "EPERM";
-	}
-};
-
 /** Default start-time token via `ps`. Undefined where `ps` is unavailable. */
 export const defaultStartToken: StartTokenFn = (pid) => {
 	try {
@@ -106,23 +33,3 @@ export const defaultStartToken: StartTokenFn = (pid) => {
 		return undefined;
 	}
 };
-
-/** Default tree kill: process group on POSIX, `taskkill /T` on Windows. */
-export const defaultKillTree: KillTreeFn = (pid, signal, force = false) => {
-	if (process.platform === "win32") {
-		spawnSync("taskkill", ["/pid", String(pid), "/T", ...(force ? ["/F"] : [])], { stdio: "ignore" });
-		return;
-	}
-	try {
-		process.kill(-pid, signal);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ESRCH") throw error;
-		// Not a group leader (for example a reattached pid); signal it directly.
-		// Callers verify the start token first, so this cannot hit a reused pid.
-		try {
-			process.kill(pid, signal);
-		} catch {
-			// Already gone.
-		}
-	}
-};