gnhf 0.1.23 → 0.1.25

package/README.md

@@ -45,7 +45,7 @@ gnhf is a [ralph](https://ghuntley.com/ralph/), [autoresearch](https://github.co
 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
+- **Long running** — each iteration is committed on success, rolled back on failure, with sensible retries; hard agent errors back off exponentially while agent-reported failures continue immediately
 - **Live terminal title** — interactive runs keep your terminal title updated with live status, token totals, and commit count, then restore the previous title on exit
 - **Agent-agnostic** — works with Claude Code, Codex, Rovo Dev, or OpenCode out of the box
 
@@ -122,7 +122,7 @@ npm link
               ┌──────────┐  ┌───────────┐                  │
               │  commit  │  │ git reset │                  │
               │  append  │  │  --hard   │                  │
-              │ notes.md │  │  backoff  │                  │
+              │ notes.md │  │ maybe wait│                  │
               └────┬─────┘  └─────┬─────┘                  │
                    │              │                        │
                    │   ┌──────────┘                        │
@@ -136,10 +136,11 @@ npm link
 ```
 
 - **Incremental commits** — each successful iteration is a separate git commit, so you can cherry-pick or revert individual changes
+- **Failure handling** - all failed iterations are rolled back with `git reset --hard`; agent-reported failures proceed to the next iteration immediately, while hard agent errors use exponential backoff
 - **Runtime caps** - `--max-iterations` stops before the next iteration begins, `--max-tokens` can abort mid-iteration once reported usage reaches the cap, and `--stop-when` ends the loop after an iteration whose agent output reports the natural-language condition is met; uncommitted work is rolled back in either case, and in the interactive TUI the final state remains visible until you press Ctrl+C to exit
 - **Shared memory** — the agent reads `notes.md` (built up from prior iterations) to communicate across iterations
 - **Local run metadata** — gnhf stores prompt, notes, and resume metadata under `.gnhf/runs/` and ignores it locally, so your branch only contains intentional work
-- **Resume support** — run `gnhf` while on an existing `gnhf/` branch to pick up where a previous run left off
+- **Resume support** — run `gnhf` while on an existing `gnhf/` branch to pick up where a previous run left off; if you provide a different prompt, gnhf asks whether to update the saved prompt and continue with the existing history, start a new branch, or quit
 
 ### Worktree Mode
 
@@ -165,17 +166,19 @@ Pass `--worktree` to run each agent in an isolated [git worktree](https://git-sc
 | `echo "<prompt>" \| gnhf` | Pipe prompt via stdin                           |
 | `cat prd.md \| gnhf`      | Pipe a large spec or PRD via stdin              |
 
+If you run `gnhf` on an existing `gnhf/` branch with a different prompt, gnhf asks whether to update `prompt.md` and continue the existing run history, start a new branch, or quit. When the prompt came from stdin, that confirmation is read from the controlling terminal, so it must be available.
+
 ### Flags
 
-| 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              |
-| `--stop-when <cond>`     | End the loop when the agent reports this natural-language condition is met | unlimited         |
-| `--prevent-sleep <mode>` | Prevent system sleep during the run (`on`/`off` or `true`/`false`)    | config file (`on`)     |
-| `--worktree`             | Run in a separate git worktree (enables multiple agents concurrently) | `false`                |
-| `--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              |
+| `--stop-when <cond>`     | End the loop when the agent reports this natural-language condition is met | unlimited              |
+| `--prevent-sleep <mode>` | Prevent system sleep during the run (`on`/`off` or `true`/`false`)         | config file (`on`)     |
+| `--worktree`             | Run in a separate git worktree (enables multiple agents concurrently)      | `false`                |
+| `--version`              | Show version                                                               |                        |
 
 ## Configuration
 
@@ -249,6 +252,8 @@ Including a snippet of `gnhf.log` is the single most useful thing you can attach
 
 ## Development
 
+If you want to contribute changes back to this repo, see [`CONTRIBUTING.md`](./CONTRIBUTING.md). Human-authored PRs targeting `main` must be opened via `git push no-mistakes` so the required `Require no-mistakes` check passes.
+
 ```sh
 npm run build          # Build with tsdown
 npm run dev            # Watch mode

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { appendFileSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, openSync, 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";
@@ -427,10 +427,8 @@ function removeWorktree(baseCwd, worktreePath) {
 }
 //#endregion
 //#region src/core/agents/types.ts
-const AGENT_OUTPUT_SCHEMA = {
-	type: "object",
-	additionalProperties: false,
-	properties: {
+function buildAgentOutputSchema(opts) {
+	const properties = {
 		success: { type: "boolean" },
 		summary: { type: "string" },
 		key_changes_made: {
@@ -440,21 +438,30 @@ const AGENT_OUTPUT_SCHEMA = {
 		key_learnings: {
 			type: "array",
 			items: { type: "string" }
-		},
-		should_fully_stop: { type: "boolean" }
-	},
-	required: [
+		}
+	};
+	const required = [
 		"success",
 		"summary",
 		"key_changes_made",
 		"key_learnings"
-	]
-};
+	];
+	if (opts.includeStopField) {
+		properties.should_fully_stop = { type: "boolean" };
+		required.push("should_fully_stop");
+	}
+	return {
+		type: "object",
+		additionalProperties: false,
+		properties,
+		required
+	};
+}
 //#endregion
 //#region src/core/run.ts
 const LOG_FILENAME = "gnhf.log";
-function writeSchemaFile(schemaPath) {
-	writeFileSync(schemaPath, JSON.stringify(AGENT_OUTPUT_SCHEMA, null, 2), "utf-8");
+function writeSchemaFile(schemaPath, includeStopField) {
+	writeFileSync(schemaPath, JSON.stringify(buildAgentOutputSchema({ includeStopField }), null, 2), "utf-8");
 }
 function ensureRunMetadataIgnored(cwd) {
 	const excludePath = execFileSync("git", [
@@ -474,16 +481,16 @@ function ensureRunMetadataIgnored(cwd) {
 		appendFileSync(resolved, `${content.length > 0 && !content.endsWith("\n") ? "\n" : ""}${entry}\n`, "utf-8");
 	} else writeFileSync(resolved, `${entry}\n`, "utf-8");
 }
-function setupRun(runId, prompt, baseCommit, cwd) {
+function setupRun(runId, prompt, baseCommit, cwd, schemaOptions) {
 	ensureRunMetadataIgnored(cwd);
 	const runDir = join(cwd, ".gnhf", "runs", runId);
 	mkdirSync(runDir, { recursive: true });
 	const promptPath = join(runDir, "prompt.md");
 	writeFileSync(promptPath, prompt, "utf-8");
 	const notesPath = join(runDir, "notes.md");
-	writeFileSync(notesPath, `# gnhf run: ${runId}\n\nObjective: ${prompt}\n\n## Iteration Log\n`, "utf-8");
+	if (!existsSync(notesPath)) writeFileSync(notesPath, `# gnhf run: ${runId}\n\nObjective: see .gnhf/runs/${runId}/prompt.md\n\n## Iteration Log\n`, "utf-8");
 	const schemaPath = join(runDir, "output-schema.json");
-	writeSchemaFile(schemaPath);
+	writeSchemaFile(schemaPath, schemaOptions.includeStopField);
 	const logPath = join(runDir, LOG_FILENAME);
 	const baseCommitPath = join(runDir, "base-commit");
 	const hasStoredBaseCommit = existsSync(baseCommitPath);
@@ -500,13 +507,13 @@ function setupRun(runId, prompt, baseCommit, cwd) {
 		baseCommitPath
 	};
 }
