gnhf 0.1.2 → 0.1.4

package/README.md

@@ -39,11 +39,11 @@
   <img src="docs/splash.png" alt="gnhf — Good Night, Have Fun" width="800">
 </p>
 
-gnhf is a [ralph loop](https://ghuntley.com/ralph/) orchestrator that keeps your agents running while you sleep — each iteration makes one small, committed, documented change towards an objective.
+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
-- **Autonomous by design** — each iteration is committed on success, rolled back on failure, with exponential backoff and auto-abort after consecutive failures
+- **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
 
 ## Quick Start
@@ -117,22 +117,24 @@ npm link
 
 - **Incremental commits** — each successful iteration is a separate git commit, so you can cherry-pick or revert individual changes
 - **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
 
 ## CLI Reference
 
-| Command                 | Description                                     |
-| ----------------------- | ----------------------------------------------- |
-| `gnhf "<prompt>"`       | Start a new run with the given objective        |
-| `gnhf`                  | Resume a run (when on an existing gnhf/ branch) |
-| `echo "prompt" \| gnhf` | Pipe prompt via stdin                           |
+| Command                   | Description                                     |
+| ------------------------- | ----------------------------------------------- |
+| `gnhf "<prompt>"`         | Start a new run with the given objective        |
+| `gnhf`                    | Resume a run (when on an existing gnhf/ branch) |
+| `echo "<prompt>" \| gnhf` | Pipe prompt via stdin                           |
+| `cat prd.md \| gnhf`      | Pipe a large spec or PRD via stdin              |
 
 ### Flags
 
-| Flag              | Description                        | Default  |
-| ----------------- | ---------------------------------- | -------- |
-| `--agent <agent>` | Agent to use (`claude` or `codex`) | `claude` |
-| `--version`       | Show version                       |          |
+| Flag              | Description                        | Default                |
+| ----------------- | ---------------------------------- | ---------------------- |
+| `--agent <agent>` | Agent to use (`claude` or `codex`) | config file (`claude`) |
+| `--version`       | Show version                       |                        |
 
 ## Configuration
 
@@ -146,6 +148,8 @@ agent: claude
 maxConsecutiveFailures: 3
 ```
 
+If the file does not exist yet, `gnhf` creates it on first run using the resolved defaults.
+
 CLI flags override config file values.
 
 ## Development

package/dist/cli.mjs

@@ -3,10 +3,10 @@ import { appendFileSync, createWriteStream, existsSync, mkdirSync, readFileSync,
 import process$1 from "node:process";
 import { createInterface } from "node:readline";
 import { Command } from "commander";
-import { join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import { homedir } from "node:os";
 import yaml from "js-yaml";
-import { execSync, spawn } from "node:child_process";
+import { execFileSync, execSync, spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
 //#region src/core/config.ts
@@ -14,18 +14,39 @@ const DEFAULT_CONFIG = {
 	agent: "claude",
 	maxConsecutiveFailures: 3
 };
+function isMissingConfigError(error) {
+	if (!(error instanceof Error)) return false;
+	return "code" in error ? error.code === "ENOENT" : error.message.includes("ENOENT");
+}
+function serializeConfig(config) {
+	return `# Agent to use by default
+agent: ${config.agent}
+
+# Abort after this many consecutive failures
+maxConsecutiveFailures: ${config.maxConsecutiveFailures}
+`;
+}
 function loadConfig(overrides) {
-	const configPath = join(homedir(), ".gnhf", "config.yml");
+	const configDir = join(homedir(), ".gnhf");
+	const configPath = join(configDir, "config.yml");
 	let fileConfig = {};
+	let shouldBootstrapConfig = false;
 	try {
 		const raw = readFileSync(configPath, "utf-8");
 		fileConfig = yaml.load(raw) ?? {};
-	} catch {}
-	return {
+	} catch (error) {
+		if (isMissingConfigError(error)) shouldBootstrapConfig = true;
+	}
+	const resolvedConfig = {
 		...DEFAULT_CONFIG,
 		...fileConfig,
 		...overrides
 	};
+	if (shouldBootstrapConfig) try {
+		mkdirSync(configDir, { recursive: true });
+		writeFileSync(configPath, serializeConfig(resolvedConfig), "utf-8");
+	} catch {}
+	return resolvedConfig;
 }
 //#endregion
 //#region src/core/git.ts
@@ -45,6 +66,28 @@ function ensureCleanWorkingTree(cwd) {
 function createBranch(branchName, cwd) {
 	git(`checkout -b ${branchName}`, cwd);
 }
+function getHeadCommit(cwd) {
+	return git("rev-parse HEAD", cwd);
+}
+function findLegacyRunBaseCommit(runId, cwd) {
+	try {
+		const marker = git("log --first-parent --reverse --format=%H%x09%s HEAD", cwd).split("\n").map((line) => {
+			const [sha, ...subjectParts] = line.split("	");
+			return {
+				sha,
+				subject: subjectParts.join("	")
+			};
+		}).find(({ subject }) => subject === `gnhf: initialize run ${runId}` || subject === `gnhf: overwrite run ${runId}`);
+		if (!marker?.sha) return null;
+		return git(`rev-parse ${marker.sha}^`, cwd);
+	} catch {
+		return null;
+	}
+}
+function getBranchCommitCount(baseCommit, cwd) {
+	if (!baseCommit) return 0;
+	return Number.parseInt(git(`rev-list --count --first-parent ${baseCommit}..HEAD`, cwd), 10);
+}
 function commitAll(message, cwd) {
 	git("add -A", cwd);
 	try {
@@ -56,8 +99,8 @@ function resetHard(cwd) {
 	git("clean -fd", cwd);
 }
 //#endregion
-//#region src/core/run.ts
-const OUTPUT_SCHEMA$1 = JSON.stringify({
+//#region src/core/agents/types.ts
+const AGENT_OUTPUT_SCHEMA = {
 	type: "object",
 	properties: {
 		success: { type: "boolean" },
@@ -77,17 +120,29 @@ const OUTPUT_SCHEMA$1 = JSON.stringify({
 		"key_changes_made",
 		"key_learnings"
 	]
-}, null, 2);
-function ensureGitignore(cwd) {
-	const gitignorePath = join(cwd, ".gitignore");
+};
+//#endregion
+//#region src/core/run.ts
+function ensureRunMetadataIgnored(cwd) {
+	const excludePath = execFileSync("git", [
+		"rev-parse",
+		"--git-path",
+		"info/exclude"
+	], {
+		cwd,
+		encoding: "utf-8"
+	}).trim();
+	const resolved = isAbsolute(excludePath) ? excludePath : join(cwd, excludePath);
 	const entry = ".gnhf/runs/";
-	if (existsSync(gitignorePath)) {
-		if (readFileSync(gitignorePath, "utf-8").split("\n").some((line) => line.trim() === entry)) return;
-		appendFileSync(gitignorePath, `\n${entry}\n`, "utf-8");
-	} else writeFileSync(gitignorePath, `${entry}\n`, "utf-8");
+	mkdirSync(dirname(resolved), { recursive: true });
+	if (existsSync(resolved)) {
+		const content = readFileSync(resolved, "utf-8");
+		if (content.split("\n").some((line) => line.trim() === entry)) return;
+		appendFileSync(resolved, `${content.length > 0 && !content.endsWith("\n") ? "\n" : ""}${entry}\n`, "utf-8");
+	} else writeFileSync(resolved, `${entry}\n`, "utf-8");
 }
-function setupRun(runId, prompt, cwd) {
-	ensureGitignore(cwd);
+function setupRun(runId, prompt, baseCommit, cwd) {
+	ensureRunMetadataIgnored(cwd);
 	const runDir = join(cwd, ".gnhf", "runs", runId);
 	mkdirSync(runDir, { recursive: true });
 	const promptPath = join(runDir, "prompt.md");
@@ -95,26 +150,43 @@ function setupRun(runId, prompt, 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, OUTPUT_SCHEMA$1, "utf-8");
+	writeFileSync(schemaPath, JSON.stringify(AGENT_OUTPUT_SCHEMA, null, 2), "utf-8");
+	const baseCommitPath = join(runDir, "base-commit");
+	const hasStoredBaseCommit = existsSync(baseCommitPath);
+	const resolvedBaseCommit = hasStoredBaseCommit ? readFileSync(baseCommitPath, "utf-8").trim() : baseCommit;
+	if (!hasStoredBaseCommit) writeFileSync(baseCommitPath, `${baseCommit}\n`, "utf-8");
 	return {
 		runId,
 		runDir,
 		promptPath,
 		notesPath,
-		schemaPath
+		schemaPath,
+		baseCommit: resolvedBaseCommit,
+		baseCommitPath
 	};
 }
 function resumeRun(runId, cwd) {
 	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");
+	const baseCommitPath = join(runDir, "base-commit");
 	return {
 		runId,
 		runDir,
-		promptPath: join(runDir, "prompt.md"),
-		notesPath: join(runDir, "notes.md"),
-		schemaPath: join(runDir, "output-schema.json")
+		promptPath,
+		notesPath,
+		schemaPath,
+		baseCommit: existsSync(baseCommitPath) ? readFileSync(baseCommitPath, "utf-8").trim() : backfillLegacyBaseCommit(runId, baseCommitPath, cwd),
+		baseCommitPath
 	};
 }
+function backfillLegacyBaseCommit(runId, baseCommitPath, cwd) {
+	const baseCommit = findLegacyRunBaseCommit(runId, cwd) ?? getHeadCommit(cwd);
+	writeFileSync(baseCommitPath, `${baseCommit}\n`, "utf-8");
+	return baseCommit;
+}
 function getLastIterationNumber(runInfo) {
 	const files = readdirSync(runInfo.runDir);
 	let max = 0;
@@ -127,37 +199,81 @@ function getLastIterationNumber(runInfo) {
 	}
 	return max;
 }
+function formatListSection(title, items) {
+	if (items.length === 0) return "";
+	return `**${title}:**\n${items.map((item) => `- ${item}`).join("\n")}\n`;
+}
 function appendNotes(notesPath, iteration, summary, changes, learnings) {
 	appendFileSync(notesPath, [
 		`\n### Iteration ${iteration}\n`,
 		`**Summary:** ${summary}\n`,
-		changes.length > 0 ? `**Changes:**\n${changes.map((c) => `- ${c}`).join("\n")}\n` : "",
-		learnings.length > 0 ? `**Learnings:**\n${learnings.map((l) => `- ${l}`).join("\n")}\n` : ""
+		formatListSection("Changes", changes),
+		formatListSection("Learnings", learnings)
 	].join("\n"), "utf-8");
 }
 //#endregion
