gnhf 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1247 @@
+#!/usr/bin/env node
+import { appendFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import process$1 from "node:process";
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import yaml from "js-yaml";
+import { execSync, spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createHash } from "node:crypto";
+//#region src/core/config.ts
+const DEFAULT_CONFIG = {
+	agent: "claude",
+	maxConsecutiveFailures: 5
+};
+function loadConfig(overrides) {
+	const configPath = join(homedir(), ".gnhf", "config.yml");
+	let fileConfig = {};
+	try {
+		const raw = readFileSync(configPath, "utf-8");
+		fileConfig = yaml.load(raw) ?? {};
+	} catch {}
+	return {
+		...DEFAULT_CONFIG,
+		...fileConfig,
+		...overrides
+	};
+}
+//#endregion
+//#region src/core/git.ts
+function git(args, cwd) {
+	return execSync(`git ${args}`, {
+		cwd,
+		encoding: "utf-8",
+		stdio: "pipe"
+	}).trim();
+}
+function getCurrentBranch(cwd) {
+	return git("rev-parse --abbrev-ref HEAD", cwd);
+}
+function ensureCleanWorkingTree(cwd) {
+	if (git("status --porcelain", cwd)) throw new Error("Working tree is not clean. Commit or stash changes first.");
+}
+function createBranch(branchName, cwd) {
+	git(`checkout -b ${branchName}`, cwd);
+}
+function commitAll(message, cwd) {
+	git("add -A", cwd);
+	try {
+		git(`commit -m "${message.replace(/"/g, "\\\"")}"`, cwd);
+	} catch {}
+}
+function resetHard(cwd) {
+	git("reset --hard HEAD", cwd);
+	git("clean -fd", cwd);
+}
+//#endregion
+//#region src/core/run.ts
+const OUTPUT_SCHEMA$1 = 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" }
+		}
+	},
+	required: [
+		"success",
+		"summary",
+		"key_changes_made",
+		"key_learnings"
+	]
+}, null, 2);
+function ensureGitignore(cwd) {
+	const gitignorePath = join(cwd, ".gitignore");
+	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");
+}
+function setupRun(runId, prompt, cwd) {
+	ensureGitignore(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");
+	const schemaPath = join(runDir, "output-schema.json");
+	writeFileSync(schemaPath, OUTPUT_SCHEMA$1, "utf-8");
+	return {
+		runId,
+		runDir,
+		promptPath,
+		notesPath,
+		schemaPath
+	};
+}
+function resumeRun(runId, cwd) {
+	const runDir = join(cwd, ".gnhf", "runs", runId);
+	if (!existsSync(runDir)) throw new Error(`Run directory not found: ${runDir}`);
+	return {
+		runId,
+		runDir,
+		promptPath: join(runDir, "prompt.md"),
+		notesPath: join(runDir, "notes.md"),
+		schemaPath: join(runDir, "output-schema.json")
+	};
+}
+function getLastIterationNumber(runInfo) {
+	const files = readdirSync(runInfo.runDir);
+	let max = 0;
+	for (const f of files) {
+		const m = f.match(/^iteration-(\d+)\.jsonl$/);
+		if (m) {
+			const n = parseInt(m[1], 10);
+			if (n > max) max = n;
+		}
+	}
+	return max;
+}
+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` : ""
+	].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" }
+		}
+	},
+	required: [
+		"success",
+		"summary",
+		"key_changes_made",
+		"key_learnings"
+	]
+});
+var ClaudeAgent = class {
+	name = "claude";
+	run(prompt, cwd, options) {
+		const { onUsage, onMessage, signal, logPath } = options ?? {};
+		return new Promise((resolve, reject) => {
+			const logStream = logPath ? createWriteStream(logPath) : null;
+			const child = spawn("claude", [
+				"-p",
+				prompt,
+				"--verbose",
+				"--output-format",
+				"stream-json",
+				"--json-schema",
+				OUTPUT_SCHEMA,
+				"--dangerously-skip-permissions"
+			], {
+				cwd,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				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 = "";
+			let resultEvent = null;
+			const cumulative = {
+				inputTokens: 0,
+				outputTokens: 0,
+				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());
+								}
+							}
+						}
+						if (event.type === "result") resultEvent = event;
+					} catch {}
+				}
+			});
+			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;
+				}
+				if (!resultEvent) {
+					reject(/* @__PURE__ */ new Error("claude returned no result event"));
+					return;
+				}
+				if (resultEvent.is_error || resultEvent.subtype !== "success") {
+					reject(/* @__PURE__ */ new Error(`claude reported error: ${JSON.stringify(resultEvent)}`));
+					return;
+				}
+				if (!resultEvent.structured_output) {
+					reject(/* @__PURE__ */ new Error("claude returned no structured_output"));
+					return;
+				}
+				const output = resultEvent.structured_output;
+				const usage = {
+					inputTokens: (resultEvent.usage.input_tokens ?? 0) + (resultEvent.usage.cache_read_input_tokens ?? 0),
+					outputTokens: resultEvent.usage.output_tokens ?? 0,
+					cacheReadTokens: resultEvent.usage.cache_read_input_tokens ?? 0,
+					cacheCreationTokens: resultEvent.usage.cache_creation_input_tokens ?? 0
+				};
+				onUsage?.(usage);
+				resolve({
+					output,
+					usage
+				});
+			});
+		});
+	}
+};
+//#endregion
+//#region src/core/agents/codex.ts
+var CodexAgent = class {
+	name = "codex";
+	schemaPath;
+	constructor(schemaPath) {
+		this.schemaPath = schemaPath;
+	}
+	run(prompt, cwd, options) {
+		const { onUsage, onMessage, signal, logPath } = options ?? {};
+		return new Promise((resolve, reject) => {
+			const logStream = logPath ? createWriteStream(logPath) : null;
+			const child = spawn("codex", [
+				"exec",
+				prompt,
+				"--json",
+				"--output-schema",
+				this.schemaPath,
+				"--dangerously-bypass-approvals-and-sandbox",
+				"--color",
+				"never"
+			], {
+				cwd,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				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 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 {}
+				}
+			});
+			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 (!lastAgentMessage) {
+					reject(/* @__PURE__ */ new Error("codex returned no agent message"));
+					return;
+				}
+				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
+						})
+					});
+				} catch (err) {
+					reject(/* @__PURE__ */ new Error(`Failed to parse codex output: ${err instanceof Error ? err.message : err}`));
+				}
+			});
+		});
+	}
+};
+//#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);
+	}
+}
+//#endregion
+//#region src/templates/iteration-prompt.ts
+function buildIterationPrompt(params) {
+	return `You are working autonomously on an objective given below.
+This is iteration ${params.n} of an ongoing loop to fully accomplish the objective.
+
+## Instructions
+
+1. Read .gnhf/runs/${params.runId}/notes.md first to understand what has been done in previous iterations.
+2. Focus on one smallest logical unit of work that's individually testable and would make incremental progress towards the objective. Do NOT try to do everything at once.
+3. Run build/tests/linters/formatters if available to validate your work.
+4. Do NOT make any git commits. Commits will be handled automatically by the gnhf orchestrator.
+5. When you are done, respond with a JSON object according to the provided schema.
+
+## Objective
+
+${params.prompt}`;
+}
+//#endregion
+//#region src/core/orchestrator.ts
+var Orchestrator = class extends EventEmitter {
+	config;
+	agent;
+	runInfo;
+	cwd;
+	prompt;
+	stopRequested = false;
+	activeAbortController = null;
+	state = {
+		status: "running",
+		currentIteration: 0,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		iterations: [],
+		successCount: 0,
+		failCount: 0,
+		consecutiveFailures: 0,
+		startTime: /* @__PURE__ */ new Date(),
+		waitingUntil: null,
+		lastMessage: null
+	};
+	constructor(config, agent, runInfo, prompt, cwd, startIteration = 0) {
+		super();
+		this.config = config;
+		this.agent = agent;
+		this.runInfo = runInfo;
+		this.prompt = prompt;
+		this.cwd = cwd;
+		this.state.currentIteration = startIteration;
+	}
+	getState() {
+		return { ...this.state };
+	}
+	stop() {
+		this.stopRequested = true;
+		this.activeAbortController?.abort();
+		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) {
+			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
+			});
+			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()
+				};
+			}
+			this.state.iterations.push(record);
+			this.emit("iteration:end", record);
+			this.emit("state", this.getState());
+			if (this.state.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+				this.state.status = "aborted";
+				const reason = `${this.config.maxConsecutiveFailures} consecutive failures`;
+				this.emit("abort", reason);
+				this.emit("state", this.getState());
+				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());
+				}
+			}
+		}
+	}
+	interruptibleSleep(ms) {
+		return new Promise((resolve) => {
+			this.activeAbortController = new AbortController();
+			const timer = setTimeout(() => {
+				this.activeAbortController = null;
+				resolve();
+			}, ms);
+			this.activeAbortController.signal.addEventListener("abort", () => {
+				clearTimeout(timer);
+				this.activeAbortController = null;
+				resolve();
+			});
+		});
+	}
+};
+//#endregion
+//#region src/mock-orchestrator.ts
+function mockIter(n, success, summary, agoMs) {
+	return {
+		number: n,
+		success,
+		summary,
+		keyChanges: [],
+		keyLearnings: [],
+		timestamp: new Date(Date.now() - agoMs)
+	};
+}
+const MOCK_ITERATIONS = [
+	mockIter(1, true, "Profiled cold start — identified 3 major bottlenecks", 252e5),
+	mockIter(2, true, "Lazy-loaded config module, shaved 340ms off init", 24e6),
+	mockIter(3, true, "Deferred plugin discovery to post-render", 228e5),
+	mockIter(4, false, "Attempted parallel module init — race condition in DI container", 21e6),
+	mockIter(5, true, "Fixed DI ordering, parallelized safe modules only", 192e5),
+	mockIter(6, true, "Replaced synchronous JSON parse with streaming decoder", 174e5),
+	mockIter(7, true, "Cached resolved dependency graph across restarts", 15e6),
+	mockIter(8, false, "Tree-shaking broke runtime dynamic import paths", 126e5),
+	mockIter(9, true, "Restored dynamic imports, added explicit entry chunks", 108e5),
+	mockIter(10, true, "Inlined critical-path CSS, deferred non-essential styles", 84e5),
+	mockIter(11, true, "Switched from full Intl polyfill to locale-on-demand", 6e6),
+	mockIter(12, true, "Pre-compiled handlebars templates at build time", 36e5),
+	mockIter(13, true, "Moved telemetry init behind requestIdleCallback", 18e5)
+];
+const AGENT_MESSAGES = [
+	"Reading src/bootstrap.ts to trace the module init order",
+	"Let me profile the require() chain with --cpu-prof",
+	"Running integration tests after the lazy-load refactor",
+	"Let me make sure HMR still works in dev mode",
+	"Nice — startup dropped from 1.24s to 0.41s so far",
+	"Found it! There's a sync readFileSync in the config loader hot path — that's blocking the entire init sequence",
+	"I'm analyzing the import graph for circular dependencies. So far I've found 3 cycles that force eager evaluation",
+	"Now I'll move database pool creation behind a first-request gate so we don't pay the connection cost at boot time",
+	"Let me check if the logger init can be deferred safely. It looks like only the error handler depends on it early",
+	"Checking the bundle size delta after tree-shaking. Went from 847KB down to 612KB — solid improvement",
+	"I'm replacing those sync fs calls with a pre-cached config lookup that gets populated during the build step",
+	"Running a cold start benchmark to establish a baseline. Currently at 1.24s — I think we can get under 500ms",
+	"I'm looking at the startup flame graph and there are three clear bottlenecks: config parsing (310ms), plugin discovery (280ms), and template compilation (190ms)",
+	"Let me verify the middleware registration order is still correct after the lazy-load refactor. The auth middleware needs to run before any route handlers get registered",
+	"I need to test what happens when the first request arrives before deferred services finish initializing. Adding a readiness gate that blocks until all critical paths are up",
+	"Now I'll investigate whether route registration can be made async without breaking the Express contract. The docs say app.listen() waits, but I want to confirm with a test",
+	"Auditing all feature flags to see if any depend on early init. Looks like none of them do — they all read from a lazy-loaded remote config that we fetch on first access",
+	"I'm adding startup timing spans to the OpenTelemetry traces so we can track cold start regressions in prod. Each phase will get its own span: config, plugins, routes, middleware",
+	"Confirming all 47 tests still pass after these changes. The config loader tests needed updating since they were assuming synchronous initialization — fixing those now",
+	"Let me validate the health check endpoint still responds within 50ms even during the deferred init window. I'll add a lightweight synthetic probe that skips the full stack"
+];
+function randInt(min, max) {
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+const INITIAL_ELAPSED_MS = 29237e3;
+var MockOrchestrator = class extends EventEmitter {
+	state = {
+		status: "running",
+		currentIteration: 14,
+		totalInputTokens: 873e5,
+		totalOutputTokens: 86e4,
+		iterations: [...MOCK_ITERATIONS],
+		successCount: 11,
+		failCount: 2,
+		consecutiveFailures: 0,
+		startTime: new Date(Date.now() - INITIAL_ELAPSED_MS),
+		waitingUntil: null,
+		lastMessage: AGENT_MESSAGES[0]
+	};
+	tokenTimer = null;
+	messageTimer = null;
+	messageIndex = 0;
+	getState() {
+		return {
+			...this.state,
+			iterations: [...this.state.iterations]
+		};
+	}
+	stop() {
+		if (this.tokenTimer) clearTimeout(this.tokenTimer);
+		if (this.messageTimer) clearTimeout(this.messageTimer);
+		this.tokenTimer = null;
+		this.messageTimer = null;
+		this.state.status = "stopped";
+		this.emit("state", this.getState());
+		this.emit("stopped");
+	}
+	start() {
+		this.emit("state", this.getState());
+		this.scheduleTokenBump();
+		this.scheduleNextMessage();
+	}
+	scheduleTokenBump() {
+		this.tokenTimer = setTimeout(() => {
+			this.state.totalInputTokens += randInt(4e4, 18e4);
+			this.state.totalOutputTokens += randInt(200, 2e3);
+			this.emit("state", this.getState());
+			if (this.state.status === "running") this.scheduleTokenBump();
+		}, randInt(1500, 7e3));
+	}
+	scheduleNextMessage() {
+		const delay = randInt(3e3, 7e3);
+		this.messageTimer = setTimeout(() => {
+			this.messageIndex = (this.messageIndex + 1) % AGENT_MESSAGES.length;
+			this.state.lastMessage = AGENT_MESSAGES[this.messageIndex];
+			this.emit("state", this.getState());
+			this.scheduleNextMessage();
+		}, delay);
+	}
+};
+//#endregion
+//#region src/utils/stars.ts
+const STAR_CHARS = [
+	"·",
+	"·",
+	"·",
+	"·",
+	"·",
+	"·",
+	"✧",
+	"⋆",
+	"⋆",
+	"⋆",
+	"°",
+	"°"
+];
+function generateStarField(width, height, density, seed) {
+	const stars = [];
+	let s = seed;
+	const rand = () => {
+		s = (s * 16807 + 0) % 2147483647;
+		return s / 2147483647;
+	};
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) if (rand() < density) {
+		const charIdx = Math.floor(rand() * STAR_CHARS.length);
+		const r = rand();
+		const rest = r < .15 ? "hidden" : r < .4 ? "dim" : "bright";
+		stars.push({
+			x,
+			y,
+			char: STAR_CHARS[charIdx],
+			phase: rand() * Math.PI * 2,
+			period: 1e4 + rand() * 15e3,
+			rest
+		});
+	}
+	return stars;
+}
+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 (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";
+		return "dim";
+	}
+	if (t > .025) return "bright";
+	return "dim";
+}
+//#endregion
+//#region src/utils/moon.ts
+const MOON_PHASES = [
+	"🌑",
+	"🌒",
+	"🌓",
+	"🌔",
+	"🌕",
+	"🌖",
+	"🌗",
+	"🌘"
+];
+function getMoonPhase(state, now = 0, periodMs = 4e3) {
+	if (state === "success") return "🌕";
+	if (state === "fail") return "🌑";
+	return MOON_PHASES[Math.floor(now % periodMs / periodMs * 8) % 8];
+}
+//#endregion
+//#region src/utils/time.ts
+function formatElapsed(ms) {
+	const s = Math.floor(ms / 1e3);
+	return `${String(Math.floor(s / 3600)).padStart(2, "0")}:${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+}
+//#endregion
+//#region src/utils/tokens.ts
+function formatTokens(count) {
+	if (count >= 0xe8d4a51000) return `${(count / 0xe8d4a51000).toFixed(1)}T`;
+	if (count >= 1e9) return `${(count / 1e9).toFixed(1)}B`;
+	if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
+	if (count >= 1e3) return `${Math.round(count / 1e3)}K`;
+	return String(count);
+}
+//#endregion
+//#region src/utils/wordwrap.ts
+function wordWrap(text, width, maxLines) {
+	if (!text) return [];
+	const words = text.split(/\s+/);
+	const lines = [];
+	let current = "";
+	for (const word of words) {
+		if (word.length > width) {
+			if (current) {
+				lines.push(current);
+				current = "";
+			}
+			for (let i = 0; i < word.length; i += width) lines.push(word.slice(i, i + width));
+			continue;
+		}
+		if (current && current.length + 1 + word.length > width) {
+			lines.push(current);
+			current = word;
+		} else current = current ? current + " " + word : word;
+	}
+	if (current) lines.push(current);
+	if (maxLines && lines.length > maxLines) {
+		const capped = lines.slice(0, maxLines);
+		const last = capped[maxLines - 1];
+		capped[maxLines - 1] = last.length >= width ? last.slice(0, width - 1) + "…" : last + "…";
+		return capped;
+	}
+	return lines;
+}
+//#endregion
+//#region src/renderer-diff.ts
+const SPACE = {
+	char: " ",
+	style: "normal",
+	width: 1
+};
+function makeCell(char, style) {
+	return {
+		char,
+		style,
+		width: (char.codePointAt(0) ?? 0) > 65535 ? 2 : 1
+	};
+}
+function textToCells(text, style) {
+	const cells = [];
+	for (const char of text) {
+		const cell = makeCell(char, style);
+		cells.push(cell);
+		if (cell.width === 2) cells.push({
+			char: "",
+			style: "normal",
+			width: 0
+		});
+	}
+	return cells;
+}
+function emptyCells(n) {
+	const cells = [];
+	for (let i = 0; i < n; i++) cells.push({ ...SPACE });
+	return cells;
+}
+function rowToString(cells) {
+	let result = "";
+	let currentStyle = "normal";
+	for (const cell of cells) {
+		if (cell.width === 0) continue;
+		if (cell.style !== currentStyle) {
+			if (currentStyle !== "normal") result += "\x1B[0m";
+			if (cell.style === "bold") result += "\x1B[1m";
+			else if (cell.style === "dim") result += "\x1B[2m";
+			currentStyle = cell.style;
+		}
+		result += cell.char;
+	}
+	if (currentStyle !== "normal") result += "\x1B[0m";
+	return result;
+}
+function diffFrames(prev, next) {
+	const changes = [];
+	const rows = Math.min(prev.length, next.length);
+	for (let r = 0; r < rows; r++) {
+		const prevRow = prev[r];
+		const nextRow = next[r];
+		const cols = Math.min(prevRow.length, nextRow.length);
+		for (let c = 0; c < cols; c++) {
+			const n = nextRow[c];
+			if (n.width === 0) continue;
+			const p = prevRow[c];
+			if (p.char !== n.char || p.style !== n.style || p.width !== n.width) changes.push({
+				row: r,
+				col: c,
+				cell: n
+			});
+		}
+	}
+	return changes;
+}
+function emitDiff(changes) {
+	if (changes.length === 0) return "";
+	let result = "";
+	let currentStyle = null;
+	let cursorRow = -1;
+	let cursorCol = -1;
+	for (const { row, col, cell } of changes) {
+		if (row !== cursorRow || col !== cursorCol) result += `\x1b[${row + 1};${col + 1}H`;
+		if (cell.style !== currentStyle) {
+			result += "\x1B[0m";
+			if (cell.style === "bold") result += "\x1B[1m";
+			else if (cell.style === "dim") result += "\x1B[2m";
+			currentStyle = cell.style;
+		}
+		result += cell.char;
+		cursorRow = row;
+		cursorCol = col + cell.width;
+	}
+	if (currentStyle !== "normal") result += "\x1B[0m";
+	return result;
+}
+//#endregion
+//#region src/renderer.ts
+const CONTENT_WIDTH = 63;
+const MAX_PROMPT_LINES = 3;
+const BASE_CONTENT_ROWS = 24;
+const STAR_DENSITY = .035;
+const TICK_MS = 200;
+const MOONS_PER_ROW = 30;
+const MOON_PHASE_PERIOD = 1600;
+const MAX_MSG_LINES = 3;
+const MAX_MSG_LINE_LEN = 64;
+function renderTitleCells() {
+	return [
+		textToCells("g n h f", "dim"),
+		[],
+		textToCells("┏━╸┏━┓┏━┓╺┳┓   ┏┓╻╻┏━╸╻ ╻╺┳╸   ╻ ╻┏━┓╻ ╻┏━╸   ┏━╸╻ ╻┏┓╻", "bold"),
+		textToCells("┃╺┓┃ ┃┃ ┃ ┃┃   ┃┗┫┃┃╺┓┣━┫ ┃    ┣━┫┣━┫┃┏┛┣╸    ┣╸ ┃ ┃┃┗┫", "bold"),
+		textToCells("┗━┛┗━┛┗━┛╺┻┛   ╹ ╹╹┗━┛╹ ╹ ╹    ╹ ╹╹ ╹┗┛ ┗━╸   ╹  ┗━┛╹ ╹", "bold")
+	];
+}
+function renderStatsCells(elapsed, inputTokens, outputTokens) {
+	return [
+		...textToCells(elapsed, "bold"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`${formatTokens(inputTokens)} in`, "normal"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`${formatTokens(outputTokens)} out`, "normal")
+	];
+}
+function renderAgentMessageCells(message, status) {
+	const lines = [];
+	if (status === "waiting") lines.push("waiting (backoff)...");
+	else if (status === "aborted" && !message) lines.push("max consecutive failures reached");
+	else if (!message) lines.push("working...");
+	else {
+		const wrapped = wordWrap(message, MAX_MSG_LINE_LEN, MAX_MSG_LINES);
+		for (const wl of wrapped) lines.push(wl);
+	}
+	while (lines.length < MAX_MSG_LINES) lines.push("");
+	return lines.map((l) => l ? textToCells(l, "dim") : []);
+}
+function renderMoonStripCells(iterations, isRunning, now) {
+	const moons = iterations.map((iter) => getMoonPhase(iter.success ? "success" : "fail"));
+	if (isRunning) moons.push(getMoonPhase("active", now, MOON_PHASE_PERIOD));
+	if (moons.length === 0) return [[]];
+	const rows = [];
+	for (let i = 0; i < moons.length; i += MOONS_PER_ROW) {
+		const slice = moons.slice(i, i + MOONS_PER_ROW);
+		const cells = [];
+		for (const moon of slice) cells.push(...textToCells(moon, "normal"));
+		rows.push(cells);
+	}
+	return rows;
+}
+function starStyle(state) {
+	if (state === "bright") return "bold";
+	if (state === "dim") return "dim";
+	return "normal";
+}
+function renderStarLineCells(stars, width, y, now) {
+	const cells = emptyCells(width);
+	for (const star of stars) {
+		if (star.y !== y) continue;
+		const state = getStarState(star, now);
+		if (state === "hidden") cells[star.x] = {
+			char: " ",
+			style: "normal",
+			width: 1
+		};
+		else cells[star.x] = {
+			char: star.char,
+			style: starStyle(state),
+			width: 1
+		};
+	}
+	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
+		};
+	}
+	return cells;
+}
+function centerLineCells(content, width) {
+	const w = content.length;
+	const pad = Math.max(0, Math.floor((width - w) / 2));
+	const rightPad = Math.max(0, width - w - pad);
+	return [
+		...emptyCells(pad),
+		...content,
+		...emptyCells(rightPad)
+	];
+}
+function buildContentCells(prompt, state, elapsed, now) {
+	const rows = [];
+	const isRunning = state.status === "running" || state.status === "waiting";
+	rows.push([]);
+	rows.push(...renderTitleCells());
+	rows.push([], []);
+	const promptLines = wordWrap(prompt, CONTENT_WIDTH, MAX_PROMPT_LINES);
+	for (let i = 0; i < MAX_PROMPT_LINES; i++) {
+		const pl = promptLines[i] ?? "";
+		rows.push(pl ? textToCells(pl, "dim") : []);
+	}
+	rows.push([], []);
+	rows.push(renderStatsCells(elapsed, state.totalInputTokens, state.totalOutputTokens));
+	rows.push([], []);
+	rows.push(...renderAgentMessageCells(state.lastMessage, state.status));
+	rows.push([], []);
+	rows.push(...renderMoonStripCells(state.iterations, isRunning, 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 contentCount = contentRows.length;
+	const remaining = Math.max(0, terminalHeight - contentCount);
+	const topHeight = Math.ceil(remaining / 2) - 1;
+	const bottomHeight = remaining - topHeight;
+	const sideWidth = Math.max(0, Math.floor((terminalWidth - CONTENT_WIDTH) / 2));
+	const frame = [];
+	for (let y = 0; y < topHeight; y++) frame.push(renderStarLineCells(topStars, terminalWidth, y, now));
+	for (let i = 0; i < contentRows.length; i++) {
+		const left = renderSideStarsCells(sideStars, i, 0, sideWidth, now);
+		const center = centerLineCells(contentRows[i], CONTENT_WIDTH);
+		const right = renderSideStarsCells(sideStars, i, terminalWidth - sideWidth, sideWidth, now);
+		frame.push([
+			...left,
+			...center,
+			...right
+		]);
+	}
+	for (let y = 0; y < bottomHeight; y++) frame.push(renderStarLineCells(bottomStars, terminalWidth, y, now));
+	return frame;
+}
+var Renderer = class {
+	orchestrator;
+	prompt;
+	state;
+	interval = null;
+	exitResolve;
+	exitPromise;
+	topStars = [];
+	bottomStars = [];
+	sideStars = [];
+	cachedWidth = 0;
+	cachedHeight = 0;
+	prevCells = [];
+	isFirstFrame = true;
+	constructor(orchestrator, prompt) {
+		this.orchestrator = orchestrator;
+		this.prompt = prompt;
+		this.state = orchestrator.getState();
+		this.exitPromise = new Promise((resolve) => {
+			this.exitResolve = resolve;
+		});
+	}
+	start() {
+		this.orchestrator.on("state", (newState) => {
+			this.state = {
+				...newState,
+				iterations: [...newState.iterations]
+			};
+		});
+		this.orchestrator.on("stopped", () => {
+			this.stop();
+		});
+		if (process$1.stdin.isTTY) {
+			process$1.stdin.setRawMode(true);
+			process$1.stdin.resume();
+			process$1.stdin.on("data", (data) => {
+				if (data[0] === 3) this.orchestrator.stop();
+			});
+		}
+		this.interval = setInterval(() => this.render(), TICK_MS);
+		this.render();
+	}
+	stop() {
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = null;
+		}
+		if (process$1.stdin.isTTY) {
+			process$1.stdin.setRawMode(false);
+			process$1.stdin.pause();
+			process$1.stdin.removeAllListeners("data");
+		}
+		this.exitResolve();
+	}
+	waitUntilExit() {
+		return this.exitPromise;
+	}
+	ensureStarFields(w, h) {
+		if (w !== this.cachedWidth || h !== this.cachedHeight) {
+			this.cachedWidth = w;
+			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 proximityRows = 8;
+			const shrinkBig = (s, nearContentRow) => {
+				if (!nearContentRow || s.x < contentStart || s.x >= contentEnd) return s;
+				const star = s.char !== "·" ? {
+					...s,
+					char: "·"
+				} : s;
+				return star.rest === "bright" ? {
+					...star,
+					rest: "dim"
+				} : star;
+			};
+			this.topStars = generateStarField(w, h, STAR_DENSITY, 42).map((s) => shrinkBig(s, s.y >= topHeight - proximityRows));
+			this.bottomStars = generateStarField(w, h, STAR_DENSITY, 137).map((s) => shrinkBig(s, s.y < proximityRows));
+			this.sideStars = generateStarField(w, BASE_CONTENT_ROWS, STAR_DENSITY, 99);
+			return true;
+		}
+		return false;
+	}
+	render() {
+		const now = Date.now();
+		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);
+		if (this.isFirstFrame || resized) {
+			process$1.stdout.write("\x1B[H" + nextCells.map(rowToString).join("\n"));
+			this.isFirstFrame = false;
+		} else {
+			const changes = diffFrames(this.prevCells, nextCells);
+			if (changes.length > 0) process$1.stdout.write(emitDiff(changes));
+		}
+		this.prevCells = nextCells;
+	}
+};
+//#endregion
+//#region src/utils/slugify.ts
+function slugifyPrompt(prompt) {
+	return `gnhf/${prompt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 20).replace(/-+$/, "")}-${createHash("sha256").update(prompt).digest("hex").slice(0, 6)}`;
+}
+//#endregion
+//#region src/cli.ts
+function ask(question) {
+	const rl = createInterface({
+		input: process$1.stdin,
+		output: process$1.stderr
+	});
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.trim().toLowerCase());
+		});
+	});
+}
+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) => {
+	if (options.mock) {
+		const mock = new MockOrchestrator();
+		enterAltScreen();
+		const renderer = new Renderer(mock, "let's minimize app startup latency without sacrificing any functionality");
+		renderer.start();
+		mock.start();
+		await renderer.waitUntilExit();
+		exitAltScreen();
+		return;
+	}
+	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") {
+		console.error(`Unknown agent: ${options.agent}. Use "claude" or "codex".`);
+		process$1.exit(1);
+	}
+	const config = loadConfig({ agent: agentName });
+	const cwd = process$1.cwd();
+	const currentBranch = getCurrentBranch(cwd);
+	const onGnhfBranch = currentBranch.startsWith("gnhf/");
+	let runInfo;
+	let startIteration = 0;
+	if (onGnhfBranch) {
+		const existingRunId = currentBranch.slice(5);
+		const existing = resumeRun(existingRunId, cwd);
+		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]: `);
+			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);
+		}
+	} 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);
+	}
+	const orchestrator = new Orchestrator(config, createAgent(agentName, runInfo), runInfo, prompt, cwd, startIteration);
+	enterAltScreen();
+	const renderer = new Renderer(orchestrator, prompt);
+	renderer.start();
+	orchestrator.start().catch((err) => {
+		renderer.stop();
+		exitAltScreen();
+		die(err instanceof Error ? err.message : String(err));
+	});
+	await renderer.waitUntilExit();
+	exitAltScreen();
+});
+function enterAltScreen() {
+	process$1.stdout.write("\x1B[?1049h");
+	process$1.stdout.write("\x1B[?25l");
+}
+function exitAltScreen() {
+	process$1.stdout.write("\x1B[?25h");
+	process$1.stdout.write("\x1B[?1049l");
+}
+function die(message) {
+	console.error(`\n  gnhf: ${message}\n`);
+	process$1.exit(1);
+}
+try {
+	await program.parseAsync();
+} catch (err) {
+	die(err instanceof Error ? err.message : String(err));
+}
+//#endregion
+export {};