-function resumeRun(runId, cwd) {
+function resumeRun(runId, cwd, schemaOptions) {
 	const runDir = join(cwd, ".gnhf", "runs", runId);
 	if (!existsSync(runDir)) throw new Error(`Run directory not found: ${runDir}`);
 	const promptPath = join(runDir, "prompt.md");
 	const notesPath = join(runDir, "notes.md");
 	const schemaPath = join(runDir, "output-schema.json");
-	writeSchemaFile(schemaPath);
+	writeSchemaFile(schemaPath, schemaOptions.includeStopField);
 	const logPath = join(runDir, LOG_FILENAME);
 	const baseCommitPath = join(runDir, "base-commit");
 	return {
@@ -1068,7 +1075,7 @@ function terminateClaudeProcess(child, platform) {
 	}
 	child.kill("SIGTERM");
 }
-function buildClaudeArgs(prompt, extraArgs) {
+function buildClaudeArgs(prompt, schema, extraArgs) {
 	const userArgs = extraArgs ?? [];
 	const userSpecifiedPermissionMode = userArgs.some((arg) => arg === "--dangerously-skip-permissions" || arg === "--permission-mode" || arg.startsWith("--permission-mode=") || arg === "--permission-prompt-tool" || arg.startsWith("--permission-prompt-tool="));
 	return [
@@ -1079,7 +1086,7 @@ function buildClaudeArgs(prompt, extraArgs) {
 		"--output-format",
 		"stream-json",
 		"--json-schema",
-		JSON.stringify(AGENT_OUTPUT_SCHEMA),
+		JSON.stringify(schema),
 		...userSpecifiedPermissionMode ? [] : ["--dangerously-skip-permissions"]
 	];
 }
@@ -1102,17 +1109,19 @@ var ClaudeAgent = class {
 	bin;
 	extraArgs;
 	platform;
+	schema;
 	constructor(binOrDeps = {}) {
 		const deps = typeof binOrDeps === "string" ? { bin: binOrDeps } : binOrDeps;
 		this.bin = deps.bin ?? "claude";
 		this.extraArgs = deps.extraArgs;
 		this.platform = deps.platform ?? process.platform;
+		this.schema = deps.schema ?? buildAgentOutputSchema({ includeStopField: false });
 	}
 	run(prompt, cwd, options) {
 		const { onUsage, onMessage, signal, logPath } = options ?? {};
 		return new Promise((resolve, reject) => {
 			const logStream = logPath ? createWriteStream(logPath) : null;
-			const child = spawn(this.bin, buildClaudeArgs(prompt, this.extraArgs), {
+			const child = spawn(this.bin, buildClaudeArgs(prompt, this.schema, this.extraArgs), {
 				cwd,
 				shell: shouldUseWindowsShell$2(this.bin, this.platform),
 				stdio: [
@@ -1124,6 +1133,7 @@ var ClaudeAgent = class {
 			});
 			if (setupAbortHandler(signal, child, reject, () => terminateClaudeProcess(child, this.platform))) return;
 			let resultEvent = null;
+			let latestResultUsage = null;
 			const cumulative = {
 				inputTokens: 0,
 				outputTokens: 0,
@@ -1192,7 +1202,11 @@ var ClaudeAgent = class {
 						}
 					}
 				}
-				if (event.type === "result") resultEvent = event;
+				if (event.type === "result") {
+					const next = event;
+					latestResultUsage = next.usage;
+					if (next.is_error || next.subtype !== "success" || next.structured_output || !resultEvent) resultEvent = next;
+				}
 			});
 			setupChildProcessHandlers(child, "claude", logStream, reject, () => {
 				if (!resultEvent) {
@@ -1208,7 +1222,7 @@ var ClaudeAgent = class {
 					return;
 				}
 				const output = resultEvent.structured_output;
-				const usage = toTokenUsage(resultEvent.usage);
+				const usage = toTokenUsage(latestResultUsage ?? resultEvent.usage);
 				onUsage?.(usage);
 				resolve({
 					output,
@@ -1339,25 +1353,27 @@ const BLANKET_PERMISSION_RULESET = [{
 	pattern: "*",
 	action: "allow"
 }];
-const STRUCTURED_OUTPUT_FORMAT = {
-	type: "json_schema",
-	schema: AGENT_OUTPUT_SCHEMA,
-	retryCount: 1
-};
+function buildStructuredOutputFormat(schema) {
+	return {
+		type: "json_schema",
+		schema,
+		retryCount: 1
+	};
+}
 function buildOpencodeChildEnv() {
 	const env = { ...process.env };
 	delete env.OPENCODE_SERVER_USERNAME;
 	delete env.OPENCODE_SERVER_PASSWORD;
 	return env;
 }
-function buildPrompt(prompt) {
+function buildPrompt(prompt, schema) {
 	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)}`
+		`The JSON must match this schema exactly: ${JSON.stringify(schema)}`
 	].join("\n");
 }
 /**
@@ -1452,6 +1468,7 @@ var OpenCodeAgent = class {
 	getPortFn;
 	killProcessFn;
 	platform;
+	schema;
 	spawnFn;
 	server = null;
 	closingPromise = null;
@@ -1462,6 +1479,7 @@ var OpenCodeAgent = class {
 		this.getPortFn = deps.getPort ?? getAvailablePort$1;
 		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
 		this.platform = deps.platform ?? process.platform;
+		this.schema = deps.schema ?? buildAgentOutputSchema({ includeStopField: false });
 		this.spawnFn = deps.spawn ?? spawn;
 	}
 	async run(prompt, cwd, options) {
@@ -1487,7 +1505,7 @@ var OpenCodeAgent = class {
 		try {
 			const server = await this.ensureServer(cwd, runController.signal);
 			sessionId = await this.createSession(server, cwd, runController.signal);
-			const result = await this.streamMessage(server, sessionId, buildPrompt(prompt), runController.signal, logStream, onUsage, onMessage);
+			const result = await this.streamMessage(server, sessionId, buildPrompt(prompt, this.schema), runController.signal, logStream, onUsage, onMessage);
 			appendDebugLog("opencode:run:end", {
 				sessionId,
 				elapsedMs: Date.now() - runStartedAt,
@@ -1764,7 +1782,7 @@ var OpenCodeAgent = class {
 							type: "text",
 							text: prompt
 						}],
-						format: STRUCTURED_OUTPUT_FORMAT
+						format: buildStructuredOutputFormat(this.schema)
 					},
 					signal
 				});
@@ -2757,11 +2775,13 @@ function withTimeoutSignal(signal, timeoutMs) {
 }
 //#endregion
 //#region src/core/agents/factory.ts
-function createAgent(name, runInfo, pathOverride, agentArgsOverride) {
+function createAgent(name, runInfo, pathOverride, agentArgsOverride, options) {
+	const schema = buildAgentOutputSchema({ includeStopField: options.includeStopField });
 	switch (name) {
 		case "claude": return new ClaudeAgent({
 			bin: pathOverride,
-			extraArgs: agentArgsOverride
+			extraArgs: agentArgsOverride,
+			schema
 		});
 		case "codex": return new CodexAgent(runInfo.schemaPath, {
 			bin: pathOverride,
@@ -2769,7 +2789,8 @@ function createAgent(name, runInfo, pathOverride, agentArgsOverride) {
 		});
 		case "opencode": return new OpenCodeAgent({
 			bin: pathOverride,
-			extraArgs: agentArgsOverride
+			extraArgs: agentArgsOverride,
+			schema
 		});
 		case "rovodev": return new RovoDevAgent(runInfo.schemaPath, {
 			bin: pathOverride,
@@ -2787,7 +2808,7 @@ function buildIterationPrompt(params) {
 		"- key_learnings: an array of new learnings that were surprising, weren't captured by previous notes and would be informative for future iterations"
 	];
 	if (params.stopWhen !== void 0) outputFields.push("- should_fully_stop: set to true ONLY when the stop condition below is fully met and the entire loop should end. default to false");
-	const stopConditionSection = params.stopWhen !== void 0 ? `\n\n## Stop Condition\n\nThe user has configured a condition to end the loop: ${params.stopWhen}\nIf this condition is fully met after this iteration's work, set should_fully_stop=true in your output. Otherwise set it to false (or omit it).` : "";
+	const stopConditionSection = params.stopWhen !== void 0 ? `\n\n## Stop Condition\n\nThe user has configured a condition to end the loop: ${params.stopWhen}\nIf this condition is fully met after this iteration's work, set should_fully_stop=true in your output. Otherwise set it to false.` : "";
 	return `You are working autonomously towards an objective given below.
 This is iteration ${params.n}. Each iteration aims to make an incremental step forward, not to complete the entire objective.
 
@@ -2833,6 +2854,7 @@ var Orchestrator = class extends EventEmitter {
 		successCount: 0,
 		failCount: 0,
 		consecutiveFailures: 0,
+		consecutiveErrors: 0,
 		startTime: /* @__PURE__ */ new Date(),
 		waitingUntil: null,
 		lastMessage: null
@@ -2977,14 +2999,14 @@ var Orchestrator = class extends EventEmitter {
 					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);
+				if (this.state.consecutiveErrors > 0 && !this.stopRequested) {
+					const backoffMs = 6e4 * Math.pow(2, this.state.consecutiveErrors - 1);
 					this.state.status = "waiting";
 					this.state.waitingUntil = new Date(Date.now() + backoffMs);
 					this.emit("state", this.getState());
 					appendDebugLog("backoff:start", {
 						iteration: this.state.currentIteration,
-						consecutiveFailures: this.state.consecutiveFailures,
+						consecutiveErrors: this.state.consecutiveErrors,
 						backoffMs
 					});
 					await this.interruptibleSleep(backoffMs);
@@ -3072,7 +3094,7 @@ var Orchestrator = class extends EventEmitter {
 			};
 			return {
 				type: "completed",
-				record: this.recordFailure(`[FAIL] ${result.output.summary}`, result.output.summary, toStringArray(result.output.key_learnings)),
+				record: this.recordFailure(`[FAIL] ${result.output.summary}`, result.output.summary, toStringArray(result.output.key_learnings), "reported"),
 				shouldFullyStop
 			};
 		} catch (err) {
@@ -3104,7 +3126,7 @@ var Orchestrator = class extends EventEmitter {
 			const summary = err instanceof Error ? err.message : String(err);
 			return {
 				type: "completed",
-				record: this.recordFailure(`[ERROR] ${summary}`, summary, []),
+				record: this.recordFailure(`[ERROR] ${summary}`, summary, [], "error"),
 				shouldFullyStop: false
 			};
 		} finally {
@@ -3118,6 +3140,7 @@ var Orchestrator = class extends EventEmitter {
 		this.state.commitCount = getBranchCommitCount(this.runInfo.baseCommit, this.cwd);
 		this.state.successCount++;
 		this.state.consecutiveFailures = 0;
+		this.state.consecutiveErrors = 0;
 		return {
 			number: this.state.currentIteration,
 			success: true,
@@ -3127,11 +3150,13 @@ var Orchestrator = class extends EventEmitter {
 			timestamp: /* @__PURE__ */ new Date()
 		};
 	}
-	recordFailure(notesSummary, recordSummary, learnings) {
+	recordFailure(notesSummary, recordSummary, learnings, kind) {
 		appendNotes(this.runInfo.notesPath, this.state.currentIteration, notesSummary, [], toStringArray(learnings));
 		resetHard(this.cwd);
 		this.state.failCount++;
 		this.state.consecutiveFailures++;
+		if (kind === "error") this.state.consecutiveErrors++;
+		else this.state.consecutiveErrors = 0;
 		return {
 			number: this.state.currentIteration,
 			success: false,
@@ -3264,6 +3289,7 @@ var MockOrchestrator = class extends EventEmitter {
 		successCount: 11,
 		failCount: 2,
 		consecutiveFailures: 0,
+		consecutiveErrors: 0,
 		startTime: new Date(Date.now() - INITIAL_ELAPSED_MS),
 		waitingUntil: null,
 		lastMessage: AGENT_MESSAGES[0]
@@ -3998,6 +4024,12 @@ 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";
+var PromptSignalError = class extends Error {
+	constructor(signal) {
+		super(signal);
+		this.signal = signal;
+	}
+};
 function parseNonNegativeInteger(value) {
 	if (!/^\d+$/.test(value)) throw new InvalidArgumentError("must be a non-negative integer");
 	const parsed = Number.parseInt(value, 10);
@@ -4013,15 +4045,15 @@ 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;
 }
-function initializeNewBranch(prompt, cwd) {
+function initializeNewBranch(prompt, cwd, schemaOptions) {
 	ensureCleanWorkingTree(cwd);
 	const baseCommit = getHeadCommit(cwd);
 	const branchName = slugifyPrompt(prompt);
 	createBranch(branchName, cwd);
 	const runId = branchName.split("/")[1];
-	return setupRun(runId, prompt, baseCommit, cwd);
+	return setupRun(runId, prompt, baseCommit, cwd, schemaOptions);
 }
-function initializeWorktreeRun(prompt, cwd) {
+function initializeWorktreeRun(prompt, cwd, schemaOptions) {
 	const repoRoot = getRepoRootDir(cwd);
 	const baseCommit = getHeadCommit(cwd);
 	const branchName = slugifyPrompt(prompt);
@@ -4029,19 +4061,80 @@ function initializeWorktreeRun(prompt, cwd) {
 	const worktreePath = join(dirname(repoRoot), `${basename(repoRoot)}-gnhf-worktrees`, runId);
 	createWorktree(repoRoot, worktreePath, branchName);
 	return {
-		runInfo: setupRun(runId, prompt, baseCommit, worktreePath),
+		runInfo: setupRun(runId, prompt, baseCommit, worktreePath, schemaOptions),
 		worktreePath,
 		effectiveCwd: worktreePath
 	};
 }
-function ask(question) {
-	const rl = createInterface({
+function openPromptTerminal() {
+	if (process$1.stdin.isTTY) return {
 		input: process$1.stdin,
-		output: process$1.stderr
+		output: process$1.stderr,
+		cleanup: () => {}
+	};
+	const inputPath = process$1.platform === "win32" ? "CONIN$" : "/dev/tty";
+	const outputPath = process$1.platform === "win32" ? "CONOUT$" : "/dev/tty";
+	const inputFd = openSync(inputPath, "r");
+	try {
+		const outputFd = openSync(outputPath, "w");
+		try {
+			const input = createReadStream("", {
+				autoClose: true,
+				fd: inputFd
+			});
+			const output = createWriteStream("", {
+				autoClose: true,
+				fd: outputFd
+			});
+			return {
+				input,
+				output,
+				cleanup: () => {
+					input.destroy();
+					output.destroy();
+				}
+			};
+		} catch (error) {
+			closeSync(outputFd);
+			throw error;
+		}
+	} catch (error) {
+		closeSync(inputFd);
+		throw error;
+	}
+}
+function ask(question, closeMessage, unavailableMessage) {
+	let terminal;
+	try {
+		terminal = openPromptTerminal();
+	} catch {
+		throw new Error(unavailableMessage);
+	}
+	const rl = createInterface({
+		input: terminal.input,
+		output: terminal.output
 	});
-	return new Promise((resolve) => {
+	return new Promise((resolve, reject) => {
+		const handleClose = () => {
+			terminal.cleanup();
+			rl.off("close", handleClose);
+			rl.off("SIGINT", handleSigInt);
+			reject(new Error(closeMessage));
+		};
+		const handleSigInt = () => {
+			rl.off("close", handleClose);
+			rl.off("SIGINT", handleSigInt);
+			rl.close();
+			terminal.cleanup();
+			reject(new PromptSignalError("SIGINT"));
+		};
+		rl.once("close", handleClose);
+		rl.once("SIGINT", handleSigInt);
 		rl.question(question, (answer) => {
+			rl.off("close", handleClose);
+			rl.off("SIGINT", handleSigInt);
 			rl.close();
+			terminal.cleanup();
 			resolve(answer.trim().toLowerCase());
 		});
 	});
@@ -4135,6 +4228,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 	let worktreeCleanup = null;
 	const currentBranch = getCurrentBranch(cwd);
 	const onGnhfBranch = currentBranch.startsWith("gnhf/");
+	const schemaOptions = { includeStopField: options.stopWhen !== void 0 };
 	let runInfo;
 	let startIteration = 0;
 	if (options.worktree) {
@@ -4146,7 +4240,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			console.error("Cannot use --worktree from a gnhf branch. Switch to the base branch first.");
 			process$1.exit(1);
 		}
-		const wt = initializeWorktreeRun(prompt, cwd);
+		const wt = initializeWorktreeRun(prompt, cwd, schemaOptions);
 		runInfo = wt.runInfo;
 		effectiveCwd = wt.effectiveCwd;
 		worktreePath = wt.worktreePath;
@@ -4161,18 +4255,19 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		});
 	} else if (onGnhfBranch) {
 		const existingRunId = currentBranch.slice(5);
-		const existing = resumeRun(existingRunId, cwd);
+		const existing = resumeRun(existingRunId, cwd, schemaOptions);
 		const existingPrompt = readFileSync(existing.promptPath, "utf-8");
 		if (!prompt || prompt === existingPrompt) {
 			prompt = existingPrompt;
 			runInfo = existing;
 			startIteration = getLastIterationNumber(existing);
 		} else {
-			const answer = await ask(`You are on gnhf branch "${currentBranch}".\n  (o) Overwrite current run with new prompt\n  (n) Start a new branch on top of this one\n  (q) Quit\nChoose [o/n/q]: `);
+			const answer = await ask(`You are on gnhf branch "${currentBranch}".\n  (o) Update prompt and continue current run\n  (n) Start a new branch on top of this one\n  (q) Quit\nChoose [o/n/q]: `, "The overwrite prompt closed before a choice was entered. Re-run gnhf from an interactive terminal and choose o, n, or q.", "Cannot show the overwrite prompt because stdin is not interactive. Re-run gnhf from an interactive terminal and choose o, n, or q.");
 			if (answer === "o") {
 				ensureCleanWorkingTree(cwd);
-				runInfo = setupRun(existingRunId, prompt, existing.baseCommit, cwd);
-			} else if (answer === "n") runInfo = initializeNewBranch(prompt, cwd);
+				runInfo = setupRun(existingRunId, prompt, existing.baseCommit, cwd, schemaOptions);
+				startIteration = getLastIterationNumber(existing);
+			} else if (answer === "n") runInfo = initializeNewBranch(prompt, cwd, schemaOptions);
 			else process$1.exit(0);
 		}
 	} else {
@@ -4180,7 +4275,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			program.help();
 			return;
 		}
-		runInfo = initializeNewBranch(prompt, cwd);
+		runInfo = initializeNewBranch(prompt, cwd, schemaOptions);
 	}
 	let sleepPreventionCleanup = null;
 	if (config.preventSleep) {
@@ -4217,7 +4312,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		nodeVersion: process$1.version,
 		gnhfVersion: packageVersion
 	});
-	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo, config.agentPathOverride[config.agent], config.agentArgsOverride?.[config.agent]), runInfo, prompt, effectiveCwd, startIteration, {
+	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo, config.agentPathOverride[config.agent], config.agentArgsOverride?.[config.agent], schemaOptions), runInfo, prompt, effectiveCwd, startIteration, {
 		maxIterations: options.maxIterations,
 		maxTokens: options.maxTokens,
 		stopWhen: options.stopWhen
@@ -4301,6 +4396,7 @@ function die(message) {
 try {
 	await program.parseAsync();
 } catch (err) {
+	if (err instanceof PromptSignalError) process$1.exit(getSignalExitCode(err.signal));
 	die(err instanceof Error ? err.message : String(err));
 }
 //#endregion

package/package.json

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