gnhf 0.1.8 → 0.1.10

package/dist/cli.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { appendFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { appendFileSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import process$1 from "node:process";
 import { createInterface } from "node:readline";
 import { Command, InvalidArgumentError } from "commander";
-import { dirname, isAbsolute, join } from "node:path";
-import { homedir } from "node:os";
 import yaml from "js-yaml";
 import { execFileSync, execSync, spawn } from "node:child_process";
 import { createServer } from "node:net";
@@ -13,8 +13,28 @@ import { createHash } from "node:crypto";
 //#region src/core/config.ts
 const DEFAULT_CONFIG = {
 	agent: "claude",
-	maxConsecutiveFailures: 3
+	maxConsecutiveFailures: 3,
+	preventSleep: true
 };
+var InvalidConfigError = class extends Error {};
+function normalizePreventSleep(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return void 0;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "on") return true;
+	if (value === "off") return false;
+}
+function normalizeConfig(config) {
+	const normalized = { ...config };
+	const hasPreventSleep = Object.prototype.hasOwnProperty.call(config, "preventSleep");
+	const preventSleep = normalizePreventSleep(config.preventSleep);
+	if (preventSleep === void 0) {
+		if (hasPreventSleep && config.preventSleep !== void 0) throw new InvalidConfigError(`Invalid config value for preventSleep: ${String(config.preventSleep)}`);
+		delete normalized.preventSleep;
+	} else normalized.preventSleep = preventSleep;
+	return normalized;
+}
 function isMissingConfigError(error) {
 	if (!(error instanceof Error)) return false;
 	return "code" in error ? error.code === "ENOENT" : error.message.includes("ENOENT");
@@ -25,6 +45,9 @@ agent: ${config.agent}
 
 # Abort after this many consecutive failures
 maxConsecutiveFailures: ${config.maxConsecutiveFailures}
+
+# Prevent the machine from sleeping during a run
+preventSleep: ${config.preventSleep}
 `;
 }
 function loadConfig(overrides) {
@@ -34,14 +57,15 @@ function loadConfig(overrides) {
 	let shouldBootstrapConfig = false;
 	try {
 		const raw = readFileSync(configPath, "utf-8");
-		fileConfig = yaml.load(raw) ?? {};
+		fileConfig = normalizeConfig(yaml.load(raw) ?? {});
 	} catch (error) {
+		if (error instanceof InvalidConfigError) throw error;
 		if (isMissingConfigError(error)) shouldBootstrapConfig = true;
 	}
 	const resolvedConfig = {
 		...DEFAULT_CONFIG,
 		...fileConfig,
-		...overrides
+		...normalizeConfig(overrides ?? {})
 	};
 	if (shouldBootstrapConfig) try {
 		mkdirSync(configDir, { recursive: true });
@@ -50,6 +74,20 @@ function loadConfig(overrides) {
 	return resolvedConfig;
 }
 //#endregion
+//#region src/core/debug-log.ts
+function appendDebugLog(event, details = {}) {
+	const logPath = process.env.GNHF_DEBUG_LOG_PATH;
+	if (!logPath) return;
+	try {
+		appendFileSync(logPath, `${JSON.stringify({
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			pid: process.pid,
+			event,
+			...details
+		})}\n`, "utf-8");
+	} catch {}
+}
+//#endregion
 //#region src/core/git.ts
 const NOT_GIT_REPOSITORY_MESSAGE = "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
 function translateGitError(error) {
@@ -250,6 +288,417 @@ function appendNotes(notesPath, iteration, summary, changes, learnings) {
 	].join("\n"), "utf-8");
 }
 //#endregion
+//#region src/core/stdin.ts
+async function readStdinText(input) {
+	const chunks = [];
+	for await (const chunk of input) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	return Buffer.concat(chunks).toString("utf-8").trim();
+}
+//#endregion
+//#region src/core/agents/managed-process.ts
+const POST_SIGKILL_GRACE_MS = 100;
+function signalChildProcess(child, options) {
+	const killProcess = options.killProcess ?? process.kill.bind(process);
+	if (options.detached && child.pid) try {
+		killProcess(-child.pid, options.signal);
+		return;
+	} catch {}
+	child.kill(options.signal);
+}
+async function shutdownChildProcess(child, options) {
+	if (child.exitCode != null || child.signalCode != null) return;
+	const timeoutMs = options.timeoutMs ?? 3e3;
+	await new Promise((resolve) => {
+		let forceKillTimer = null;
+		let hardDeadlineTimer = null;
+		let settled = false;
+		const settle = () => {
+			if (settled) return;
+			settled = true;
+			if (forceKillTimer) {
+				clearTimeout(forceKillTimer);
+				forceKillTimer = null;
+			}
+			if (hardDeadlineTimer) {
+				clearTimeout(hardDeadlineTimer);
+				hardDeadlineTimer = null;
+			}
+			child.off("close", handleClose);
+			resolve();
+		};
+		const handleClose = () => {
+			settle();
+		};
+		child.on("close", handleClose);
+		try {
+			signalChildProcess(child, {
+				...options,
+				signal: "SIGTERM"
+			});
+		} catch {}
+		forceKillTimer = setTimeout(() => {
+			try {
+				signalChildProcess(child, {
+					...options,
+					signal: "SIGKILL"
+				});
+			} catch {}
+			hardDeadlineTimer = setTimeout(() => {
+				settle();
+			}, POST_SIGKILL_GRACE_MS);
+			hardDeadlineTimer.unref?.();
+		}, timeoutMs);
+		forceKillTimer.unref?.();
+	});
+}
+//#endregion
+//#region src/core/sleep.ts
+const SYSTEMD_INHIBIT_READY_TIMEOUT_MS = 5e3;
+const SYSTEMD_INHIBIT_READY_POLL_MS = 25;
+const GNHF_SLEEP_REEXEC_READY_PATH = "GNHF_SLEEP_REEXEC_READY_PATH";
+const GNHF_SLEEP_REEXEC_READY_DIR_PREFIX = "gnhf-sleep-";
+const GNHF_SLEEP_REEXEC_READY_FILENAME = "reexec-ready";
+const HELPER_STARTUP_GRACE_MS = 100;
+function getSignalExitCode$1(signal) {
+	if (signal === "SIGINT") return 130;
+	if (signal === "SIGTERM") return 143;
+	return 1;
+}
+async function waitForSpawn(child) {
+	return await new Promise((resolve) => {
+		child.once("spawn", () => resolve(true));
+		child.once("error", () => resolve(false));
+	});
+}
+async function waitForHelperStability(child, timeoutMs) {
+	return await new Promise((resolve) => {
+		let settled = false;
+		let timer = null;
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			resolve(value);
+		};
+		child.once("exit", () => {
+			settle(false);
+		});
+		child.once("error", () => {
+			settle(false);
+		});
+		if (child.exitCode != null || child.signalCode != null) {
+			settle(false);
+			return;
+		}
+		timer = setTimeout(() => {
+			settle(true);
+		}, timeoutMs);
+		timer.unref?.();
+	});
+}
+function isTrustedLinuxReexecReadyPath(readyPath) {
+	const resolvedReadyPath = resolve(readyPath);
+	const readyDir = dirname(resolvedReadyPath);
+	return basename(resolvedReadyPath) === GNHF_SLEEP_REEXEC_READY_FILENAME && dirname(readyDir) === resolve(tmpdir()) && basename(readyDir).startsWith(GNHF_SLEEP_REEXEC_READY_DIR_PREFIX);
+}
+function signalLinuxReexecReady(env) {
+	const readyPath = env[GNHF_SLEEP_REEXEC_READY_PATH];
+	if (!readyPath) return;
+	if (!isTrustedLinuxReexecReadyPath(readyPath)) {
+		appendDebugLog("sleep:ready-signal-failed", {
+			command: "systemd-inhibit",
+			error: "untrusted ready path"
+		});
+		return;
+	}
+	try {
+		writeFileSync(readyPath, "ready\n", {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+	} catch (error) {
+		appendDebugLog("sleep:ready-signal-failed", {
+			command: "systemd-inhibit",
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+async function waitForLinuxReexecReady(readyPath, exitStatePromise, timeoutMs) {
+	if (existsSync(readyPath)) return { type: "ready" };
+	return await new Promise((resolve) => {
+		let settled = false;
+		const settle = (result) => {
+			if (settled) return;
+			settled = true;
+			clearInterval(poller);
+			clearTimeout(timeout);
+			resolve(result);
+		};
+		const poller = setInterval(() => {
+			if (existsSync(readyPath)) settle({ type: "ready" });
+		}, SYSTEMD_INHIBIT_READY_POLL_MS);
+		poller.unref?.();
+		const timeout = setTimeout(() => {
+			settle({ type: "timeout" });
+		}, timeoutMs);
+		timeout.unref?.();
+		exitStatePromise.then(({ exitCode, signal }) => {
+			settle({
+				type: "exit",
+				exitCode,
+				signal
+			});
+		});
+	});
+}
+function forwardTerminationSignalsToChild(child, detached, killProcess, processOn, processOff) {
+	const listeners = [];
+	for (const signal of ["SIGINT", "SIGTERM"]) {
+		const listener = () => {
+			try {
+				signalChildProcess(child, {
+					detached,
+					killProcess,
+					signal
+				});
+			} catch {}
+		};
+		processOn(signal, listener);
+		listeners.push([signal, listener]);
+	}
+	return () => {
+		for (const [signal, listener] of listeners) processOff(signal, listener);
+	};
+}
+function buildPowerShellCommand(parentPid) {
+	return [
+		"Add-Type @'",
+		"using System;",
+		"using System.Runtime.InteropServices;",
+		"public static class SleepBlock {",
+		"  [DllImport(\"kernel32.dll\")]",
+		"  public static extern uint SetThreadExecutionState(uint flags);",
+		"}",
+		"'@;",
+		"$ES_CONTINUOUS = 0x80000000;",
+		"$ES_SYSTEM_REQUIRED = 0x00000001;",
+		"[SleepBlock]::SetThreadExecutionState($ES_CONTINUOUS -bor $ES_SYSTEM_REQUIRED) | Out-Null;",
+		`try { Wait-Process -Id ${parentPid} } catch { } finally { [SleepBlock]::SetThreadExecutionState($ES_CONTINUOUS) | Out-Null }`
+	].join("\n");
+}
+async function startHelperProcess(command, args, spawnFn, env) {
+	const child = spawnFn(command, args, {
+		env,
+		stdio: "ignore"
+	});
+	if (!await waitForSpawn(child)) {
+		appendDebugLog("sleep:unavailable", { command });
+		return null;
+	}
+	if (!await waitForHelperStability(child, HELPER_STARTUP_GRACE_MS)) {
+		appendDebugLog("sleep:unavailable", {
+			command,
+			reason: "early-exit"
+		});
+		return null;
+	}
+	return child;
+}
+async function startSleepPrevention(argv, deps = {}) {
+	const env = deps.env ?? process.env;
+	const killProcess = deps.killProcess ?? process.kill.bind(process);
+	const pid = deps.pid ?? process.pid;
+	const platform = deps.platform ?? process.platform;
+	const processExecArgv = deps.processExecArgv ?? process.execArgv;
+	const processArgv1 = deps.processArgv1 ?? process.argv[1];
+	const processExecPath = deps.processExecPath ?? process.execPath;
+	const processOn = deps.processOn ?? process.on.bind(process);
+	const processOff = deps.processOff ?? process.off.bind(process);
+	const reexecEnv = deps.reexecEnv ?? {};
+	const spawnFn = deps.spawn ?? spawn;
+	if (platform === "linux") {
+		if (env.GNHF_SLEEP_INHIBITED === "1") {
+			signalLinuxReexecReady(env);
+			return {
+				type: "skipped",
+				reason: "already-inhibited"
+			};
+		}
+		const readyDir = mkdtempSync(join(tmpdir(), GNHF_SLEEP_REEXEC_READY_DIR_PREFIX));
+		const readyPath = join(readyDir, GNHF_SLEEP_REEXEC_READY_FILENAME);
+		const child = spawnFn("systemd-inhibit", [
+			"--what=idle:sleep",
+			"--mode=block",
+			"--who=gnhf",
+			"--why=Prevent sleep while gnhf is running",
+			processExecPath,
+			...processExecArgv,
+			processArgv1,
+			...argv
+		], {
+			detached: true,
+			env: {
+				...env,
+				...reexecEnv,
+				GNHF_SLEEP_INHIBITED: "1",
+				[GNHF_SLEEP_REEXEC_READY_PATH]: readyPath
+			},
+			stdio: "inherit"
+		});
+		const exitStatePromise = new Promise((resolve) => {
+			child.once("exit", (code, signal) => {
+				resolve({
+					exitCode: signal ? getSignalExitCode$1(signal) : code ?? 1,
+					signal
+				});
+			});
+		});
+		const stopForwardingSignals = forwardTerminationSignalsToChild(child, true, killProcess, processOn, processOff);
+		if (!await waitForSpawn(child)) {
+			stopForwardingSignals();
+			rmSync(readyDir, {
+				recursive: true,
+				force: true
+			});
+			appendDebugLog("sleep:unavailable", { command: "systemd-inhibit" });
+			return {
+				type: "skipped",
+				reason: "unavailable"
+			};
+		}
+		try {
+			const readyState = await waitForLinuxReexecReady(readyPath, exitStatePromise, SYSTEMD_INHIBIT_READY_TIMEOUT_MS);
+			try {
+				if (readyState.type === "ready") {
+					appendDebugLog("sleep:reexec", { command: "systemd-inhibit" });
+					const { exitCode } = await exitStatePromise;
+					return {
+						type: "reexeced",
+						exitCode
+					};
+				}
+				if (readyState.type === "exit") {
+					if (readyState.signal === "SIGINT" || readyState.signal === "SIGTERM") {
+						appendDebugLog("sleep:reexec", {
+							command: "systemd-inhibit",
+							signal: readyState.signal
+						});
+						return {
+							type: "reexeced",
+							exitCode: readyState.exitCode
+						};
+					}
+					if (readyState.exitCode !== 0) {
+						if (existsSync(readyPath)) {
+							appendDebugLog("sleep:reexec", {
+								command: "systemd-inhibit",
+								exitCode: readyState.exitCode,
+								readySignal: "late"
+							});
+							return {
+								type: "reexeced",
+								exitCode: readyState.exitCode
+							};
+						}
+						appendDebugLog("sleep:unavailable", {
+							command: "systemd-inhibit",
+							exitCode: readyState.exitCode
+						});
+						return {
+							type: "skipped",
+							reason: "unavailable"
+						};
+					}
+					appendDebugLog("sleep:reexec", {
+						command: "systemd-inhibit",
+						readySignal: false
+					});
+					return {
+						type: "reexeced",
+						exitCode: readyState.exitCode
+					};
+				}
+				appendDebugLog("sleep:unavailable", {
+					command: "systemd-inhibit",
+					reason: "timeout",
+					timeoutMs: SYSTEMD_INHIBIT_READY_TIMEOUT_MS
+				});
+				await shutdownChildProcess(child, {
+					detached: true,
+					killProcess,
+					timeoutMs: 1e3
+				});
+				return {
+					type: "skipped",
+					reason: "unavailable"
+				};
+			} finally {
+				stopForwardingSignals();
+			}
+		} finally {
+			rmSync(readyDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	if (platform === "darwin") {
+		const child = await startHelperProcess("caffeinate", [
+			"-i",
+			"-w",
+			String(pid)
+		], spawnFn, env);
+		if (!child) return {
+			type: "skipped",
+			reason: "unavailable"
+		};
+		appendDebugLog("sleep:active", { command: "caffeinate" });
+		return {
+			type: "active",
+			cleanup: async () => {
+				appendDebugLog("sleep:cleanup", { command: "caffeinate" });
+				await shutdownChildProcess(child, {
+					detached: false,
+					timeoutMs: 1e3
+				});
+			}
+		};
+	}
+	if (platform === "win32") {
+		const child = await startHelperProcess("powershell.exe", [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+			buildPowerShellCommand(pid)
+		], spawnFn, env);
+		if (!child) return {
+			type: "skipped",
+			reason: "unavailable"
+		};
+		appendDebugLog("sleep:active", { command: "powershell.exe" });
+		return {
+			type: "active",
+			cleanup: async () => {
+				appendDebugLog("sleep:cleanup", { command: "powershell.exe" });
+				await shutdownChildProcess(child, {
+					detached: false,
+					timeoutMs: 1e3
+				});
+			}
+		};
+	}
+	return {
+		type: "skipped",
+		reason: "unsupported"
+	};
+}
+//#endregion
 //#region src/core/agents/stream-utils.ts
 /**
 * Wire stderr collection, spawn-error handling, and the common close-handler
@@ -486,6 +935,21 @@ function buildPrompt(prompt) {
 		`The JSON must match this schema exactly: ${JSON.stringify(AGENT_OUTPUT_SCHEMA)}`
 	].join("\n");
 }
+/**
+* On Windows with `shell: true`, `child.pid` is the `cmd.exe` wrapper, not
+* the actual server process.  `taskkill /T` terminates the entire process
+* tree rooted at that PID so the real server doesn't survive shutdown.
+*/
+async function killWindowsProcessTree(pid) {
+	try {
+		execFileSync("taskkill", [
+			"/T",
+			"/F",
+			"/PID",
+			String(pid)
+		], { stdio: "ignore" });
+	} catch {}
+}
 function createAbortError$1() {
 	return /* @__PURE__ */ new Error("Agent was aborted");
 }
@@ -557,6 +1021,7 @@ var OpenCodeAgent = class {
 	fetchFn;
 	getPortFn;
 	killProcessFn;
+	platform;
 	spawnFn;
 	server = null;
 	closingPromise = null;
@@ -564,6 +1029,7 @@ var OpenCodeAgent = class {
 		this.fetchFn = deps.fetch ?? fetch;
 		this.getPortFn = deps.getPort ?? getAvailablePort$1;
 		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
+		this.platform = deps.platform ?? process.platform;
 		this.spawnFn = deps.spawn ?? spawn;
 	}
 	async run(prompt, cwd, options) {
@@ -609,7 +1075,8 @@ var OpenCodeAgent = class {
 			return this.server;
 		}
 		const port = await this.getPortFn();
-		const detached = process.platform !== "win32";
+		const isWindows = this.platform === "win32";
+		const detached = !isWindows;
 		const child = this.spawnFn("opencode", [
 			"serve",
 			"--hostname",
@@ -620,6 +1087,7 @@ var OpenCodeAgent = class {
 		], {
 			cwd,
 			detached,
+			shell: isWindows,
 			stdio: [
 				"ignore",
 				"pipe",
@@ -652,6 +1120,11 @@ var OpenCodeAgent = class {
 			if (this.server === server) this.server = null;
 		});
 		this.server = server;
+		appendDebugLog("opencode:spawn", {
+			cwd,
+			port,
+			detached
+		});
 		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
 			await this.shutdownServer();
 			throw error;
@@ -934,37 +1407,20 @@ var OpenCodeAgent = class {
 			return;
 		}
 		const server = this.server;
-		const waitForClose = new Promise((resolve) => {
-			if (server.closed) {
-				resolve();
-				return;
-			}
-			server.child.once("close", () => resolve());
-		});
-		try {
-			this.signalServer(server, "SIGTERM");
-		} catch {}
-		const forceKill = new Promise((resolve) => {
-			setTimeout(() => {
-				if (!server.closed) try {
-					this.signalServer(server, "SIGKILL");
-				} catch {}
-				resolve();
-			}, 3e3).unref?.();
+		appendDebugLog("opencode:shutdown", {
+			cwd: server.cwd,
+			port: server.port
 		});
-		this.closingPromise = Promise.race([waitForClose, forceKill]).finally(() => {
+		this.closingPromise = (this.platform === "win32" && server.child.pid ? killWindowsProcessTree(server.child.pid) : shutdownChildProcess(server.child, {
+			detached: server.detached,
+			killProcess: this.killProcessFn,
+			timeoutMs: 3e3
+		})).finally(() => {
 			if (this.server === server) this.server = null;
 			this.closingPromise = null;
 		});
 		await this.closingPromise;
 	}
-	signalServer(server, signal) {
-		if (server.detached && server.child.pid) try {
-			this.killProcessFn(-server.child.pid, signal);
-			return;
-		} catch {}
-		server.child.kill(signal);
-	}
 	async requestJSON(server, path, options) {
 		const body = await this.requestText(server, path, options);
 		return JSON.parse(body);
@@ -1149,6 +1605,11 @@ var RovoDevAgent = class {
 			if (this.server === server) this.server = null;
 		});
 		this.server = server;
+		appendDebugLog("rovodev:spawn", {
+			cwd,
+			port,
+			detached
+		});
 		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
 			await this.shutdownServer();
 			throw error;
@@ -1158,13 +1619,13 @@ var RovoDevAgent = class {
 	}
 	async waitForHealthy(server, signal) {
 		const deadline = Date.now() + 3e4;
-		let spawnError = null;
+		let spawnErrorMessage = null;
 		server.child.once("error", (error) => {
-			spawnError = error;
+			spawnErrorMessage = error.message;
 		});
 		while (Date.now() < deadline) {
 			if (signal?.aborted) throw createAbortError();
-			if (spawnError) throw new Error(`Failed to spawn rovodev: ${spawnError.message}`);
+			if (spawnErrorMessage) throw new Error(`Failed to spawn rovodev: ${spawnErrorMessage}`);
 			if (server.closed) {
 				const output = server.stderr.trim() || server.stdout.trim();
 				throw new Error(output ? `rovodev exited before becoming ready: ${output}` : "rovodev exited before becoming ready");
@@ -1372,37 +1833,20 @@ var RovoDevAgent = class {
 			return;
 		}
 		const server = this.server;
-		const waitForClose = new Promise((resolve) => {
-			if (server.closed) {
-				resolve();
-				return;
-			}
-			server.child.once("close", () => resolve());
-		});
-		try {
-			this.signalServer(server, "SIGTERM");
-		} catch {}
-		const forceKill = new Promise((resolve) => {
-			setTimeout(() => {
-				if (!server.closed) try {
-					this.signalServer(server, "SIGKILL");
-				} catch {}
-				resolve();
-			}, 3e3).unref?.();
+		appendDebugLog("rovodev:shutdown", {
+			cwd: server.cwd,
+			port: server.port
 		});
-		this.closingPromise = Promise.race([waitForClose, forceKill]).finally(() => {
+		this.closingPromise = shutdownChildProcess(server.child, {
+			detached: server.detached,
+			killProcess: this.killProcessFn,
+			timeoutMs: 3e3
+		}).finally(() => {
 			if (this.server === server) this.server = null;
 			this.closingPromise = null;
 		});
 		await this.closingPromise;
 	}
-	signalServer(server, signal) {
-		if (server.detached && server.child.pid) try {
-			this.killProcessFn(-server.child.pid, signal);
-			return;
-		} catch {}
-		server.child.kill(signal);
-	}
 	async requestJSON(server, path, options) {
 		return await (await this.request(server, path, options)).json();
 	}
@@ -1466,6 +1910,7 @@ ${params.prompt}`;
 }
 //#endregion
 //#region src/core/orchestrator.ts
+const STOP_CLOSE_AGENT_GRACE_MS = 250;
 var Orchestrator = class extends EventEmitter {
 	config;
 	agent;
@@ -1475,6 +1920,7 @@ var Orchestrator = class extends EventEmitter {
 	limits;
 	stopRequested = false;
 	stopPromise = null;
+	activeIterationPromise = null;
 	activeAbortController = null;
 	pendingAbortReason = null;
 	state = {
@@ -1510,7 +1956,23 @@ var Orchestrator = class extends EventEmitter {
 		this.activeAbortController?.abort();
 		if (this.stopPromise) return;
 		this.stopPromise = (async () => {
-			await this.closeAgent();
+			if (this.activeIterationPromise) {
+				const iterationPromise = this.activeIterationPromise.catch(() => void 0);
+				await new Promise((resolve) => {
+					let settled = false;
+					const settle = () => {
+						if (settled) return;
+						settled = true;
+						clearTimeout(timer);
+						resolve();
+					};
+					const timer = setTimeout(settle, STOP_CLOSE_AGENT_GRACE_MS);
+					timer.unref?.();
+					iterationPromise.finally(settle);
+				});
+				await this.closeAgent();
+				await iterationPromise;
+			} else await this.closeAgent();
 			resetHard(this.cwd);
 			this.state.status = "stopped";
 			this.emit("state", this.getState());
@@ -1537,7 +1999,10 @@ var Orchestrator = class extends EventEmitter {
 					runId: this.runInfo.runId,
 					prompt: this.prompt
 				});
-				const result = await this.runIteration(iterationPrompt);
+				this.activeIterationPromise = this.runIteration(iterationPrompt);
+				const result = await this.activeIterationPromise;
+				this.activeIterationPromise = null;
+				if (result.type === "stopped") break;
 				if (result.type === "aborted") {
 					this.abort(result.reason);
 					break;
@@ -1569,6 +2034,7 @@ var Orchestrator = class extends EventEmitter {
 				}
 			}
 		} finally {
+			this.activeIterationPromise = null;
 			if (this.stopPromise) await this.stopPromise;
 			else await this.closeAgent();
 		}
@@ -1600,6 +2066,7 @@ var Orchestrator = class extends EventEmitter {
 				signal: this.activeAbortController.signal,
 				logPath
 			});
+			if (this.stopRequested) return { type: "stopped" };
 			if (result.output.success) return {
 				type: "completed",
 				record: this.recordSuccess(result.output)
@@ -1616,6 +2083,7 @@ var Orchestrator = class extends EventEmitter {
 					reason: this.pendingAbortReason
 				};
 			}
+			if (this.stopRequested) return { type: "stopped" };
 			const summary = err instanceof Error ? err.message : String(err);
 			return {
 				type: "completed",
@@ -1888,7 +2356,68 @@ function formatTokens(count) {
 	return String(count);
 }
 //#endregion
+//#region src/utils/terminal-width.ts
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+const MARK_REGEX = /\p{Mark}/u;
+const REGIONAL_INDICATOR_REGEX = /\p{Regional_Indicator}/u;
+const EXTENDED_PICTOGRAPHIC_REGEX = /\p{Extended_Pictographic}/u;
+function isFullWidthCodePoint(codePoint) {
+	return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12871 && codePoint !== 12351 || codePoint >= 12880 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42182 || codePoint >= 43360 && codePoint <= 43388 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65131 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 110592 && codePoint <= 110593 || codePoint >= 127488 && codePoint <= 127569 || codePoint >= 131072 && codePoint <= 262141);
+}
+function codePointWidth(codePoint) {
+	if (codePoint === 0 || codePoint === 8204 || codePoint === 8205 || codePoint === 65038 || codePoint === 65039) return 0;
+	if (MARK_REGEX.test(String.fromCodePoint(codePoint))) return 0;
+	return isFullWidthCodePoint(codePoint) ? 2 : 1;
+}
+function isWideEmojiGrapheme(grapheme) {
+	return grapheme.includes("‍") || grapheme.includes("️") || grapheme.includes("⃣") || REGIONAL_INDICATOR_REGEX.test(grapheme) || Array.from(grapheme).some((char) => EXTENDED_PICTOGRAPHIC_REGEX.test(char));
+}
+function splitGraphemes(text) {
+	return Array.from(graphemeSegmenter.segment(text), ({ segment }) => segment);
+}
+function graphemeWidth(grapheme) {
+	if (!grapheme) return 0;
+	if (isWideEmojiGrapheme(grapheme)) return 2;
+	let width = 0;
+	for (const char of grapheme) width += codePointWidth(char.codePointAt(0) ?? 0);
+	return width;
+}
+function stringWidth(text) {
+	let width = 0;
+	for (const grapheme of splitGraphemes(text)) width += graphemeWidth(grapheme);
+	return width;
+}
+//#endregion
 //#region src/utils/wordwrap.ts
+function sliceToWidth(text, width) {
+	let result = "";
+	let currentWidth = 0;
+	for (const grapheme of splitGraphemes(text)) {
+		const nextWidth = currentWidth + graphemeWidth(grapheme);
+		if (nextWidth > width) break;
+		result += grapheme;
+		currentWidth = nextWidth;
+	}
+	return result;
+}
+function splitByWidth(text, width) {
+	const lines = [];
+	let current = "";
+	let currentWidth = 0;
+	for (const grapheme of splitGraphemes(text)) {
+		const glyphWidth = graphemeWidth(grapheme);
+		if (current && currentWidth + glyphWidth > width) {
+			lines.push(current);
+			current = grapheme;
+			currentWidth = glyphWidth;
+			continue;
+		}
+		current += grapheme;
+		currentWidth += glyphWidth;
+	}
+	if (current) lines.push(current);
+	return lines;
+}
 function wordWrap(text, width, maxLines) {
 	if (!text) return [];
 	const lines = [];
@@ -1899,26 +2428,34 @@ function wordWrap(text, width, maxLines) {
 			continue;
 		}
 		let current = "";
+		let currentWidth = 0;
 		for (const word of words) {
-			if (word.length > width) {
+			const wordWidth = stringWidth(word);
+			if (wordWidth > width) {
 				if (current) {
 					lines.push(current);
 					current = "";
+					currentWidth = 0;
 				}
-				for (let i = 0; i < word.length; i += width) lines.push(word.slice(i, i + width));
+				for (const slice of splitByWidth(word, width)) lines.push(slice);
 				continue;
 			}
-			if (current && current.length + 1 + word.length > width) {
+			const nextWidth = current ? currentWidth + 1 + wordWidth : wordWidth;
+			if (current && nextWidth > width) {
 				lines.push(current);
 				current = word;
-			} else current = current ? current + " " + word : word;
+				currentWidth = wordWidth;
+			} else {
+				current = current ? current + " " + word : word;
+				currentWidth = nextWidth;
+			}
 		}
 		if (current) lines.push(current);
 	}
 	if (maxLines && lines.length > maxLines) {
 		const capped = lines.slice(0, maxLines);
 		const last = capped[maxLines - 1];
-		capped[maxLines - 1] = last.length >= width ? last.slice(0, width - 1) + "…" : last + "…";
+		capped[maxLines - 1] = stringWidth(last) >= width ? sliceToWidth(last, width - 1) + "…" : last + "…";
 		return capped;
 	}
 	return lines;
@@ -1934,13 +2471,13 @@ function makeCell(char, style) {
 	return {
 		char,
 		style,
-		width: (char.codePointAt(0) ?? 0) > 65535 ? 2 : 1
+		width: graphemeWidth(char)
 	};
 }
 function textToCells(text, style) {
 	const cells = [];
-	for (const char of text) {
-		const cell = makeCell(char, style);
+	for (const grapheme of splitGraphemes(text)) {
+		const cell = makeCell(grapheme, style);
 		cells.push(cell);
 		if (cell.width === 2) cells.push({
 			char: "",
@@ -2022,7 +2559,7 @@ const TICK_MS = 200;
 const MOONS_PER_ROW = 30;
 const MOON_PHASE_PERIOD = 1600;
 const MAX_MSG_LINES = 3;
-const MAX_MSG_LINE_LEN = 64;
+const MAX_MSG_LINE_LEN = CONTENT_WIDTH;
 const RESUME_HINT = "[ctrl+c to stop, gnhf again to resume]";
 function spacedLabel(text) {
 	return text.split("").join(" ");
@@ -2116,52 +2653,124 @@ function renderSideStarsCells(stars, rowIndex, xOffset, sideWidth, now) {
 	placeStarsInCells(cells, stars, rowIndex, xOffset, xOffset + sideWidth, xOffset, now);
 	return cells;
 }
+function clampCellsToWidth(content, width) {
+	if (content.length <= width) return content;
+	const clamped = [];
+	let remaining = width;
+	for (let i = 0; i < content.length && remaining > 0; i++) {
+		const cell = content[i];
+		if (cell.width === 0) continue;
+		if (cell.width > remaining) break;
+		clamped.push(cell);
+		remaining -= cell.width;
+		if (cell.width === 2 && content[i + 1]?.width === 0) {
+			clamped.push(content[i + 1]);
+			i += 1;
+		}
+	}
+	return clamped;
+}
 function centerLineCells(content, width) {
-	const w = content.length;
+	const clamped = clampCellsToWidth(content, width);
+	const w = clamped.length;
 	const pad = Math.max(0, Math.floor((width - w) / 2));
 	const rightPad = Math.max(0, width - w - pad);
 	return [
 		...emptyCells(pad),
-		...content,
+		...clamped,
 		...emptyCells(rightPad)
 	];
 }
 function renderResumeHintCells(width) {
 	return centerLineCells(textToCells(RESUME_HINT, "dim"), width);
 }
-function fitContentRows(contentRows, maxRows) {
-	if (contentRows.length <= maxRows) return contentRows;
-	const fitted = [...contentRows];
-	while (fitted.length > maxRows) {
-		const emptyRowIndex = fitted.findIndex((row) => row.length === 0);
-		if (emptyRowIndex === -1) break;
-		fitted.splice(emptyRowIndex, 1);
-	}
-	return fitted.length > maxRows ? fitted.slice(fitted.length - maxRows) : fitted;
-}
-function buildContentCells(prompt, agentName, state, elapsed, now) {
-	const rows = [];
+/**
+* Builds the centered content viewport for the renderer.
+*
+* When `availableHeight` is constrained, the layout drops optional sections in
+* priority order (ASCII art, eyebrow, agent message, then prompt) so the stats
+* row remains visible and any remaining space is used for the newest moon rows.
+*/
+function buildContentCells(prompt, agentName, state, elapsed, now, availableHeight) {
 	const isRunning = state.status === "running" || state.status === "waiting";
-	rows.push([]);
-	rows.push(...renderTitleCells(agentName));
-	rows.push([], []);
+	const moonRows = renderMoonStripCells(state.iterations, isRunning, now);
+	const maxRows = availableHeight ?? Infinity;
+	if (maxRows <= 0) return [];
+	const titleCells = renderTitleCells(agentName);
+	const titleSpacer = titleCells[1] ?? [];
 	const promptLines = wordWrap(prompt, CONTENT_WIDTH, MAX_PROMPT_LINES);
+	const promptRows = [];
 	for (let i = 0; i < MAX_PROMPT_LINES; i++) {
 		const pl = promptLines[i] ?? "";
-		rows.push(pl ? textToCells(pl, "dim") : []);
-	}
-	rows.push([], []);
-	rows.push(renderStatsCells(elapsed, state.totalInputTokens, state.totalOutputTokens, state.commitCount));
-	rows.push([], []);
-	rows.push(...renderAgentMessageCells(state.lastMessage, state.status));
-	rows.push([], []);
-	rows.push(...renderMoonStripCells(state.iterations, isRunning, now));
+		promptRows.push(pl ? textToCells(pl, "dim") : []);
+	}
+	const sections = {
+		top: [[]],
+		eyebrow: [
+			titleCells[0],
+			[],
+			[]
+		],
+		art: titleCells.slice(2),
+		prompt: [
+			titleSpacer,
+			...promptRows,
+			[],
+			[]
+		],
+		stats: [renderStatsCells(elapsed, state.totalInputTokens, state.totalOutputTokens, state.commitCount)],
+		agent: [
+			[],
+			[],
+			...renderAgentMessageCells(state.lastMessage, state.status)
+		],
+		moon: [
+			[],
+			[],
+			...moonRows
+		]
+	};
+	const flattenSections = () => [
+		...sections.top,
+		...sections.eyebrow,
+		...sections.art,
+		...sections.prompt,
+		...sections.stats,
+		...sections.agent,
+		...sections.moon
+	];
+	const optionalSections = [
+		"art",
+		"eyebrow",
+		"agent",
+		"prompt"
+	];
+	let rows = flattenSections();
+	for (const section of optionalSections) {
+		if (rows.length <= maxRows) break;
+		sections[section] = [];
+		rows = flattenSections();
+	}
+	if (rows.length > maxRows) rows = rows.filter((row) => row.length > 0);
+	if (rows.length > maxRows) {
+		const nonMoonRows = [
+			...sections.top,
+			...sections.eyebrow,
+			...sections.art,
+			...sections.prompt,
+			...sections.stats,
+			...sections.agent
+		].filter((row) => row.length > 0);
+		const allowedMoonRows = Math.max(0, maxRows - nonMoonRows.length);
+		const visibleMoonRows = allowedMoonRows === 0 ? [] : moonRows.filter((row) => row.length > 0).slice(-allowedMoonRows);
+		rows = [...nonMoonRows, ...visibleMoonRows];
+	}
 	return rows;
 }
 function buildFrameCells(prompt, agentName, state, topStars, bottomStars, sideStars, now, terminalWidth, terminalHeight) {
 	const elapsed = formatElapsed(now - state.startTime.getTime());
 	const availableHeight = Math.max(0, terminalHeight - 2);
-	const contentRows = fitContentRows(buildContentCells(prompt, agentName, state, elapsed, now), availableHeight);
+	const contentRows = buildContentCells(prompt, agentName, state, elapsed, now, availableHeight);
 	while (contentRows.length < Math.min(BASE_CONTENT_ROWS, availableHeight)) contentRows.push([]);
 	const contentCount = contentRows.length;
 	const remaining = Math.max(0, availableHeight - contentCount);
@@ -2200,11 +2809,17 @@ var Renderer = class {
 	cachedHeight = 0;
 	prevCells = [];
 	isFirstFrame = true;
+	seedTop;
+	seedBottom;
+	seedSide;
 	constructor(orchestrator, prompt, agentName) {
 		this.orchestrator = orchestrator;
 		this.prompt = prompt;
 		this.agentName = agentName;
 		this.state = orchestrator.getState();
+		this.seedTop = Math.floor(Math.random() * 2147483646) + 1;
+		this.seedBottom = Math.floor(Math.random() * 2147483646) + 1;
+		this.seedSide = Math.floor(Math.random() * 2147483646) + 1;
 		this.exitPromise = new Promise((resolve) => {
 			this.exitResolve = resolve;
 		});
@@ -2217,14 +2832,14 @@ var Renderer = class {
 			};
 		});
 		this.orchestrator.on("stopped", () => {
-			this.stop();
+			this.stop("stopped");
 		});
 		if (process$1.stdin.isTTY) {
 			process$1.stdin.setRawMode(true);
 			process$1.stdin.resume();
 			process$1.stdin.on("data", (data) => {
 				if (data[0] === 3) {
-					this.stop();
+					this.stop("interrupted");
 					this.orchestrator.stop();
 				}
 			});
@@ -2232,7 +2847,7 @@ var Renderer = class {
 		this.interval = setInterval(() => this.render(), TICK_MS);
 		this.render();
 	}
-	stop() {
+	stop(reason = "stopped") {
 		if (this.interval) {
 			clearInterval(this.interval);
 			this.interval = null;
@@ -2242,7 +2857,7 @@ var Renderer = class {
 			process$1.stdin.pause();
 			process$1.stdin.removeAllListeners("data");
 		}
-		this.exitResolve();
+		this.exitResolve(reason);
 	}
 	waitUntilExit() {
 		return this.exitPromise;
@@ -2268,9 +2883,9 @@ var Renderer = class {
 					rest: "dim"
 				} : star;
 			};
-			this.topStars = generateStarField(w, h, STAR_DENSITY, 42).map((s) => shrinkBig(s, s.y >= topHeight - proximityRows));
-			this.bottomStars = generateStarField(w, h, STAR_DENSITY, 137).map((s) => shrinkBig(s, s.y < proximityRows));
-			this.sideStars = generateStarField(w, Math.max(BASE_CONTENT_ROWS, availableHeight), STAR_DENSITY, 99);
+			this.topStars = generateStarField(w, h, STAR_DENSITY, this.seedTop).map((s) => shrinkBig(s, s.y >= topHeight - proximityRows));
+			this.bottomStars = generateStarField(w, h, STAR_DENSITY, this.seedBottom).map((s) => shrinkBig(s, s.y < proximityRows));
+			this.sideStars = generateStarField(w, Math.max(BASE_CONTENT_ROWS, availableHeight), STAR_DENSITY, this.seedSide);
 			return true;
 		}
 		return false;
@@ -2300,12 +2915,21 @@ function slugifyPrompt(prompt) {
 //#region src/cli.ts
 const packageVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
 const FORCE_EXIT_TIMEOUT_MS = 5e3;
+const GNHF_REEXEC_STDIN_PROMPT = "GNHF_REEXEC_STDIN_PROMPT";
+const GNHF_REEXEC_STDIN_PROMPT_FILE = "GNHF_REEXEC_STDIN_PROMPT_FILE";
+const GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX = "gnhf-stdin-";
+const GNHF_REEXEC_STDIN_PROMPT_FILENAME = "prompt.txt";
 function parseNonNegativeInteger(value) {
 	if (!/^\d+$/.test(value)) throw new InvalidArgumentError("must be a non-negative integer");
 	const parsed = Number.parseInt(value, 10);
 	if (!Number.isSafeInteger(parsed)) throw new InvalidArgumentError("must be a safe integer");
 	return parsed;
 }
+function parseOnOffBoolean(value) {
+	if (value === "on" || value === "true") return true;
+	if (value === "off" || value === "false") return false;
+	throw new InvalidArgumentError("must be one of: \"on\", \"off\", \"true\", \"false\"");
+}
 function humanizeErrorMessage(message) {
 	if (message.includes("not a git repository")) return "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
 	return message;
@@ -2330,8 +2954,57 @@ function ask(question) {
 		});
 	});
 }
+function getSignalExitCode(signal) {
+	return signal === "SIGINT" ? 130 : 143;
+}
+function persistStdinPromptForReexec(prompt) {
+	const promptDir = mkdtempSync(join(tmpdir(), GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX));
+	const promptPath = join(promptDir, GNHF_REEXEC_STDIN_PROMPT_FILENAME);
+	writeFileSync(promptPath, prompt, {
+		encoding: "utf-8",
+		mode: 384
+	});
+	return {
+		path: promptPath,
+		cleanup: () => {
+			rmSync(promptDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+function isTrustedReexecPromptPath(promptPath) {
+	const resolvedPromptPath = resolve(promptPath);
+	const promptDir = dirname(resolvedPromptPath);
+	return basename(resolvedPromptPath) === GNHF_REEXEC_STDIN_PROMPT_FILENAME && dirname(promptDir) === resolve(tmpdir()) && basename(promptDir).startsWith(GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX);
+}
+function cleanupTrustedReexecPromptPath(promptPath) {
+	if (!isTrustedReexecPromptPath(promptPath)) return;
+	const resolvedPromptPath = resolve(promptPath);
+	rmSync(resolvedPromptPath, { force: true });
+	try {
+		rmdirSync(dirname(resolvedPromptPath));
+	} catch {}
+}
+function readReexecStdinPrompt(env) {
+	const promptPath = env[GNHF_REEXEC_STDIN_PROMPT_FILE];
+	if (promptPath !== void 0) {
+		delete env[GNHF_REEXEC_STDIN_PROMPT_FILE];
+		try {
+			return readFileSync(promptPath, "utf-8");
+		} finally {
+			cleanupTrustedReexecPromptPath(promptPath);
+		}
+	}
+	const prompt = env[GNHF_REEXEC_STDIN_PROMPT];
+	if (prompt !== void 0) {
+		delete env[GNHF_REEXEC_STDIN_PROMPT];
+		return prompt;
+	}
+}
 const program = new Command();
-program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", "Agent to use (claude, codex, rovodev, or opencode)").option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--mock", "", false).action(async (promptArg, options) => {
+program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", "Agent to use (claude, codex, rovodev, or opencode)").option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--mock", "", false).action(async (promptArg, options) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
@@ -2342,18 +3015,28 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		exitAltScreen();
 		return;
 	}
+	let initialSleepPrevention = null;
+	if (process$1.env.GNHF_SLEEP_INHIBITED === "1") initialSleepPrevention = await startSleepPrevention(process$1.argv.slice(2));
 	let prompt = promptArg;
-	if (!prompt && !process$1.stdin.isTTY) prompt = readFileSync("/dev/stdin", "utf-8").trim();
+	let promptFromStdin = false;
 	const agentName = options.agent;
 	if (agentName !== void 0 && agentName !== "claude" && agentName !== "codex" && agentName !== "rovodev" && agentName !== "opencode") {
 		console.error(`Unknown agent: ${options.agent}. Use "claude", "codex", "rovodev", or "opencode".`);
 		process$1.exit(1);
 	}
-	const config = loadConfig(agentName ? { agent: agentName } : void 0);
+	const config = {
+		...loadConfig(agentName ? { agent: agentName } : {}),
+		...options.preventSleep === void 0 ? {} : { preventSleep: options.preventSleep }
+	};
 	if (config.agent !== "claude" && config.agent !== "codex" && config.agent !== "rovodev" && config.agent !== "opencode") {
 		console.error(`Unknown agent: ${config.agent}. Use "claude", "codex", "rovodev", or "opencode".`);
 		process$1.exit(1);
 	}
+	if (!prompt && process$1.env.GNHF_SLEEP_INHIBITED === "1") prompt = readReexecStdinPrompt(process$1.env);
+	if (!prompt && !process$1.stdin.isTTY) {
+		prompt = await readStdinText(process$1.stdin);
+		promptFromStdin = true;
+	}
 	const cwd = process$1.cwd();
 	const currentBranch = getCurrentBranch(cwd);
 	const onGnhfBranch = currentBranch.startsWith("gnhf/");
@@ -2382,27 +3065,67 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		}
 		runInfo = initializeNewBranch(prompt, cwd);
 	}
+	let sleepPreventionCleanup = null;
+	if (config.preventSleep) {
+		const persistedPrompt = promptFromStdin && prompt !== void 0 ? persistStdinPromptForReexec(prompt) : null;
+		let reexeced = false;
+		try {
+			const sleepPrevention = initialSleepPrevention ?? await startSleepPrevention(process$1.argv.slice(2), { reexecEnv: persistedPrompt ? { [GNHF_REEXEC_STDIN_PROMPT_FILE]: persistedPrompt.path } : void 0 });
+			if (sleepPrevention.type === "reexeced") {
+				reexeced = true;
+				process$1.exit(sleepPrevention.exitCode);
+			}
+			if (sleepPrevention.type === "active") sleepPreventionCleanup = sleepPrevention.cleanup;
+		} finally {
+			if (!reexeced) persistedPrompt?.cleanup();
+		}
+	}
+	appendDebugLog("run:start", { args: process$1.argv.slice(2) });
 	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo), runInfo, prompt, cwd, startIteration, {
 		maxIterations: options.maxIterations,
 		maxTokens: options.maxTokens
 	});
+	let shutdownSignal = null;
 	enterAltScreen();
 	const renderer = new Renderer(orchestrator, prompt, config.agent);
 	renderer.start();
+	const requestShutdown = (signal) => {
+		if (shutdownSignal) return;
+		shutdownSignal = signal;
+		appendDebugLog(`signal:${signal}`);
+		renderer.stop();
+		orchestrator.stop();
+	};
+	const handleSigInt = () => requestShutdown("SIGINT");
+	const handleSigTerm = () => requestShutdown("SIGTERM");
+	process$1.on("SIGINT", handleSigInt);
+	process$1.on("SIGTERM", handleSigTerm);
 	const orchestratorPromise = orchestrator.start().finally(() => {
 		renderer.stop();
 	}).catch((err) => {
 		exitAltScreen();
 		die(err instanceof Error ? err.message : String(err));
 	});
-	await renderer.waitUntilExit();
-	exitAltScreen();
-	if (await Promise.race([orchestratorPromise.then(() => "done"), new Promise((resolve) => {
-		setTimeout(() => resolve("timeout"), FORCE_EXIT_TIMEOUT_MS).unref();
-	})]) === "timeout") {
-		console.error(`\n  gnhf: shutdown timed out after ${FORCE_EXIT_TIMEOUT_MS / 1e3}s, forcing exit\n`);
-		process$1.exit(130);
+	try {
+		if (await renderer.waitUntilExit() === "interrupted" && !shutdownSignal) {
+			shutdownSignal = "SIGINT";
+			appendDebugLog("signal:SIGINT");
+		}
+		exitAltScreen();
+		if (await Promise.race([orchestratorPromise.then(() => "done"), new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), FORCE_EXIT_TIMEOUT_MS).unref();
+		})]) === "timeout") {
+			appendDebugLog("run:shutdown-timeout", { timeoutMs: FORCE_EXIT_TIMEOUT_MS });
+			console.error(`\n  gnhf: shutdown timed out after ${FORCE_EXIT_TIMEOUT_MS / 1e3}s, forcing exit\n`);
+			process$1.exit(getSignalExitCode(shutdownSignal ?? "SIGINT"));
+		}
+	} finally {
+		process$1.off("SIGINT", handleSigInt);
+		process$1.off("SIGTERM", handleSigTerm);
+		await sleepPreventionCleanup?.();
 	}
+	appendDebugLog("run:complete", { signal: shutdownSignal });
+	if (shutdownSignal) process$1.exit(getSignalExitCode(shutdownSignal));
 });
 function enterAltScreen() {
 	process$1.stdout.write("\x1B[?1049h");