@aibridge/cli 0.0.1

package/dist/context-BLjTHa41.mjs

@@ -0,0 +1,1529 @@
+import { createRequire } from "node:module";
+import { ExitCode, buildApplication, buildCommand, buildRouteMap, run } from "@stricli/core";
+import { appendFileSync, closeSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { isNotFound, runCaptured } from "@aibridge/proc";
+import * as agy from "@aibridge/agy";
+import { fetchAgyQuota, findModelQuota } from "@aibridge/agy";
+import * as claude from "@aibridge/claude";
+import { fetchClaudeQuota } from "@aibridge/claude";
+import * as codex from "@aibridge/codex";
+import { fetchCodexQuota } from "@aibridge/codex";
+import * as grok from "@aibridge/grok";
+import { randomBytes } from "node:crypto";
+//#region src/models.ts
+const MODELS = {
+	"xai-grok/grok-4.5": {
+		slug: "xai-grok/grok-4.5",
+		backend: "grok",
+		backendModel: "grok-4.5",
+		efforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		brief: "xAI Grok 4.5 via grok CLI — default for plan & review; off-budget"
+	},
+	"google-antigravity/gemini-3.6-flash": {
+		slug: "google-antigravity/gemini-3.6-flash",
+		backend: "agy",
+		backendModel: "gemini-3.6-flash",
+		efforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "high",
+		brief: "Google Gemini 3.6 Flash via agy — default for implement; off-budget"
+	},
+	"google-antigravity/claude-sonnet-4-6": {
+		slug: "google-antigravity/claude-sonnet-4-6",
+		backend: "agy",
+		backendModel: "claude-sonnet-4-6",
+		efforts: null,
+		brief: "Claude Sonnet 4.6 (thinking) via agy — off-budget"
+	},
+	"google-antigravity/claude-opus-4-6-thinking": {
+		slug: "google-antigravity/claude-opus-4-6-thinking",
+		backend: "agy",
+		backendModel: "claude-opus-4-6-thinking",
+		efforts: null,
+		brief: "Claude Opus 4.6 (thinking) via agy — off-budget heavyweight"
+	},
+	"google-antigravity/gpt-oss-120b-medium": {
+		slug: "google-antigravity/gpt-oss-120b-medium",
+		backend: "agy",
+		backendModel: "gpt-oss-120b-medium",
+		efforts: null,
+		brief: "GPT-OSS 120B (medium) via agy — off-budget"
+	},
+	"openai-codex/gpt-5.6-sol": {
+		slug: "openai-codex/gpt-5.6-sol",
+		backend: "codex",
+		backendModel: "gpt-5.6-sol",
+		efforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		],
+		brief: "OpenAI Codex gpt-5.6-sol via codex CLI"
+	},
+	"anthropic-claude/sonnet": {
+		slug: "anthropic-claude/sonnet",
+		backend: "claude",
+		backendModel: "sonnet",
+		efforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		brief: "Claude Sonnet via claude CLI — bills your Claude subscription"
+	},
+	"anthropic-claude/opus": {
+		slug: "anthropic-claude/opus",
+		backend: "claude",
+		backendModel: "opus",
+		efforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		],
+		defaultEffort: "high",
+		brief: "Claude Opus via claude CLI (default effort: high) — bills subscription"
+	}
+};
+const DEFAULT_MODEL = "xai-grok/grok-4.5";
+const DEFAULT_IMPLEMENTER = "google-antigravity/gemini-3.6-flash";
+const DEFAULT_IMAGE_GEN = "openai-codex/gpt-5.6-sol";
+const IMAGE_GEN_BACKENDS = /* @__PURE__ */ new Set(["codex", "grok"]);
+function supportsImageGen(resolved) {
+	return IMAGE_GEN_BACKENDS.has(resolved.spec.backend);
+}
+const EFFORTS_SET = /* @__PURE__ */ new Set([
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+]);
+function resolveModel(input) {
+	if (MODELS[input]) {
+		const spec = MODELS[input];
+		return {
+			spec,
+			effort: spec.defaultEffort
+		};
+	}
+	const lastDashIdx = input.lastIndexOf("-");
+	if (lastDashIdx > 0) {
+		const prefix = input.slice(0, lastDashIdx);
+		const token = input.slice(lastDashIdx + 1);
+		const spec = MODELS[prefix];
+		if (spec && EFFORTS_SET.has(token) && spec.efforts && spec.efforts.includes(token)) return {
+			spec,
+			effort: token
+		};
+	}
+}
+function backendModelId(resolved) {
+	if (!resolved.spec.backendModel) return;
+	if (resolved.spec.backend === "agy") {
+		const effort = resolved.effort ?? resolved.spec.defaultEffort;
+		if (effort) return `${resolved.spec.backendModel}-${effort}`;
+	}
+	return resolved.spec.backendModel;
+}
+function listModelHelpLines(opts = {}) {
+	const lines = [];
+	for (const [slug, spec] of Object.entries(MODELS)) {
+		if (opts.imageOnly && !IMAGE_GEN_BACKENDS.has(spec.backend)) continue;
+		lines.push(`  ${slug}`);
+		lines.push(`    ${spec.brief}`);
+	}
+	return lines;
+}
+function formatUnknownModelError(input) {
+	return [
+		`Unknown model "${input}".`,
+		"Available models:",
+		...listModelHelpLines()
+	].join("\n");
+}
+function formatImageGenModelError(input, resolved) {
+	return [
+		`Model "${input}" (${resolved.spec.slug}) cannot generate images — backend "${resolved.spec.backend}" has no image path.`,
+		"Image-gen seats (canonical slug):",
+		...listModelHelpLines({ imageOnly: true })
+	].join("\n");
+}
+//#endregion
+//#region src/parsers.ts
+/**
+* stricli `parse` functions (string -> T). Throwing inside one makes stricli
+* reject the argument up-front with a clean, flag-named error — instead of
+* silently letting a bad value (NaN, Infinity, "") flow into an impl where it
+* gets masked or, worse, breaks `setTimeout`.
+*/
+function positiveIntSeconds(input) {
+	const n = Number(input);
+	if (!Number.isInteger(n) || n <= 0) throw new RangeError(`expected a positive whole number of seconds, got "${input}"`);
+	if (n > 86400) throw new RangeError(`timeout too large: ${n}s (max 86400 = 24h)`);
+	return n;
+}
+function nonEmptyPrompt(input) {
+	if (input.trim().length === 0) throw new Error("prompt must not be empty");
+	return input;
+}
+//#endregion
+//#region src/drivers.ts
+const DRIVERS = {
+	agy: {
+		probe: () => agy.probe(),
+		run: (task) => agy.run(task),
+		quota: () => agy.fetchAgyQuota()
+	},
+	grok: {
+		probe: () => grok.probe(),
+		run: (task) => grok.run(task),
+		generateImage: (req) => grok.generateImage(req)
+	},
+	codex: {
+		probe: () => codex.probe(),
+		run: (task) => codex.run(task),
+		quota: () => codex.fetchCodexQuota(),
+		generateImage: (req) => codex.generateImage(req)
+	},
+	claude: {
+		probe: () => claude.probe(),
+		run: (task) => claude.run(task),
+		quota: () => claude.fetchClaudeQuota()
+	}
+};
+function getDriver(backend) {
+	const driver = DRIVERS[backend];
+	if (!driver) throw new Error(`Unknown backend "${backend}"`);
+	return driver;
+}
+//#endregion
+//#region src/commands/image-gen/impl.ts
+const MIN_REAL_BYTES_CODEX = 1e5;
+const MIN_REAL_BYTES_GROK = 1e4;
+async function imageGen$1(flags, prompt) {
+	const fail = (msg) => {
+		this.process.stderr.write(`aibridge image-gen: ${msg}\n`);
+		this.process.exitCode = 1;
+	};
+	const inputSlug = flags.model ?? "openai-codex/gpt-5.6-sol";
+	const model = resolveModel(inputSlug);
+	if (!model) return fail(formatUnknownModelError(inputSlug));
+	if (!supportsImageGen(model)) return fail(formatImageGenModelError(inputSlug, model));
+	if (model.spec.backend === "codex" && model.effort) return fail(`effort "-${model.effort}" has no effect on image-gen (gpt-image-2 renders, not the seat model); use ${DEFAULT_IMAGE_GEN}.`);
+	const quality = (flags.quality ?? "high").toLowerCase();
+	if (![
+		"low",
+		"medium",
+		"high"
+	].includes(quality)) return fail(`invalid --quality "${flags.quality}" (use low | medium | high)`);
+	let size;
+	if (flags.size !== void 0) {
+		const m = flags.size.match(/^(\d+)\s*x\s*(\d+)$/i);
+		if (!m) return fail(`invalid --size "${flags.size}" (expected e.g. 1024x1024)`);
+		size = {
+			w: Number(m[1]),
+			h: Number(m[2])
+		};
+		if (model.spec.backend === "codex") {
+			const constraint = sizeConstraintError(size.w, size.h);
+			if (constraint) return fail(`invalid --size ${size.w}x${size.h}: ${constraint}`);
+		} else if (size.w < 1 || size.h < 1) return fail(`invalid --size ${size.w}x${size.h}: dimensions must be positive`);
+	}
+	const timeoutSec = flags.timeout ?? 600;
+	const outPath = resolve(this.process.cwd(), flags.out ?? "./aibridge-image.png");
+	const imagePaths = [];
+	if (flags.image !== void 0) for (const raw of flags.image.split(",").map((s) => s.trim()).filter(Boolean)) {
+		const abs = resolve(this.process.cwd(), raw);
+		if (!existsSync(abs)) return fail(`reference image not found: ${raw}`);
+		imagePaths.push(abs);
+	}
+	const driver = getDriver(model.spec.backend);
+	if (!driver.generateImage) return fail(formatImageGenModelError(inputSlug, model));
+	const minBytes = model.spec.backend === "codex" ? MIN_REAL_BYTES_CODEX : MIN_REAL_BYTES_GROK;
+	const work = mkdtempSync(join(tmpdir(), "aibridge-imagegen-"));
+	try {
+		let outcome = await driver.generateImage({
+			prompt,
+			workDir: work,
+			backendModel: model.spec.backendModel,
+			effort: model.effort,
+			quality,
+			size,
+			imagePaths,
+			timeoutSec,
+			forceful: false,
+			minBytes
+		});
+		if (model.spec.backend === "codex" && outcome.kind === "suspect") outcome = await driver.generateImage({
+			prompt,
+			workDir: work,
+			backendModel: model.spec.backendModel,
+			effort: model.effort,
+			quality,
+			size,
+			imagePaths,
+			timeoutSec,
+			forceful: true,
+			minBytes
+		});
+		if (outcome.kind === "ok" && outcome.bytes < minBytes) outcome = { kind: "suspect" };
+		if (outcome.kind === "error") return fail(outcome.reason);
+		if (outcome.kind === "suspect") return fail(model.spec.backend === "grok" ? "grok produced no usable image. Check SuperGrok image access and re-run with a simpler prompt." : "codex produced only a tiny/code-drawn image, not a real gpt-image-2 render. Try --quality high or a clearer, simpler prompt.");
+		const local = join(work, "result.bin");
+		copyFileSync(outcome.path, local);
+		let dims = imageSize(local);
+		if (size && dims && (dims.width !== size.w || dims.height !== size.h)) if (await magick([
+			local,
+			"-resize",
+			`${size.w}x${size.h}!`,
+			local
+		])) dims = imageSize(local) ?? dims;
+		else this.process.stderr.write(`aibridge image-gen: rendered ${dims.width}x${dims.height}, wanted ${size.w}x${size.h}, and ImageMagick (magick/convert) is unavailable to resize.
+`);
+		const outExt = /\.png$/i.test(outPath) ? "png" : /\.jpe?g$/i.test(outPath) ? "jpg" : null;
+		const actualFmt = pngSize(local) ? "png" : jpegSize(local) ? "jpg" : null;
+		const needsConvert = outExt !== null && actualFmt !== null && outExt !== actualFmt;
+		if (!needsConvert || !await magick([local, outPath])) {
+			if (needsConvert) this.process.stderr.write(`aibridge image-gen: render is ${actualFmt.toUpperCase()} but out path wants ${outExt.toUpperCase()}, and ImageMagick (magick/convert) is unavailable to convert; writing the raw bytes as-is.
+`);
+			copyFileSync(local, outPath);
+		}
+		const bytes = statSync(outPath).size;
+		if (flags.json) this.process.stdout.write(`${JSON.stringify({
+			out: outPath,
+			bytes,
+			width: dims?.width ?? null,
+			height: dims?.height ?? null,
+			sizeRequested: flags.size ?? null,
+			quality: model.spec.backend === "codex" ? quality : null,
+			model: model.spec.slug,
+			backend: model.spec.backend,
+			real: true
+		})}\n`);
+		else {
+			const kb = Math.round(bytes / 1024);
+			const dimStr = dims ? `${dims.width}x${dims.height}, ` : "";
+			const qualityStr = model.spec.backend === "codex" ? `, ${quality} quality` : "";
+			this.process.stdout.write(`✓ Wrote ${outPath} (${dimStr}${kb} KB${qualityStr}, ${model.spec.slug})\n`);
+		}
+	} finally {
+		rmSync(work, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function sizeConstraintError(w, h) {
+	if (w % 16 !== 0 || h % 16 !== 0) return "each edge must be divisible by 16";
+	const long = Math.max(w, h);
+	if (long / Math.min(w, h) > 3) return "aspect ratio must be within 1:3–3:1";
+	if (long > 3840) return "longest edge must be <= 3840px";
+	const px = w * h;
+	if (px < 655360 || px > 8294400) return "total pixels must be 655,360–8,294,400";
+	return null;
+}
+function imageSize(path) {
+	return pngSize(path) ?? jpegSize(path);
+}
+function pngSize(path) {
+	try {
+		const fd = openSync(path, "r");
+		const head = Buffer.alloc(24);
+		readSync(fd, head, 0, 24, 0);
+		closeSync(fd);
+		if (head.toString("latin1", 1, 4) !== "PNG") return null;
+		if (head.toString("latin1", 12, 16) !== "IHDR") return null;
+		return {
+			width: head.readUInt32BE(16),
+			height: head.readUInt32BE(20)
+		};
+	} catch {
+		return null;
+	}
+}
+function jpegSize(path) {
+	try {
+		const fd = openSync(path, "r");
+		const buf = Buffer.alloc(64 * 1024);
+		const n = readSync(fd, buf, 0, buf.length, 0);
+		closeSync(fd);
+		if (n < 4 || buf[0] !== 255 || buf[1] !== 216) return null;
+		let i = 2;
+		while (i + 9 < n) {
+			if (buf[i] !== 255) return null;
+			const marker = buf[i + 1];
+			if (marker === void 0) return null;
+			if (marker === 192 || marker === 193 || marker === 194) {
+				const height = buf.readUInt16BE(i + 5);
+				return {
+					width: buf.readUInt16BE(i + 7),
+					height
+				};
+			}
+			if (marker === 217 || marker === 218) return null;
+			const len = buf.readUInt16BE(i + 2);
+			if (len < 2) return null;
+			i += 2 + len;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+async function magick(args) {
+	for (const tool of ["magick", "convert"]) try {
+		const r = await runCaptured(tool, [...args], { timeoutMs: 6e4 });
+		if (!r.timedOut && r.code === 0) return true;
+	} catch (err) {
+		if (!isNotFound(err)) throw err;
+	}
+	return false;
+}
+//#endregion
+//#region src/commands/image-gen/command.ts
+const fullDescription$6 = [
+	"Renders an image by driving the seat's CLI (codex → gpt-image-2, grok →",
+	"Imagine), then verifies the result is a real render before returning it.",
+	"",
+	"Image-gen seats (canonical slug):",
+	...listModelHelpLines({ imageOnly: true }),
+	`Default: ${DEFAULT_IMAGE_GEN} (gpt-image-2 via codex; historical default).`
+].join("\n");
+const imageGen = buildCommand({
+	func: imageGen$1,
+	parameters: {
+		flags: {
+			model: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: `Model slug (default: ${DEFAULT_IMAGE_GEN})`
+			},
+			out: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Path to write the image (default: ./aibridge-image.png)"
+			},
+			size: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "WIDTHxHEIGHT (codex: each edge ÷16; grok: mapped to aspect_ratio, then optionally resized)"
+			},
+			image: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Reference image path(s), comma-separated — visual reference"
+			},
+			quality: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "low | medium | high (codex/gpt-image-2; default high)"
+			},
+			timeout: {
+				kind: "parsed",
+				parse: positiveIntSeconds,
+				optional: true,
+				brief: "Max seconds to wait for the render (default: 600)"
+			},
+			json: {
+				kind: "boolean",
+				withNegated: false,
+				brief: "Emit a machine-readable JSON result instead of prose"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Description of the image to generate",
+				parse: nonEmptyPrompt,
+				placeholder: "prompt"
+			}]
+		}
+	},
+	docs: {
+		brief: "Generate a raster image via a model seat",
+		fullDescription: fullDescription$6
+	}
+});
+//#endregion
+//#region src/delegate.ts
+const PREAMBLE = "You are the sole executing agent for this task: do it yourself with your tools, now. Never defer to, wait for, or claim to hand off to another agent or process — no one else will act, and work not done in this run does not happen.\n\n";
+async function delegate(opts, driver = getDriver(opts.model.spec.backend)) {
+	const effectivePrompt = opts.tools ? PREAMBLE + opts.prompt : opts.prompt;
+	const result = await driver.run({
+		prompt: effectivePrompt,
+		tools: opts.tools,
+		timeoutSec: opts.timeoutSec,
+		cwd: opts.cwd,
+		backendModel: backendModelId(opts.model) ?? opts.model.spec.backendModel,
+		effort: opts.model.effort,
+		onStdout: (c) => opts.run.stdout(c),
+		onStderr: (c) => opts.run.stderr(c),
+		onSpawn: (pid) => opts.run.setPid(pid)
+	});
+	if (result.ok) opts.run.finish("done", result.exitCode);
+	else opts.run.finish(result.kind === "timeout" ? "timeout" : "error", result.exitCode);
+	return result;
+}
+//#endregion
+//#region src/quotaPreflight.ts
+function evaluateAgyPreflight(snapshot, backendModel) {
+	const quota = findModelQuota(snapshot, backendModel);
+	if (!quota) return {
+		ok: true,
+		warning: `model "${backendModel}" not in quota snapshot; proceeding`
+	};
+	if (quota.exhausted) {
+		let resetAt = quota.resetTime;
+		if (!resetAt) {
+			for (const group of snapshot.groups) if (group.displayName.includes("Gemini")) {
+				for (const bucket of group.buckets) if (bucket.resetTime) {
+					if (!resetAt || new Date(bucket.resetTime).getTime() < new Date(resetAt).getTime()) resetAt = bucket.resetTime;
+				}
+			}
+		}
+		return {
+			ok: false,
+			message: `agy model "${backendModel}" is quota-exhausted`,
+			resetAt
+		};
+	}
+	return { ok: true };
+}
+function evaluateCodexPreflight(snapshot) {
+	if (snapshot.limitReached) return {
+		ok: false,
+		message: "codex quota limit reached",
+		resetAt: snapshot.windows.find((w) => w.resetAt)?.resetAt
+	};
+	const exhaustedWindow = snapshot.windows.find((w) => w.usedPercent >= 100);
+	if (exhaustedWindow) return {
+		ok: false,
+		message: "codex quota limit reached",
+		resetAt: exhaustedWindow.resetAt
+	};
+	return { ok: true };
+}
+async function preflightModel(resolved) {
+	if (resolved.spec.backend === "codex") return preflightCodex();
+	if (resolved.spec.backend !== "agy") return { ok: true };
+	try {
+		return evaluateAgyPreflight(await fetchAgyQuota(), backendModelId(resolved) ?? "");
+	} catch (err) {
+		return {
+			ok: true,
+			warning: `quota preflight failed (${err.message}); proceeding`
+		};
+	}
+}
+async function preflightCodex() {
+	try {
+		return evaluateCodexPreflight(await fetchCodexQuota());
+	} catch (err) {
+		return {
+			ok: true,
+			warning: `quota preflight failed (${err.message}); proceeding`
+		};
+	}
+}
+function formatReset$1(resetTime) {
+	if (!resetTime) return "-";
+	const ms = new Date(resetTime).getTime() - Date.now();
+	if (Number.isNaN(ms)) return resetTime;
+	if (ms <= 0) return "now";
+	const mins = Math.round(ms / 6e4);
+	const rel = mins < 60 ? `${mins}m` : `${Math.floor(mins / 60)}h${mins % 60}m`;
+	return `${new Date(resetTime).toLocaleTimeString()} (in ${rel})`;
+}
+function renderPreflightRefusal(cmd, verdict) {
+	const resetClause = verdict.resetAt ? ` Resets ${formatReset$1(verdict.resetAt)}.` : "";
+	return `aibridge ${cmd}: refusing — ${verdict.message}.${resetClause} Use --no-preflight to override, or a claude-backend fallback (subagent --model sonnet|opus — bills the Claude subscription).`;
+}
+//#endregion
+//#region src/runlog.ts
+function getTimestamp() {
+	const d = /* @__PURE__ */ new Date();
+	return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}-${String(d.getHours()).padStart(2, "0")}${String(d.getMinutes()).padStart(2, "0")}${String(d.getSeconds()).padStart(2, "0")}`;
+}
+function pruneOldRuns(runsDir) {
+	try {
+		if (!existsSync(runsDir)) return;
+		const dirs = readdirSync(runsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+		if (dirs.length > 50) {
+			const toDelete = dirs.slice(0, dirs.length - 50);
+			for (const d of toDelete) try {
+				rmSync(join(runsDir, d), {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	} catch {}
+}
+function startRun(command, detail) {
+	const runsDir = join(homedir(), ".aibridge", "runs");
+	try {
+		mkdirSync(runsDir, { recursive: true });
+		pruneOldRuns(runsDir);
+		const id = `${getTimestamp()}-${command}-${randomBytes(2).toString("hex")}`;
+		const dir = join(runsDir, id);
+		mkdirSync(dir, { recursive: true });
+		const meta = {
+			id,
+			command,
+			detail,
+			pid: null,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			endedAt: null,
+			status: "running",
+			exitCode: null
+		};
+		const metaJsonPath = join(dir, "meta.json");
+		const stdoutLogPath = join(dir, "stdout.log");
+		const stderrLogPath = join(dir, "stderr.log");
+		writeFileSync(metaJsonPath, JSON.stringify(meta, null, 2), "utf8");
+		writeFileSync(stdoutLogPath, "", "utf8");
+		writeFileSync(stderrLogPath, "", "utf8");
+		return {
+			id,
+			dir,
+			setPid(pid) {
+				try {
+					meta.pid = pid;
+					writeFileSync(metaJsonPath, JSON.stringify(meta, null, 2), "utf8");
+				} catch {}
+			},
+			stdout(chunk) {
+				try {
+					appendFileSync(stdoutLogPath, chunk, "utf8");
+				} catch {}
+			},
+			stderr(chunk) {
+				try {
+					appendFileSync(stderrLogPath, chunk, "utf8");
+				} catch {}
+			},
+			finish(status, exitCode) {
+				try {
+					meta.status = status;
+					meta.exitCode = exitCode;
+					meta.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+					writeFileSync(metaJsonPath, JSON.stringify(meta, null, 2), "utf8");
+				} catch {}
+			}
+		};
+	} catch {
+		return {
+			id: "",
+			dir: "",
+			setPid() {},
+			stdout() {},
+			stderr() {},
+			finish() {}
+		};
+	}
+}
+function listRuns() {
+	const runsDir = join(homedir(), ".aibridge", "runs");
+	if (!existsSync(runsDir)) return [];
+	try {
+		const entries = readdirSync(runsDir, { withFileTypes: true });
+		const runs = [];
+		for (const entry of entries) if (entry.isDirectory()) try {
+			const metaPath = join(runsDir, entry.name, "meta.json");
+			if (existsSync(metaPath)) {
+				const content = readFileSync(metaPath, "utf8");
+				const parsed = JSON.parse(content);
+				if (parsed && typeof parsed === "object" && parsed.id && parsed.startedAt && typeof parsed.detail === "string") runs.push(parsed);
+			}
+		} catch {}
+		return runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+	} catch {
+		return [];
+	}
+}
+function readRunLogs(id) {
+	const dir = join(join(homedir(), ".aibridge", "runs"), id);
+	const metaPath = join(dir, "meta.json");
+	const stdoutPath = join(dir, "stdout.log");
+	const stderrPath = join(dir, "stderr.log");
+	if (!existsSync(metaPath)) return null;
+	try {
+		return {
+			meta: JSON.parse(readFileSync(metaPath, "utf8")),
+			stdout: existsSync(stdoutPath) ? readFileSync(stdoutPath, "utf8") : "",
+			stderr: existsSync(stderrPath) ? readFileSync(stderrPath, "utf8") : ""
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/commands/implement/impl.ts
+async function implement$1(flags, planFile) {
+	const inputSlug = flags.model ?? "google-antigravity/gemini-3.6-flash";
+	const model = resolveModel(inputSlug);
+	if (!model) {
+		this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	const cwd = this.process.cwd();
+	const absPlanPath = isAbsolute(planFile) ? planFile : resolve(cwd, planFile);
+	if (!existsSync(absPlanPath)) {
+		this.process.stderr.write(`aibridge implement: plan file "${absPlanPath}" not found\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	if (flags.preflight) {
+		const verdict = await preflightModel(model);
+		if (!verdict.ok) {
+			this.process.stderr.write(`${renderPreflightRefusal("implement", verdict)}\n`);
+			this.process.exitCode = 3;
+			return;
+		}
+		if (verdict.warning) this.process.stderr.write(`aibridge implement: ${verdict.warning}\n`);
+	}
+	const timeoutSec = flags.timeout ?? 1800;
+	const run = startRun("implement", `${model.spec.slug}: ${planFile}`);
+	const outcome = await delegate({
+		model,
+		prompt: `Read the implementation plan file at ${absPlanPath} and implement it EXACTLY.\nEdit only the files it names. Run the project's REAL typecheck and tests and fix until green.\nDo NOT commit, push, or delete unrelated files. Reply with a short summary (files changed + final typecheck/test results).`,
+		tools: true,
+		timeoutSec,
+		cwd,
+		run
+	});
+	if (!outcome.ok) {
+		this.process.stderr.write(`${outcome.message}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	const diffStat = (await runCaptured("git", ["diff", "--stat"], { cwd })).stdout.trim();
+	const statusRes = await runCaptured("git", ["status", "--porcelain"], { cwd });
+	let untrackedCount = 0;
+	if (statusRes.code === 0) {
+		for (const line of statusRes.stdout.split(/\r?\n/)) if (line.startsWith("??")) untrackedCount++;
+	}
+	if (diffStat.length === 0 && untrackedCount === 0) {
+		this.process.stderr.write(`aibridge implement: delegate completed but made zero working tree changes.\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	const outputParts = [outcome.response, ""];
+	if (diffStat.length > 0) outputParts.push(diffStat);
+	outputParts.push(`untracked files: ${untrackedCount}`);
+	outputParts.push(`run: ${run.id}`);
+	this.process.stdout.write(`${outputParts.join("\n")}\n`);
+}
+//#endregion
+//#region src/commands/implement/command.ts
+const fullDescription$5 = [
+	"Reads an implementation plan file and delegates execution to a model.",
+	"",
+	"Available models (canonical slug):",
+	...listModelHelpLines()
+].join("\n");
+const implement = buildCommand({
+	func: implement$1,
+	parameters: {
+		flags: {
+			model: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: `Model slug (default: ${DEFAULT_IMPLEMENTER})`
+			},
+			timeout: {
+				kind: "parsed",
+				parse: positiveIntSeconds,
+				optional: true,
+				brief: "Max seconds for implementation (default: 1800)"
+			},
+			preflight: {
+				kind: "boolean",
+				default: true,
+				brief: "Check model quota before running (use --no-preflight to skip)"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Path to the plan file to implement",
+				parse: String,
+				placeholder: "plan-file"
+			}]
+		}
+	},
+	docs: {
+		brief: "Execute an implementation plan",
+		fullDescription: fullDescription$5
+	}
+});
+//#endregion
+//#region src/commands/plan/impl.ts
+function countOpenQuestions(markdown) {
+	const headingIdx = markdown.search(/^## Open questions[ \t]*$/m);
+	if (headingIdx === -1) return 0;
+	const lines = markdown.slice(headingIdx).split(/\r?\n/);
+	lines.shift();
+	let count = 0;
+	for (const line of lines) {
+		if (/^## /.test(line)) break;
+		const trimmed = line.trim();
+		if (trimmed === "None." && count === 0) return 0;
+		if (/^[-*] /.test(trimmed)) count++;
+	}
+	return count;
+}
+async function getPorcelainStatus(cwd) {
+	const res = await runCaptured("git", ["status", "--porcelain"], { cwd });
+	if (res.code !== 0) return /* @__PURE__ */ new Set();
+	const set = /* @__PURE__ */ new Set();
+	for (const line of res.stdout.split(/\r?\n/)) if (line.trim().length > 0) set.add(line);
+	return set;
+}
+function extractPathFromPorcelainLine(line) {
+	let content = line.slice(3).trim();
+	if (content.includes(" -> ")) {
+		const parts = content.split(" -> ");
+		content = (parts[parts.length - 1] ?? "").trim();
+	}
+	if (content.startsWith("\"") && content.endsWith("\"")) content = content.slice(1, -1);
+	return content;
+}
+async function plan$1(flags, taskPrompt) {
+	const inputSlug = flags.model ?? "xai-grok/grok-4.5";
+	const model = resolveModel(inputSlug);
+	if (!model) {
+		this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	if (flags.preflight) {
+		const verdict = await preflightModel(model);
+		if (!verdict.ok) {
+			this.process.stderr.write(`${renderPreflightRefusal("plan", verdict)}\n`);
+			this.process.exitCode = 3;
+			return;
+		}
+		if (verdict.warning) this.process.stderr.write(`aibridge plan: ${verdict.warning}\n`);
+	}
+	const timeoutSec = flags.timeout ?? 1800;
+	const cwd = this.process.cwd();
+	const promptSnippet = taskPrompt.replace(/\r?\n/g, " ").slice(0, 80);
+	const run = startRun("plan", `${model.spec.slug}: ${promptSnippet}`);
+	const absOutPath = flags.out ? isAbsolute(flags.out) ? flags.out : resolve(cwd, flags.out) : resolve(run.dir, "plan.md");
+	const beforePorcelain = await getPorcelainStatus(cwd);
+	const outcome = await delegate({
+		model,
+		prompt: `You are a senior implementation planner. Study the real codebase with your tools at ${cwd}.\nDesign module boundaries, interfaces, and naming. Name every file to touch and describe what changes; define clear verification gates.\nWrite EXACTLY one file to the absolute path: ${absOutPath}\nTouch nothing else in the working tree.\nEnd the document with a section titled "## Open questions" (write "None." under it if you are confident and have no open questions).\nDo not commit or push.\n\nTask Prompt:\n${taskPrompt}`,
+		tools: true,
+		timeoutSec,
+		cwd,
+		run
+	});
+	if (!outcome.ok) {
+		this.process.stderr.write(`${outcome.message}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	if (!existsSync(absOutPath)) {
+		this.process.stderr.write(`aibridge plan: plan file was not written to ${absOutPath}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	const planContent = readFileSync(absOutPath, "utf8");
+	if (planContent.trim().length === 0) {
+		this.process.stderr.write(`aibridge plan: plan file at ${absOutPath} is empty\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	if (!/^## Open questions/m.test(planContent)) {
+		this.process.stderr.write(`aibridge plan: plan file at ${absOutPath} missing required "## Open questions" section\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	const afterPorcelain = await getPorcelainStatus(cwd);
+	const normalizedOut = resolve(absOutPath);
+	const normalizedCwd = resolve(cwd);
+	const isOutInRepo = normalizedOut.startsWith(normalizedCwd);
+	const unexpectedPaths = [];
+	for (const line of afterPorcelain) if (!beforePorcelain.has(line)) {
+		const relPath = extractPathFromPorcelainLine(line);
+		const absPath = resolve(cwd, relPath);
+		if (isOutInRepo && absPath === normalizedOut) continue;
+		unexpectedPaths.push(relPath);
+	}
+	if (unexpectedPaths.length > 0) {
+		this.process.stderr.write(`aibridge plan: unexpected working tree changes beyond plan file:\n${unexpectedPaths.map((p) => `  ${p}`).join("\n")}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	const openQuestions = countOpenQuestions(planContent);
+	this.process.stdout.write(`plan: ${absOutPath}\nopen questions: ${openQuestions}\nrun: ${run.id}\n`);
+}
+//#endregion
+//#region src/commands/plan/command.ts
+const fullDescription$4 = [
+	"Produce a detailed implementation plan for a task prompt.",
+	"",
+	"Available models (canonical slug):",
+	...listModelHelpLines()
+].join("\n");
+const plan = buildCommand({
+	func: plan$1,
+	parameters: {
+		flags: {
+			model: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: `Model slug (default: ${DEFAULT_MODEL})`
+			},
+			out: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Where to write the plan (default: <run.dir>/plan.md)"
+			},
+			timeout: {
+				kind: "parsed",
+				parse: positiveIntSeconds,
+				optional: true,
+				brief: "Max seconds for planning (default: 1800)"
+			},
+			preflight: {
+				kind: "boolean",
+				default: true,
+				brief: "Check model quota before running (use --no-preflight to skip)"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Task prompt to expand into a detailed implementation plan",
+				parse: nonEmptyPrompt,
+				placeholder: "task-prompt"
+			}]
+		}
+	},
+	docs: {
+		brief: "Produce a detailed implementation plan for a task prompt",
+		fullDescription: fullDescription$4
+	}
+});
+//#endregion
+//#region src/commands/quota/impl.ts
+function formatReset(resetTime) {
+	if (!resetTime) return "-";
+	const ms = new Date(resetTime).getTime() - Date.now();
+	if (Number.isNaN(ms)) return resetTime;
+	if (ms <= 0) return "now";
+	const mins = Math.round(ms / 6e4);
+	const rel = mins < 60 ? `${mins}m` : `${Math.floor(mins / 60)}h${mins % 60}m`;
+	return `${new Date(resetTime).toLocaleTimeString()} (in ${rel})`;
+}
+function renderAgy(ctx, snapshot) {
+	ctx.process.stdout.write("=== agy (Antigravity) — remaining per model group ===\n");
+	for (const group of snapshot.groups) {
+		ctx.process.stdout.write(`${group.displayName}\n`);
+		for (const b of group.buckets) {
+			const pct = b.remainingFraction === 0 ? "EXHAUSTED" : `${Math.round(b.remainingFraction * 100)}%`;
+			ctx.process.stdout.write(`  ${b.displayName.padEnd(18)} ${pct.padEnd(10)} ${formatReset(b.resetTime)}\n`);
+		}
+	}
+	const exhausted = snapshot.models.filter((m) => m.exhausted);
+	if (exhausted.length > 0) ctx.process.stdout.write(`Exhausted models: ${[...new Set(exhausted.map((m) => m.label))].join(", ")}\n`);
+}
+function renderCodex(ctx, snapshot) {
+	const plan = snapshot.planType ? ` — plan: ${snapshot.planType}` : "";
+	const reached = snapshot.limitReached ? " [LIMIT REACHED]" : "";
+	ctx.process.stdout.write(`=== codex (ChatGPT)${plan}${reached} — used per window ===\n`);
+	ctx.process.stdout.write(`${"WINDOW".padEnd(10)} ${"USED".padEnd(10)} RESET\n`);
+	for (const w of snapshot.windows) ctx.process.stdout.write(`${w.window.padEnd(10)} ${`${w.usedPercent}%`.padEnd(10)} ${formatReset(w.resetAt)}\n`);
+}
+function renderClaude(ctx, snapshot) {
+	ctx.process.stdout.write("=== claude (Claude Code subscription) — used per window ===\n");
+	ctx.process.stdout.write(`${"WINDOW".padEnd(20)} ${"USED".padEnd(10)} RESET\n`);
+	for (const w of snapshot.windows) ctx.process.stdout.write(`${w.window.padEnd(20)} ${`${w.usedPercent}%`.padEnd(10)} ${w.resetsText || "-"}\n`);
+}
+function renderSection(ctx, result, title, render) {
+	if (result.status === "fulfilled") render(ctx, result.value);
+	else ctx.process.stdout.write(`=== ${title} ===\nunavailable: ${result.reason.message}\n`);
+}
+async function quotaImpl(flags) {
+	const [agy, codex, claude] = await Promise.allSettled([
+		fetchAgyQuota(),
+		fetchCodexQuota(),
+		fetchClaudeQuota()
+	]);
+	const allFailed = agy.status === "rejected" && codex.status === "rejected" && claude.status === "rejected";
+	if (flags.json) {
+		this.process.stdout.write(`${JSON.stringify({
+			agy: agy.status === "fulfilled" ? agy.value : { error: String(agy.reason) },
+			codex: codex.status === "fulfilled" ? codex.value : { error: String(codex.reason) },
+			claude: claude.status === "fulfilled" ? claude.value : { error: String(claude.reason) }
+		}, null, 2)}\n`);
+		if (allFailed) this.process.exitCode = 1;
+		return;
+	}
+	renderSection(this, agy, "agy (Antigravity)", renderAgy);
+	this.process.stdout.write("\n");
+	renderSection(this, codex, "codex (ChatGPT)", renderCodex);
+	this.process.stdout.write("\n");
+	renderSection(this, claude, "claude (Claude Code subscription)", renderClaude);
+	if (allFailed) this.process.exitCode = 1;
+}
+const quota = buildCommand({
+	func: quotaImpl,
+	parameters: { flags: { json: {
+		kind: "boolean",
+		withNegated: false,
+		brief: "Emit the raw snapshot as JSON"
+	} } },
+	docs: {
+		brief: "Show agy / codex / claude quota with reset times",
+		fullDescription: [
+			"agy: reads its cached OAuth token (~/.gemini/antigravity-cli/) and asks the",
+			"Cloud Code API for per-model remaining quota. EXHAUSTED means agy turns on",
+			"that model fail with an empty answer until the reset time.",
+			"codex: reads ~/.codex/auth.json and asks the ChatGPT usage endpoint for the",
+			"5-hour and weekly windows (used % + reset). No separate logins for either.",
+			"claude: shells out to `claude -p \"/usage\"` (the slow leg, ~5-10s) and parses",
+			"the session + weekly windows — no HTTP endpoint exists and we never touch",
+			"the Keychain; the claude CLI uses its own credentials."
+		].join("\n")
+	}
+});
+//#endregion
+//#region src/commands/review/impl.ts
+function matchVerdictLine(line) {
+	if (/^PASS\b/i.test(line)) return { kind: "pass" };
+	const match = line.match(/^FINDINGS:\s*(?:(\d+)\s*critical,?\s*)?(?:(\d+)\s*major,?\s*)?(?:(\d+)\s*minor)?/i);
+	if (match) {
+		const critical = match[1] ? Number.parseInt(match[1], 10) : 0;
+		const major = match[2] ? Number.parseInt(match[2], 10) : 0;
+		const minor = match[3] ? Number.parseInt(match[3], 10) : 0;
+		return {
+			kind: "findings",
+			critical,
+			major,
+			minor,
+			formattedLine: `FINDINGS: ${critical} critical, ${major} major, ${minor} minor`
+		};
+	}
+	return null;
+}
+function parseReviewVerdict(response) {
+	const lines = response.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+	if (lines.length === 0) return {
+		kind: "unparseable",
+		rawLine: ""
+	};
+	const first = matchVerdictLine(lines[0]);
+	if (first) return first;
+	const last = matchVerdictLine(lines[lines.length - 1]);
+	if (last) return last;
+	const embedded = [...response.matchAll(/FINDINGS:\s*(\d+)\s*critical,?\s*(\d+)\s*major,?\s*(\d+)\s*minor/gi)].at(-1);
+	if (embedded) {
+		const critical = Number.parseInt(embedded[1], 10);
+		const major = Number.parseInt(embedded[2], 10);
+		const minor = Number.parseInt(embedded[3], 10);
+		return {
+			kind: "findings",
+			critical,
+			major,
+			minor,
+			formattedLine: `FINDINGS: ${critical} critical, ${major} major, ${minor} minor`
+		};
+	}
+	return {
+		kind: "unparseable",
+		rawLine: lines[0]
+	};
+}
+async function review$1(flags) {
+	const inputSlug = flags.model ?? "xai-grok/grok-4.5";
+	const model = resolveModel(inputSlug);
+	if (!model) {
+		this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	const cwd = this.process.cwd();
+	const baseRef = flags.base ?? "HEAD";
+	let absPlanPath;
+	if (flags.plan) {
+		absPlanPath = isAbsolute(flags.plan) ? flags.plan : resolve(cwd, flags.plan);
+		if (!existsSync(absPlanPath)) {
+			this.process.stderr.write(`aibridge review: plan file "${absPlanPath}" not found\n`);
+			this.process.exitCode = 2;
+			return;
+		}
+	}
+	const diffRes = await runCaptured("git", [
+		"diff",
+		"--quiet",
+		baseRef
+	], { cwd });
+	if (diffRes.code !== 0 && diffRes.code !== 1) {
+		const detail = diffRes.stderr.trim().split("\n")[0] ?? `exit code ${diffRes.code}`;
+		this.process.stderr.write(`aibridge review: git diff failed for base "${baseRef}": ${detail}\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	const hasDiff = diffRes.code === 1;
+	const statusRes = await runCaptured("git", ["status", "--porcelain"], { cwd });
+	const hasPorcelain = statusRes.code === 0 && statusRes.stdout.trim().length > 0;
+	const isDirty = hasDiff || hasPorcelain;
+	if (!isDirty && !absPlanPath) {
+		this.process.stderr.write(`aibridge review: nothing to review\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	if (flags.preflight) {
+		const verdict = await preflightModel(model);
+		if (!verdict.ok) {
+			this.process.stderr.write(`${renderPreflightRefusal("review", verdict)}\n`);
+			this.process.exitCode = 3;
+			return;
+		}
+		if (verdict.warning) this.process.stderr.write(`aibridge review: ${verdict.warning}\n`);
+	}
+	const timeoutSec = flags.timeout ?? 1200;
+	const modeDetail = isDirty ? absPlanPath ? `diff + plan (${absPlanPath})` : `diff (${baseRef})` : `plan-only (${absPlanPath})`;
+	const run = startRun("review", `${model.spec.slug}: ${modeDetail}`);
+	const absOutPath = flags.out ? isAbsolute(flags.out) ? flags.out : resolve(cwd, flags.out) : resolve(run.dir, "review.md");
+	let reviewPrompt;
+	if (isDirty) reviewPrompt = `You are an expert code reviewer. Inspect the working tree diff against base '${baseRef}' and untracked files at ${cwd}.\n` + (absPlanPath ? `Compare the implementation against the plan contract at ${absPlanPath}. Any file modified or feature added outside the plan contract counts as over-reach (severity: major unless harmful, then critical).\n` : "") + `Write your detailed review report to the file ${absOutPath}. For each finding, include file:line, severity (critical|major|minor), and rationale.\nYour final answer (last message) must consist of EXACTLY ONE VERDICT LINE:\nEither: "PASS"\nOr: "FINDINGS: <c> critical, <m> major, <n> minor"`;
+	else reviewPrompt = `You are an expert architecture reviewer. Inspect the plan contract file at ${absPlanPath}.\nReview the plan for soundness, missing edge cases, safety, and feasibility.\nWrite your detailed review report to the file ${absOutPath}. For each finding, include severity (critical|major|minor) and rationale.\nYour final answer (last message) must consist of EXACTLY ONE VERDICT LINE:\nEither: "PASS"\nOr: "FINDINGS: <c> critical, <m> major, <n> minor"`;
+	const outcome = await delegate({
+		model,
+		prompt: reviewPrompt,
+		tools: true,
+		timeoutSec,
+		cwd,
+		run
+	});
+	if (!outcome.ok) {
+		this.process.stderr.write(`${outcome.message}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	if (!existsSync(absOutPath) || readFileSync(absOutPath, "utf8").trim().length === 0) {
+		this.process.stderr.write(`aibridge review: review file was not written to ${absOutPath}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	const verdictResult = parseReviewVerdict(outcome.response);
+	if (verdictResult.kind === "unparseable") {
+		this.process.stderr.write(`aibridge review: could not parse a verdict line from the answer.\n`);
+		this.process.stdout.write(`${outcome.response}\nreview: ${absOutPath}\nrun: ${run.id}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	if (verdictResult.kind === "pass") {
+		this.process.stdout.write(`PASS\nreview: ${absOutPath}\nrun: ${run.id}\n`);
+		this.process.exitCode = 0;
+		return;
+	}
+	this.process.stdout.write(`${verdictResult.formattedLine}\nreview: ${absOutPath}\nrun: ${run.id}\n`);
+	const isPassing = verdictResult.critical === 0 && verdictResult.major === 0;
+	this.process.exitCode = isPassing ? 0 : 1;
+}
+//#endregion
+//#region src/commands/review/command.ts
+const fullDescription$2 = [
+	"Inspects code diffs or plan contracts and writes a review report.",
+	"",
+	"Available models (canonical slug):",
+	...listModelHelpLines()
+].join("\n");
+const review = buildCommand({
+	func: review$1,
+	parameters: { flags: {
+		model: {
+			kind: "parsed",
+			parse: String,
+			optional: true,
+			brief: `Model slug (default: ${DEFAULT_MODEL})`
+		},
+		plan: {
+			kind: "parsed",
+			parse: String,
+			optional: true,
+			brief: "Plan file for contract / over-reach check"
+		},
+		base: {
+			kind: "parsed",
+			parse: String,
+			optional: true,
+			brief: "Base git ref to diff against (default: HEAD)"
+		},
+		out: {
+			kind: "parsed",
+			parse: String,
+			optional: true,
+			brief: "Where to write the review report (default: <run.dir>/review.md)"
+		},
+		timeout: {
+			kind: "parsed",
+			parse: positiveIntSeconds,
+			optional: true,
+			brief: "Max seconds for review (default: 1200)"
+		},
+		preflight: {
+			kind: "boolean",
+			default: true,
+			brief: "Check model quota before running (use --no-preflight to skip)"
+		}
+	} },
+	docs: {
+		brief: "Review working tree diff or plan contract",
+		fullDescription: fullDescription$2
+	}
+});
+//#endregion
+//#region src/commands/runs/impl.ts
+function formatElapsed(startedAtStr, endedAtStr) {
+	const start = new Date(startedAtStr).getTime();
+	const end = endedAtStr ? new Date(endedAtStr).getTime() : Date.now();
+	const diffSec = Math.max(0, Math.floor((end - start) / 1e3));
+	if (diffSec < 60) return `${diffSec}s`;
+	return `${Math.floor(diffSec / 60)}m${diffSec % 60}s`;
+}
+function getStatus(run) {
+	if (run.status === "running" && run.pid !== null) try {
+		process.kill(run.pid, 0);
+	} catch {
+		return "stale";
+	}
+	return run.status;
+}
+async function runs$1(flags, idPrefix) {
+	if (idPrefix !== void 0) {
+		const matches = listRuns().filter((r) => r.id.startsWith(idPrefix));
+		if (matches.length === 0) {
+			this.process.stderr.write(`aibridge runs: no run matches prefix "${idPrefix}"\n`);
+			this.process.exitCode = 1;
+			return;
+		}
+		if (matches.length > 1) {
+			this.process.stderr.write(`aibridge runs: ambiguous prefix "${idPrefix}" matches:\n${matches.map((m) => `  ${m.id}`).join("\n")}\n`);
+			this.process.exitCode = 1;
+			return;
+		}
+		const target = matches[0];
+		if (target === void 0) return;
+		const logs = readRunLogs(target.id);
+		if (!logs) {
+			this.process.stderr.write(`aibridge runs: failed to read logs for run "${target.id}"\n`);
+			this.process.exitCode = 1;
+			return;
+		}
+		const status = getStatus(logs.meta).toUpperCase();
+		const elapsed = formatElapsed(logs.meta.startedAt, logs.meta.endedAt);
+		const summaryLines = [
+			`ID:      ${logs.meta.id}`,
+			`COMMAND: ${logs.meta.command}`,
+			`STATUS:  ${status}`,
+			`ELAPSED: ${elapsed}`,
+			`DETAIL:  ${logs.meta.detail}`
+		];
+		if (logs.meta.pid !== null) summaryLines.push(`PID:     ${logs.meta.pid}`);
+		if (logs.meta.exitCode !== null) summaryLines.push(`EXIT:    ${logs.meta.exitCode}`);
+		this.process.stdout.write(`${summaryLines.join("\n")}\n\n`);
+		const stdoutLines = logs.stdout.split("\n");
+		if (stdoutLines.length > 1 && stdoutLines[stdoutLines.length - 1] === "") stdoutLines.pop();
+		const lastStdout = stdoutLines.slice(-40).join("\n");
+		this.process.stdout.write(`${lastStdout}\n`);
+		if (logs.stderr.trim().length > 0) {
+			const stderrLines = logs.stderr.split("\n");
+			if (stderrLines.length > 1 && stderrLines[stderrLines.length - 1] === "") stderrLines.pop();
+			const lastStderr = stderrLines.slice(-10).join("\n");
+			this.process.stdout.write(`\n--- stderr (last 10 lines) ---\n${lastStderr}\n`);
+		}
+		return;
+	}
+	if (flags.watch) {
+		const update = () => {
+			this.process.stdout.write("\x1B[2J\x1B[H");
+			const timeStr = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+			this.process.stdout.write(`aibridge runs — ${timeStr} (ctrl-c to quit)\n\n`);
+			const runs = listRuns();
+			if (runs.length === 0) {
+				this.process.stdout.write("no runs yet\n");
+				return;
+			}
+			const limit = runs.slice(0, 10);
+			this.process.stdout.write(`${"STATUS".padEnd(10)} ${"ID".padEnd(35)} ${"ELAPSED".padEnd(10)} DETAIL\n`);
+			for (const r of limit) {
+				const status = getStatus(r).toUpperCase();
+				const elapsed = formatElapsed(r.startedAt, r.endedAt);
+				const detail = r.detail.replace(/\r?\n/g, " ");
+				const truncatedDetail = detail.length > 60 ? `${detail.slice(0, 57)}...` : detail;
+				this.process.stdout.write(`${status.padEnd(10)} ${r.id.padEnd(35)} ${elapsed.padEnd(10)} ${truncatedDetail}\n`);
+			}
+			const runningRuns = runs.filter((r) => getStatus(r) === "running");
+			for (const r of runningRuns) {
+				const logs = readRunLogs(r.id);
+				if (logs) {
+					this.process.stdout.write(`\n--- stdout: ${r.id} ---\n`);
+					const lines = logs.stdout.split("\n");
+					if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+					const lastSix = lines.slice(-6).join("\n");
+					this.process.stdout.write(`${lastSix}\n`);
+				}
+			}
+		};
+		update();
+		setInterval(update, 2e3);
+		return new Promise(() => {});
+	}
+	const runs = listRuns();
+	if (runs.length === 0) {
+		this.process.stdout.write("no runs yet\n");
+		return;
+	}
+	if (flags.json) {
+		const limit = runs.slice(0, 20);
+		for (const r of limit) {
+			const status = getStatus(r);
+			const withStatus = {
+				...r,
+				status
+			};
+			this.process.stdout.write(`${JSON.stringify(withStatus)}\n`);
+		}
+		return;
+	}
+	const limit = runs.slice(0, 20);
+	this.process.stdout.write(`${"STATUS".padEnd(10)} ${"ID".padEnd(35)} ${"ELAPSED".padEnd(10)} DETAIL\n`);
+	for (const r of limit) {
+		const status = getStatus(r).toUpperCase();
+		const elapsed = formatElapsed(r.startedAt, r.endedAt);
+		const detail = r.detail.replace(/\r?\n/g, " ");
+		const truncatedDetail = detail.length > 60 ? `${detail.slice(0, 57)}...` : detail;
+		this.process.stdout.write(`${status.padEnd(10)} ${r.id.padEnd(35)} ${elapsed.padEnd(10)} ${truncatedDetail}\n`);
+	}
+}
+//#endregion
+//#region src/commands/runs/command.ts
+const fullDescription$1 = "Lists recent runs, watches active runs, or displays logs for a specific run.";
+async function runsCommand(flags, idPrefix) {
+	if (flags.watch && idPrefix !== void 0) {
+		this.process.stderr.write("aibridge runs: cannot specify <id> when using --watch\n");
+		this.process.exitCode = 2;
+		return;
+	}
+	if (flags.watch && flags.json) {
+		this.process.stderr.write("aibridge runs: cannot specify --json when using --watch\n");
+		this.process.exitCode = 2;
+		return;
+	}
+	await runs$1.call(this, flags, idPrefix);
+}
+const runs = buildCommand({
+	func: runsCommand,
+	parameters: {
+		flags: {
+			watch: {
+				kind: "boolean",
+				withNegated: false,
+				brief: "Watch running runs in real time (refresh every 2s)"
+			},
+			json: {
+				kind: "boolean",
+				withNegated: false,
+				brief: "Emit output in JSON Lines format (list mode only)"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Run id prefix to inspect (defaults to listing recent runs)",
+				parse: String,
+				placeholder: "id-prefix",
+				optional: true
+			}]
+		}
+	},
+	docs: {
+		brief: "Monitor and inspect execution runs",
+		fullDescription: fullDescription$1
+	}
+});
+//#endregion
+//#region src/commands/subagent/impl.ts
+async function subagent$1(flags, prompt) {
+	const inputSlug = flags.model ?? "xai-grok/grok-4.5";
+	const model = resolveModel(inputSlug);
+	if (!model) {
+		this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+		this.process.exitCode = 2;
+		return;
+	}
+	if (flags.preflight) {
+		const verdict = await preflightModel(model);
+		if (!verdict.ok) {
+			if (flags.json) this.process.stdout.write(`${JSON.stringify({
+				error: "quota_exhausted",
+				message: verdict.message,
+				resetAt: verdict.resetAt ?? null,
+				slug: model.spec.slug
+			})}\n`);
+			else this.process.stderr.write(`${renderPreflightRefusal("subagent", verdict)}\n`);
+			this.process.exitCode = 3;
+			return;
+		}
+		if (verdict.warning) this.process.stderr.write(`aibridge subagent: ${verdict.warning}\n`);
+	}
+	const timeoutSec = flags.timeout ?? 600;
+	const workDir = this.process.cwd();
+	const promptSnippet = prompt.replace(/\r?\n/g, " ").slice(0, 80);
+	const run = startRun("subagent", `${model.spec.slug}: ${promptSnippet}`);
+	const outcome = await delegate({
+		model,
+		prompt,
+		tools: flags.tools,
+		timeoutSec,
+		cwd: workDir,
+		run
+	});
+	if (!outcome.ok) {
+		this.process.stderr.write(`${outcome.message}\n`);
+		this.process.exitCode = 1;
+		return;
+	}
+	if (flags.json) {
+		const modelId = backendModelId(model) ?? null;
+		this.process.stdout.write(`${JSON.stringify({
+			model: modelId,
+			slug: model.spec.slug,
+			response: outcome.response,
+			exitCode: outcome.exitCode
+		})}\n`);
+	} else this.process.stdout.write(`${outcome.response}\n`);
+}
+//#endregion
+//#region src/commands/subagent/command.ts
+const fullDescription = [
+	"Hands a self-contained prompt to another model and returns its answer.",
+	"",
+	"Available models (canonical slug):",
+	...listModelHelpLines(),
+	`Default: ${DEFAULT_MODEL} (off-budget). The claude-backend slugs are FALLBACKS for`,
+	"when the off-budget CLIs are quota-exhausted — they bill your Claude subscription."
+].join("\n");
+const subagent = buildCommand({
+	func: subagent$1,
+	parameters: {
+		flags: {
+			model: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: `Model slug to delegate to (default: ${DEFAULT_MODEL})`
+			},
+			timeout: {
+				kind: "parsed",
+				parse: positiveIntSeconds,
+				optional: true,
+				brief: "Max seconds to wait for the backend (default: 600)"
+			},
+			tools: {
+				kind: "boolean",
+				default: true,
+				brief: "Allow delegate model to use tools (use --no-tools to restrict to reasoning only)"
+			},
+			preflight: {
+				kind: "boolean",
+				default: true,
+				brief: "Check model quota before running (use --no-preflight to skip)"
+			},
+			json: {
+				kind: "boolean",
+				withNegated: false,
+				brief: "Emit a machine-readable JSON result (using canonical slug) instead of prose"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Self-contained task prompt for the delegate model",
+				parse: nonEmptyPrompt,
+				placeholder: "prompt"
+			}]
+		}
+	},
+	docs: {
+		brief: "Delegate a self-contained task to another model",
+		fullDescription
+	}
+});
+//#endregion
+//#region src/exitCode.ts
+/**
+* Stricli uses negative ExitCode values for parse/route failures.
+* Our public contract is Unix-style: 0 ok, 1 op fail, 2 bad args, 3 quota refuse.
+* Call after `run()`; never overwrite a code already set by an impl (run uses ??=).
+*/
+function normalizeExitCode(ctx) {
+	const code = ctx.process.exitCode;
+	if (typeof code !== "number") return;
+	if (code === ExitCode.InvalidArgument || code === ExitCode.UnknownCommand) {
+		ctx.process.exitCode = 2;
+		return;
+	}
+	if (code !== 0 && code !== 1 && code !== 2 && code !== 3) ctx.process.exitCode = 1;
+}
+//#endregion
+//#region src/app.ts
+const { version } = createRequire(import.meta.url)("../package.json");
+const app = buildApplication(buildRouteMap({
+	routes: {
+		plan,
+		implement,
+		review,
+		subagent,
+		"image-gen": imageGen,
+		runs,
+		quota
+	},
+	docs: { brief: "Bridge tasks to non-Claude AI CLIs — a plan → implement → review workflow, task delegation, and image generation (codex gpt-image-2 / grok Imagine)." }
+}), {
+	name: "aibridge",
+	versionInfo: { currentVersion: version },
+	scanner: { caseStyle: "allow-kebab-for-camel" }
+});
+/** Public entry used by cli.ts and index.ts — preserves runCli(ctx, argv) surface. */
+async function runCli(ctx, argv) {
+	await run(app, argv, ctx);
+	normalizeExitCode(ctx);
+}
+//#endregion
+//#region src/context.ts
+function buildContext(process) {
+	return { process };
+}
+//#endregion
+export { listModelHelpLines as C, formatUnknownModelError as S, supportsImageGen as T, DEFAULT_IMPLEMENTER as _, readRunLogs as a, backendModelId as b, evaluateCodexPreflight as c, renderPreflightRefusal as d, delegate as f, DEFAULT_IMAGE_GEN as g, positiveIntSeconds as h, listRuns as i, preflightCodex as l, nonEmptyPrompt as m, app as n, startRun as o, getDriver as p, runCli as r, evaluateAgyPreflight as s, buildContext as t, preflightModel as u, DEFAULT_MODEL as v, resolveModel as w, formatImageGenModelError as x, MODELS as y };