-//#region src/core/agents/claude.ts
-const OUTPUT_SCHEMA = JSON.stringify({
-	type: "object",
-	properties: {
-		success: { type: "boolean" },
-		summary: { type: "string" },
-		key_changes_made: {
-			type: "array",
-			items: { type: "string" }
-		},
-		key_learnings: {
-			type: "array",
-			items: { type: "string" }
+//#region src/core/agents/stream-utils.ts
+/**
+* Wire stderr collection, spawn-error handling, and the common close-handler
+* prefix (logStream.end + non-zero exit code rejection) for a child process.
+* Calls `onSuccess` only when the process exits with code 0.
+*/
+function setupChildProcessHandlers(child, agentName, logStream, reject, onSuccess) {
+	let stderr = "";
+	child.stderr.on("data", (data) => {
+		stderr += data.toString();
+	});
+	child.on("error", (err) => {
+		reject(/* @__PURE__ */ new Error(`Failed to spawn ${agentName}: ${err.message}`));
+	});
+	child.on("close", (code) => {
+		logStream?.end();
+		if (code !== 0) {
+			reject(/* @__PURE__ */ new Error(`${agentName} exited with code ${code}: ${stderr}`));
+			return;
 		}
-	},
-	required: [
-		"success",
-		"summary",
-		"key_changes_made",
-		"key_learnings"
-	]
-});
+		onSuccess();
+	});
+}
+/**
+* Parse a JSONL stream, calling the callback for each parsed event.
+* Handles buffering of incomplete lines and skips unparseable lines.
+*/
+function parseJSONLStream(stream, logStream, callback) {
+	let buffer = "";
+	stream.on("data", (data) => {
+		logStream?.write(data);
+		buffer += data.toString();
+		const lines = buffer.split("\n");
+		buffer = lines.pop() ?? "";
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				callback(JSON.parse(line));
+			} catch {}
+		}
+	});
+}
+/**
+* Wire an AbortSignal to kill a child process.
+* Returns true if the signal was already aborted (caller should return early).
+*/
+function setupAbortHandler(signal, child, reject) {
+	if (!signal) return false;
+	const onAbort = () => {
+		child.kill("SIGTERM");
+		reject(/* @__PURE__ */ new Error("Agent was aborted"));
+	};
+	if (signal.aborted) {
+		onAbort();
+		return true;
+	}
+	signal.addEventListener("abort", onAbort, { once: true });
+	child.on("close", () => signal.removeEventListener("abort", onAbort));
+	return false;
+}
+//#endregion
+//#region src/core/agents/claude.ts
 var ClaudeAgent = class {
 	name = "claude";
 	run(prompt, cwd, options) {
@@ -171,7 +287,7 @@ var ClaudeAgent = class {
 				"--output-format",
 				"stream-json",
 				"--json-schema",
-				OUTPUT_SCHEMA,
+				JSON.stringify(AGENT_OUTPUT_SCHEMA),
 				"--dangerously-skip-permissions"
 			], {
 				cwd,
@@ -182,20 +298,7 @@ var ClaudeAgent = class {
 				],
 				env: process.env
 			});
-			if (signal) {
-				const onAbort = () => {
-					child.kill("SIGTERM");
-					reject(/* @__PURE__ */ new Error("Agent was aborted"));
-				};
-				if (signal.aborted) {
-					onAbort();
-					return;
-				}
-				signal.addEventListener("abort", onAbort, { once: true });
-				child.on("close", () => signal.removeEventListener("abort", onAbort));
-			}
-			let stderr = "";
-			let buffer = "";
+			if (setupAbortHandler(signal, child, reject)) return;
 			let resultEvent = null;
 			const cumulative = {
 				inputTokens: 0,
@@ -203,45 +306,24 @@ var ClaudeAgent = class {
 				cacheReadTokens: 0,
 				cacheCreationTokens: 0
 			};
-			child.stdout.on("data", (data) => {
-				logStream?.write(data);
-				buffer += data.toString();
-				const lines = buffer.split("\n");
-				buffer = lines.pop() ?? "";
-				for (const line of lines) {
-					if (!line.trim()) continue;
-					try {
-						const event = JSON.parse(line);
-						if (event.type === "assistant") {
-							const msg = event.message;
-							cumulative.inputTokens += (msg.usage.input_tokens ?? 0) + (msg.usage.cache_read_input_tokens ?? 0);
-							cumulative.outputTokens += msg.usage.output_tokens ?? 0;
-							cumulative.cacheReadTokens += msg.usage.cache_read_input_tokens ?? 0;
-							cumulative.cacheCreationTokens += msg.usage.cache_creation_input_tokens ?? 0;
-							onUsage?.({ ...cumulative });
-							if (onMessage) {
-								const content = msg.content;
-								if (Array.isArray(content)) {
-									for (const block of content) if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) onMessage(block.text.trim());
-								}
-							}
+			parseJSONLStream(child.stdout, logStream, (event) => {
+				if (event.type === "assistant") {
+					const msg = event.message;
+					cumulative.inputTokens += (msg.usage.input_tokens ?? 0) + (msg.usage.cache_read_input_tokens ?? 0);
+					cumulative.outputTokens += msg.usage.output_tokens ?? 0;
+					cumulative.cacheReadTokens += msg.usage.cache_read_input_tokens ?? 0;
+					cumulative.cacheCreationTokens += msg.usage.cache_creation_input_tokens ?? 0;
+					onUsage?.({ ...cumulative });
+					if (onMessage) {
+						const content = msg.content;
+						if (Array.isArray(content)) {
+							for (const block of content) if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) onMessage(block.text.trim());
 						}
-						if (event.type === "result") resultEvent = event;
-					} catch {}
+					}
 				}
+				if (event.type === "result") resultEvent = event;
 			});
-			child.stderr.on("data", (data) => {
-				stderr += data.toString();
-			});
-			child.on("error", (err) => {
-				reject(/* @__PURE__ */ new Error(`Failed to spawn claude: ${err.message}`));
-			});
-			child.on("close", (code) => {
-				logStream?.end();
-				if (code !== 0) {
-					reject(/* @__PURE__ */ new Error(`claude exited with code ${code}: ${stderr}`));
-					return;
-				}
+			setupChildProcessHandlers(child, "claude", logStream, reject, () => {
 				if (!resultEvent) {
 					reject(/* @__PURE__ */ new Error("claude returned no result event"));
 					return;
@@ -300,64 +382,28 @@ var CodexAgent = class {
 				],
 				env: process.env
 			});
-			if (signal) {
-				const onAbort = () => {
-					child.kill("SIGTERM");
-					reject(/* @__PURE__ */ new Error("Agent was aborted"));
-				};
-				if (signal.aborted) {
-					onAbort();
-					return;
-				}
-				signal.addEventListener("abort", onAbort, { once: true });
-				child.on("close", () => signal.removeEventListener("abort", onAbort));
-			}
-			let stderr = "";
+			if (setupAbortHandler(signal, child, reject)) return;
 			let lastAgentMessage = null;
-			const usages = [];
-			let buffer = "";
-			child.stdout.on("data", (data) => {
-				logStream?.write(data);
-				buffer += data.toString();
-				const lines = buffer.split("\n");
-				buffer = lines.pop() ?? "";
-				for (const line of lines) {
-					if (!line.trim()) continue;
-					try {
-						const event = JSON.parse(line);
-						if (event.type === "item.completed" && "item" in event && event.item.type === "agent_message") {
-							lastAgentMessage = event.item.text;
-							onMessage?.(lastAgentMessage);
-						}
-						if (event.type === "turn.completed" && "usage" in event) {
-							usages.push(event.usage);
-							if (onUsage) onUsage(usages.reduce((acc, u) => ({
-								inputTokens: acc.inputTokens + (u.input_tokens ?? 0),
-								outputTokens: acc.outputTokens + (u.output_tokens ?? 0),
-								cacheReadTokens: acc.cacheReadTokens + (u.cached_input_tokens ?? 0),
-								cacheCreationTokens: 0
-							}), {
-								inputTokens: 0,
-								outputTokens: 0,
-								cacheReadTokens: 0,
-								cacheCreationTokens: 0
-							}));
-						}
-					} catch {}
+			const cumulative = {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0
+			};
+			parseJSONLStream(child.stdout, logStream, (event) => {
+				if (event.type === "item.completed" && "item" in event && event.item.type === "agent_message") {
+					lastAgentMessage = event.item.text;
+					onMessage?.(lastAgentMessage);
 				}
-			});
-			child.stderr.on("data", (data) => {
-				stderr += data.toString();
-			});
-			child.on("error", (err) => {
-				reject(/* @__PURE__ */ new Error(`Failed to spawn codex: ${err.message}`));
-			});
-			child.on("close", (code) => {
-				logStream?.end();
-				if (code !== 0) {
-					reject(/* @__PURE__ */ new Error(`codex exited with code ${code}: ${stderr}`));
-					return;
+				if (event.type === "turn.completed" && "usage" in event) {
+					const u = event.usage;
+					cumulative.inputTokens += u.input_tokens ?? 0;
+					cumulative.outputTokens += u.output_tokens ?? 0;
+					cumulative.cacheReadTokens += u.cached_input_tokens ?? 0;
+					onUsage?.({ ...cumulative });
 				}
+			});
+			setupChildProcessHandlers(child, "codex", logStream, reject, () => {
 				if (!lastAgentMessage) {
 					reject(/* @__PURE__ */ new Error("codex returned no agent message"));
 					return;
@@ -365,17 +411,7 @@ var CodexAgent = class {
 				try {
 					resolve({
 						output: JSON.parse(lastAgentMessage),
-						usage: usages.reduce((acc, u) => ({
-							inputTokens: acc.inputTokens + (u.input_tokens ?? 0),
-							outputTokens: acc.outputTokens + (u.output_tokens ?? 0),
-							cacheReadTokens: acc.cacheReadTokens + (u.cached_input_tokens ?? 0),
-							cacheCreationTokens: acc.cacheCreationTokens
-						}), {
-							inputTokens: 0,
-							outputTokens: 0,
-							cacheReadTokens: 0,
-							cacheCreationTokens: 0
-						})
+						usage: cumulative
 					});
 				} catch (err) {
 					reject(/* @__PURE__ */ new Error(`Failed to parse codex output: ${err instanceof Error ? err.message : err}`));
@@ -432,6 +468,7 @@ var Orchestrator = class extends EventEmitter {
 		currentIteration: 0,
 		totalInputTokens: 0,
 		totalOutputTokens: 0,
+		commitCount: 0,
 		iterations: [],
 		successCount: 0,
 		failCount: 0,
@@ -448,6 +485,7 @@ var Orchestrator = class extends EventEmitter {
 		this.prompt = prompt;
 		this.cwd = cwd;
 		this.state.currentIteration = startIteration;
+		this.state.commitCount = getBranchCommitCount(this.runInfo.baseCommit, this.cwd);
 	}
 	getState() {
 		return { ...this.state };
@@ -474,69 +512,7 @@ var Orchestrator = class extends EventEmitter {
 				runId: this.runInfo.runId,
 				prompt: this.prompt
 			});
-			let record;
-			const baseInputTokens = this.state.totalInputTokens;
-			const baseOutputTokens = this.state.totalOutputTokens;
-			this.activeAbortController = new AbortController();
-			const onUsage = (usage) => {
-				this.state.totalInputTokens = baseInputTokens + usage.inputTokens;
-				this.state.totalOutputTokens = baseOutputTokens + usage.outputTokens;
-				this.emit("state", this.getState());
-			};
-			const onMessage = (text) => {
-				this.state.lastMessage = text;
-				this.emit("state", this.getState());
-			};
-			const logPath = join(this.runInfo.runDir, `iteration-${this.state.currentIteration}.jsonl`);
-			try {
-				const result = await this.agent.run(iterationPrompt, this.cwd, {
-					onUsage,
-					onMessage,
-					signal: this.activeAbortController.signal,
-					logPath
-				});
-				if (result.output.success) {
-					appendNotes(this.runInfo.notesPath, this.state.currentIteration, result.output.summary, result.output.key_changes_made, result.output.key_learnings);
-					commitAll(`gnhf #${this.state.currentIteration}: ${result.output.summary}`, this.cwd);
-					this.state.successCount++;
-					this.state.consecutiveFailures = 0;
-					record = {
-						number: this.state.currentIteration,
-						success: true,
-						summary: result.output.summary,
-						keyChanges: result.output.key_changes_made,
-						keyLearnings: result.output.key_learnings,
-						timestamp: /* @__PURE__ */ new Date()
-					};
-				} else {
-					appendNotes(this.runInfo.notesPath, this.state.currentIteration, `[FAIL] ${result.output.summary}`, [], result.output.key_learnings);
-					resetHard(this.cwd);
-					this.state.failCount++;
-					this.state.consecutiveFailures++;
-					record = {
-						number: this.state.currentIteration,
-						success: false,
-						summary: result.output.summary,
-						keyChanges: [],
-						keyLearnings: result.output.key_learnings,
-						timestamp: /* @__PURE__ */ new Date()
-					};
-				}
-			} catch (err) {
-				const summary = err instanceof Error ? err.message : String(err);
-				appendNotes(this.runInfo.notesPath, this.state.currentIteration, `[ERROR] ${summary}`, [], []);
-				resetHard(this.cwd);
-				this.state.failCount++;
-				this.state.consecutiveFailures++;
-				record = {
-					number: this.state.currentIteration,
-					success: false,
-					summary,
-					keyChanges: [],
-					keyLearnings: [],
-					timestamp: /* @__PURE__ */ new Date()
-				};
-			}
+			const record = await this.runIteration(iterationPrompt);
 			this.state.iterations.push(record);
 			this.emit("iteration:end", record);
 			this.emit("state", this.getState());
@@ -561,6 +537,63 @@ var Orchestrator = class extends EventEmitter {
 			}
 		}
 	}
+	async runIteration(prompt) {
+		const baseInputTokens = this.state.totalInputTokens;
+		const baseOutputTokens = this.state.totalOutputTokens;
+		this.activeAbortController = new AbortController();
+		const onUsage = (usage) => {
+			this.state.totalInputTokens = baseInputTokens + usage.inputTokens;
+			this.state.totalOutputTokens = baseOutputTokens + usage.outputTokens;
+			this.emit("state", this.getState());
+		};
+		const onMessage = (text) => {
+			this.state.lastMessage = text;
+			this.emit("state", this.getState());
+		};
+		const logPath = join(this.runInfo.runDir, `iteration-${this.state.currentIteration}.jsonl`);
+		try {
+			const result = await this.agent.run(prompt, this.cwd, {
+				onUsage,
+				onMessage,
+				signal: this.activeAbortController.signal,
+				logPath
+			});
+			if (result.output.success) return this.recordSuccess(result.output);
+			return this.recordFailure(`[FAIL] ${result.output.summary}`, result.output.summary, result.output.key_learnings);
+		} catch (err) {
+			const summary = err instanceof Error ? err.message : String(err);
+			return this.recordFailure(`[ERROR] ${summary}`, summary, []);
+		}
+	}
+	recordSuccess(output) {
+		appendNotes(this.runInfo.notesPath, this.state.currentIteration, output.summary, output.key_changes_made, output.key_learnings);
+		commitAll(`gnhf #${this.state.currentIteration}: ${output.summary}`, this.cwd);
+		this.state.commitCount = getBranchCommitCount(this.runInfo.baseCommit, this.cwd);
+		this.state.successCount++;
+		this.state.consecutiveFailures = 0;
+		return {
+			number: this.state.currentIteration,
+			success: true,
+			summary: output.summary,
+			keyChanges: output.key_changes_made,
+			keyLearnings: output.key_learnings,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+	}
+	recordFailure(notesSummary, recordSummary, learnings) {
+		appendNotes(this.runInfo.notesPath, this.state.currentIteration, notesSummary, [], learnings);
+		resetHard(this.cwd);
+		this.state.failCount++;
+		this.state.consecutiveFailures++;
+		return {
+			number: this.state.currentIteration,
+			success: false,
+			summary: recordSummary,
+			keyChanges: [],
+			keyLearnings: learnings,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+	}
 	interruptibleSleep(ms) {
 		return new Promise((resolve) => {
 			this.activeAbortController = new AbortController();
@@ -635,6 +668,7 @@ var MockOrchestrator = class extends EventEmitter {
 		currentIteration: 14,
 		totalInputTokens: 873e5,
 		totalOutputTokens: 86e4,
+		commitCount: 11,
 		iterations: [...MOCK_ITERATIONS],
 		successCount: 11,
 		failCount: 2,
@@ -725,14 +759,10 @@ function generateStarField(width, height, density, seed) {
 function getStarState(star, now) {
 	const t = (now % star.period / star.period + star.phase / (Math.PI * 2)) % 1;
 	if (t > .05) return star.rest;
-	if (star.rest === "bright") {
+	if (star.rest === "bright" || star.rest === "hidden") {
+		const opposite = star.rest === "bright" ? "hidden" : "bright";
 		if (t > .0325) return "dim";
-		if (t > .0175) return "hidden";
-		return "dim";
-	}
-	if (star.rest === "hidden") {
-		if (t > .0325) return "dim";
-		if (t > .0175) return "bright";
+		if (t > .0175) return opposite;
 		return "dim";
 	}
 	if (t > .025) return "bright";
@@ -906,6 +936,7 @@ const MOONS_PER_ROW = 30;
 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() {
 	return [
 		textToCells("g n h f", "dim"),
@@ -915,7 +946,8 @@ function renderTitleCells() {
 		textToCells("┗━┛┗━┛┗━┛╺┻┛   ╹ ╹╹┗━┛╹ ╹ ╹    ╹ ╹╹ ╹┗┛ ┗━╸   ╹  ┗━┛╹ ╹", "bold")
 	];
 }
-function renderStatsCells(elapsed, inputTokens, outputTokens) {
+function renderStatsCells(elapsed, inputTokens, outputTokens, commitCount) {
+	const commitLabel = commitCount === 1 ? "commit" : "commits";
 	return [
 		...textToCells(elapsed, "bold"),
 		...textToCells("  ", "normal"),
@@ -925,7 +957,11 @@ function renderStatsCells(elapsed, inputTokens, outputTokens) {
 		...textToCells("  ", "normal"),
 		...textToCells("·", "dim"),
 		...textToCells("  ", "normal"),
-		...textToCells(`${formatTokens(outputTokens)} out`, "normal")
+		...textToCells(`${formatTokens(outputTokens)} out`, "normal"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`${commitCount} ${commitLabel}`, "normal")
 	];
 }
 function renderAgentMessageCells(message, status) {
@@ -958,42 +994,31 @@ function starStyle(state) {
 	if (state === "dim") return "dim";
 	return "normal";
 }
-function renderStarLineCells(stars, width, y, now) {
-	const cells = emptyCells(width);
+function placeStarsInCells(cells, stars, row, xMin, xMax, xOffset, now) {
 	for (const star of stars) {
-		if (star.y !== y) continue;
+		if (star.y !== row || star.x < xMin || star.x >= xMax) continue;
 		const state = getStarState(star, now);
-		if (state === "hidden") cells[star.x] = {
+		const localX = star.x - xOffset;
+		cells[localX] = state === "hidden" ? {
 			char: " ",
 			style: "normal",
 			width: 1
-		};
-		else cells[star.x] = {
+		} : {
 			char: star.char,
 			style: starStyle(state),
 			width: 1
 		};
 	}
+}
+function renderStarLineCells(stars, width, y, now) {
+	const cells = emptyCells(width);
+	placeStarsInCells(cells, stars, y, 0, width, 0, now);
 	return cells;
 }
 function renderSideStarsCells(stars, rowIndex, xOffset, sideWidth, now) {
 	if (sideWidth <= 0) return [];
 	const cells = emptyCells(sideWidth);
-	for (const star of stars) {
-		if (star.y !== rowIndex || star.x < xOffset || star.x >= xOffset + sideWidth) continue;
-		const localX = star.x - xOffset;
-		const state = getStarState(star, now);
-		if (state === "hidden") cells[localX] = {
-			char: " ",
-			style: "normal",
-			width: 1
-		};
-		else cells[localX] = {
-			char: star.char,
-			style: starStyle(state),
-			width: 1
-		};
-	}
+	placeStarsInCells(cells, stars, rowIndex, xOffset, xOffset + sideWidth, xOffset, now);
 	return cells;
 }
 function centerLineCells(content, width) {
@@ -1006,6 +1031,19 @@ function centerLineCells(content, width) {
 		...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, state, elapsed, now) {
 	const rows = [];
 	const isRunning = state.status === "running" || state.status === "waiting";
@@ -1018,7 +1056,7 @@ function buildContentCells(prompt, state, elapsed, now) {
 		rows.push(pl ? textToCells(pl, "dim") : []);
 	}
 	rows.push([], []);
-	rows.push(renderStatsCells(elapsed, state.totalInputTokens, state.totalOutputTokens));
+	rows.push(renderStatsCells(elapsed, state.totalInputTokens, state.totalOutputTokens, state.commitCount));
 	rows.push([], []);
 	rows.push(...renderAgentMessageCells(state.lastMessage, state.status));
 	rows.push([], []);
@@ -1026,11 +1064,13 @@ function buildContentCells(prompt, state, elapsed, now) {
 	return rows;
 }
 function buildFrameCells(prompt, state, topStars, bottomStars, sideStars, now, terminalWidth, terminalHeight) {
-	const contentRows = buildContentCells(prompt, state, formatElapsed(now - state.startTime.getTime()), now);
-	while (contentRows.length < BASE_CONTENT_ROWS) contentRows.push([]);
+	const elapsed = formatElapsed(now - state.startTime.getTime());
+	const availableHeight = Math.max(0, terminalHeight - 2);
+	const contentRows = fitContentRows(buildContentCells(prompt, state, elapsed, now), availableHeight);
+	while (contentRows.length < Math.min(BASE_CONTENT_ROWS, availableHeight)) contentRows.push([]);
 	const contentCount = contentRows.length;
-	const remaining = Math.max(0, terminalHeight - contentCount);
-	const topHeight = Math.ceil(remaining / 2) - 1;
+	const remaining = Math.max(0, availableHeight - contentCount);
+	const topHeight = Math.max(0, Math.ceil(remaining / 2));
 	const bottomHeight = remaining - topHeight;
 	const sideWidth = Math.max(0, Math.floor((terminalWidth - CONTENT_WIDTH) / 2));
 	const frame = [];
@@ -1046,6 +1086,8 @@ function buildFrameCells(prompt, state, topStars, bottomStars, sideStars, now, t
 		]);
 	}
 	for (let y = 0; y < bottomHeight; y++) frame.push(renderStarLineCells(bottomStars, terminalWidth, y, now));
+	frame.push(renderResumeHintCells(terminalWidth));
+	frame.push(emptyCells(terminalWidth));
 	return frame;
 }
 var Renderer = class {
@@ -1111,8 +1153,9 @@ var Renderer = class {
 			this.cachedHeight = h;
 			const contentStart = Math.max(0, Math.floor((w - CONTENT_WIDTH) / 2) - 8);
 			const contentEnd = contentStart + CONTENT_WIDTH + 16;
-			const remaining = Math.max(0, h - BASE_CONTENT_ROWS);
-			const topHeight = Math.ceil(remaining / 2) - 1;
+			const availableHeight = Math.max(0, h - 2);
+			const remaining = Math.max(0, availableHeight - BASE_CONTENT_ROWS);
+			const topHeight = Math.max(0, Math.ceil(remaining / 2));
 			const proximityRows = 8;
 			const shrinkBig = (s, nearContentRow) => {
 				if (!nearContentRow || s.x < contentStart || s.x >= contentEnd) return s;
@@ -1127,7 +1170,7 @@ var Renderer = class {
 			};
 			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, BASE_CONTENT_ROWS, STAR_DENSITY, 99);
+			this.sideStars = generateStarField(w, Math.max(BASE_CONTENT_ROWS, availableHeight), STAR_DENSITY, 99);
 			return true;
 		}
 		return false;
@@ -1155,6 +1198,15 @@ function slugifyPrompt(prompt) {
 }
 //#endregion
 //#region src/cli.ts
+const packageVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
+function initializeNewBranch(prompt, cwd) {
+	ensureCleanWorkingTree(cwd);
+	const baseCommit = getHeadCommit(cwd);
+	const branchName = slugifyPrompt(prompt);
+	createBranch(branchName, cwd);
+	const runId = branchName.split("/")[1];
+	return setupRun(runId, prompt, baseCommit, cwd);
+}
 function ask(question) {
 	const rl = createInterface({
 		input: process$1.stdin,
@@ -1168,7 +1220,7 @@ 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("0.1.0").argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", "Agent to use (claude or codex)", "claude").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 or codex)").option("--mock", "", false).action(async (promptArg, options) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
@@ -1182,11 +1234,15 @@ 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 !== "claude" && agentName !== "codex") {
+	if (agentName !== void 0 && agentName !== "claude" && agentName !== "codex") {
 		console.error(`Unknown agent: ${options.agent}. Use "claude" or "codex".`);
 		process$1.exit(1);
 	}
-	const config = loadConfig({ agent: agentName });
+	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".`);
+		process$1.exit(1);
+	}
 	const cwd = process$1.cwd();
 	const currentBranch = getCurrentBranch(cwd);
 	const onGnhfBranch = currentBranch.startsWith("gnhf/");
@@ -1204,30 +1260,18 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			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]: `);
 			if (answer === "o") {
 				ensureCleanWorkingTree(cwd);
-				runInfo = setupRun(existingRunId, prompt, cwd);
-				commitAll(`gnhf: overwrite run ${existingRunId}`, cwd);
-			} else if (answer === "n") {
-				ensureCleanWorkingTree(cwd);
-				const branchName = slugifyPrompt(prompt);
-				createBranch(branchName, cwd);
-				const runId = branchName.split("/")[1];
-				runInfo = setupRun(runId, prompt, cwd);
-				commitAll(`gnhf: initialize run ${runId}`, cwd);
-			} else process$1.exit(0);
+				runInfo = setupRun(existingRunId, prompt, existing.baseCommit, cwd);
+			} else if (answer === "n") runInfo = initializeNewBranch(prompt, cwd);
+			else process$1.exit(0);
 		}
 	} else {
 		if (!prompt) {
 			program.help();
 			return;
 		}
-		ensureCleanWorkingTree(cwd);
-		const branchName = slugifyPrompt(prompt);
-		createBranch(branchName, cwd);
-		const runId = branchName.split("/")[1];
-		runInfo = setupRun(runId, prompt, cwd);
-		commitAll(`gnhf: initialize run ${runId}`, cwd);
+		runInfo = initializeNewBranch(prompt, cwd);
 	}
-	const orchestrator = new Orchestrator(config, createAgent(agentName, runInfo), runInfo, prompt, cwd, startIteration);
+	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo), runInfo, prompt, cwd, startIteration);
 	enterAltScreen();
 	const renderer = new Renderer(orchestrator, prompt);
 	renderer.start();

package/package.json

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