gnhf 0.1.6 → 0.1.8

package/README.md

@@ -39,12 +39,14 @@
   <img src="docs/splash.png" alt="gnhf — Good Night, Have Fun" width="800">
 </p>
 
+Never wake up empty-handed.
+
 gnhf is a [ralph](https://ghuntley.com/ralph/), [autoresearch](https://github.com/karpathy/autoresearch)-style orchestrator that keeps your agents running while you sleep — each iteration makes one small, committed, documented change towards an objective.
 You wake up to a branch full of clean work and a log of everything that happened.
 
 - **Dead simple** — one command starts an autonomous loop that runs until you Ctrl+C or a configured runtime cap is reached
 - **Long running** — each iteration is committed on success, rolled back on failure, with sensible retries and exponential backoff
-- **Agent-agnostic** — works with Claude Code or Codex out of the box
+- **Agent-agnostic** — works with Claude Code, Codex, Rovo Dev, or OpenCode out of the box
 
 ## Quick Start
 
@@ -141,19 +143,19 @@ npm link
 
 ### Flags
 
-| Flag                   | Description                               | Default                |
-| ---------------------- | ----------------------------------------- | ---------------------- |
-| `--agent <agent>`      | Agent to use (`claude` or `codex`)        | config file (`claude`) |
-| `--max-iterations <n>` | Abort after `n` total iterations          | unlimited              |
-| `--max-tokens <n>`     | Abort after `n` total input+output tokens | unlimited              |
-| `--version`            | Show version                              |                        |
+| Flag                   | Description                                                | Default                |
+| ---------------------- | ---------------------------------------------------------- | ---------------------- |
+| `--agent <agent>`      | Agent to use (`claude`, `codex`, `rovodev`, or `opencode`) | config file (`claude`) |
+| `--max-iterations <n>` | Abort after `n` total iterations                           | unlimited              |
+| `--max-tokens <n>`     | Abort after `n` total input+output tokens                  | unlimited              |
+| `--version`            | Show version                                               |                        |
 
 ## Configuration
 
 Config lives at `~/.gnhf/config.yml`:
 
 ```yaml
-# Agent to use by default
+# Agent to use by default (claude, codex, rovodev, or opencode)
 agent: claude
 
 # Abort after this many consecutive failures
@@ -164,6 +166,17 @@ If the file does not exist yet, `gnhf` creates it on first run using the resolve
 
 CLI flags override config file values. The iteration and token caps are runtime-only flags and are not persisted in `config.yml`.
 
+## Agents
+
+`gnhf` supports four agents:
+
+| Agent       | Flag               | Requirements                                                               | Notes                                                                                                                                                                                                            |
+| ----------- | ------------------ | -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Claude Code | `--agent claude`   | Install Anthropic's `claude` CLI and sign in first.                        | `gnhf` invokes `claude` directly in non-interactive mode.                                                                                                                                                        |
+| Codex       | `--agent codex`    | Install OpenAI's `codex` CLI and sign in first.                            | `gnhf` invokes `codex exec` directly in non-interactive mode.                                                                                                                                                    |
+| Rovo Dev    | `--agent rovodev`  | Install Atlassian's `acli` and authenticate it with Rovo Dev first.        | `gnhf` starts a local `acli rovodev serve --disable-session-token <port>` process automatically in the repo workspace.                                                                                           |
+| OpenCode    | `--agent opencode` | Install `opencode` and configure at least one usable model provider first. | `gnhf` starts a local `opencode serve --hostname 127.0.0.1 --port <port> --print-logs` process automatically, creates a per-run session, and applies a blanket allow rule so tool calls do not block on prompts. |
+
 ## Development
 
 ```sh

package/dist/cli.mjs

@@ -7,6 +7,7 @@ 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";
 import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
 //#region src/core/config.ts
@@ -134,6 +135,7 @@ function resetHard(cwd) {
 //#region src/core/agents/types.ts
 const AGENT_OUTPUT_SCHEMA = {
 	type: "object",
+	additionalProperties: false,
 	properties: {
 		success: { type: "boolean" },
 		summary: { type: "string" },
@@ -155,6 +157,9 @@ const AGENT_OUTPUT_SCHEMA = {
 };
 //#endregion
 //#region src/core/run.ts
+function writeSchemaFile(schemaPath) {
+	writeFileSync(schemaPath, JSON.stringify(AGENT_OUTPUT_SCHEMA, null, 2), "utf-8");
+}
 function ensureRunMetadataIgnored(cwd) {
 	const excludePath = execFileSync("git", [
 		"rev-parse",
@@ -182,7 +187,7 @@ function setupRun(runId, prompt, baseCommit, cwd) {
 	const notesPath = join(runDir, "notes.md");
 	writeFileSync(notesPath, `# gnhf run: ${runId}\n\nObjective: ${prompt}\n\n## Iteration Log\n`, "utf-8");
 	const schemaPath = join(runDir, "output-schema.json");
-	writeFileSync(schemaPath, JSON.stringify(AGENT_OUTPUT_SCHEMA, null, 2), "utf-8");
+	writeSchemaFile(schemaPath);
 	const baseCommitPath = join(runDir, "base-commit");
 	const hasStoredBaseCommit = existsSync(baseCommitPath);
 	const resolvedBaseCommit = hasStoredBaseCommit ? readFileSync(baseCommitPath, "utf-8").trim() : baseCommit;
@@ -203,6 +208,7 @@ function resumeRun(runId, cwd) {
 	const promptPath = join(runDir, "prompt.md");
 	const notesPath = join(runDir, "notes.md");
 	const schemaPath = join(runDir, "output-schema.json");
+	writeSchemaFile(schemaPath);
 	const baseCommitPath = join(runDir, "base-commit");
 	return {
 		runId,
@@ -453,11 +459,984 @@ var CodexAgent = class {
 	}
 };
 //#endregion
+//#region src/core/agents/opencode.ts
+const BLANKET_PERMISSION_RULESET = [{
+	permission: "*",
+	pattern: "*",
+	action: "allow"
+}];
+const STRUCTURED_OUTPUT_FORMAT = {
+	type: "json_schema",
+	schema: AGENT_OUTPUT_SCHEMA,
+	retryCount: 1
+};
+function buildOpencodeChildEnv() {
+	const env = { ...process.env };
+	delete env.OPENCODE_SERVER_USERNAME;
+	delete env.OPENCODE_SERVER_PASSWORD;
+	return env;
+}
+function buildPrompt(prompt) {
+	return [
+		prompt,
+		"",
+		"When you finish, reply with only valid JSON.",
+		"Do not wrap the JSON in markdown fences.",
+		"Do not include any prose before or after the JSON.",
+		`The JSON must match this schema exactly: ${JSON.stringify(AGENT_OUTPUT_SCHEMA)}`
+	].join("\n");
+}
+function createAbortError$1() {
+	return /* @__PURE__ */ new Error("Agent was aborted");
+}
+function isAgentAbortError(error) {
+	return error instanceof Error && error.message === "Agent was aborted";
+}
+function isAbortError$1(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function getAvailablePort$1() {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Failed to allocate a port for opencode"));
+				return;
+			}
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(address.port);
+			});
+		});
+	});
+}
+async function delay$1(ms, signal) {
+	if (!signal) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+		return;
+	}
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(createAbortError$1());
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function toUsage(tokens) {
+	return {
+		inputTokens: tokens?.input ?? 0,
+		outputTokens: tokens?.output ?? 0,
+		cacheReadTokens: tokens?.cache?.read ?? 0,
+		cacheCreationTokens: tokens?.cache?.write ?? 0
+	};
+}
+function withTimeoutSignal$1(signal, timeoutMs) {
+	if (timeoutMs === void 0) return signal;
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+var OpenCodeAgent = class {
+	name = "opencode";
+	fetchFn;
+	getPortFn;
+	killProcessFn;
+	spawnFn;
+	server = null;
+	closingPromise = null;
+	constructor(deps = {}) {
+		this.fetchFn = deps.fetch ?? fetch;
+		this.getPortFn = deps.getPort ?? getAvailablePort$1;
+		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
+		this.spawnFn = deps.spawn ?? spawn;
+	}
+	async run(prompt, cwd, options) {
+		const { onUsage, onMessage, signal, logPath } = options ?? {};
+		const logStream = logPath ? createWriteStream(logPath) : null;
+		const runController = new AbortController();
+		let sessionId = null;
+		const onAbort = () => {
+			runController.abort();
+		};
+		if (signal?.aborted) {
+			logStream?.end();
+			throw createAbortError$1();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			const server = await this.ensureServer(cwd, runController.signal);
+			sessionId = await this.createSession(server, cwd, runController.signal);
+			return await this.streamMessage(server, sessionId, buildPrompt(prompt), runController.signal, logStream, onUsage, onMessage);
+		} catch (error) {
+			if (runController.signal.aborted || isAbortError$1(error)) throw createAbortError$1();
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+			logStream?.end();
+			if (this.server && sessionId) {
+				if (runController.signal.aborted) await this.abortSession(this.server, sessionId);
+				await this.deleteSession(this.server, sessionId);
+			}
+		}
+	}
+	async close() {
+		await this.shutdownServer();
+	}
+	async ensureServer(cwd, signal) {
+		if (this.server && !this.server.closed) if (this.server.cwd !== cwd) await this.shutdownServer();
+		else {
+			await this.server.readyPromise;
+			return this.server;
+		}
+		if (this.server && !this.server.closed) {
+			await this.server.readyPromise;
+			return this.server;
+		}
+		const port = await this.getPortFn();
+		const detached = process.platform !== "win32";
+		const child = this.spawnFn("opencode", [
+			"serve",
+			"--hostname",
+			"127.0.0.1",
+			"--port",
+			String(port),
+			"--print-logs"
+		], {
+			cwd,
+			detached,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: buildOpencodeChildEnv()
+		});
+		const server = {
+			baseUrl: `http://127.0.0.1:${port}`,
+			child,
+			closed: false,
+			cwd,
+			detached,
+			port,
+			readyPromise: Promise.resolve(),
+			stderr: "",
+			stdout: ""
+		};
+		const maxOutput = 64 * 1024;
+		child.stdout.on("data", (data) => {
+			server.stdout += data.toString();
+			if (server.stdout.length > maxOutput) server.stdout = server.stdout.slice(-maxOutput);
+		});
+		child.stderr.on("data", (data) => {
+			server.stderr += data.toString();
+			if (server.stderr.length > maxOutput) server.stderr = server.stderr.slice(-maxOutput);
+		});
+		child.on("close", () => {
+			server.closed = true;
+			if (this.server === server) this.server = null;
+		});
+		this.server = server;
+		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
+			await this.shutdownServer();
+			throw error;
+		});
+		await server.readyPromise;
+		return server;
+	}
+	async waitForHealthy(server, signal) {
+		const deadline = Date.now() + 3e4;
+		let spawnErrorMessage = null;
+		server.child.once("error", (error) => {
+			spawnErrorMessage = error.message;
+		});
+		while (Date.now() < deadline) {
+			if (signal?.aborted) throw createAbortError$1();
+			if (spawnErrorMessage) throw new Error(`Failed to spawn opencode: ${spawnErrorMessage}`);
+			if (server.closed) {
+				const output = server.stderr.trim() || server.stdout.trim();
+				throw new Error(output ? `opencode exited before becoming ready: ${output}` : "opencode exited before becoming ready");
+			}
+			try {
+				if ((await this.fetchFn(`${server.baseUrl}/global/health`, {
+					method: "GET",
+					signal
+				})).ok) return;
+			} catch (error) {
+				if (isAbortError$1(error)) throw createAbortError$1();
+			}
+			await delay$1(250, signal);
+		}
+		throw new Error(`Timed out waiting for opencode serve to become ready on port ${server.port}`);
+	}
+	async createSession(server, cwd, signal) {
+		return (await this.requestJSON(server, "/session", {
+			method: "POST",
+			body: {
+				directory: cwd,
+				permission: BLANKET_PERMISSION_RULESET
+			},
+			signal
+		})).id;
+	}
+	async streamMessage(server, sessionId, prompt, signal, logStream, onUsage, onMessage) {
+		const streamAbortController = new AbortController();
+		const streamSignal = AbortSignal.any([signal, streamAbortController.signal]);
+		const eventResponse = await this.request(server, "/global/event", {
+			method: "GET",
+			headers: { accept: "text/event-stream" },
+			signal: streamSignal
+		});
+		if (!eventResponse.body) throw new Error("opencode returned no event stream body");
+		let messageRequestError = null;
+		const messageRequest = (async () => {
+			try {
+				return {
+					ok: true,
+					body: await this.requestText(server, `/session/${sessionId}/message`, {
+						method: "POST",
+						body: {
+							role: "user",
+							parts: [{
+								type: "text",
+								text: prompt
+							}],
+							format: STRUCTURED_OUTPUT_FORMAT
+						},
+						signal
+					})
+				};
+			} catch (error) {
+				messageRequestError = error;
+				streamAbortController.abort();
+				return {
+					ok: false,
+					error
+				};
+			}
+		})();
+		const usage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0
+		};
+		const usageByMessageId = /* @__PURE__ */ new Map();
+		const textParts = /* @__PURE__ */ new Map();
+		let lastText = null;
+		let lastFinalAnswerText = null;
+		let lastUsageSignature = "0:0:0:0";
+		const updateUsage = (messageId, tokens) => {
+			if (!messageId || !tokens) return;
+			usageByMessageId.set(messageId, toUsage(tokens));
+			let nextInputTokens = 0;
+			let nextOutputTokens = 0;
+			let nextCacheReadTokens = 0;
+			let nextCacheCreationTokens = 0;
+			for (const messageUsage of usageByMessageId.values()) {
+				nextInputTokens += messageUsage.inputTokens;
+				nextOutputTokens += messageUsage.outputTokens;
+				nextCacheReadTokens += messageUsage.cacheReadTokens;
+				nextCacheCreationTokens += messageUsage.cacheCreationTokens;
+			}
+			const signature = [
+				nextInputTokens,
+				nextOutputTokens,
+				nextCacheReadTokens,
+				nextCacheCreationTokens
+			].join(":");
+			usage.inputTokens = nextInputTokens;
+			usage.outputTokens = nextOutputTokens;
+			usage.cacheReadTokens = nextCacheReadTokens;
+			usage.cacheCreationTokens = nextCacheCreationTokens;
+			if (signature !== lastUsageSignature) {
+				lastUsageSignature = signature;
+				onUsage?.({ ...usage });
+			}
+		};
+		const emitText = (partId, nextText, phase) => {
+			const trimmed = nextText.trim();
+			textParts.set(partId, {
+				text: nextText,
+				phase
+			});
+			if (!trimmed) return;
+			lastText = nextText;
+			if (phase === "final_answer") lastFinalAnswerText = nextText;
+			onMessage?.(trimmed);
+		};
+		const handleEvent = (event) => {
+			const payload = event.payload;
+			const properties = payload?.properties;
+			if (!properties || properties.sessionID !== sessionId) return false;
+			if (payload?.type === "message.part.delta" && properties.field === "text" && typeof properties.partID === "string" && typeof properties.delta === "string") {
+				const current = textParts.get(properties.partID);
+				emitText(properties.partID, `${current?.text ?? ""}${properties.delta}`, current?.phase);
+				return false;
+			}
+			if (payload?.type === "message.part.updated") {
+				const part = properties.part;
+				if (!part) return false;
+				if (part.type === "text" && typeof part.id === "string") {
+					emitText(part.id, part.text ?? "", part.metadata?.openai?.phase);
+					return false;
+				}
+				if (part.type === "step-finish") {
+					updateUsage(part.messageID, part.tokens);
+					return false;
+				}
+				return false;
+			}
+			if (payload?.type === "message.updated") {
+				if (properties.info?.role === "assistant") updateUsage(properties.info.id, properties.info.tokens);
+				return false;
+			}
+			return payload?.type === "session.idle";
+		};
+		const decoder = new TextDecoder();
+		const reader = eventResponse.body.getReader();
+		let buffer = "";
+		let sawSessionIdle = false;
+		const processRawEvent = (rawEvent) => {
+			if (!rawEvent.trim()) return;
+			const dataLines = rawEvent.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+			if (dataLines.length === 0) return;
+			try {
+				if (handleEvent(JSON.parse(dataLines.join("\n")))) sawSessionIdle = true;
+			} catch {}
+		};
+		const processBufferedEvents = (flushRemainder = false) => {
+			while (true) {
+				const lfBoundary = buffer.indexOf("\n\n");
+				const crlfBoundary = buffer.indexOf("\r\n\r\n");
+				let boundary;
+				let separatorLen;
+				if (lfBoundary === -1 && crlfBoundary === -1) break;
+				if (crlfBoundary !== -1 && (lfBoundary === -1 || crlfBoundary < lfBoundary)) {
+					boundary = crlfBoundary;
+					separatorLen = 4;
+				} else {
+					boundary = lfBoundary;
+					separatorLen = 2;
+				}
+				processRawEvent(buffer.slice(0, boundary));
+				buffer = buffer.slice(boundary + separatorLen);
+				if (sawSessionIdle) return;
+			}
+			if (flushRemainder && buffer.trim()) {
+				processRawEvent(buffer);
+				buffer = "";
+			}
+		};
+		try {
+			while (!sawSessionIdle) {
+				let readResult;
+				try {
+					readResult = await reader.read();
+				} catch (error) {
+					if (messageRequestError) {
+						if (isAbortError$1(messageRequestError) || isAgentAbortError(messageRequestError)) throw createAbortError$1();
+						throw messageRequestError;
+					}
+					if (isAbortError$1(error)) throw createAbortError$1();
+					throw error;
+				}
+				if (readResult.done) {
+					const tail = decoder.decode();
+					if (tail) {
+						logStream?.write(tail);
+						buffer += tail;
+					}
+					processBufferedEvents(true);
+					break;
+				}
+				const chunk = decoder.decode(readResult.value, { stream: true });
+				logStream?.write(chunk);
+				buffer += chunk;
+				processBufferedEvents();
+			}
+		} finally {
+			streamAbortController.abort();
+			await reader.cancel().catch(() => void 0);
+		}
+		const messageResult = await messageRequest;
+		if (!messageResult.ok) {
+			if (isAbortError$1(messageResult.error) || isAgentAbortError(messageResult.error)) throw createAbortError$1();
+			throw messageResult.error;
+		}
+		const body = messageResult.body;
+		let response;
+		try {
+			response = JSON.parse(body);
+		} catch (error) {
+			throw new Error(`Failed to parse opencode response: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (response.info?.role === "assistant") updateUsage(response.info.id, response.info.tokens);
+		for (const part of response.parts ?? []) {
+			if (part.type !== "text" || typeof part.text !== "string") continue;
+			if (!part.text.trim()) continue;
+			lastText = part.text;
+			if (part.metadata?.openai?.phase === "final_answer") lastFinalAnswerText = part.text;
+		}
+		if (response.info?.structured) return {
+			output: response.info.structured,
+			usage
+		};
+		const outputText = lastFinalAnswerText ?? lastText;
+		if (!outputText) throw new Error("opencode returned no text output");
+		try {
+			return {
+				output: JSON.parse(outputText),
+				usage
+			};
+		} catch (error) {
+			throw new Error(`Failed to parse opencode output: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async deleteSession(server, sessionId) {
+		try {
+			await this.request(server, `/session/${sessionId}`, {
+				method: "DELETE",
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async abortSession(server, sessionId) {
+		try {
+			await this.request(server, `/session/${sessionId}/abort`, {
+				method: "POST",
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async shutdownServer() {
+		if (!this.server || this.server.closed) {
+			this.server = null;
+			return;
+		}
+		if (this.closingPromise) {
+			await this.closingPromise;
+			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?.();
+		});
+		this.closingPromise = Promise.race([waitForClose, forceKill]).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);
+	}
+	async requestText(server, path, options) {
+		return await (await this.request(server, path, options)).text();
+	}
+	async request(server, path, options) {
+		const headers = new Headers(options.headers);
+		if (options.body !== void 0) headers.set("content-type", "application/json");
+		const signal = withTimeoutSignal$1(options.signal, options.timeoutMs);
+		const response = await this.fetchFn(`${server.baseUrl}${path}`, {
+			method: options.method,
+			headers,
+			body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+			signal
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw new Error(`opencode ${options.method} ${path} failed with ${response.status}: ${body}`);
+		}
+		return response;
+	}
+};
+//#endregion
+//#region src/core/agents/rovodev.ts
+function buildSystemPrompt(schema) {
+	return [
+		"You are the coding agent used by gnhf.",
+		"Work autonomously in the current workspace and use tools when needed.",
+		"When you finish, reply with only valid JSON.",
+		"Do not wrap the JSON in markdown fences.",
+		"Do not include any prose before or after the JSON.",
+		`The JSON must match this schema exactly: ${schema}`
+	].join(" ");
+}
+function createAbortError() {
+	return /* @__PURE__ */ new Error("Agent was aborted");
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function getAvailablePort() {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Failed to allocate a port for rovodev"));
+				return;
+			}
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(address.port);
+			});
+		});
+	});
+}
+async function delay(ms, signal) {
+	if (!signal) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+		return;
+	}
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(createAbortError());
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+var RovoDevAgent = class {
+	name = "rovodev";
+	schemaPath;
+	fetchFn;
+	getPortFn;
+	killProcessFn;
+	spawnFn;
+	server = null;
+	closingPromise = null;
+	constructor(schemaPath, deps = {}) {
+		this.schemaPath = schemaPath;
+		this.fetchFn = deps.fetch ?? fetch;
+		this.getPortFn = deps.getPort ?? getAvailablePort;
+		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
+		this.spawnFn = deps.spawn ?? spawn;
+	}
+	async run(prompt, cwd, options) {
+		const { onUsage, onMessage, signal, logPath } = options ?? {};
+		const logStream = logPath ? createWriteStream(logPath) : null;
+		const runController = new AbortController();
+		let sessionId = null;
+		const onAbort = () => {
+			runController.abort();
+		};
+		if (signal?.aborted) {
+			logStream?.end();
+			throw createAbortError();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			const server = await this.ensureServer(cwd, runController.signal);
+			sessionId = await this.createSession(server, runController.signal);
+			await this.setInlineSystemPrompt(server, sessionId, runController.signal);
+			await this.setChatMessage(server, sessionId, prompt, runController.signal);
+			return await this.streamChat(server, sessionId, runController.signal, logStream, onUsage, onMessage);
+		} catch (error) {
+			if (runController.signal.aborted || isAbortError(error)) throw createAbortError();
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+			logStream?.end();
+			if (this.server && sessionId) {
+				if (runController.signal.aborted) await this.cancelSession(this.server, sessionId);
+				await this.deleteSession(this.server, sessionId);
+			}
+		}
+	}
+	async close() {
+		await this.shutdownServer();
+	}
+	async ensureServer(cwd, signal) {
+		if (this.server && !this.server.closed && this.server.cwd === cwd) {
+			await this.server.readyPromise;
+			return this.server;
+		}
+		if (this.server && !this.server.closed) await this.shutdownServer();
+		const port = await this.getPortFn();
+		const detached = process.platform !== "win32";
+		const child = this.spawnFn("acli", [
+			"rovodev",
+			"serve",
+			"--disable-session-token",
+			String(port)
+		], {
+			cwd,
+			detached,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: process.env
+		});
+		const server = {
+			baseUrl: `http://127.0.0.1:${port}`,
+			child,
+			cwd,
+			detached,
+			port,
+			readyPromise: Promise.resolve(),
+			closed: false,
+			stdout: "",
+			stderr: ""
+		};
+		const MAX_OUTPUT = 64 * 1024;
+		child.stdout.on("data", (data) => {
+			server.stdout += data.toString();
+			if (server.stdout.length > MAX_OUTPUT) server.stdout = server.stdout.slice(-MAX_OUTPUT);
+		});
+		child.stderr.on("data", (data) => {
+			server.stderr += data.toString();
+			if (server.stderr.length > MAX_OUTPUT) server.stderr = server.stderr.slice(-MAX_OUTPUT);
+		});
+		child.on("close", () => {
+			server.closed = true;
+			if (this.server === server) this.server = null;
+		});
+		this.server = server;
+		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
+			await this.shutdownServer();
+			throw error;
+		});
+		await server.readyPromise;
+		return server;
+	}
+	async waitForHealthy(server, signal) {
+		const deadline = Date.now() + 3e4;
+		let spawnError = null;
+		server.child.once("error", (error) => {
+			spawnError = error;
+		});
+		while (Date.now() < deadline) {
+			if (signal?.aborted) throw createAbortError();
+			if (spawnError) throw new Error(`Failed to spawn rovodev: ${spawnError.message}`);
+			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");
+			}
+			try {
+				if ((await this.fetchFn(`${server.baseUrl}/healthcheck`, {
+					method: "GET",
+					signal
+				})).ok) return;
+			} catch (error) {
+				if (isAbortError(error)) throw createAbortError();
+			}
+			await delay(250, signal);
+		}
+		throw new Error(`Timed out waiting for rovodev serve to become ready on port ${server.port}`);
+	}
+	async createSession(server, signal) {
+		return (await this.requestJSON(server, "/v3/sessions/create", {
+			method: "POST",
+			body: { custom_title: "gnhf" },
+			signal
+		})).session_id;
+	}
+	async setInlineSystemPrompt(server, sessionId, signal) {
+		const schema = readFileSync(this.schemaPath, "utf-8").trim();
+		await this.requestJSON(server, "/v3/inline-system-prompt", {
+			method: "PUT",
+			sessionId,
+			body: { prompt: buildSystemPrompt(schema) },
+			signal
+		});
+	}
+	async setChatMessage(server, sessionId, prompt, signal) {
+		await this.requestJSON(server, "/v3/set_chat_message", {
+			method: "POST",
+			sessionId,
+			body: { message: prompt },
+			signal
+		});
+	}
+	async cancelSession(server, sessionId) {
+		try {
+			await this.request(server, "/v3/cancel", {
+				method: "POST",
+				sessionId,
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async deleteSession(server, sessionId) {
+		try {
+			await this.request(server, `/v3/sessions/${sessionId}`, {
+				method: "DELETE",
+				sessionId,
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async streamChat(server, sessionId, signal, logStream, onUsage, onMessage) {
+		const response = await this.request(server, "/v3/stream_chat", {
+			method: "GET",
+			sessionId,
+			headers: { accept: "text/event-stream" },
+			signal
+		});
+		if (!response.body) throw new Error("rovodev returned no response body");
+		const usage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0
+		};
+		let latestTextSegment = "";
+		let currentTextParts = [];
+		let currentTextIndexes = /* @__PURE__ */ new Map();
+		const decoder = new TextDecoder();
+		const reader = response.body.getReader();
+		let buffer = "";
+		const emitMessage = () => {
+			const message = currentTextParts.join("").trim();
+			if (message) {
+				latestTextSegment = message;
+				onMessage?.(message);
+			}
+		};
+		const resetCurrentMessage = () => {
+			currentTextParts = [];
+			currentTextIndexes = /* @__PURE__ */ new Map();
+		};
+		const handleUsage = (event) => {
+			usage.inputTokens += event.input_tokens ?? 0;
+			usage.outputTokens += event.output_tokens ?? 0;
+			usage.cacheReadTokens += event.cache_read_tokens ?? 0;
+			usage.cacheCreationTokens += event.cache_write_tokens ?? 0;
+			onUsage?.({ ...usage });
+		};
+		const handleEvent = (rawEvent) => {
+			const lines = rawEvent.split(/\r?\n/);
+			let eventName = "";
+			const dataLines = [];
+			for (const line of lines) {
+				if (line.startsWith("event:")) {
+					eventName = line.slice(6).trim();
+					continue;
+				}
+				if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+			}
+			const rawData = dataLines.join("\n");
+			if (rawData.length === 0) return;
+			let payload;
+			try {
+				payload = JSON.parse(rawData);
+			} catch {
+				return;
+			}
+			const kind = eventName || (typeof payload.event_kind === "string" ? payload.event_kind : "");
+			if (kind === "request-usage") {
+				handleUsage(payload);
+				return;
+			}
+			if (kind === "tool-return" || kind === "on_call_tools_start") {
+				resetCurrentMessage();
+				return;
+			}
+			if (kind === "text") {
+				const content = payload.content;
+				if (typeof content === "string") {
+					currentTextParts = [content];
+					currentTextIndexes = /* @__PURE__ */ new Map();
+					emitMessage();
+				}
+				return;
+			}
+			if (kind === "part_start") {
+				const partStart = payload;
+				if (typeof partStart.index === "number" && partStart.part?.part_kind === "text" && typeof partStart.part.content === "string") {
+					const nextIndex = currentTextParts.push(partStart.part.content) - 1;
+					currentTextIndexes.set(partStart.index, nextIndex);
+					emitMessage();
+				}
+				return;
+			}
+			if (kind === "part_delta") {
+				const partDelta = payload;
+				if (typeof partDelta.index === "number" && partDelta.delta?.part_delta_kind === "text" && typeof partDelta.delta.content_delta === "string") {
+					const textIndex = currentTextIndexes.get(partDelta.index);
+					if (textIndex === void 0) {
+						const nextIndex = currentTextParts.push(partDelta.delta.content_delta) - 1;
+						currentTextIndexes.set(partDelta.index, nextIndex);
+					} else currentTextParts[textIndex] += partDelta.delta.content_delta;
+					emitMessage();
+				}
+			}
+		};
+		while (true) {
+			let readResult;
+			try {
+				readResult = await reader.read();
+			} catch (error) {
+				if (isAbortError(error)) throw createAbortError();
+				throw error;
+			}
+			if (readResult.done) break;
+			const chunk = decoder.decode(readResult.value, { stream: true });
+			logStream?.write(chunk);
+			buffer += chunk;
+			while (true) {
+				const lfBoundary = buffer.indexOf("\n\n");
+				const crlfBoundary = buffer.indexOf("\r\n\r\n");
+				let boundary;
+				let separatorLen;
+				if (lfBoundary === -1 && crlfBoundary === -1) break;
+				if (crlfBoundary !== -1 && (lfBoundary === -1 || crlfBoundary < lfBoundary)) {
+					boundary = crlfBoundary;
+					separatorLen = 4;
+				} else {
+					boundary = lfBoundary;
+					separatorLen = 2;
+				}
+				const rawEvent = buffer.slice(0, boundary);
+				buffer = buffer.slice(boundary + separatorLen);
+				if (rawEvent.trim()) handleEvent(rawEvent);
+			}
+		}
+		buffer += decoder.decode();
+		if (buffer.trim()) handleEvent(buffer);
+		const finalText = latestTextSegment.trim();
+		if (!finalText) throw new Error("rovodev returned no text output");
+		try {
+			return {
+				output: JSON.parse(finalText),
+				usage
+			};
+		} catch (error) {
+			throw new Error(`Failed to parse rovodev output: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async shutdownServer() {
+		if (!this.server || this.server.closed) {
+			this.server = null;
+			return;
+		}
+		if (this.closingPromise) {
+			await this.closingPromise;
+			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?.();
+		});
+		this.closingPromise = Promise.race([waitForClose, forceKill]).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();
+	}
+	async request(server, path, options) {
+		const headers = new Headers(options.headers);
+		if (options.sessionId) headers.set("x-session-id", options.sessionId);
+		if (options.body !== void 0 && !headers.has("content-type")) headers.set("content-type", "application/json");
+		const signal = withTimeoutSignal(options.signal, options.timeoutMs);
+		const response = await this.fetchFn(`${server.baseUrl}${path}`, {
+			method: options.method,
+			headers,
+			body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+			signal
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw new Error(`rovodev ${options.method} ${path} failed with ${response.status}: ${body}`);
+		}
+		return response;
+	}
+};
+function withTimeoutSignal(signal, timeoutMs) {
+	if (timeoutMs === void 0) return signal;
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+//#endregion
 //#region src/core/agents/factory.ts
 function createAgent(name, runInfo) {
 	switch (name) {
 		case "claude": return new ClaudeAgent();
 		case "codex": return new CodexAgent(runInfo.schemaPath);
+		case "opencode": return new OpenCodeAgent();
+		case "rovodev": return new RovoDevAgent(runInfo.schemaPath);
 	}
 }
 //#endregion
@@ -495,6 +1474,7 @@ var Orchestrator = class extends EventEmitter {
 	prompt;
 	limits;
 	stopRequested = false;
+	stopPromise = null;
 	activeAbortController = null;
 	pendingAbortReason = null;
 	state = {
@@ -528,60 +1508,69 @@ var Orchestrator = class extends EventEmitter {
 	stop() {
 		this.stopRequested = true;
 		this.activeAbortController?.abort();
-		resetHard(this.cwd);
-		this.state.status = "stopped";
-		this.emit("state", this.getState());
-		this.emit("stopped");
+		if (this.stopPromise) return;
+		this.stopPromise = (async () => {
+			await this.closeAgent();
+			resetHard(this.cwd);
+			this.state.status = "stopped";
+			this.emit("state", this.getState());
+			this.emit("stopped");
+		})();
 	}
 	async start() {
 		this.state.startTime = /* @__PURE__ */ new Date();
 		this.state.status = "running";
 		this.emit("state", this.getState());
-		while (!this.stopRequested) {
-			const preIterationAbortReason = this.getPreIterationAbortReason();
-			if (preIterationAbortReason) {
-				this.abort(preIterationAbortReason);
-				break;
-			}
-			this.state.currentIteration++;
-			this.state.status = "running";
-			this.emit("iteration:start", this.state.currentIteration);
-			this.emit("state", this.getState());
-			const iterationPrompt = buildIterationPrompt({
-				n: this.state.currentIteration,
-				runId: this.runInfo.runId,
-				prompt: this.prompt
-			});
-			const result = await this.runIteration(iterationPrompt);
-			if (result.type === "aborted") {
-				this.abort(result.reason);
-				break;
-			}
-			const { record } = result;
-			this.state.iterations.push(record);
-			this.emit("iteration:end", record);
-			this.emit("state", this.getState());
-			const postIterationAbortReason = this.getPostIterationAbortReason();
-			if (postIterationAbortReason) {
-				this.abort(postIterationAbortReason);
-				break;
-			}
-			if (this.state.consecutiveFailures >= this.config.maxConsecutiveFailures) {
-				this.abort(`${this.config.maxConsecutiveFailures} consecutive failures`);
-				break;
-			}
-			if (this.state.consecutiveFailures > 0 && !this.stopRequested) {
-				const backoffMs = 6e4 * Math.pow(2, this.state.consecutiveFailures - 1);
-				this.state.status = "waiting";
-				this.state.waitingUntil = new Date(Date.now() + backoffMs);
+		try {
+			while (!this.stopRequested) {
+				const preIterationAbortReason = this.getPreIterationAbortReason();
+				if (preIterationAbortReason) {
+					this.abort(preIterationAbortReason);
+					break;
+				}
+				this.state.currentIteration++;
+				this.state.status = "running";
+				this.emit("iteration:start", this.state.currentIteration);
 				this.emit("state", this.getState());
-				await this.interruptibleSleep(backoffMs);
-				this.state.waitingUntil = null;
-				if (!this.stopRequested) {
-					this.state.status = "running";
+				const iterationPrompt = buildIterationPrompt({
+					n: this.state.currentIteration,
+					runId: this.runInfo.runId,
+					prompt: this.prompt
+				});
+				const result = await this.runIteration(iterationPrompt);
+				if (result.type === "aborted") {
+					this.abort(result.reason);
+					break;
+				}
+				const { record } = result;
+				this.state.iterations.push(record);
+				this.emit("iteration:end", record);
+				this.emit("state", this.getState());
+				const postIterationAbortReason = this.getPostIterationAbortReason();
+				if (postIterationAbortReason) {
+					this.abort(postIterationAbortReason);
+					break;
+				}
+				if (this.state.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+					this.abort(`${this.config.maxConsecutiveFailures} consecutive failures`);
+					break;
+				}
+				if (this.state.consecutiveFailures > 0 && !this.stopRequested) {
+					const backoffMs = 6e4 * Math.pow(2, this.state.consecutiveFailures - 1);
+					this.state.status = "waiting";
+					this.state.waitingUntil = new Date(Date.now() + backoffMs);
 					this.emit("state", this.getState());
+					await this.interruptibleSleep(backoffMs);
+					this.state.waitingUntil = null;
+					if (!this.stopRequested) {
+						this.state.status = "running";
+						this.emit("state", this.getState());
+					}
 				}
 			}
+		} finally {
+			if (this.stopPromise) await this.stopPromise;
+			else await this.closeAgent();
 		}
 	}
 	async runIteration(prompt) {
@@ -701,6 +1690,11 @@ var Orchestrator = class extends EventEmitter {
 		this.emit("abort", reason);
 		this.emit("state", this.getState());
 	}
+	async closeAgent() {
+		try {
+			await this.agent.close?.();
+		} catch {}
+	}
 };
 //#endregion
 //#region src/mock-orchestrator.ts
@@ -1030,9 +2024,17 @@ const MOON_PHASE_PERIOD = 1600;
 const MAX_MSG_LINES = 3;
 const MAX_MSG_LINE_LEN = 64;
 const RESUME_HINT = "[ctrl+c to stop, gnhf again to resume]";
-function renderTitleCells() {
+function spacedLabel(text) {
+	return text.split("").join(" ");
+}
+function renderTitleCells(agentName) {
 	return [
-		textToCells("g n h f", "dim"),
+		[...textToCells(spacedLabel("gnhf"), "dim"), ...agentName ? [
+			...textToCells("  ", "normal"),
+			...textToCells("·", "dim"),
+			...textToCells("  ", "normal"),
+			...textToCells(spacedLabel(agentName), "dim")
+		] : []],
 		[],
 		textToCells("┏━╸┏━┓┏━┓╺┳┓   ┏┓╻╻┏━╸╻ ╻╺┳╸   ╻ ╻┏━┓╻ ╻┏━╸   ┏━╸╻ ╻┏┓╻", "bold"),
 		textToCells("┃╺┓┃ ┃┃ ┃ ┃┃   ┃┗┫┃┃╺┓┣━┫ ┃    ┣━┫┣━┫┃┏┛┣╸    ┣╸ ┃ ┃┃┗┫", "bold"),
@@ -1137,11 +2139,11 @@ function fitContentRows(contentRows, maxRows) {
 	}
 	return fitted.length > maxRows ? fitted.slice(fitted.length - maxRows) : fitted;
 }
-function buildContentCells(prompt, state, elapsed, now) {
+function buildContentCells(prompt, agentName, state, elapsed, now) {
 	const rows = [];
 	const isRunning = state.status === "running" || state.status === "waiting";
 	rows.push([]);
-	rows.push(...renderTitleCells());
+	rows.push(...renderTitleCells(agentName));
 	rows.push([], []);
 	const promptLines = wordWrap(prompt, CONTENT_WIDTH, MAX_PROMPT_LINES);
 	for (let i = 0; i < MAX_PROMPT_LINES; i++) {
@@ -1156,10 +2158,10 @@ function buildContentCells(prompt, state, elapsed, now) {
 	rows.push(...renderMoonStripCells(state.iterations, isRunning, now));
 	return rows;
 }
-function buildFrameCells(prompt, state, topStars, bottomStars, sideStars, now, terminalWidth, terminalHeight) {
+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, state, elapsed, now), availableHeight);
+	const contentRows = fitContentRows(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);
@@ -1186,6 +2188,7 @@ function buildFrameCells(prompt, state, topStars, bottomStars, sideStars, now, t
 var Renderer = class {
 	orchestrator;
 	prompt;
+	agentName;
 	state;
 	interval = null;
 	exitResolve;
@@ -1197,9 +2200,10 @@ var Renderer = class {
 	cachedHeight = 0;
 	prevCells = [];
 	isFirstFrame = true;
-	constructor(orchestrator, prompt) {
+	constructor(orchestrator, prompt, agentName) {
 		this.orchestrator = orchestrator;
 		this.prompt = prompt;
+		this.agentName = agentName;
 		this.state = orchestrator.getState();
 		this.exitPromise = new Promise((resolve) => {
 			this.exitResolve = resolve;
@@ -1219,7 +2223,10 @@ var Renderer = class {
 			process$1.stdin.setRawMode(true);
 			process$1.stdin.resume();
 			process$1.stdin.on("data", (data) => {
-				if (data[0] === 3) this.orchestrator.stop();
+				if (data[0] === 3) {
+					this.stop();
+					this.orchestrator.stop();
+				}
 			});
 		}
 		this.interval = setInterval(() => this.render(), TICK_MS);
@@ -1273,7 +2280,7 @@ var Renderer = class {
 		const w = process$1.stdout.columns || 80;
 		const h = process$1.stdout.rows || 24;
 		const resized = this.ensureStarFields(w, h);
-		const nextCells = buildFrameCells(this.prompt, this.state, this.topStars, this.bottomStars, this.sideStars, now, w, h);
+		const nextCells = buildFrameCells(this.prompt, this.agentName, this.state, this.topStars, this.bottomStars, this.sideStars, now, w, h);
 		if (this.isFirstFrame || resized) {
 			process$1.stdout.write("\x1B[H" + nextCells.map(rowToString).join("\n"));
 			this.isFirstFrame = false;
@@ -1292,6 +2299,7 @@ function slugifyPrompt(prompt) {
 //#endregion
 //#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;
 function parseNonNegativeInteger(value) {
 	if (!/^\d+$/.test(value)) throw new InvalidArgumentError("must be a non-negative integer");
 	const parsed = Number.parseInt(value, 10);
@@ -1323,11 +2331,11 @@ function ask(question) {
 	});
 }
 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 or codex)").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("--mock", "", false).action(async (promptArg, options) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
-		const renderer = new Renderer(mock, "let's minimize app startup latency without sacrificing any functionality");
+		const renderer = new Renderer(mock, "let's minimize app startup latency without sacrificing any functionality", "claude");
 		renderer.start();
 		mock.start();
 		await renderer.waitUntilExit();
@@ -1337,13 +2345,13 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 	let prompt = promptArg;
 	if (!prompt && !process$1.stdin.isTTY) prompt = readFileSync("/dev/stdin", "utf-8").trim();
 	const agentName = options.agent;
-	if (agentName !== void 0 && agentName !== "claude" && agentName !== "codex") {
-		console.error(`Unknown agent: ${options.agent}. Use "claude" or "codex".`);
+	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);
-	if (config.agent !== "claude" && config.agent !== "codex") {
-		console.error(`Unknown agent: ${config.agent}. Use "claude" or "codex".`);
+	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);
 	}
 	const cwd = process$1.cwd();
@@ -1379,15 +2387,22 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		maxTokens: options.maxTokens
 	});
 	enterAltScreen();
-	const renderer = new Renderer(orchestrator, prompt);
+	const renderer = new Renderer(orchestrator, prompt, config.agent);
 	renderer.start();
-	orchestrator.start().catch((err) => {
+	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);
+	}
 });
 function enterAltScreen() {
 	process$1.stdout.write("\x1B[?1049h");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnhf",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Before I go to bed, I tell my agents: good night, have fun",
   "type": "module",
   "bin": {