fly-to-moon 0.1.12

package/dist/cli.mjs

@@ -0,0 +1,3374 @@
+#!/usr/bin/env node
+import { appendFileSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import process$1 from "node:process";
+import { createInterface } from "node:readline";
+import { Command, InvalidArgumentError } from "commander";
+import yaml from "js-yaml";
+import { execFileSync, execSync, spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { EventEmitter } from "node:events";
+import { createHash } from "node:crypto";
+//#region src/core/config.ts
+const AGENT_NAMES = [
+	"claude",
+	"codex",
+	"rovodev",
+	"opencode"
+];
+const DEFAULT_CONFIG = {
+	agent: "claude",
+	agentPathOverride: {},
+	maxConsecutiveFailures: 3,
+	preventSleep: true
+};
+var InvalidConfigError = class extends Error {};
+function normalizePreventSleep(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return void 0;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "on") return true;
+	if (value === "off") return false;
+}
+/**
+* Resolve a user-supplied path against the config directory (~/.fttm).
+* Expands leading `~` or `~/` to the home directory, then resolves relative
+* paths against `baseDir` so that entries like `./bin/codex` work predictably
+* regardless of the repo's cwd. Bare executable names and absolute paths pass
+* through unchanged.
+*/
+function resolveConfigPath(raw, baseDir) {
+	if (raw !== "~" && !raw.startsWith("~/") && !raw.startsWith("~\\") && !raw.includes("/") && !raw.includes("\\")) return raw;
+	const home = homedir();
+	let expanded = raw;
+	if (expanded === "~") expanded = home;
+	else if (expanded.startsWith("~/") || expanded.startsWith("~\\")) expanded = join(home, expanded.slice(2));
+	return resolve(baseDir, expanded);
+}
+function normalizeAgentPathOverride(value, configDir) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "object" || Array.isArray(value)) throw new InvalidConfigError(`Invalid config value for agentPathOverride: expected an object mapping agent names to paths`);
+	const validNames = new Set(AGENT_NAMES);
+	const result = {};
+	for (const [key, val] of Object.entries(value)) {
+		if (!validNames.has(key)) throw new InvalidConfigError(`Invalid agent name in agentPathOverride: "${key}". Use "claude", "codex", "rovodev", or "opencode".`);
+		if (typeof val !== "string") throw new InvalidConfigError(`Invalid path for agentPathOverride.${key}: expected a string`);
+		if (val.trim() === "") throw new InvalidConfigError(`Invalid path for agentPathOverride.${key}: expected a non-empty string`);
+		result[key] = resolveConfigPath(val, configDir);
+	}
+	return result;
+}
+function normalizeConfig(config, configDir) {
+	const normalized = { ...config };
+	const hasPreventSleep = Object.prototype.hasOwnProperty.call(config, "preventSleep");
+	const preventSleep = normalizePreventSleep(config.preventSleep);
+	if (preventSleep === void 0) {
+		if (hasPreventSleep && config.preventSleep !== void 0) throw new InvalidConfigError(`Invalid config value for preventSleep: ${String(config.preventSleep)}`);
+		delete normalized.preventSleep;
+	} else normalized.preventSleep = preventSleep;
+	if (Object.prototype.hasOwnProperty.call(config, "agentPathOverride")) {
+		const resolveDir = configDir ?? join(homedir(), ".fttm");
+		const agentPathOverride = normalizeAgentPathOverride(config.agentPathOverride, resolveDir);
+		if (agentPathOverride === void 0) delete normalized.agentPathOverride;
+		else normalized.agentPathOverride = agentPathOverride;
+	} else delete normalized.agentPathOverride;
+	return normalized;
+}
+function isMissingConfigError(error) {
+	if (!(error instanceof Error)) return false;
+	return "code" in error ? error.code === "ENOENT" : error.message.includes("ENOENT");
+}
+function serializeAgentPathOverride(agentPathOverride) {
+	const serializedOverrides = Object.fromEntries(AGENT_NAMES.flatMap((name) => {
+		const value = agentPathOverride[name];
+		return value === void 0 ? [] : [[name, value]];
+	}));
+	if (Object.keys(serializedOverrides).length === 0) return "";
+	return yaml.dump({ agentPathOverride: serializedOverrides }, {
+		lineWidth: -1,
+		noRefs: true,
+		sortKeys: false
+	}).trimEnd();
+}
+function serializeConfig(config) {
+	const agentPathOverrideSection = serializeAgentPathOverride(config.agentPathOverride);
+	const lines = [
+		"# Agent to use by default",
+		`agent: ${config.agent}`,
+		"",
+		"# Custom paths to agent binaries (optional)",
+		"# Paths may be absolute, bare executable names on PATH,",
+		"# ~-prefixed, or relative to this config directory.",
+		"# Note: rovodev overrides must point to an acli-compatible binary.",
+		"# agentPathOverride:",
+		"#   claude: /path/to/custom-claude",
+		"#   codex: /path/to/custom-codex"
+	];
+	if (agentPathOverrideSection) lines.push(...agentPathOverrideSection.split("\n"));
+	lines.push("", "# Abort after this many consecutive failures", `maxConsecutiveFailures: ${config.maxConsecutiveFailures}`, "", "# Prevent the machine from sleeping during a run", `preventSleep: ${config.preventSleep}`, "");
+	return lines.join("\n");
+}
+function loadConfig(overrides) {
+	const configDir = join(homedir(), ".fttm");
+	const configPath = join(configDir, "config.yml");
+	let fileConfig = {};
+	let shouldBootstrapConfig = false;
+	try {
+		const raw = readFileSync(configPath, "utf-8");
+		fileConfig = normalizeConfig(yaml.load(raw) ?? {}, configDir);
+	} catch (error) {
+		if (error instanceof InvalidConfigError) throw error;
+		if (isMissingConfigError(error)) shouldBootstrapConfig = true;
+	}
+	const resolvedConfig = {
+		...DEFAULT_CONFIG,
+		...fileConfig,
+		...normalizeConfig(overrides ?? {})
+	};
+	if (shouldBootstrapConfig) try {
+		mkdirSync(configDir, { recursive: true });
+		writeFileSync(configPath, serializeConfig(resolvedConfig), "utf-8");
+	} catch {}
+	return resolvedConfig;
+}
+//#endregion
+//#region src/core/debug-log.ts
+function appendDebugLog(event, details = {}) {
+	const logPath = process.env.GNHF_DEBUG_LOG_PATH;
+	if (!logPath) return;
+	try {
+		appendFileSync(logPath, `${JSON.stringify({
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			pid: process.pid,
+			event,
+			...details
+		})}\n`, "utf-8");
+	} catch {}
+}
+//#endregion
+//#region src/core/git.ts
+const NOT_GIT_REPOSITORY_MESSAGE = "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
+function translateGitError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function git(args, cwd) {
+	try {
+		return execSync(`git ${args}`, {
+			cwd,
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).trim();
+	} catch (error) {
+		throw translateGitError(error);
+	}
+}
+function isGitRepository(cwd) {
+	try {
+		execSync("git rev-parse --git-dir", {
+			cwd,
+			encoding: "utf-8",
+			stdio: "pipe",
+			env: {
+				...process.env,
+				LC_ALL: "C"
+			}
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function ensureGitRepository(cwd) {
+	if (!isGitRepository(cwd)) throw new Error(NOT_GIT_REPOSITORY_MESSAGE);
+}
+function getCurrentBranch(cwd) {
+	ensureGitRepository(cwd);
+	try {
+		return git("symbolic-ref --short HEAD", cwd);
+	} catch {
+		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 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 === `fttm: initialize run ${runId}` || subject === `fttm: 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 {
+		git(`commit -m "${message.replace(/"/g, "\\\"")}"`, cwd);
+	} catch {}
+}
+function resetHard(cwd) {
+	git("reset --hard HEAD", cwd);
+	git("clean -fd", cwd);
+}
+//#endregion
+//#region src/core/agents/types.ts
+const AGENT_OUTPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	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"
+	]
+};
+//#endregion
+//#region src/core/run.ts
+function writeSchemaFile(schemaPath) {
+	writeFileSync(schemaPath, JSON.stringify(AGENT_OUTPUT_SCHEMA, null, 2), "utf-8");
+}
+function ensureRunMetadataIgnored(cwd) {
+	const excludePath = execFileSync("git", [
+		"rev-parse",
+		"--git-path",
+		"info/exclude"
+	], {
+		cwd,
+		encoding: "utf-8"
+	}).trim();
+	const resolved = isAbsolute(excludePath) ? excludePath : join(cwd, excludePath);
+	const entry = ".fttm/runs/";
+	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, baseCommit, cwd) {
+	ensureRunMetadataIgnored(cwd);
+	const runDir = join(cwd, ".fttm", "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, `# fttm run: ${runId}\n\nObjective: ${prompt}\n\n## Iteration Log\n`, "utf-8");
+	const schemaPath = join(runDir, "output-schema.json");
+	writeSchemaFile(schemaPath);
+	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,
+		baseCommit: resolvedBaseCommit,
+		baseCommitPath
+	};
+}
+function resumeRun(runId, cwd) {
+	const runDir = join(cwd, ".fttm", "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);
+	const baseCommitPath = join(runDir, "base-commit");
+	return {
+		runId,
+		runDir,
+		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;
+	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 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`,
+		formatListSection("Changes", changes),
+		formatListSection("Learnings", learnings)
+	].join("\n"), "utf-8");
+}
+//#endregion
+//#region src/core/stdin.ts
+async function readStdinText(input) {
+	const chunks = [];
+	for await (const chunk of input) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	return Buffer.concat(chunks).toString("utf-8").trim();
+}
+//#endregion
+//#region src/core/agents/managed-process.ts
+const POST_SIGKILL_GRACE_MS = 100;
+function signalChildProcess(child, options) {
+	const killProcess = options.killProcess ?? process.kill.bind(process);
+	if (options.detached && child.pid) try {
+		killProcess(-child.pid, options.signal);
+		return;
+	} catch {}
+	child.kill(options.signal);
+}
+async function shutdownChildProcess(child, options) {
+	if (child.exitCode != null || child.signalCode != null) return;
+	const timeoutMs = options.timeoutMs ?? 3e3;
+	await new Promise((resolve) => {
+		let forceKillTimer = null;
+		let hardDeadlineTimer = null;
+		let settled = false;
+		const settle = () => {
+			if (settled) return;
+			settled = true;
+			if (forceKillTimer) {
+				clearTimeout(forceKillTimer);
+				forceKillTimer = null;
+			}
+			if (hardDeadlineTimer) {
+				clearTimeout(hardDeadlineTimer);
+				hardDeadlineTimer = null;
+			}
+			child.off("close", handleClose);
+			resolve();
+		};
+		const handleClose = () => {
+			settle();
+		};
+		child.on("close", handleClose);
+		try {
+			signalChildProcess(child, {
+				...options,
+				signal: "SIGTERM"
+			});
+		} catch {}
+		forceKillTimer = setTimeout(() => {
+			try {
+				signalChildProcess(child, {
+					...options,
+					signal: "SIGKILL"
+				});
+			} catch {}
+			hardDeadlineTimer = setTimeout(() => {
+				settle();
+			}, POST_SIGKILL_GRACE_MS);
+			hardDeadlineTimer.unref?.();
+		}, timeoutMs);
+		forceKillTimer.unref?.();
+	});
+}
+//#endregion
+//#region src/core/sleep.ts
+const SYSTEMD_INHIBIT_READY_TIMEOUT_MS = 5e3;
+const SYSTEMD_INHIBIT_READY_POLL_MS = 25;
+const GNHF_SLEEP_REEXEC_READY_PATH = "GNHF_SLEEP_REEXEC_READY_PATH";
+const GNHF_SLEEP_REEXEC_READY_DIR_PREFIX = "fttm-sleep-";
+const GNHF_SLEEP_REEXEC_READY_FILENAME = "reexec-ready";
+const HELPER_STARTUP_GRACE_MS = 100;
+function getSignalExitCode$1(signal) {
+	if (signal === "SIGINT") return 130;
+	if (signal === "SIGTERM") return 143;
+	return 1;
+}
+async function waitForSpawn(child) {
+	return await new Promise((resolve) => {
+		child.once("spawn", () => resolve(true));
+		child.once("error", () => resolve(false));
+	});
+}
+async function waitForHelperStability(child, timeoutMs) {
+	return await new Promise((resolve) => {
+		let settled = false;
+		let timer = null;
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			resolve(value);
+		};
+		child.once("exit", () => {
+			settle(false);
+		});
+		child.once("error", () => {
+			settle(false);
+		});
+		if (child.exitCode != null || child.signalCode != null) {
+			settle(false);
+			return;
+		}
+		timer = setTimeout(() => {
+			settle(true);
+		}, timeoutMs);
+		timer.unref?.();
+	});
+}
+function isTrustedLinuxReexecReadyPath(readyPath) {
+	const resolvedReadyPath = resolve(readyPath);
+	const readyDir = dirname(resolvedReadyPath);
+	return basename(resolvedReadyPath) === GNHF_SLEEP_REEXEC_READY_FILENAME && dirname(readyDir) === resolve(tmpdir()) && basename(readyDir).startsWith(GNHF_SLEEP_REEXEC_READY_DIR_PREFIX);
+}
+function signalLinuxReexecReady(env) {
+	const readyPath = env[GNHF_SLEEP_REEXEC_READY_PATH];
+	if (!readyPath) return;
+	if (!isTrustedLinuxReexecReadyPath(readyPath)) {
+		appendDebugLog("sleep:ready-signal-failed", {
+			command: "systemd-inhibit",
+			error: "untrusted ready path"
+		});
+		return;
+	}
+	try {
+		writeFileSync(readyPath, "ready\n", {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+	} catch (error) {
+		appendDebugLog("sleep:ready-signal-failed", {
+			command: "systemd-inhibit",
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+async function waitForLinuxReexecReady(readyPath, exitStatePromise, timeoutMs) {
+	if (existsSync(readyPath)) return { type: "ready" };
+	return await new Promise((resolve) => {
+		let settled = false;
+		const settle = (result) => {
+			if (settled) return;
+			settled = true;
+			clearInterval(poller);
+			clearTimeout(timeout);
+			resolve(result);
+		};
+		const poller = setInterval(() => {
+			if (existsSync(readyPath)) settle({ type: "ready" });
+		}, SYSTEMD_INHIBIT_READY_POLL_MS);
+		poller.unref?.();
+		const timeout = setTimeout(() => {
+			settle({ type: "timeout" });
+		}, timeoutMs);
+		timeout.unref?.();
+		exitStatePromise.then(({ exitCode, signal }) => {
+			settle({
+				type: "exit",
+				exitCode,
+				signal
+			});
+		});
+	});
+}
+function forwardTerminationSignalsToChild(child, detached, killProcess, processOn, processOff) {
+	const listeners = [];
+	for (const signal of ["SIGINT", "SIGTERM"]) {
+		const listener = () => {
+			try {
+				signalChildProcess(child, {
+					detached,
+					killProcess,
+					signal
+				});
+			} catch {}
+		};
+		processOn(signal, listener);
+		listeners.push([signal, listener]);
+	}
+	return () => {
+		for (const [signal, listener] of listeners) processOff(signal, listener);
+	};
+}
+function buildPowerShellCommand(parentPid) {
+	return [
+		"Add-Type @'",
+		"using System;",
+		"using System.Runtime.InteropServices;",
+		"public static class SleepBlock {",
+		"  [DllImport(\"kernel32.dll\")]",
+		"  public static extern uint SetThreadExecutionState(uint flags);",
+		"}",
+		"'@;",
+		"$ES_CONTINUOUS = 0x80000000;",
+		"$ES_SYSTEM_REQUIRED = 0x00000001;",
+		"[SleepBlock]::SetThreadExecutionState($ES_CONTINUOUS -bor $ES_SYSTEM_REQUIRED) | Out-Null;",
+		`try { Wait-Process -Id ${parentPid} } catch { } finally { [SleepBlock]::SetThreadExecutionState($ES_CONTINUOUS) | Out-Null }`
+	].join("\n");
+}
+async function startHelperProcess(command, args, spawnFn, env) {
+	const child = spawnFn(command, args, {
+		env,
+		stdio: "ignore"
+	});
+	if (!await waitForSpawn(child)) {
+		appendDebugLog("sleep:unavailable", { command });
+		return null;
+	}
+	if (!await waitForHelperStability(child, HELPER_STARTUP_GRACE_MS)) {
+		appendDebugLog("sleep:unavailable", {
+			command,
+			reason: "early-exit"
+		});
+		return null;
+	}
+	return child;
+}
+async function startSleepPrevention(argv, deps = {}) {
+	const env = deps.env ?? process.env;
+	const killProcess = deps.killProcess ?? process.kill.bind(process);
+	const pid = deps.pid ?? process.pid;
+	const platform = deps.platform ?? process.platform;
+	const processExecArgv = deps.processExecArgv ?? process.execArgv;
+	const processArgv1 = deps.processArgv1 ?? process.argv[1];
+	const processExecPath = deps.processExecPath ?? process.execPath;
+	const processOn = deps.processOn ?? process.on.bind(process);
+	const processOff = deps.processOff ?? process.off.bind(process);
+	const reexecEnv = deps.reexecEnv ?? {};
+	const spawnFn = deps.spawn ?? spawn;
+	const detach = deps.detach ?? false;
+	if (platform === "linux") {
+		if (env.GNHF_SLEEP_INHIBITED === "1") {
+			signalLinuxReexecReady(env);
+			return {
+				type: "skipped",
+				reason: "already-inhibited"
+			};
+		}
+		const readyDir = mkdtempSync(join(tmpdir(), GNHF_SLEEP_REEXEC_READY_DIR_PREFIX));
+		const readyPath = join(readyDir, GNHF_SLEEP_REEXEC_READY_FILENAME);
+		const child = spawnFn("systemd-inhibit", [
+			"--what=idle:sleep",
+			"--mode=block",
+			"--who=fttm",
+			"--why=Prevent sleep while fttm is running",
+			processExecPath,
+			...processExecArgv,
+			processArgv1,
+			...argv
+		], {
+			detached: detach,
+			env: {
+				...env,
+				...reexecEnv,
+				GNHF_SLEEP_INHIBITED: "1",
+				[GNHF_SLEEP_REEXEC_READY_PATH]: readyPath
+			},
+			stdio: "inherit"
+		});
+		const exitStatePromise = new Promise((resolve) => {
+			child.once("exit", (code, signal) => {
+				resolve({
+					exitCode: signal ? getSignalExitCode$1(signal) : code ?? 1,
+					signal
+				});
+			});
+		});
+		const stopForwardingSignals = forwardTerminationSignalsToChild(child, true, killProcess, processOn, processOff);
+		if (!await waitForSpawn(child)) {
+			stopForwardingSignals();
+			rmSync(readyDir, {
+				recursive: true,
+				force: true
+			});
+			appendDebugLog("sleep:unavailable", { command: "systemd-inhibit" });
+			return {
+				type: "skipped",
+				reason: "unavailable"
+			};
+		}
+		try {
+			const readyState = await waitForLinuxReexecReady(readyPath, exitStatePromise, SYSTEMD_INHIBIT_READY_TIMEOUT_MS);
+			try {
+				if (readyState.type === "ready") {
+					appendDebugLog("sleep:reexec", { command: "systemd-inhibit" });
+					const { exitCode } = await exitStatePromise;
+					return {
+						type: "reexeced",
+						exitCode
+					};
+				}
+				if (readyState.type === "exit") {
+					if (readyState.signal === "SIGINT" || readyState.signal === "SIGTERM") {
+						appendDebugLog("sleep:reexec", {
+							command: "systemd-inhibit",
+							signal: readyState.signal
+						});
+						return {
+							type: "reexeced",
+							exitCode: readyState.exitCode
+						};
+					}
+					if (readyState.exitCode !== 0) {
+						if (existsSync(readyPath)) {
+							appendDebugLog("sleep:reexec", {
+								command: "systemd-inhibit",
+								exitCode: readyState.exitCode,
+								readySignal: "late"
+							});
+							return {
+								type: "reexeced",
+								exitCode: readyState.exitCode
+							};
+						}
+						appendDebugLog("sleep:unavailable", {
+							command: "systemd-inhibit",
+							exitCode: readyState.exitCode
+						});
+						return {
+							type: "skipped",
+							reason: "unavailable"
+						};
+					}
+					appendDebugLog("sleep:reexec", {
+						command: "systemd-inhibit",
+						readySignal: false
+					});
+					return {
+						type: "reexeced",
+						exitCode: readyState.exitCode
+					};
+				}
+				appendDebugLog("sleep:unavailable", {
+					command: "systemd-inhibit",
+					reason: "timeout",
+					timeoutMs: SYSTEMD_INHIBIT_READY_TIMEOUT_MS
+				});
+				await shutdownChildProcess(child, {
+					detached: true,
+					killProcess,
+					timeoutMs: 1e3
+				});
+				return {
+					type: "skipped",
+					reason: "unavailable"
+				};
+			} finally {
+				stopForwardingSignals();
+			}
+		} finally {
+			rmSync(readyDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	if (platform === "darwin") {
+		if (detach) {
+			if (!await startHelperProcess("caffeinate", ["-i"], spawnFn, env)) return {
+				type: "skipped",
+				reason: "unavailable"
+			};
+			appendDebugLog("sleep:reexec", { command: "caffeinate" });
+			return {
+				type: "reexeced",
+				exitCode: 0
+			};
+		}
+		const child = await startHelperProcess("caffeinate", [
+			"-i",
+			"-w",
+			String(pid)
+		], spawnFn, env);
+		if (!child) return {
+			type: "skipped",
+			reason: "unavailable"
+		};
+		appendDebugLog("sleep:active", { command: "caffeinate" });
+		return {
+			type: "active",
+			cleanup: async () => {
+				appendDebugLog("sleep:cleanup", { command: "caffeinate" });
+				await shutdownChildProcess(child, {
+					detached: false,
+					timeoutMs: 1e3
+				});
+			}
+		};
+	}
+	if (platform === "win32") {
+		const child = await startHelperProcess("powershell.exe", [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+			buildPowerShellCommand(pid)
+		], spawnFn, env);
+		if (!child) return {
+			type: "skipped",
+			reason: "unavailable"
+		};
+		appendDebugLog("sleep:active", { command: "powershell.exe" });
+		return {
+			type: "active",
+			cleanup: async () => {
+				appendDebugLog("sleep:cleanup", { command: "powershell.exe" });
+				await shutdownChildProcess(child, {
+					detached: false,
+					timeoutMs: 1e3
+				});
+			}
+		};
+	}
+	return {
+		type: "skipped",
+		reason: "unsupported"
+	};
+}
+//#endregion
+//#region src/core/agents/stream-utils.ts
+/**
+* Wire stderr collection, spawn-error handling, and the common close-handler
+* 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;
+		}
+		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, abortChild = () => {
+	child.kill("SIGTERM");
+}) {
+	if (!signal) return false;
+	const onAbort = () => {
+		abortChild();
+		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
+function shouldUseWindowsShell$2(bin, platform) {
+	if (platform !== "win32") return false;
+	if (/\.(cmd|bat)$/i.test(bin)) return true;
+	if (/[\\/]/.test(bin)) return false;
+	try {
+		const firstMatch = execFileSync("where", [bin], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+		return firstMatch ? /\.(cmd|bat)$/i.test(firstMatch) : false;
+	} catch {
+		return false;
+	}
+}
+function terminateClaudeProcess(child, platform) {
+	if (platform === "win32" && child.pid) {
+		try {
+			execFileSync("taskkill", [
+				"/T",
+				"/F",
+				"/PID",
+				String(child.pid)
+			], { stdio: "ignore" });
+		} catch {}
+		return;
+	}
+	child.kill("SIGTERM");
+}
+var ClaudeAgent = class {
+	name = "claude";
+	bin;
+	platform;
+	constructor(binOrDeps = {}) {
+		const deps = typeof binOrDeps === "string" ? { bin: binOrDeps } : binOrDeps;
+		this.bin = deps.bin ?? "claude";
+		this.platform = deps.platform ?? process.platform;
+	}
+	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, [
+				"-p",
+				prompt,
+				"--verbose",
+				"--output-format",
+				"stream-json",
+				"--json-schema",
+				JSON.stringify(AGENT_OUTPUT_SCHEMA),
+				"--dangerously-skip-permissions"
+			], {
+				cwd,
+				shell: shouldUseWindowsShell$2(this.bin, this.platform),
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				env: process.env
+			});
+			if (setupAbortHandler(signal, child, reject, () => terminateClaudeProcess(child, this.platform))) return;
+			let resultEvent = null;
+			const cumulative = {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0
+			};
+			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;
+			});
+			setupChildProcessHandlers(child, "claude", logStream, reject, () => {
+				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
+function shouldUseWindowsShell$1(bin, platform) {
+	if (platform !== "win32") return false;
+	if (/\.(cmd|bat)$/i.test(bin)) return true;
+	if (/[\\/]/.test(bin)) return false;
+	try {
+		const firstMatch = execFileSync("where", [bin], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+		return firstMatch ? /\.(cmd|bat)$/i.test(firstMatch) : false;
+	} catch {
+		return false;
+	}
+}
+function terminateCodexProcess(child, platform) {
+	if (platform === "win32" && child.pid) {
+		try {
+			execFileSync("taskkill", [
+				"/T",
+				"/F",
+				"/PID",
+				String(child.pid)
+			], { stdio: "ignore" });
+		} catch {}
+		return;
+	}
+	child.kill("SIGTERM");
+}
+var CodexAgent = class {
+	name = "codex";
+	bin;
+	platform;
+	schemaPath;
+	constructor(schemaPath, binOrDeps = {}) {
+		const deps = typeof binOrDeps === "string" ? { bin: binOrDeps } : binOrDeps;
+		this.bin = deps.bin ?? "codex";
+		this.platform = deps.platform ?? process.platform;
+		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(this.bin, [
+				"exec",
+				prompt,
+				"--json",
+				"--output-schema",
+				this.schemaPath,
+				"--dangerously-bypass-approvals-and-sandbox",
+				"--color",
+				"never"
+			], {
+				cwd,
+				shell: shouldUseWindowsShell$1(this.bin, this.platform),
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				env: process.env
+			});
+			if (setupAbortHandler(signal, child, reject, () => terminateCodexProcess(child, this.platform))) return;
+			let lastAgentMessage = null;
+			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);
+				}
+				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;
+				}
+				try {
+					resolve({
+						output: JSON.parse(lastAgentMessage),
+						usage: cumulative
+					});
+				} catch (err) {
+					reject(/* @__PURE__ */ new Error(`Failed to parse codex output: ${err instanceof Error ? err.message : err}`));
+				}
+			});
+		});
+	}
+};
+//#endregion
+//#region src/core/agents/opencode.ts
+const BLANKET_PERMISSION_RULESET = [{
+	permission: "*",
+	pattern: "*",
+	action: "allow"
+}];
+const STRUCTURED_OUTPUT_FORMAT = {
+	type: "json_schema",
+	schema: AGENT_OUTPUT_SCHEMA,
+	retryCount: 1
+};
+function buildOpencodeChildEnv() {
+	const env = { ...process.env };
+	delete env.OPENCODE_SERVER_USERNAME;
+	delete env.OPENCODE_SERVER_PASSWORD;
+	return env;
+}
+function buildPrompt(prompt) {
+	return [
+		prompt,
+		"",
+		"When you finish, reply with only valid JSON.",
+		"Do not wrap the JSON in markdown fences.",
+		"Do not include any prose before or after the JSON.",
+		`The JSON must match this schema exactly: ${JSON.stringify(AGENT_OUTPUT_SCHEMA)}`
+	].join("\n");
+}
+/**
+* On Windows with `shell: true`, `child.pid` is the `cmd.exe` wrapper, not
+* the actual server process.  `taskkill /T` terminates the entire process
+* tree rooted at that PID so the real server doesn't survive shutdown.
+*/
+async function killWindowsProcessTree(pid) {
+	try {
+		execFileSync("taskkill", [
+			"/T",
+			"/F",
+			"/PID",
+			String(pid)
+		], { stdio: "ignore" });
+	} catch {}
+}
+function createAbortError$1() {
+	return /* @__PURE__ */ new Error("Agent was aborted");
+}
+function isAgentAbortError(error) {
+	return error instanceof Error && error.message === "Agent was aborted";
+}
+function isAbortError$1(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function getAvailablePort$1() {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Failed to allocate a port for opencode"));
+				return;
+			}
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(address.port);
+			});
+		});
+	});
+}
+async function delay$1(ms, signal) {
+	if (!signal) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+		return;
+	}
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(createAbortError$1());
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function toUsage(tokens) {
+	return {
+		inputTokens: tokens?.input ?? 0,
+		outputTokens: tokens?.output ?? 0,
+		cacheReadTokens: tokens?.cache?.read ?? 0,
+		cacheCreationTokens: tokens?.cache?.write ?? 0
+	};
+}
+function withTimeoutSignal$1(signal, timeoutMs) {
+	if (timeoutMs === void 0) return signal;
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+var OpenCodeAgent = class {
+	name = "opencode";
+	bin;
+	model;
+	fetchFn;
+	getPortFn;
+	killProcessFn;
+	platform;
+	spawnFn;
+	server = null;
+	closingPromise = null;
+	constructor(deps = {}) {
+		this.bin = deps.bin ?? "opencode";
+		this.model = deps.model ?? "";
+		this.fetchFn = deps.fetch ?? fetch;
+		this.getPortFn = deps.getPort ?? getAvailablePort$1;
+		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
+		this.platform = deps.platform ?? process.platform;
+		this.spawnFn = deps.spawn ?? spawn;
+	}
+	async run(prompt, cwd, options) {
+		const { onUsage, onMessage, signal, logPath } = options ?? {};
+		const logStream = logPath ? createWriteStream(logPath) : null;
+		const runController = new AbortController();
+		let sessionId = null;
+		const onAbort = () => {
+			runController.abort();
+		};
+		if (signal?.aborted) {
+			logStream?.end();
+			throw createAbortError$1();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			const server = await this.ensureServer(cwd, runController.signal);
+			sessionId = await this.createSession(server, cwd, runController.signal);
+			return await this.streamMessage(server, sessionId, buildPrompt(prompt), runController.signal, logStream, onUsage, onMessage);
+		} catch (error) {
+			if (runController.signal.aborted || isAbortError$1(error)) throw createAbortError$1();
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+			logStream?.end();
+			if (this.server && sessionId) {
+				if (runController.signal.aborted) await this.abortSession(this.server, sessionId);
+				await this.deleteSession(this.server, sessionId);
+			}
+		}
+	}
+	async close() {
+		await this.shutdownServer();
+	}
+	async ensureServer(cwd, signal) {
+		if (this.server && !this.server.closed) if (this.server.cwd !== cwd) await this.shutdownServer();
+		else {
+			await this.server.readyPromise;
+			return this.server;
+		}
+		if (this.server && !this.server.closed) {
+			await this.server.readyPromise;
+			return this.server;
+		}
+		const port = await this.getPortFn();
+		const isWindows = this.platform === "win32";
+		const detached = !isWindows;
+		const args = [
+			"serve",
+			"--hostname",
+			"127.0.0.1",
+			"--port",
+			String(port),
+			"--print-logs"
+		];
+		const child = this.spawnFn(this.bin, args, {
+			cwd,
+			detached,
+			shell: isWindows,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: buildOpencodeChildEnv()
+		});
+		const server = {
+			baseUrl: `http://127.0.0.1:${port}`,
+			child,
+			closed: false,
+			cwd,
+			detached,
+			port,
+			readyPromise: Promise.resolve(),
+			stderr: "",
+			stdout: ""
+		};
+		const maxOutput = 64 * 1024;
+		child.stdout.on("data", (data) => {
+			server.stdout += data.toString();
+			if (server.stdout.length > maxOutput) server.stdout = server.stdout.slice(-maxOutput);
+		});
+		child.stderr.on("data", (data) => {
+			server.stderr += data.toString();
+			if (server.stderr.length > maxOutput) server.stderr = server.stderr.slice(-maxOutput);
+		});
+		child.on("close", () => {
+			server.closed = true;
+			if (this.server === server) this.server = null;
+		});
+		this.server = server;
+		appendDebugLog("opencode:spawn", {
+			cwd,
+			port,
+			detached
+		});
+		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
+			await this.shutdownServer();
+			throw error;
+		});
+		await server.readyPromise;
+		return server;
+	}
+	async waitForHealthy(server, signal) {
+		const deadline = Date.now() + 3e4;
+		let spawnErrorMessage = null;
+		server.child.once("error", (error) => {
+			spawnErrorMessage = error.message;
+		});
+		while (Date.now() < deadline) {
+			if (signal?.aborted) throw createAbortError$1();
+			if (spawnErrorMessage) throw new Error(`Failed to spawn opencode: ${spawnErrorMessage}`);
+			if (server.closed) {
+				const output = server.stderr.trim() || server.stdout.trim();
+				throw new Error(output ? `opencode exited before becoming ready: ${output}` : "opencode exited before becoming ready");
+			}
+			try {
+				if ((await this.fetchFn(`${server.baseUrl}/global/health`, {
+					method: "GET",
+					signal
+				})).ok) return;
+			} catch (error) {
+				if (isAbortError$1(error)) throw createAbortError$1();
+			}
+			await delay$1(250, signal);
+		}
+		throw new Error(`Timed out waiting for opencode serve to become ready on port ${server.port}`);
+	}
+	async createSession(server, cwd, signal) {
+		return (await this.requestJSON(server, "/session", {
+			method: "POST",
+			body: {
+				directory: cwd,
+				permission: BLANKET_PERMISSION_RULESET
+			},
+			signal
+		})).id;
+	}
+	async streamMessage(server, sessionId, prompt, signal, logStream, onUsage, onMessage) {
+		const streamAbortController = new AbortController();
+		const streamSignal = AbortSignal.any([signal, streamAbortController.signal]);
+		const eventResponse = await this.request(server, "/global/event", {
+			method: "GET",
+			headers: { accept: "text/event-stream" },
+			signal: streamSignal
+		});
+		if (!eventResponse.body) throw new Error("opencode returned no event stream body");
+		let messageRequestError = null;
+		const messageRequest = (async () => {
+			try {
+				return {
+					ok: true,
+					body: await this.requestText(server, `/session/${sessionId}/message`, {
+						method: "POST",
+						body: {
+							role: "user",
+							parts: [{
+								type: "text",
+								text: prompt
+							}],
+							...this.model ? { model: (() => {
+								const parts = this.model.split("/");
+								if (parts.length === 2) return {
+									providerID: parts[0],
+									modelID: parts[1]
+								};
+								return {
+									providerID: "opencode",
+									modelID: this.model
+								};
+							})() } : {},
+							format: STRUCTURED_OUTPUT_FORMAT
+						},
+						signal
+					})
+				};
+			} catch (error) {
+				messageRequestError = error;
+				streamAbortController.abort();
+				return {
+					ok: false,
+					error
+				};
+			}
+		})();
+		const usage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0
+		};
+		const usageByMessageId = /* @__PURE__ */ new Map();
+		const textParts = /* @__PURE__ */ new Map();
+		let lastText = null;
+		let lastFinalAnswerText = null;
+		let lastUsageSignature = "0:0:0:0";
+		const updateUsage = (messageId, tokens) => {
+			if (!messageId || !tokens) return;
+			usageByMessageId.set(messageId, toUsage(tokens));
+			let nextInputTokens = 0;
+			let nextOutputTokens = 0;
+			let nextCacheReadTokens = 0;
+			let nextCacheCreationTokens = 0;
+			for (const messageUsage of usageByMessageId.values()) {
+				nextInputTokens += messageUsage.inputTokens;
+				nextOutputTokens += messageUsage.outputTokens;
+				nextCacheReadTokens += messageUsage.cacheReadTokens;
+				nextCacheCreationTokens += messageUsage.cacheCreationTokens;
+			}
+			const signature = [
+				nextInputTokens,
+				nextOutputTokens,
+				nextCacheReadTokens,
+				nextCacheCreationTokens
+			].join(":");
+			usage.inputTokens = nextInputTokens;
+			usage.outputTokens = nextOutputTokens;
+			usage.cacheReadTokens = nextCacheReadTokens;
+			usage.cacheCreationTokens = nextCacheCreationTokens;
+			if (signature !== lastUsageSignature) {
+				lastUsageSignature = signature;
+				onUsage?.({ ...usage });
+			}
+		};
+		const emitText = (partId, nextText, phase) => {
+			const trimmed = nextText.trim();
+			textParts.set(partId, {
+				text: nextText,
+				phase
+			});
+			if (!trimmed) return;
+			lastText = nextText;
+			if (phase === "final_answer") lastFinalAnswerText = nextText;
+			onMessage?.(trimmed);
+		};
+		const handleEvent = (event) => {
+			const payload = event.payload;
+			const properties = payload?.properties;
+			if (!properties || properties.sessionID !== sessionId) return false;
+			if (payload?.type === "message.part.delta" && properties.field === "text" && typeof properties.partID === "string" && typeof properties.delta === "string") {
+				const current = textParts.get(properties.partID);
+				emitText(properties.partID, `${current?.text ?? ""}${properties.delta}`, current?.phase);
+				return false;
+			}
+			if (payload?.type === "message.part.updated") {
+				const part = properties.part;
+				if (!part) return false;
+				if (part.type === "text" && typeof part.id === "string") {
+					emitText(part.id, part.text ?? "", part.metadata?.openai?.phase);
+					return false;
+				}
+				if (part.type === "step-finish") {
+					updateUsage(part.messageID, part.tokens);
+					return false;
+				}
+				return false;
+			}
+			if (payload?.type === "message.updated") {
+				if (properties.info?.role === "assistant") updateUsage(properties.info.id, properties.info.tokens);
+				return false;
+			}
+			return payload?.type === "session.idle";
+		};
+		const decoder = new TextDecoder();
+		const reader = eventResponse.body.getReader();
+		let buffer = "";
+		let sawSessionIdle = false;
+		const processRawEvent = (rawEvent) => {
+			if (!rawEvent.trim()) return;
+			const dataLines = rawEvent.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+			if (dataLines.length === 0) return;
+			try {
+				if (handleEvent(JSON.parse(dataLines.join("\n")))) sawSessionIdle = true;
+			} catch {}
+		};
+		const processBufferedEvents = (flushRemainder = false) => {
+			while (true) {
+				const lfBoundary = buffer.indexOf("\n\n");
+				const crlfBoundary = buffer.indexOf("\r\n\r\n");
+				let boundary;
+				let separatorLen;
+				if (lfBoundary === -1 && crlfBoundary === -1) break;
+				if (crlfBoundary !== -1 && (lfBoundary === -1 || crlfBoundary < lfBoundary)) {
+					boundary = crlfBoundary;
+					separatorLen = 4;
+				} else {
+					boundary = lfBoundary;
+					separatorLen = 2;
+				}
+				processRawEvent(buffer.slice(0, boundary));
+				buffer = buffer.slice(boundary + separatorLen);
+				if (sawSessionIdle) return;
+			}
+			if (flushRemainder && buffer.trim()) {
+				processRawEvent(buffer);
+				buffer = "";
+			}
+		};
+		try {
+			while (!sawSessionIdle) {
+				let readResult;
+				try {
+					readResult = await reader.read();
+				} catch (error) {
+					if (messageRequestError) {
+						if (isAbortError$1(messageRequestError) || isAgentAbortError(messageRequestError)) throw createAbortError$1();
+						throw messageRequestError;
+					}
+					if (isAbortError$1(error)) throw createAbortError$1();
+					throw error;
+				}
+				if (readResult.done) {
+					const tail = decoder.decode();
+					if (tail) {
+						logStream?.write(tail);
+						buffer += tail;
+					}
+					processBufferedEvents(true);
+					break;
+				}
+				const chunk = decoder.decode(readResult.value, { stream: true });
+				logStream?.write(chunk);
+				buffer += chunk;
+				processBufferedEvents();
+			}
+		} finally {
+			streamAbortController.abort();
+			await reader.cancel().catch(() => void 0);
+		}
+		const messageResult = await messageRequest;
+		if (!messageResult.ok) {
+			if (isAbortError$1(messageResult.error) || isAgentAbortError(messageResult.error)) throw createAbortError$1();
+			throw messageResult.error;
+		}
+		const body = messageResult.body;
+		let response;
+		try {
+			response = JSON.parse(body);
+		} catch (error) {
+			throw new Error(`Failed to parse opencode response: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (response.info?.role === "assistant") updateUsage(response.info.id, response.info.tokens);
+		for (const part of response.parts ?? []) {
+			if (part.type !== "text" || typeof part.text !== "string") continue;
+			if (!part.text.trim()) continue;
+			lastText = part.text;
+			if (part.metadata?.openai?.phase === "final_answer") lastFinalAnswerText = part.text;
+		}
+		if (response.info?.structured) return {
+			output: response.info.structured,
+			usage
+		};
+		const outputText = lastFinalAnswerText ?? lastText;
+		if (!outputText) throw new Error("opencode returned no text output");
+		try {
+			return {
+				output: JSON.parse(outputText),
+				usage
+			};
+		} catch (error) {
+			throw new Error(`Failed to parse opencode output: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async deleteSession(server, sessionId) {
+		try {
+			await this.request(server, `/session/${sessionId}`, {
+				method: "DELETE",
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async abortSession(server, sessionId) {
+		try {
+			await this.request(server, `/session/${sessionId}/abort`, {
+				method: "POST",
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async shutdownServer() {
+		if (!this.server || this.server.closed) {
+			this.server = null;
+			return;
+		}
+		if (this.closingPromise) {
+			await this.closingPromise;
+			return;
+		}
+		const server = this.server;
+		appendDebugLog("opencode:shutdown", {
+			cwd: server.cwd,
+			port: server.port
+		});
+		this.closingPromise = (this.platform === "win32" && server.child.pid ? killWindowsProcessTree(server.child.pid) : shutdownChildProcess(server.child, {
+			detached: server.detached,
+			killProcess: this.killProcessFn,
+			timeoutMs: 3e3
+		})).finally(() => {
+			if (this.server === server) this.server = null;
+			this.closingPromise = null;
+		});
+		await this.closingPromise;
+	}
+	async requestJSON(server, path, options) {
+		const body = await this.requestText(server, path, options);
+		return JSON.parse(body);
+	}
+	async requestText(server, path, options) {
+		return await (await this.request(server, path, options)).text();
+	}
+	async request(server, path, options) {
+		const headers = new Headers(options.headers);
+		if (options.body !== void 0) headers.set("content-type", "application/json");
+		const signal = withTimeoutSignal$1(options.signal, options.timeoutMs);
+		const response = await this.fetchFn(`${server.baseUrl}${path}`, {
+			method: options.method,
+			headers,
+			body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+			signal
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw new Error(`opencode ${options.method} ${path} failed with ${response.status}: ${body}`);
+		}
+		return response;
+	}
+};
+//#endregion
+//#region src/core/agents/rovodev.ts
+function buildSystemPrompt(schema) {
+	return [
+		"You are the coding agent used by fttm.",
+		"Work autonomously in the current workspace and use tools when needed.",
+		"When you finish, reply with only valid JSON.",
+		"Do not wrap the JSON in markdown fences.",
+		"Do not include any prose before or after the JSON.",
+		`The JSON must match this schema exactly: ${schema}`
+	].join(" ");
+}
+function createAbortError() {
+	return /* @__PURE__ */ new Error("Agent was aborted");
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function shouldUseWindowsShell(bin, platform) {
+	if (platform !== "win32") return false;
+	if (/\.(cmd|bat)$/i.test(bin)) return true;
+	if (/[\\/]/.test(bin)) return false;
+	try {
+		const firstMatch = execFileSync("where", [bin], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+		return firstMatch ? /\.(cmd|bat)$/i.test(firstMatch) : false;
+	} catch {
+		return false;
+	}
+}
+function terminateRovoDevProcess(child, platform) {
+	if (platform === "win32" && child.pid) {
+		try {
+			execFileSync("taskkill", [
+				"/T",
+				"/F",
+				"/PID",
+				String(child.pid)
+			], { stdio: "ignore" });
+		} catch {}
+		return;
+	}
+	child.kill("SIGTERM");
+}
+function getAvailablePort() {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Failed to allocate a port for rovodev"));
+				return;
+			}
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(address.port);
+			});
+		});
+	});
+}
+async function delay(ms, signal) {
+	if (!signal) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+		return;
+	}
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(createAbortError());
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+var RovoDevAgent = class {
+	name = "rovodev";
+	bin;
+	schemaPath;
+	fetchFn;
+	getPortFn;
+	killProcessFn;
+	platform;
+	spawnFn;
+	server = null;
+	closingPromise = null;
+	constructor(schemaPath, deps = {}) {
+		this.bin = deps.bin ?? "acli";
+		this.schemaPath = schemaPath;
+		this.fetchFn = deps.fetch ?? fetch;
+		this.getPortFn = deps.getPort ?? getAvailablePort;
+		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
+		this.platform = deps.platform ?? process.platform;
+		this.spawnFn = deps.spawn ?? spawn;
+	}
+	async run(prompt, cwd, options) {
+		const { onUsage, onMessage, signal, logPath } = options ?? {};
+		const logStream = logPath ? createWriteStream(logPath) : null;
+		const runController = new AbortController();
+		let sessionId = null;
+		const onAbort = () => {
+			runController.abort();
+		};
+		if (signal?.aborted) {
+			logStream?.end();
+			throw createAbortError();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			const server = await this.ensureServer(cwd, runController.signal);
+			sessionId = await this.createSession(server, runController.signal);
+			await this.setInlineSystemPrompt(server, sessionId, runController.signal);
+			await this.setChatMessage(server, sessionId, prompt, runController.signal);
+			return await this.streamChat(server, sessionId, runController.signal, logStream, onUsage, onMessage);
+		} catch (error) {
+			if (runController.signal.aborted || isAbortError(error)) throw createAbortError();
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+			logStream?.end();
+			if (this.server && sessionId) {
+				if (runController.signal.aborted) await this.cancelSession(this.server, sessionId);
+				await this.deleteSession(this.server, sessionId);
+			}
+		}
+	}
+	async close() {
+		await this.shutdownServer();
+	}
+	async ensureServer(cwd, signal) {
+		if (this.server && !this.server.closed && this.server.cwd === cwd) {
+			await this.server.readyPromise;
+			return this.server;
+		}
+		if (this.server && !this.server.closed) await this.shutdownServer();
+		const port = await this.getPortFn();
+		const detached = this.platform !== "win32";
+		const child = this.spawnFn(this.bin, [
+			"rovodev",
+			"serve",
+			"--disable-session-token",
+			String(port)
+		], {
+			cwd,
+			detached,
+			shell: shouldUseWindowsShell(this.bin, this.platform),
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: process.env
+		});
+		const server = {
+			baseUrl: `http://127.0.0.1:${port}`,
+			child,
+			cwd,
+			detached,
+			port,
+			readyPromise: Promise.resolve(),
+			closed: false,
+			stdout: "",
+			stderr: ""
+		};
+		const MAX_OUTPUT = 64 * 1024;
+		child.stdout.on("data", (data) => {
+			server.stdout += data.toString();
+			if (server.stdout.length > MAX_OUTPUT) server.stdout = server.stdout.slice(-MAX_OUTPUT);
+		});
+		child.stderr.on("data", (data) => {
+			server.stderr += data.toString();
+			if (server.stderr.length > MAX_OUTPUT) server.stderr = server.stderr.slice(-MAX_OUTPUT);
+		});
+		child.on("close", () => {
+			server.closed = true;
+			if (this.server === server) this.server = null;
+		});
+		this.server = server;
+		appendDebugLog("rovodev:spawn", {
+			cwd,
+			port,
+			detached
+		});
+		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
+			await this.shutdownServer();
+			throw error;
+		});
+		await server.readyPromise;
+		return server;
+	}
+	async waitForHealthy(server, signal) {
+		const deadline = Date.now() + 3e4;
+		let spawnErrorMessage = null;
+		server.child.once("error", (error) => {
+			spawnErrorMessage = error.message;
+		});
+		while (Date.now() < deadline) {
+			if (signal?.aborted) throw createAbortError();
+			if (spawnErrorMessage) throw new Error(`Failed to spawn rovodev: ${spawnErrorMessage}`);
+			if (server.closed) {
+				const output = server.stderr.trim() || server.stdout.trim();
+				throw new Error(output ? `rovodev exited before becoming ready: ${output}` : "rovodev exited before becoming ready");
+			}
+			try {
+				if ((await this.fetchFn(`${server.baseUrl}/healthcheck`, {
+					method: "GET",
+					signal
+				})).ok) return;
+			} catch (error) {
+				if (isAbortError(error)) throw createAbortError();
+			}
+			await delay(250, signal);
+		}
+		throw new Error(`Timed out waiting for rovodev serve to become ready on port ${server.port}`);
+	}
+	async createSession(server, signal) {
+		return (await this.requestJSON(server, "/v3/sessions/create", {
+			method: "POST",
+			body: { custom_title: "fttm" },
+			signal
+		})).session_id;
+	}
+	async setInlineSystemPrompt(server, sessionId, signal) {
+		const schema = readFileSync(this.schemaPath, "utf-8").trim();
+		await this.requestJSON(server, "/v3/inline-system-prompt", {
+			method: "PUT",
+			sessionId,
+			body: { prompt: buildSystemPrompt(schema) },
+			signal
+		});
+	}
+	async setChatMessage(server, sessionId, prompt, signal) {
+		await this.requestJSON(server, "/v3/set_chat_message", {
+			method: "POST",
+			sessionId,
+			body: { message: prompt },
+			signal
+		});
+	}
+	async cancelSession(server, sessionId) {
+		try {
+			await this.request(server, "/v3/cancel", {
+				method: "POST",
+				sessionId,
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async deleteSession(server, sessionId) {
+		try {
+			await this.request(server, `/v3/sessions/${sessionId}`, {
+				method: "DELETE",
+				sessionId,
+				timeoutMs: 1e3
+			});
+		} catch {}
+	}
+	async streamChat(server, sessionId, signal, logStream, onUsage, onMessage) {
+		const response = await this.request(server, "/v3/stream_chat", {
+			method: "GET",
+			sessionId,
+			headers: { accept: "text/event-stream" },
+			signal
+		});
+		if (!response.body) throw new Error("rovodev returned no response body");
+		const usage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0
+		};
+		let latestTextSegment = "";
+		let currentTextParts = [];
+		let currentTextIndexes = /* @__PURE__ */ new Map();
+		const decoder = new TextDecoder();
+		const reader = response.body.getReader();
+		let buffer = "";
+		const emitMessage = () => {
+			const message = currentTextParts.join("").trim();
+			if (message) {
+				latestTextSegment = message;
+				onMessage?.(message);
+			}
+		};
+		const resetCurrentMessage = () => {
+			currentTextParts = [];
+			currentTextIndexes = /* @__PURE__ */ new Map();
+		};
+		const handleUsage = (event) => {
+			usage.inputTokens += event.input_tokens ?? 0;
+			usage.outputTokens += event.output_tokens ?? 0;
+			usage.cacheReadTokens += event.cache_read_tokens ?? 0;
+			usage.cacheCreationTokens += event.cache_write_tokens ?? 0;
+			onUsage?.({ ...usage });
+		};
+		const handleEvent = (rawEvent) => {
+			const lines = rawEvent.split(/\r?\n/);
+			let eventName = "";
+			const dataLines = [];
+			for (const line of lines) {
+				if (line.startsWith("event:")) {
+					eventName = line.slice(6).trim();
+					continue;
+				}
+				if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+			}
+			const rawData = dataLines.join("\n");
+			if (rawData.length === 0) return;
+			let payload;
+			try {
+				payload = JSON.parse(rawData);
+			} catch {
+				return;
+			}
+			const kind = eventName || (typeof payload.event_kind === "string" ? payload.event_kind : "");
+			if (kind === "request-usage") {
+				handleUsage(payload);
+				return;
+			}
+			if (kind === "tool-return" || kind === "on_call_tools_start") {
+				resetCurrentMessage();
+				return;
+			}
+			if (kind === "text") {
+				const content = payload.content;
+				if (typeof content === "string") {
+					currentTextParts = [content];
+					currentTextIndexes = /* @__PURE__ */ new Map();
+					emitMessage();
+				}
+				return;
+			}
+			if (kind === "part_start") {
+				const partStart = payload;
+				if (typeof partStart.index === "number" && partStart.part?.part_kind === "text" && typeof partStart.part.content === "string") {
+					const nextIndex = currentTextParts.push(partStart.part.content) - 1;
+					currentTextIndexes.set(partStart.index, nextIndex);
+					emitMessage();
+				}
+				return;
+			}
+			if (kind === "part_delta") {
+				const partDelta = payload;
+				if (typeof partDelta.index === "number" && partDelta.delta?.part_delta_kind === "text" && typeof partDelta.delta.content_delta === "string") {
+					const textIndex = currentTextIndexes.get(partDelta.index);
+					if (textIndex === void 0) {
+						const nextIndex = currentTextParts.push(partDelta.delta.content_delta) - 1;
+						currentTextIndexes.set(partDelta.index, nextIndex);
+					} else currentTextParts[textIndex] += partDelta.delta.content_delta;
+					emitMessage();
+				}
+			}
+		};
+		while (true) {
+			let readResult;
+			try {
+				readResult = await reader.read();
+			} catch (error) {
+				if (isAbortError(error)) throw createAbortError();
+				throw error;
+			}
+			if (readResult.done) break;
+			const chunk = decoder.decode(readResult.value, { stream: true });
+			logStream?.write(chunk);
+			buffer += chunk;
+			while (true) {
+				const lfBoundary = buffer.indexOf("\n\n");
+				const crlfBoundary = buffer.indexOf("\r\n\r\n");
+				let boundary;
+				let separatorLen;
+				if (lfBoundary === -1 && crlfBoundary === -1) break;
+				if (crlfBoundary !== -1 && (lfBoundary === -1 || crlfBoundary < lfBoundary)) {
+					boundary = crlfBoundary;
+					separatorLen = 4;
+				} else {
+					boundary = lfBoundary;
+					separatorLen = 2;
+				}
+				const rawEvent = buffer.slice(0, boundary);
+				buffer = buffer.slice(boundary + separatorLen);
+				if (rawEvent.trim()) handleEvent(rawEvent);
+			}
+		}
+		buffer += decoder.decode();
+		if (buffer.trim()) handleEvent(buffer);
+		const finalText = latestTextSegment.trim();
+		if (!finalText) throw new Error("rovodev returned no text output");
+		try {
+			return {
+				output: JSON.parse(finalText),
+				usage
+			};
+		} catch (error) {
+			throw new Error(`Failed to parse rovodev output: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async shutdownServer() {
+		if (!this.server || this.server.closed) {
+			this.server = null;
+			return;
+		}
+		if (this.closingPromise) {
+			await this.closingPromise;
+			return;
+		}
+		const server = this.server;
+		appendDebugLog("rovodev:shutdown", {
+			cwd: server.cwd,
+			port: server.port
+		});
+		this.closingPromise = this.platform === "win32" ? new Promise((resolve) => {
+			const handleClose = () => {
+				server.child.off("close", handleClose);
+				resolve();
+			};
+			server.child.on("close", handleClose);
+			try {
+				terminateRovoDevProcess(server.child, this.platform);
+			} catch {
+				server.child.off("close", handleClose);
+				resolve();
+				return;
+			}
+			setTimeout(() => {
+				server.child.off("close", handleClose);
+				resolve();
+			}, 100).unref?.();
+		}) : shutdownChildProcess(server.child, {
+			detached: server.detached,
+			killProcess: this.killProcessFn,
+			timeoutMs: 3e3
+		});
+		this.closingPromise = this.closingPromise.finally(() => {
+			if (this.server === server) this.server = null;
+			this.closingPromise = null;
+		});
+		await this.closingPromise;
+	}
+	async requestJSON(server, path, options) {
+		return await (await this.request(server, path, options)).json();
+	}
+	async request(server, path, options) {
+		const headers = new Headers(options.headers);
+		if (options.sessionId) headers.set("x-session-id", options.sessionId);
+		if (options.body !== void 0 && !headers.has("content-type")) headers.set("content-type", "application/json");
+		const signal = withTimeoutSignal(options.signal, options.timeoutMs);
+		const response = await this.fetchFn(`${server.baseUrl}${path}`, {
+			method: options.method,
+			headers,
+			body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+			signal
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw new Error(`rovodev ${options.method} ${path} failed with ${response.status}: ${body}`);
+		}
+		return response;
+	}
+};
+function withTimeoutSignal(signal, timeoutMs) {
+	if (timeoutMs === void 0) return signal;
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+//#endregion
+//#region src/core/agents/factory.ts
+function createAgent(name, runInfo, pathOverride, model) {
+	switch (name) {
+		case "claude": return new ClaudeAgent(pathOverride);
+		case "codex": return new CodexAgent(runInfo.schemaPath, pathOverride);
+		case "opencode": return new OpenCodeAgent({
+			bin: pathOverride,
+			model
+		});
+		case "rovodev": return new RovoDevAgent(runInfo.schemaPath, { bin: pathOverride });
+	}
+}
+//#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 .fttm/runs/${params.runId}/notes.md first to understand what has been done in previous iterations.
+2. Focus on the next smallest logical unit of work that's individually testable and would make incremental progress towards the objective - that's the scope of this iteration.
+3. If you made code changes, 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 fttm orchestrator.
+5. When you are done, respond with a JSON object according to the provided schema.
+
+## Output
+
+- success: whether you were able to complete your iteration. set to false only if something made it impossible for you to do your work
+- summary: a concise one-sentence summary of the accomplishment in this iteration
+- key_changes_made: an array of descriptions for key changes you made. don't group this by file - group by logical units of work. don't describe activities - describe material outcomes
+- key_learnings: an array of new learnings that were surprising and weren't captured by previous notes
+
+## Objective
+
+${params.prompt}`;
+}
+//#endregion
+//#region src/core/orchestrator.ts
+const STOP_CLOSE_AGENT_GRACE_MS = 250;
+var Orchestrator = class extends EventEmitter {
+	config;
+	agent;
+	runInfo;
+	cwd;
+	prompt;
+	limits;
+	stopRequested = false;
+	stopPromise = null;
+	activeIterationPromise = null;
+	activeAbortController = null;
+	pendingAbortReason = null;
+	state = {
+		status: "running",
+		currentIteration: 0,
+		maxIterations: void 0,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		commitCount: 0,
+		iterations: [],
+		successCount: 0,
+		failCount: 0,
+		consecutiveFailures: 0,
+		startTime: /* @__PURE__ */ new Date(),
+		waitingUntil: null,
+		lastMessage: null
+	};
+	constructor(config, agent, runInfo, prompt, cwd, startIteration = 0, limits = {}) {
+		super();
+		this.config = config;
+		this.agent = agent;
+		this.runInfo = runInfo;
+		this.prompt = prompt;
+		this.cwd = cwd;
+		this.limits = limits;
+		this.state.currentIteration = startIteration;
+		this.state.maxIterations = limits.maxIterations;
+		this.state.commitCount = getBranchCommitCount(this.runInfo.baseCommit, this.cwd);
+	}
+	getState() {
+		return { ...this.state };
+	}
+	stop() {
+		this.stopRequested = true;
+		this.activeAbortController?.abort();
+		if (this.stopPromise) return;
+		this.stopPromise = (async () => {
+			if (this.activeIterationPromise) {
+				const iterationPromise = this.activeIterationPromise.catch(() => void 0);
+				await new Promise((resolve) => {
+					let settled = false;
+					const settle = () => {
+						if (settled) return;
+						settled = true;
+						clearTimeout(timer);
+						resolve();
+					};
+					const timer = setTimeout(settle, STOP_CLOSE_AGENT_GRACE_MS);
+					timer.unref?.();
+					iterationPromise.finally(settle);
+				});
+				await this.closeAgent();
+				await iterationPromise;
+			} else await this.closeAgent();
+			resetHard(this.cwd);
+			this.state.status = "stopped";
+			this.emit("state", this.getState());
+			this.emit("stopped");
+		})();
+	}
+	async start() {
+		this.state.startTime = /* @__PURE__ */ new Date();
+		this.state.status = "running";
+		this.emit("state", this.getState());
+		try {
+			while (!this.stopRequested) {
+				const preIterationAbortReason = this.getPreIterationAbortReason();
+				if (preIterationAbortReason) {
+					this.abort(preIterationAbortReason);
+					break;
+				}
+				this.state.currentIteration++;
+				this.state.status = "running";
+				this.emit("iteration:start", this.state.currentIteration);
+				this.emit("state", this.getState());
+				const iterationPrompt = buildIterationPrompt({
+					n: this.state.currentIteration,
+					runId: this.runInfo.runId,
+					prompt: this.prompt
+				});
+				this.activeIterationPromise = this.runIteration(iterationPrompt);
+				const result = await this.activeIterationPromise;
+				this.activeIterationPromise = null;
+				if (result.type === "stopped") break;
+				if (result.type === "aborted") {
+					this.abort(result.reason);
+					break;
+				}
+				const { record } = result;
+				this.state.iterations.push(record);
+				this.emit("iteration:end", record);
+				this.emit("state", this.getState());
+				const postIterationAbortReason = this.getPostIterationAbortReason();
+				if (postIterationAbortReason) {
+					this.abort(postIterationAbortReason);
+					break;
+				}
+				if (this.state.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+					this.abort(`${this.config.maxConsecutiveFailures} consecutive failures`);
+					break;
+				}
+				if (this.state.consecutiveFailures > 0 && !this.stopRequested) {
+					const backoffMs = 6e4 * Math.pow(2, this.state.consecutiveFailures - 1);
+					this.state.status = "waiting";
+					this.state.waitingUntil = new Date(Date.now() + backoffMs);
+					this.emit("state", this.getState());
+					await this.interruptibleSleep(backoffMs);
+					this.state.waitingUntil = null;
+					if (!this.stopRequested) {
+						this.state.status = "running";
+						this.emit("state", this.getState());
+					}
+				}
+			}
+		} finally {
+			this.activeIterationPromise = null;
+			if (this.stopPromise) await this.stopPromise;
+			else await this.closeAgent();
+		}
+	}
+	async runIteration(prompt) {
+		const baseInputTokens = this.state.totalInputTokens;
+		const baseOutputTokens = this.state.totalOutputTokens;
+		this.activeAbortController = new AbortController();
+		this.pendingAbortReason = null;
+		const onUsage = (usage) => {
+			this.state.totalInputTokens = baseInputTokens + usage.inputTokens;
+			this.state.totalOutputTokens = baseOutputTokens + usage.outputTokens;
+			this.emit("state", this.getState());
+			const reason = this.getTokenAbortReason();
+			if (reason && this.activeAbortController && !this.activeAbortController.signal.aborted) {
+				this.pendingAbortReason = reason;
+				this.activeAbortController.abort();
+			}
+		};
+		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 (this.stopRequested) return { type: "stopped" };
+			if (result.output.success) return {
+				type: "completed",
+				record: this.recordSuccess(result.output)
+			};
+			return {
+				type: "completed",
+				record: this.recordFailure(`[FAIL] ${result.output.summary}`, result.output.summary, result.output.key_learnings)
+			};
+		} catch (err) {
+			if (this.pendingAbortReason && err instanceof Error && err.message === "Agent was aborted") {
+				resetHard(this.cwd);
+				return {
+					type: "aborted",
+					reason: this.pendingAbortReason
+				};
+			}
+			if (this.stopRequested) return { type: "stopped" };
+			const summary = err instanceof Error ? err.message : String(err);
+			return {
+				type: "completed",
+				record: this.recordFailure(`[ERROR] ${summary}`, summary, [])
+			};
+		} finally {
+			this.activeAbortController = null;
+			this.pendingAbortReason = null;
+		}
+	}
+	recordSuccess(output) {
+		appendNotes(this.runInfo.notesPath, this.state.currentIteration, output.summary, output.key_changes_made, output.key_learnings);
+		commitAll(`fttm #${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();
+			const timer = setTimeout(() => {
+				this.activeAbortController = null;
+				resolve();
+			}, ms);
+			this.activeAbortController.signal.addEventListener("abort", () => {
+				clearTimeout(timer);
+				this.activeAbortController = null;
+				resolve();
+			});
+		});
+	}
+	getPreIterationAbortReason() {
+		if (this.limits.maxIterations !== void 0 && this.state.currentIteration >= this.limits.maxIterations) return `max iterations reached (${this.limits.maxIterations})`;
+		return this.getTokenAbortReason();
+	}
+	getPostIterationAbortReason() {
+		if (this.limits.maxIterations !== void 0 && this.state.currentIteration >= this.limits.maxIterations) return `max iterations reached (${this.limits.maxIterations})`;
+		return this.getTokenAbortReason();
+	}
+	getTokenAbortReason() {
+		if (this.limits.maxTokens === void 0) return null;
+		const totalTokens = this.state.totalInputTokens + this.state.totalOutputTokens;
+		if (totalTokens < this.limits.maxTokens) return null;
+		return `max tokens reached (${totalTokens}/${this.limits.maxTokens})`;
+	}
+	abort(reason) {
+		this.state.status = "aborted";
+		this.state.lastMessage = reason;
+		this.state.waitingUntil = null;
+		this.emit("abort", reason);
+		this.emit("state", this.getState());
+	}
+	async closeAgent() {
+		try {
+			await this.agent.close?.();
+		} catch {}
+	}
+};
+//#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,
+		commitCount: 11,
+		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" || star.rest === "hidden") {
+		const opposite = star.rest === "bright" ? "hidden" : "bright";
+		if (t > .0325) return "dim";
+		if (t > .0175) return opposite;
+		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/terminal-width.ts
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+const MARK_REGEX = /\p{Mark}/u;
+const REGIONAL_INDICATOR_REGEX = /\p{Regional_Indicator}/u;
+const EXTENDED_PICTOGRAPHIC_REGEX = /\p{Extended_Pictographic}/u;
+function isFullWidthCodePoint(codePoint) {
+	return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12871 && codePoint !== 12351 || codePoint >= 12880 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42182 || codePoint >= 43360 && codePoint <= 43388 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65131 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 110592 && codePoint <= 110593 || codePoint >= 127488 && codePoint <= 127569 || codePoint >= 131072 && codePoint <= 262141);
+}
+function codePointWidth(codePoint) {
+	if (codePoint === 0 || codePoint === 8204 || codePoint === 8205 || codePoint === 65038 || codePoint === 65039) return 0;
+	if (MARK_REGEX.test(String.fromCodePoint(codePoint))) return 0;
+	return isFullWidthCodePoint(codePoint) ? 2 : 1;
+}
+function isWideEmojiGrapheme(grapheme) {
+	return grapheme.includes("‍") || grapheme.includes("️") || grapheme.includes("⃣") || REGIONAL_INDICATOR_REGEX.test(grapheme) || Array.from(grapheme).some((char) => EXTENDED_PICTOGRAPHIC_REGEX.test(char));
+}
+function splitGraphemes(text) {
+	return Array.from(graphemeSegmenter.segment(text), ({ segment }) => segment);
+}
+function graphemeWidth(grapheme) {
+	if (!grapheme) return 0;
+	if (isWideEmojiGrapheme(grapheme)) return 2;
+	let width = 0;
+	for (const char of grapheme) width += codePointWidth(char.codePointAt(0) ?? 0);
+	return width;
+}
+function stringWidth(text) {
+	let width = 0;
+	for (const grapheme of splitGraphemes(text)) width += graphemeWidth(grapheme);
+	return width;
+}
+//#endregion
+//#region src/utils/wordwrap.ts
+function sliceToWidth(text, width) {
+	let result = "";
+	let currentWidth = 0;
+	for (const grapheme of splitGraphemes(text)) {
+		const nextWidth = currentWidth + graphemeWidth(grapheme);
+		if (nextWidth > width) break;
+		result += grapheme;
+		currentWidth = nextWidth;
+	}
+	return result;
+}
+function splitByWidth(text, width) {
+	const lines = [];
+	let current = "";
+	let currentWidth = 0;
+	for (const grapheme of splitGraphemes(text)) {
+		const glyphWidth = graphemeWidth(grapheme);
+		if (current && currentWidth + glyphWidth > width) {
+			lines.push(current);
+			current = grapheme;
+			currentWidth = glyphWidth;
+			continue;
+		}
+		current += grapheme;
+		currentWidth += glyphWidth;
+	}
+	if (current) lines.push(current);
+	return lines;
+}
+function wordWrap(text, width, maxLines) {
+	if (!text) return [];
+	const lines = [];
+	for (const paragraph of text.split("\n")) {
+		const words = paragraph.split(/\s+/).filter(Boolean);
+		if (words.length === 0) {
+			lines.push("");
+			continue;
+		}
+		let current = "";
+		let currentWidth = 0;
+		for (const word of words) {
+			const wordWidth = stringWidth(word);
+			if (wordWidth > width) {
+				if (current) {
+					lines.push(current);
+					current = "";
+					currentWidth = 0;
+				}
+				for (const slice of splitByWidth(word, width)) lines.push(slice);
+				continue;
+			}
+			const nextWidth = current ? currentWidth + 1 + wordWidth : wordWidth;
+			if (current && nextWidth > width) {
+				lines.push(current);
+				current = word;
+				currentWidth = wordWidth;
+			} else {
+				current = current ? current + " " + word : word;
+				currentWidth = nextWidth;
+			}
+		}
+		if (current) lines.push(current);
+	}
+	if (maxLines && lines.length > maxLines) {
+		const capped = lines.slice(0, maxLines);
+		const last = capped[maxLines - 1];
+		capped[maxLines - 1] = stringWidth(last) >= width ? sliceToWidth(last, 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: graphemeWidth(char)
+	};
+}
+function textToCells(text, style) {
+	const cells = [];
+	for (const grapheme of splitGraphemes(text)) {
+		const cell = makeCell(grapheme, 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 = CONTENT_WIDTH;
+const RESUME_HINT = "[ctrl+c to stop, fttm again to resume]";
+function spacedLabel(text) {
+	return text.split("").join(" ");
+}
+function renderTitleCells(agentName) {
+	return [
+		[...textToCells(spacedLabel("fttm"), "dim"), ...agentName ? [
+			...textToCells("  ", "normal"),
+			...textToCells("·", "dim"),
+			...textToCells("  ", "normal"),
+			...textToCells(spacedLabel(agentName), "dim")
+		] : []],
+		[],
+		textToCells("┏━╸╻  ╻ ╻   ╺┳╸┏━┓   ╺┳╸╻ ╻┏━╸   ┏┳┓┏━┓┏━┓┏┓╻", "bold"),
+		textToCells("┣╸ ┃  ┗┳┛    ┃ ┃ ┃    ┃ ┣━┫┣╸    ┃┃┃┃ ┃┃ ┃┃┗┫", "bold"),
+		textToCells("╹  ┗━┛ ╹     ╹ ┗━┛    ╹ ╹ ╹┗━╸   ╹ ╹┗━┛┗━┛╹ ╹", "bold")
+	];
+}
+function renderStatsCells(elapsed, inputTokens, outputTokens, commitCount, currentIteration, maxIterations) {
+	const commitLabel = commitCount === 1 ? "commit" : "commits";
+	const iterationStr = maxIterations !== void 0 ? `${currentIteration}/${maxIterations}` : `${currentIteration}/\u221e`;
+	return [
+		...textToCells(elapsed, "bold"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`iter ${iterationStr}`, "normal"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`${formatTokens(inputTokens)} in`, "normal"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`${formatTokens(outputTokens)} out`, "normal"),
+		...textToCells("  ", "normal"),
+		...textToCells("·", "dim"),
+		...textToCells("  ", "normal"),
+		...textToCells(`${commitCount} ${commitLabel}`, "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 placeStarsInCells(cells, stars, row, xMin, xMax, xOffset, now) {
+	for (const star of stars) {
+		if (star.y !== row || star.x < xMin || star.x >= xMax) continue;
+		const state = getStarState(star, now);
+		const localX = star.x - xOffset;
+		cells[localX] = state === "hidden" ? {
+			char: " ",
+			style: "normal",
+			width: 1
+		} : {
+			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);
+	placeStarsInCells(cells, stars, rowIndex, xOffset, xOffset + sideWidth, xOffset, now);
+	return cells;
+}
+function clampCellsToWidth(content, width) {
+	if (content.length <= width) return content;
+	const clamped = [];
+	let remaining = width;
+	for (let i = 0; i < content.length && remaining > 0; i++) {
+		const cell = content[i];
+		if (cell.width === 0) continue;
+		if (cell.width > remaining) break;
+		clamped.push(cell);
+		remaining -= cell.width;
+		if (cell.width === 2 && content[i + 1]?.width === 0) {
+			clamped.push(content[i + 1]);
+			i += 1;
+		}
+	}
+	return clamped;
+}
+function centerLineCells(content, width) {
+	const clamped = clampCellsToWidth(content, width);
+	const w = clamped.length;
+	const pad = Math.max(0, Math.floor((width - w) / 2));
+	const rightPad = Math.max(0, width - w - pad);
+	return [
+		...emptyCells(pad),
+		...clamped,
+		...emptyCells(rightPad)
+	];
+}
+function renderResumeHintCells(width, modelName) {
+	const hint = RESUME_HINT;
+	if (modelName) return centerLineCells(textToCells(`${modelName}  ${hint}`, "dim"), width);
+	return centerLineCells(textToCells(hint, "dim"), width);
+}
+/**
+* Builds the centered content viewport for the renderer.
+*
+* When `availableHeight` is constrained, the layout drops optional sections in
+* priority order (ASCII art, eyebrow, agent message, then prompt) so the stats
+* row remains visible and any remaining space is used for the newest moon rows.
+*/
+function buildContentCells(prompt, agentName, modelName, state, elapsed, now, availableHeight) {
+	const isRunning = state.status === "running" || state.status === "waiting";
+	const moonRows = renderMoonStripCells(state.iterations, isRunning, now);
+	const maxRows = availableHeight ?? Infinity;
+	if (maxRows <= 0) return [];
+	const titleCells = renderTitleCells(agentName);
+	const titleSpacer = titleCells[1] ?? [];
+	const promptLines = wordWrap(prompt, CONTENT_WIDTH, MAX_PROMPT_LINES);
+	const promptRows = [];
+	for (let i = 0; i < MAX_PROMPT_LINES; i++) {
+		const pl = promptLines[i] ?? "";
+		promptRows.push(pl ? textToCells(pl, "dim") : []);
+	}
+	const sections = {
+		top: [[]],
+		eyebrow: [
+			titleCells[0],
+			[],
+			[]
+		],
+		art: titleCells.slice(2),
+		prompt: [
+			titleSpacer,
+			...promptRows,
+			[],
+			[]
+		],
+		stats: [renderStatsCells(elapsed, state.totalInputTokens, state.totalOutputTokens, state.commitCount, state.currentIteration, state.maxIterations)],
+		agent: [
+			[],
+			[],
+			...renderAgentMessageCells(state.lastMessage, state.status)
+		],
+		moon: [
+			[],
+			[],
+			...moonRows
+		]
+	};
+	const flattenSections = () => [
+		...sections.top,
+		...sections.eyebrow,
+		...sections.art,
+		...sections.prompt,
+		...sections.stats,
+		...sections.agent,
+		...sections.moon
+	];
+	const optionalSections = [
+		"art",
+		"eyebrow",
+		"agent",
+		"prompt"
+	];
+	let rows = flattenSections();
+	for (const section of optionalSections) {
+		if (rows.length <= maxRows) break;
+		sections[section] = [];
+		rows = flattenSections();
+	}
+	if (rows.length > maxRows) rows = rows.filter((row) => row.length > 0);
+	if (rows.length > maxRows) {
+		const nonMoonRows = [
+			...sections.top,
+			...sections.eyebrow,
+			...sections.art,
+			...sections.prompt,
+			...sections.stats,
+			...sections.agent
+		].filter((row) => row.length > 0);
+		const allowedMoonRows = Math.max(0, maxRows - nonMoonRows.length);
+		const visibleMoonRows = allowedMoonRows === 0 ? [] : moonRows.filter((row) => row.length > 0).slice(-allowedMoonRows);
+		rows = [...nonMoonRows, ...visibleMoonRows];
+	}
+	return rows;
+}
+function buildFrameCells(prompt, agentName, modelName, state, topStars, bottomStars, sideStars, now, terminalWidth, terminalHeight) {
+	const elapsed = formatElapsed(now - state.startTime.getTime());
+	const availableHeight = Math.max(0, terminalHeight - 2);
+	const contentRows = buildContentCells(prompt, agentName, modelName, state, elapsed, now, availableHeight);
+	while (contentRows.length < Math.min(BASE_CONTENT_ROWS, availableHeight)) contentRows.push([]);
+	const contentCount = contentRows.length;
+	const remaining = Math.max(0, availableHeight - contentCount);
+	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 = [];
+	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));
+	frame.push(renderResumeHintCells(terminalWidth, modelName));
+	frame.push(emptyCells(terminalWidth));
+	return frame;
+}
+var Renderer = class {
+	seedTop;
+	seedBottom;
+	seedSide;
+	modelName;
+	constructor(orchestrator, prompt, agentName, modelName) {
+		this.orchestrator = orchestrator;
+		this.prompt = prompt;
+		this.agentName = agentName;
+		this.modelName = modelName;
+		this.state = orchestrator.getState();
+		this.seedTop = Math.floor(Math.random() * 2147483646) + 1;
+		this.seedBottom = Math.floor(Math.random() * 2147483646) + 1;
+		this.seedSide = Math.floor(Math.random() * 2147483646) + 1;
+		this.exitPromise = new Promise((resolve) => {
+			this.exitResolve = resolve;
+		});
+	}
+	start() {
+		this.orchestrator.on("state", (newState) => {
+			this.state = {
+				...newState,
+				iterations: [...newState.iterations]
+			};
+		});
+		this.orchestrator.on("stopped", () => {
+			this.stop("stopped");
+		});
+		if (process$1.stdin.isTTY) {
+			process$1.stdin.setRawMode(true);
+			process$1.stdin.resume();
+			process$1.stdin.on("data", (data) => {
+				if (data[0] === 3) {
+					this.stop("interrupted");
+					this.orchestrator.stop();
+				}
+			});
+		}
+		this.interval = setInterval(() => this.render(), TICK_MS);
+		this.render();
+	}
+	stop(reason = "stopped") {
+		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(reason);
+	}
+	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 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;
+				const star = s.char !== "·" ? {
+					...s,
+					char: "·"
+				} : s;
+				return star.rest === "bright" ? {
+					...star,
+					rest: "dim"
+				} : star;
+			};
+			this.topStars = generateStarField(w, h, STAR_DENSITY, this.seedTop).map((s) => shrinkBig(s, s.y >= topHeight - proximityRows));
+			this.bottomStars = generateStarField(w, h, STAR_DENSITY, this.seedBottom).map((s) => shrinkBig(s, s.y < proximityRows));
+			this.sideStars = generateStarField(w, Math.max(BASE_CONTENT_ROWS, availableHeight), STAR_DENSITY, this.seedSide);
+			return true;
+		}
+		return false;
+	}
+	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.agentName, this.modelName, 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 `fttm/${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
+const packageVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
+const FORCE_EXIT_TIMEOUT_MS = 5e3;
+const GNHF_REEXEC_STDIN_PROMPT = "GNHF_REEXEC_STDIN_PROMPT";
+const GNHF_REEXEC_STDIN_PROMPT_FILE = "GNHF_REEXEC_STDIN_PROMPT_FILE";
+const GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX = "fttm-stdin-";
+const GNHF_REEXEC_STDIN_PROMPT_FILENAME = "prompt.txt";
+function parseNonNegativeInteger(value) {
+	if (!/^\d+$/.test(value)) throw new InvalidArgumentError("must be a non-negative integer");
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isSafeInteger(parsed)) throw new InvalidArgumentError("must be a safe integer");
+	return parsed;
+}
+function parseOnOffBoolean(value) {
+	if (value === "on" || value === "true") return true;
+	if (value === "off" || value === "false") return false;
+	throw new InvalidArgumentError("must be one of: \"on\", \"off\", \"true\", \"false\"");
+}
+function humanizeErrorMessage(message) {
+	if (message.includes("not a git repository")) return "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
+	return message;
+}
+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,
+		output: process$1.stderr
+	});
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.trim().toLowerCase());
+		});
+	});
+}
+function getSignalExitCode(signal) {
+	return signal === "SIGINT" ? 130 : 143;
+}
+function persistStdinPromptForReexec(prompt) {
+	const promptDir = mkdtempSync(join(tmpdir(), GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX));
+	const promptPath = join(promptDir, GNHF_REEXEC_STDIN_PROMPT_FILENAME);
+	writeFileSync(promptPath, prompt, {
+		encoding: "utf-8",
+		mode: 384
+	});
+	return {
+		path: promptPath,
+		cleanup: () => {
+			rmSync(promptDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+function isTrustedReexecPromptPath(promptPath) {
+	const resolvedPromptPath = resolve(promptPath);
+	const promptDir = dirname(resolvedPromptPath);
+	return basename(resolvedPromptPath) === GNHF_REEXEC_STDIN_PROMPT_FILENAME && dirname(promptDir) === resolve(tmpdir()) && basename(promptDir).startsWith(GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX);
+}
+function cleanupTrustedReexecPromptPath(promptPath) {
+	if (!isTrustedReexecPromptPath(promptPath)) return;
+	const resolvedPromptPath = resolve(promptPath);
+	rmSync(resolvedPromptPath, { force: true });
+	try {
+		rmdirSync(dirname(resolvedPromptPath));
+	} catch {}
+}
+function readReexecStdinPrompt(env) {
+	const promptPath = env[GNHF_REEXEC_STDIN_PROMPT_FILE];
+	if (promptPath !== void 0) {
+		delete env[GNHF_REEXEC_STDIN_PROMPT_FILE];
+		try {
+			return readFileSync(promptPath, "utf-8");
+		} finally {
+			cleanupTrustedReexecPromptPath(promptPath);
+		}
+	}
+	const prompt = env[GNHF_REEXEC_STDIN_PROMPT];
+	if (prompt !== void 0) {
+		delete env[GNHF_REEXEC_STDIN_PROMPT];
+		return prompt;
+	}
+}
+const program = new Command();
+program.name("fttm").description("Fly to the moon, fly to the mars - AI agents for humans").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", "Agent to use (claude, codex, rovodev, or opencode)").option("--model <model>", "Model to use (e.g., opencode/claude-sonnet-4-6, minimax-m2.7)").option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--detach", "Run in background (default: false, use with --max-iterations for true daemon mode)", false).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--mock", "", false).action(async (promptArg, options) => {
+	if (options.mock) {
+		const mock = new MockOrchestrator();
+		enterAltScreen();
+		const renderer = new Renderer(mock, "let's minimize app startup latency without sacrificing any functionality", "claude");
+		renderer.start();
+		mock.start();
+		await renderer.waitUntilExit();
+		exitAltScreen();
+		return;
+	}
+	let initialSleepPrevention = null;
+	if (process$1.env.GNHF_SLEEP_INHIBITED === "1") initialSleepPrevention = await startSleepPrevention(process$1.argv.slice(2));
+	let prompt = promptArg;
+	let promptFromStdin = false;
+	const agentName = options.agent;
+	if (agentName !== void 0 && agentName !== "claude" && agentName !== "codex" && agentName !== "rovodev" && agentName !== "opencode") {
+		console.error(`Unknown agent: ${options.agent}. Use "claude", "codex", "rovodev", or "opencode".`);
+		process$1.exit(1);
+	}
+	const config = {
+		...loadConfig(agentName ? { agent: agentName } : {}),
+		...options.preventSleep === void 0 ? {} : { preventSleep: options.preventSleep }
+	};
+	if (config.agent !== "claude" && config.agent !== "codex" && config.agent !== "rovodev" && config.agent !== "opencode") {
+		console.error(`Unknown agent: ${config.agent}. Use "claude", "codex", "rovodev", or "opencode".`);
+		process$1.exit(1);
+	}
+	if (!prompt && process$1.env.GNHF_SLEEP_INHIBITED === "1") prompt = readReexecStdinPrompt(process$1.env);
+	if (!prompt && !process$1.stdin.isTTY) {
+		prompt = await readStdinText(process$1.stdin);
+		promptFromStdin = true;
+	}
+	const cwd = process$1.cwd();
+	const currentBranch = getCurrentBranch(cwd);
+	const onGnhfBranch = currentBranch.startsWith("fttm/");
+	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 fttm 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, existing.baseCommit, cwd);
+			} else if (answer === "n") runInfo = initializeNewBranch(prompt, cwd);
+			else process$1.exit(0);
+		}
+	} else {
+		if (!prompt) {
+			program.help();
+			return;
+		}
+		runInfo = initializeNewBranch(prompt, cwd);
+	}
+	let sleepPreventionCleanup = null;
+	if (config.preventSleep) {
+		const persistedPrompt = promptFromStdin && prompt !== void 0 ? persistStdinPromptForReexec(prompt) : null;
+		let reexeced = false;
+		try {
+			const sleepPrevention = initialSleepPrevention ?? await startSleepPrevention(process$1.argv.slice(2), {
+				reexecEnv: persistedPrompt ? { [GNHF_REEXEC_STDIN_PROMPT_FILE]: persistedPrompt.path } : void 0,
+				detach: options.detach
+			});
+			if (sleepPrevention.type === "reexeced") {
+				reexeced = true;
+				process$1.exit(sleepPrevention.exitCode);
+			}
+			if (sleepPrevention.type === "active") sleepPreventionCleanup = sleepPrevention.cleanup;
+		} finally {
+			if (!reexeced) persistedPrompt?.cleanup();
+		}
+	}
+	appendDebugLog("run:start", { args: process$1.argv.slice(2) });
+	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo, config.agentPathOverride[config.agent], options.model), runInfo, prompt, cwd, startIteration, {
+		maxIterations: options.maxIterations,
+		maxTokens: options.maxTokens
+	});
+	let shutdownSignal = null;
+	enterAltScreen();
+	const renderer = new Renderer(orchestrator, prompt, config.agent, options.model);
+	renderer.start();
+	const requestShutdown = (signal) => {
+		if (shutdownSignal) return;
+		shutdownSignal = signal;
+		appendDebugLog(`signal:${signal}`);
+		renderer.stop();
+		orchestrator.stop();
+	};
+	const handleSigInt = () => requestShutdown("SIGINT");
+	const handleSigTerm = () => requestShutdown("SIGTERM");
+	process$1.on("SIGINT", handleSigInt);
+	process$1.on("SIGTERM", handleSigTerm);
+	const orchestratorPromise = orchestrator.start().finally(() => {
+		renderer.stop();
+	}).catch((err) => {
+		exitAltScreen();
+		die(err instanceof Error ? err.message : String(err));
+	});
+	try {
+		if (await renderer.waitUntilExit() === "interrupted" && !shutdownSignal) {
+			shutdownSignal = "SIGINT";
+			appendDebugLog("signal:SIGINT");
+		}
+		exitAltScreen();
+		if (await Promise.race([orchestratorPromise.then(() => "done"), new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), FORCE_EXIT_TIMEOUT_MS).unref();
+		})]) === "timeout") {
+			appendDebugLog("run:shutdown-timeout", { timeoutMs: FORCE_EXIT_TIMEOUT_MS });
+			console.error(`\n  fttm: shutdown timed out after ${FORCE_EXIT_TIMEOUT_MS / 1e3}s, forcing exit\n`);
+			process$1.exit(getSignalExitCode(shutdownSignal ?? "SIGINT"));
+		}
+	} finally {
+		process$1.off("SIGINT", handleSigInt);
+		process$1.off("SIGTERM", handleSigTerm);
+		await sleepPreventionCleanup?.();
+	}
+	appendDebugLog("run:complete", { signal: shutdownSignal });
+	if (shutdownSignal) process$1.exit(getSignalExitCode(shutdownSignal));
+});
+function enterAltScreen() {
+	process$1.stdout.write("\x1B[?1049h");
+	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  fttm: ${humanizeErrorMessage(message)}\n`);
+	process$1.exit(1);
+}
+try {
+	await program.parseAsync();
+} catch (err) {
+	die(err instanceof Error ? err.message : String(err));
+}
+//#endregion
+export {};