@kunkun.sh/kuota 0.0.0-stage → 0.1.0

package/dist/bin.mjs

@@ -0,0 +1,1303 @@
+#!/usr/bin/env node
+import { a as makeObservation, c as windowProfile, i as historyEventsFromSnapshot, n as calculatePace, o as makeUnavailableSnapshot, r as decodeHistoryEvent, s as normalizeWindow, t as buildForecastV1 } from "./dist-CIjerpSd.mjs";
+import { Effect, Either, Option } from "effect";
+import { spawn } from "node:child_process";
+import { mkdir, mkdtemp, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { accessSync, constants } from "node:fs";
+import { Command, Options } from "@effect/cli";
+import * as NodeContext from "@effect/platform-node/NodeContext";
+import { randomUUID } from "node:crypto";
+// ../history/dist/index.mjs
+const FILE = /^events-(\d{4}-\d{2}-\d{2})(?:\.(\d+))?\.jsonl$/;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const utcDate = (iso) => new Date(iso).toISOString().slice(0, 10);
+async function listParts(directory, date) {
+	let names;
+	try {
+		names = await readdir(directory);
+	} catch {
+		return [];
+	}
+	const parts = [];
+	for (const name of names) {
+		const match = FILE.exec(name);
+		if (!match || !DATE.test(match[1])) continue;
+		if (date !== void 0 && match[1] !== date) continue;
+		parts.push({
+			name,
+			date: match[1],
+			part: match[2] === void 0 ? 0 : Number(match[2])
+		});
+	}
+	return parts.sort((a, b) => a.date.localeCompare(b.date) || a.part - b.part);
+}
+function partName(date, part) {
+	return part === 0 ? `events-${date}.jsonl` : `events-${date}.${part}.jsonl`;
+}
+async function parseFile(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch {
+		return {
+			events: [],
+			invalid: 0
+		};
+	}
+	const events = [];
+	let invalid = 0;
+	for (const line of text.split("\n")) {
+		if (line.trim() === "") continue;
+		try {
+			const decoded = decodeHistoryEvent(JSON.parse(line));
+			if (Either.isRight(decoded)) events.push(decoded.right);
+			else invalid++;
+		} catch {
+			invalid++;
+		}
+	}
+	return {
+		events,
+		invalid
+	};
+}
+function createLocalJsonlJournal(options) {
+	const directory = options.directory;
+	const maxFileBytes = options.maxFileBytes ?? 16777216;
+	const retentionDays = options.retentionDays ?? 400;
+	const doSync = options.fsync ?? true;
+	const lockStaleMs = options.lockStaleMs ?? 3e4;
+	const lockTimeoutMs = options.lockTimeoutMs ?? 15e3;
+	const lockPath = join(directory, ".lock");
+	let queue = Promise.resolve();
+	async function withLock(fn) {
+		await mkdir(directory, {
+			recursive: true,
+			mode: 448
+		});
+		const deadline = Date.now() + lockTimeoutMs;
+		for (;;) try {
+			const handle = await open(lockPath, "wx", 384);
+			await handle.writeFile(String(process.pid));
+			await handle.close();
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			try {
+				const info = await stat(lockPath);
+				if (Date.now() - info.mtimeMs > lockStaleMs) {
+					await rm(lockPath, { force: true });
+					continue;
+				}
+			} catch {
+				continue;
+			}
+			if (Date.now() > deadline) throw new Error("JOURNAL_LOCK_TIMEOUT");
+			await sleep(5);
+		}
+		try {
+			return await fn();
+		} finally {
+			await rm(lockPath, { force: true });
+		}
+	}
+	async function appendDate(date, events) {
+		const parts = await listParts(directory, date);
+		const known = /* @__PURE__ */ new Set();
+		for (const part of parts) for (const event of (await parseFile(join(directory, part.name))).events) known.add(event.eventId);
+		const fresh = [];
+		let duplicates = 0;
+		for (const event of events) if (known.has(event.eventId)) duplicates++;
+		else {
+			known.add(event.eventId);
+			fresh.push(event);
+		}
+		if (fresh.length === 0) return {
+			written: 0,
+			duplicates
+		};
+		let partNumber = parts.length === 0 ? 0 : parts[parts.length - 1].part;
+		let path = join(directory, partName(date, partNumber));
+		let size = 0;
+		let endsWithNewline = true;
+		try {
+			size = (await stat(path)).size;
+			if (size > 0) {
+				const handle = await open(path, "r");
+				const last = Buffer.alloc(1);
+				await handle.read(last, 0, 1, size - 1);
+				await handle.close();
+				endsWithNewline = last[0] === 10;
+			}
+		} catch {
+			size = 0;
+		}
+		const buckets = [[]];
+		let current = size;
+		for (const event of fresh) {
+			const line = JSON.stringify(event) + "\n";
+			if (current > 0 && current + line.length > maxFileBytes) {
+				buckets.push([]);
+				current = 0;
+			}
+			buckets[buckets.length - 1].push(line);
+			current += line.length;
+		}
+		for (const [index, lines] of buckets.entries()) {
+			if (index > 0) {
+				partNumber += 1;
+				path = join(directory, partName(date, partNumber));
+				endsWithNewline = true;
+			}
+			const payload = (endsWithNewline ? "" : "\n") + lines.join("");
+			const handle = await open(path, "a", 384);
+			try {
+				await handle.write(payload);
+				if (doSync) await handle.sync();
+			} finally {
+				await handle.close();
+			}
+		}
+		return {
+			written: fresh.length,
+			duplicates
+		};
+	}
+	async function readAll(opts) {
+		const fromMs = Date.parse(opts.from);
+		const toMs = Date.parse(opts.to);
+		if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) throw new Error("INVALID_RANGE");
+		const fromDate = utcDate(opts.from);
+		const toDate = utcDate(opts.to);
+		const events = [];
+		let invalidLines = 0;
+		for (const part of await listParts(directory)) {
+			if (part.date < fromDate || part.date > toDate) continue;
+			const parsed = await parseFile(join(directory, part.name));
+			invalidLines += parsed.invalid;
+			for (const event of parsed.events) {
+				const t = Date.parse(event.observedAt);
+				if (t < fromMs || t > toMs) continue;
+				if (opts.provider !== void 0 && event.provider !== opts.provider) continue;
+				if (opts.windowId !== void 0 && event.windowId !== opts.windowId) continue;
+				events.push(event);
+			}
+		}
+		return {
+			events,
+			invalidLines
+		};
+	}
+	return {
+		append(events) {
+			for (const event of events) if (Either.isLeft(decodeHistoryEvent(event))) return Promise.reject(/* @__PURE__ */ new Error("INVALID_HISTORY_EVENT"));
+			const run = queue.then(() => withLock(async () => {
+				const byDate = /* @__PURE__ */ new Map();
+				for (const event of events) {
+					const date = utcDate(event.observedAt);
+					byDate.set(date, [...byDate.get(date) ?? [], event]);
+				}
+				let written = 0;
+				let duplicates = 0;
+				for (const [date, list] of [...byDate].sort(([a], [b]) => a.localeCompare(b))) {
+					const result = await appendDate(date, list);
+					written += result.written;
+					duplicates += result.duplicates;
+				}
+				return {
+					written,
+					duplicates
+				};
+			}));
+			queue = run.catch(() => void 0);
+			return run;
+		},
+		readAll,
+		async *read(opts) {
+			for (const event of (await readAll(opts)).events) yield event;
+		},
+		async applyRetention(now = /* @__PURE__ */ new Date()) {
+			const cutoffMs = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()) - (Math.max(1, retentionDays) - 1) * 864e5;
+			const cutoff = new Date(cutoffMs).toISOString().slice(0, 10);
+			return queue.then(() => withLock(async () => {
+				let removed = 0;
+				for (const part of await listParts(directory)) if (part.date < cutoff) {
+					await rm(join(directory, part.name), { force: true });
+					removed++;
+				}
+				return removed;
+			}));
+		}
+	};
+}
+function defaultHistoryDirectory(env = process.env, platform = process.platform) {
+	if (env.KUOTA_HISTORY_DIR) return env.KUOTA_HISTORY_DIR;
+	if (platform === "darwin") return join(homedir(), "Library", "Application Support", "kuota", "history");
+	return join(env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "kuota", "history");
+}
+// ../providers/dist/index.mjs
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/** Parses only the non-sensitive subset of the Codex app-server v2 quota response. */
+function parseCodexRateLimits(raw, fetchedAt = /* @__PURE__ */ new Date()) {
+	const response = asRecord(raw);
+	const limits = asRecord(response?.rateLimits);
+	const common = {
+		provider: "codex",
+		source: "codex-app-server",
+		fetchedAt: fetchedAt.toISOString()
+	};
+	if (!limits) return {
+		...common,
+		status: "unavailable",
+		windows: [],
+		errorCode: "NO_RATE_LIMITS"
+	};
+	let malformed = false;
+	const windows = [];
+	for (const windowId of ["primary", "secondary"]) {
+		const window = asRecord(limits[windowId]);
+		if (!window) continue;
+		const usedPercent = window.usedPercent;
+		if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100) malformed = true;
+		const reset = window.resetsAt;
+		const resetAt = typeof reset === "number" && Number.isFinite(reset) && reset >= 0 ? (/* @__PURE__ */ new Date(reset * 1e3)).toISOString() : null;
+		windows.push(normalizeWindow({
+			windowId,
+			usedPercent,
+			resetAt
+		}));
+	}
+	const blocked = response?.ordinaryUsageAllowed === false;
+	return {
+		...common,
+		status: windows.length === 0 ? "unavailable" : malformed || blocked ? "partial" : "ok",
+		windows,
+		errorCode: windows.length === 0 ? "NO_WINDOWS" : blocked ? "ORDINARY_USAGE_BLOCKED" : malformed ? "INVALID_WINDOW" : null
+	};
+}
+/** Fixed, safe error messages: never forward stderr or a raw RPC response. */
+var CodexTransportError = class extends Error {
+	code;
+	constructor(code) {
+		super({
+			BINARY_NOT_FOUND: "Codex executable was not found",
+			TIMEOUT: "Codex app-server did not respond in time",
+			PROTOCOL_ERROR: "Codex app-server protocol failed"
+		}[code]);
+		this.code = code;
+		this.name = "CodexTransportError";
+	}
+};
+/** One bounded RPC session. Never spawns a bare Codex TUI and never prints raw output. */
+function requestCodexRateLimits(options = {}) {
+	const binary = options.binary ?? "codex";
+	const args = options.args ?? ["app-server"];
+	const timeoutMs = Math.max(100, Math.min(options.timeoutMs ?? 15e3, 6e4));
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, [...args], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			shell: false
+		});
+		let settled = false;
+		let phase = "initializing";
+		let buffer = "";
+		const finish = (error, result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			child.stdin.end();
+			if (!child.killed && child.exitCode === null) child.kill("SIGTERM");
+			if (error) reject(error);
+			else resolve(result);
+		};
+		const timeout = setTimeout(() => finish(new CodexTransportError("TIMEOUT")), timeoutMs);
+		const send = (message) => {
+			if (settled) return;
+			try {
+				child.stdin.write(`${JSON.stringify(message)}\n`);
+			} catch {
+				finish(new CodexTransportError("PROTOCOL_ERROR"));
+			}
+		};
+		child.once("error", (error) => {
+			finish(new CodexTransportError(error.code === "ENOENT" ? "BINARY_NOT_FOUND" : "PROTOCOL_ERROR"));
+		});
+		child.once("exit", () => finish(new CodexTransportError("PROTOCOL_ERROR")));
+		child.stdin.on("error", () => finish(new CodexTransportError("PROTOCOL_ERROR")));
+		child.stderr.resume();
+		const onMessage = (value) => {
+			const msg = value !== null && typeof value === "object" ? value : null;
+			if (!msg || typeof msg.id !== "number") return;
+			if (phase === "initializing" && msg.id === 1) {
+				if (msg.error || !msg.result) return finish(new CodexTransportError("PROTOCOL_ERROR"));
+				phase = "reading";
+				send({ method: "initialized" });
+				send({
+					id: 2,
+					method: "account/rateLimits/read"
+				});
+			} else if (phase === "reading" && msg.id === 2) {
+				if (msg.error || !msg.result) return finish(new CodexTransportError("PROTOCOL_ERROR"));
+				finish(void 0, msg.result);
+			}
+		};
+		child.stdout.on("data", (chunk) => {
+			if (settled) return;
+			buffer += chunk.toString("utf8");
+			if (buffer.length > 2e6) return finish(new CodexTransportError("PROTOCOL_ERROR"));
+			while (!settled) {
+				const index = buffer.indexOf("\n");
+				if (index < 0) break;
+				const line = buffer.slice(0, index).trim();
+				buffer = buffer.slice(index + 1);
+				if (!line) continue;
+				try {
+					onMessage(JSON.parse(line));
+				} catch {
+					finish(new CodexTransportError("PROTOCOL_ERROR"));
+				}
+			}
+		});
+		send({
+			id: 1,
+			method: "initialize",
+			params: { clientInfo: {
+				name: "kuota",
+				version: "0.1.0"
+			} }
+		});
+	});
+}
+function readCodex(options = {}) {
+	return Effect.promise(async () => {
+		try {
+			return parseCodexRateLimits(await requestCodexRateLimits(options));
+		} catch (error) {
+			const code = error instanceof CodexTransportError ? error.code : "UNKNOWN";
+			return makeUnavailableSnapshot("codex", code, code === "BINARY_NOT_FOUND" ? "unsupported" : "unavailable");
+		}
+	});
+}
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function slug$1(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "quota";
+}
+function groupId(value) {
+	if (/^gemini models?$/i.test(value)) return "gemini";
+	if (/^claude and gpt(?: models?)?$/i.test(value)) return "claude-gpt";
+	return slug$1(value);
+}
+function validFraction(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+/** Parses agy >=1.1.11's structured `-p /usage --output-format json` response. */
+function parseAntigravityUsageReport(raw) {
+	const data = record$1(raw);
+	const command = record$1(data?.command);
+	const payload = record$1(command?.data);
+	if (data?.status !== "SUCCESS" || command?.name !== "usage" || !Array.isArray(payload?.groups)) throw new Error("INVALID_USAGE_REPORT");
+	const windows = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const group of payload.groups) {
+		const info = record$1(group);
+		if (!info || !Array.isArray(info.buckets)) continue;
+		const family = groupId(typeof info.name === "string" ? info.name : typeof info.display_name === "string" ? info.display_name : "quota");
+		for (const bucket of info.buckets) {
+			const value = record$1(bucket);
+			if (!value || value.disabled === true) continue;
+			const nested = record$1(value.remaining);
+			const remaining = value.remaining_fraction ?? nested?.remaining_fraction ?? (nested?.case === "remainingFraction" ? nested.value : void 0);
+			if (!validFraction(remaining)) continue;
+			const name = `${family}.${typeof value.window === "string" ? slug$1(value.window) : typeof value.id === "string" ? slug$1(value.id) : "quota"}`;
+			const windowId = seen.has(name) ? `${name}:${slug$1(String(value.id ?? value.bucket_id ?? "additional"))}` : name;
+			seen.add(windowId);
+			windows.push(normalizeWindow({
+				windowId,
+				usedPercent: Number(((1 - remaining) * 100).toFixed(2)),
+				resetAt: value.reset_time ?? value.resetTime
+			}));
+		}
+	}
+	if (windows.length === 0) throw new Error("NO_MEASURED_QUOTA");
+	return {
+		provider: "antigravity",
+		status: "ok",
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: "agy-cli-print",
+		windows,
+		errorCode: null
+	};
+}
+/** Version strings with suffixes are intentionally rejected to avoid guessing support. */
+function parseAgyVersion(value) {
+	const match = /^(\d+)\.(\d+)\.(\d+)\s*$/.exec(value.trim());
+	if (!match) return false;
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	const patch = Number(match[3]);
+	return major > 1 || major === 1 && (minor > 1 || minor === 1 && patch >= 11);
+}
+var AgyProbeError = class extends Error {
+	code;
+	constructor(code) {
+		super(code);
+		this.code = code;
+	}
+};
+/** Bound subprocess output and lifetime; never print raw stdout/stderr or OAuth URLs. */
+function execute(binary, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, args, {
+			cwd: options.cwd,
+			env: options.env,
+			detached: process.platform !== "win32",
+			windowsHide: true,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const chunks = [];
+		let bytes = 0;
+		let stderr = "";
+		let settled = false;
+		const stop = () => {
+			if (child.pid && process.platform !== "win32") try {
+				process.kill(-child.pid, "SIGTERM");
+			} catch {}
+			else try {
+				child.kill("SIGTERM");
+			} catch {}
+		};
+		const finish = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			stop();
+			if (error) reject(error);
+			else resolve(Buffer.concat(chunks).toString("utf8"));
+		};
+		const timer = setTimeout(() => finish(new AgyProbeError("TIMEOUT")), options.timeoutMs);
+		child.stdout?.on("data", (chunk) => {
+			bytes += chunk.length;
+			if (bytes > options.maxOutputBytes) finish(new AgyProbeError("OUTPUT_TOO_LARGE"));
+			else if (!settled) chunks.push(chunk);
+		});
+		child.stderr?.on("data", (chunk) => {
+			if (stderr.length < 4096) stderr += chunk.toString("utf8").slice(0, 4096 - stderr.length);
+		});
+		child.once("error", (error) => finish(new AgyProbeError(error.code === "ENOENT" ? "BINARY_NOT_FOUND" : "CLI_FAILED")));
+		child.once("close", (code) => {
+			if (code === 0) finish();
+			else if (/not logged in|authentication required|sign.?in|please visit/i.test(stderr)) finish(new AgyProbeError("AUTH_REQUIRED"));
+			else finish(new AgyProbeError("CLI_FAILED"));
+		});
+	});
+}
+/** No new account login. Existing agy credentials only, guarded from browser launch and auto-update. */
+function readAntigravity(options = {}) {
+	return Effect.promise(async () => {
+		const directory = await mkdtemp(join(tmpdir(), "kuota-agy-"));
+		try {
+			const script = "#!/bin/sh\nexit 1\n";
+			for (const name of [
+				"open",
+				"xdg-open",
+				"browser"
+			]) await writeFile(join(directory, name), script, { mode: 448 });
+			const env = { ...process.env };
+			delete env.ANTIGRAVITY_OAUTH_CREDENTIALS_JSON;
+			env.AGY_CLI_DISABLE_AUTO_UPDATE = "true";
+			env.PATH = `${directory}${delimiter}${process.env.PATH ?? ""}`;
+			env.BROWSER = join(directory, "browser");
+			const binary = options.binary ?? "agy";
+			const context = {
+				cwd: directory,
+				env
+			};
+			if (!parseAgyVersion(await execute(binary, ["--version"], {
+				...context,
+				timeoutMs: 3e3,
+				maxOutputBytes: 8192
+			}))) throw new AgyProbeError("UNSUPPORTED_VERSION");
+			const text = await execute(binary, [
+				"-p",
+				"/usage",
+				"--output-format",
+				"json",
+				"--print-timeout",
+				"90s"
+			], {
+				...context,
+				timeoutMs: options.timeoutMs ?? 2e4,
+				maxOutputBytes: options.maxOutputBytes ?? 1048576
+			});
+			try {
+				return parseAntigravityUsageReport(JSON.parse(text));
+			} catch {
+				throw new AgyProbeError("PROTOCOL_ERROR");
+			}
+		} catch (error) {
+			const code = error instanceof AgyProbeError ? error.code : "CLI_FAILED";
+			return makeUnavailableSnapshot("antigravity", code, code === "AUTH_REQUIRED" ? "unauthenticated" : "unavailable");
+		} finally {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function validPercent(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100;
+}
+function slug(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+/** Only a Claude subscription OAuth token works; MCP-only and API keys are not quota tokens. */
+function extractClaudeOAuthToken(raw, now = Date.now()) {
+	const oauth = record(record(raw)?.claudeAiOauth);
+	const token = oauth?.accessToken;
+	const expiresAt = oauth?.expiresAt;
+	if (typeof token !== "string" || !token.trim() || !validExpiry(expiresAt, now)) return null;
+	return token.trim();
+}
+function validExpiry(value, now) {
+	return typeof value === "number" && Number.isFinite(value) && value > now;
+}
+/** Claude API reports utilization (used percent), not remaining percent. */
+function parseClaudeOAuthUsage(raw) {
+	const payload = record(raw);
+	if (!payload) throw new Error("INVALID_CLAUDE_USAGE");
+	const windows = [];
+	const add = (windowId, value) => {
+		const data = record(value);
+		if (!validPercent(data?.utilization)) return;
+		windows.push(normalizeWindow({
+			windowId,
+			usedPercent: data.utilization,
+			resetAt: data.resets_at
+		}));
+	};
+	add("session.5h", payload.five_hour);
+	if (validPercent(record(payload.seven_day)?.utilization)) add("weekly.all", payload.seven_day);
+	else add("weekly.oauth-apps", payload.seven_day_oauth_apps);
+	add("weekly.sonnet", payload.seven_day_sonnet);
+	add("weekly.opus", payload.seven_day_opus);
+	for (const key of [
+		"seven_day_routines",
+		"seven_day_claude_routines",
+		"claude_routines",
+		"routines",
+		"seven_day_cowork",
+		"cowork"
+	]) if (validPercent(record(payload[key])?.utilization)) {
+		add("weekly.routines", payload[key]);
+		break;
+	}
+	if (Array.isArray(payload.limits)) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const entry of payload.limits) {
+			const limit = record(entry);
+			const model = record(record(limit?.scope)?.model);
+			if (limit?.kind !== "weekly_scoped" || !validPercent(limit.percent)) continue;
+			const id = slug(typeof model?.display_name === "string" ? model.display_name : typeof model?.id === "string" ? model.id : "");
+			if (!id || id === "all-models") continue;
+			const windowId = `weekly.${id}`;
+			if (seen.has(windowId) || windows.some((w) => w.windowId === windowId)) continue;
+			seen.add(windowId);
+			windows.push(normalizeWindow({
+				windowId,
+				usedPercent: limit.percent,
+				resetAt: limit.resets_at
+			}));
+		}
+	}
+	return {
+		provider: "claude",
+		source: "claude-oauth-usage",
+		status: windows.length ? "ok" : "unavailable",
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		windows,
+		errorCode: windows.length ? null : "NO_MEASURED_QUOTA"
+	};
+}
+const ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
+const MAX_BODY = 1048576;
+/** Read at most 1 MiB, without placing raw HTTP error responses in logs or JSON output. */
+async function readBoundedResponse(response) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const buffers = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > MAX_BODY) throw new Error("RESPONSE_TOO_LARGE");
+			buffers.push(value);
+		}
+		const joined = new Uint8Array(total);
+		let offset = 0;
+		for (const buffer of buffers) {
+			joined.set(buffer, offset);
+			offset += buffer.byteLength;
+		}
+		return new TextDecoder().decode(joined);
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function resolveToken(options) {
+	if (options.token) return options.token.trim() || null;
+	const fromEnvironment = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+	if (fromEnvironment?.trim()) return fromEnvironment.trim();
+	try {
+		const file = options.credentialsFile ?? join(homedir(), ".claude", ".credentials.json");
+		return extractClaudeOAuthToken(JSON.parse(await readFile(file, "utf8")));
+	} catch {
+		return null;
+	}
+}
+/** No Keychain UI access, credential refresh, browser sign-in or CLI session side effects. */
+function readClaude(options = {}) {
+	return Effect.promise(async () => {
+		const token = await resolveToken(options);
+		if (!token) return makeUnavailableSnapshot("claude", "AUTH_REQUIRED", "unauthenticated");
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 12e3);
+		try {
+			const request = (url, agent) => (options.fetchImpl ?? fetch)(url, {
+				method: "GET",
+				redirect: "error",
+				cache: "no-store",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					Accept: "application/json",
+					"Content-Type": "application/json",
+					"anthropic-beta": "oauth-2025-04-20",
+					"User-Agent": agent
+				},
+				signal: controller.signal
+			});
+			let response = await request(`${ENDPOINT}?cedar_ember=1`, "claude-cli/2.1.0 (external, cli)");
+			if (response.status === 400 || response.status === 403) response = await request(ENDPOINT, "claude-code/2.1.0");
+			if (response.status === 401) return makeUnavailableSnapshot("claude", "AUTH_REQUIRED", "unauthenticated");
+			if (response.status === 429) return makeUnavailableSnapshot("claude", "RATE_LIMITED");
+			if (response.status !== 200) return makeUnavailableSnapshot("claude", "HTTP_ERROR");
+			const content = await readBoundedResponse(response);
+			try {
+				return parseClaudeOAuthUsage(JSON.parse(content));
+			} catch {
+				return makeUnavailableSnapshot("claude", "PROTOCOL_ERROR");
+			}
+		} catch (error) {
+			return makeUnavailableSnapshot("claude", controller.signal.aborted ? "TIMEOUT" : error instanceof Error && error.message === "RESPONSE_TOO_LARGE" ? "OUTPUT_TOO_LARGE" : "NETWORK_ERROR");
+		} finally {
+			clearTimeout(timer);
+		}
+	});
+}
+const PROVIDER_METADATA = [
+	{
+		id: "codex",
+		label: "OpenAI Codex",
+		implemented: true,
+		source: "codex-app-server"
+	},
+	{
+		id: "claude",
+		label: "Claude Code",
+		implemented: true,
+		source: "claude-oauth-usage"
+	},
+	{
+		id: "antigravity",
+		label: "Google Antigravity",
+		implemented: true,
+		source: "agy-cli-print"
+	}
+];
+/** Static names are extensible to runtime manifests in the later plugin phase. */
+function isProviderId(value) {
+	return PROVIDER_METADATA.some((provider) => provider.id === value);
+}
+function builtInProviders() {
+	return [
+		{
+			id: "codex",
+			label: "OpenAI Codex",
+			read: () => readCodex()
+		},
+		{
+			id: "claude",
+			label: "Claude Code",
+			read: () => readClaude()
+		},
+		{
+			id: "antigravity",
+			label: "Google Antigravity",
+			read: () => readAntigravity()
+		}
+	];
+}
+/** One failed adapter never prevents other providers from reporting. */
+function readAll(ids, providers = builtInProviders()) {
+	const byId = new Map(providers.map((provider) => [provider.id, provider]));
+	return Effect.all(ids.map((id) => {
+		const provider = byId.get(id);
+		if (!provider) return Effect.succeed(makeUnavailableSnapshot(id, "NOT_REGISTERED", "unsupported"));
+		return provider.read().pipe(Effect.catchAllCause(() => Effect.succeed(makeUnavailableSnapshot(id, "PROVIDER_FAILED"))));
+	}), { concurrency: 3 });
+}
+const COMMON = {
+	errorRetryMs: 6e4,
+	authRetryMs: 3e5,
+	rateLimitCooldownMs: 9e5,
+	staleMaxAgeMs: 864e5
+};
+const DEFAULT_POLICIES = {
+	codex: {
+		...COMMON,
+		successTtlMs: 6e4
+	},
+	claude: {
+		...COMMON,
+		successTtlMs: 9e5
+	},
+	antigravity: {
+		...COMMON,
+		successTtlMs: 3e5
+	}
+};
+const emptySlot = (generation) => ({
+	lastGood: null,
+	lastFailure: null,
+	lastCheckedAtMs: 0,
+	nextAttemptAtMs: 0,
+	inflight: null,
+	generation
+});
+const isMeasurable = (s) => (s.status === "ok" || s.status === "partial") && s.windows.length > 0;
+/**
+* Process-local TTL cache with per-provider singleflight, failure cooldowns and honest
+* stale labelling. Only normalized snapshots are retained.
+*/
+function createQuotaService(options = {}) {
+	const now = options.now ?? Date.now;
+	const providers = new Map((options.providers ?? builtInProviders()).map((provider) => [provider.id, provider]));
+	const slots = /* @__PURE__ */ new Map();
+	const generations = /* @__PURE__ */ new Map();
+	const policyFor = (id) => ({
+		...DEFAULT_POLICIES[id],
+		...options.policies?.[id]
+	});
+	const slotFor = (id) => {
+		let slot = slots.get(id);
+		if (!slot) {
+			slot = emptySlot(generations.get(id) ?? 0);
+			slots.set(id, slot);
+		}
+		return slot;
+	};
+	const view = (id, freshProbe) => {
+		const slot = slots.get(id);
+		if (!slot) return null;
+		const t = now();
+		const policy = policyFor(id);
+		const good = slot.lastGood;
+		const goodMs = good ? Date.parse(good.fetchedAt) : NaN;
+		const goodUsable = good !== null && !(t - (Number.isFinite(goodMs) ? goodMs : slot.lastCheckedAtMs) > policy.staleMaxAgeMs);
+		const nextAttemptAtMs = slot.nextAttemptAtMs > t ? slot.nextAttemptAtMs : null;
+		if (good && goodUsable) {
+			const failed = slot.lastFailure;
+			return makeObservation({
+				snapshot: good,
+				freshness: failed ? "stale" : freshProbe ? "live" : "cached",
+				checkedAtMs: slot.lastCheckedAtMs,
+				nowMs: t,
+				nextAttemptAtMs,
+				latestErrorCode: failed?.errorCode ?? null
+			});
+		}
+		if (slot.lastFailure) return makeObservation({
+			snapshot: slot.lastFailure,
+			freshness: freshProbe ? "live" : "cached",
+			checkedAtMs: slot.lastCheckedAtMs,
+			nowMs: t,
+			nextAttemptAtMs,
+			latestErrorCode: slot.lastFailure.errorCode
+		});
+		return null;
+	};
+	const probe = (id, provider, slot) => {
+		const attemptAt = now();
+		const settled = Effect.runPromise(provider.read().pipe(Effect.catchAllCause(() => Effect.succeed({
+			...makeUnavailableSnapshot(id, "PROVIDER_FAILED"),
+			fetchedAt: new Date(attemptAt).toISOString()
+		})))).catch(() => ({
+			...makeUnavailableSnapshot(id, "PROVIDER_FAILED"),
+			fetchedAt: new Date(attemptAt).toISOString()
+		})).then((snapshot) => {
+			if (slots.get(id) !== slot || slot.generation !== (generations.get(id) ?? 0)) return;
+			const policy = policyFor(id);
+			const t = now();
+			slot.lastCheckedAtMs = attemptAt;
+			if (isMeasurable(snapshot)) {
+				slot.lastGood = snapshot;
+				slot.lastFailure = null;
+				slot.nextAttemptAtMs = 0;
+				return;
+			}
+			slot.lastFailure = snapshot;
+			if (snapshot.errorCode === "RATE_LIMITED") slot.nextAttemptAtMs = t + policy.rateLimitCooldownMs;
+			else if (snapshot.errorCode === "AUTH_REQUIRED" || snapshot.status === "unauthenticated") {
+				slot.lastGood = null;
+				slot.nextAttemptAtMs = t + policy.authRetryMs;
+			} else slot.nextAttemptAtMs = t + policy.errorRetryMs;
+		}).finally(() => {
+			if (slot.inflight === settled) slot.inflight = null;
+		});
+		slot.inflight = settled;
+		return settled;
+	};
+	const readOne = async (id, force) => {
+		const provider = providers.get(id);
+		if (!provider) {
+			const t = now();
+			return makeObservation({
+				snapshot: {
+					...makeUnavailableSnapshot(id, "NOT_REGISTERED", "unsupported"),
+					fetchedAt: new Date(t).toISOString()
+				},
+				freshness: "live",
+				checkedAtMs: t,
+				nowMs: t,
+				latestErrorCode: "NOT_REGISTERED"
+			});
+		}
+		const slot = slotFor(id);
+		if (slot.inflight) {
+			await slot.inflight;
+			return view(id, true) ?? await readOne(id, force);
+		}
+		const t = now();
+		const coolingDown = slot.nextAttemptAtMs > t;
+		const goodMs = slot.lastGood ? Date.parse(slot.lastGood.fetchedAt) : NaN;
+		const fresh = slot.lastGood !== null && slot.lastFailure === null && Number.isFinite(goodMs) && t - goodMs < policyFor(id).successTtlMs;
+		if (coolingDown || fresh && !force) {
+			const cached = view(id, false);
+			if (cached) return cached;
+		}
+		await probe(id, provider, slot);
+		const result = view(id, true);
+		if (result) return result;
+		const t2 = now();
+		return makeObservation({
+			snapshot: makeUnavailableSnapshot(id, "INVALIDATED"),
+			freshness: "live",
+			checkedAtMs: t2,
+			nowMs: t2,
+			latestErrorCode: "INVALIDATED"
+		});
+	};
+	return {
+		read: (ids, opts) => Effect.promise(() => Promise.all(ids.map((id) => readOne(id, opts?.force === true)))),
+		peek: (id) => view(id, false),
+		invalidate: (id) => {
+			for (const target of id ? [id] : [
+				"codex",
+				"claude",
+				"antigravity"
+			]) {
+				generations.set(target, (generations.get(target) ?? 0) + 1);
+				slots.delete(target);
+			}
+		}
+	};
+}
+// ../cli/src/history-commands.ts
+async function loadDeviceId(directory) {
+	const path = join(directory, "device-id");
+	try {
+		const existing = (await readFile(path, "utf8")).trim();
+		if (/^[0-9a-f-]{36}$/.test(existing)) return existing;
+	} catch {}
+	await mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const id = randomUUID();
+	await writeFile(path, id, { mode: 384 });
+	return id;
+}
+const DAY = 864e5;
+function historyCommands(output, providers, runtime, setExit) {
+	const now = () => (runtime.now ?? (() => /* @__PURE__ */ new Date()))();
+	const directory = runtime.directory ?? defaultHistoryDirectory();
+	const journal = () => createLocalJsonlJournal({ directory });
+	const emit = (json, value, human) => output.writeStdout(json ? JSON.stringify({
+		schemaVersion: 1,
+		generatedAt: now().toISOString(),
+		...value
+	}) : human());
+	const fail = (json, code, exit = 2) => {
+		setExit(exit);
+		if (json) emit(true, { errors: [{ code }] }, () => "");
+		else output.writeStderr(`Error: ${code}`);
+	};
+	const provSelector = (provider, json) => {
+		const value = Option.getOrUndefined(provider);
+		if (value === void 0) return null;
+		if (!isProviderId(value)) {
+			fail(json, "UNKNOWN_PROVIDER");
+			return "bad";
+		}
+		return value;
+	};
+	const parseDate = (value, fallback, json) => {
+		const raw = Option.getOrUndefined(value);
+		if (raw === void 0) return fallback;
+		const parsed = new Date(raw);
+		if (!Number.isFinite(parsed.getTime())) {
+			fail(json, "INVALID_DATE");
+			return null;
+		}
+		return parsed;
+	};
+	const provider = Options.optional(Options.text("provider"));
+	const windowOpt = Options.optional(Options.text("window"));
+	const json = Options.boolean("json");
+	const collect = Command.make("collect", {
+		once: Options.boolean("once"),
+		provider,
+		json
+	}, ({ once, provider: p, json: asJson }) => Effect.gen(function* () {
+		if (!once) return fail(asJson, "ONCE_REQUIRED");
+		const selected = provSelector(p, asJson);
+		if (selected === "bad") return;
+		const snapshots = yield* readAll(selected ? [selected] : PROVIDER_METADATA.map((m) => m.id), providers);
+		const store = journal();
+		const deviceId = runtime.deviceId ?? (yield* Effect.promise(() => loadDeviceId(directory)));
+		const recordedAt = now().toISOString();
+		const collected = [];
+		const errors = [];
+		for (const snapshot of snapshots) {
+			const events = historyEventsFromSnapshot(snapshot, {
+				deviceId,
+				accountScope: null,
+				recordedAt
+			});
+			try {
+				const result = yield* Effect.promise(() => store.append(events));
+				collected.push({
+					provider: snapshot.provider,
+					status: snapshot.status,
+					...result
+				});
+			} catch {
+				errors.push({ code: "JOURNAL_WRITE_FAILED" });
+			}
+		}
+		yield* Effect.promise(() => store.applyRetention(now())).pipe(Effect.catchAllDefect(() => Effect.void));
+		if (errors.length > 0) setExit(1);
+		emit(asJson, {
+			collected,
+			errors
+		}, () => collected.map((c) => `${c.provider}: ${c.status}, ${c.written} written, ${c.duplicates} duplicate`).join("\n"));
+	}));
+	const history = Command.make("history", {
+		provider,
+		window: windowOpt,
+		from: Options.optional(Options.text("from")),
+		to: Options.optional(Options.text("to")),
+		json
+	}, ({ provider: p, window: w, from, to, json: asJson }) => Effect.gen(function* () {
+		const selected = provSelector(p, asJson);
+		if (selected === "bad") return;
+		const end = parseDate(to, now(), asJson);
+		const start = end && parseDate(from, /* @__PURE__ */ new Date(end.getTime() - 7 * DAY), asJson);
+		if (!end || !start) return;
+		const result = yield* Effect.promise(() => journal().readAll({
+			from: start.toISOString(),
+			to: end.toISOString(),
+			...selected ? { provider: selected } : {},
+			...Option.isSome(w) ? { windowId: w.value } : {}
+		}));
+		emit(asJson, {
+			from: start.toISOString(),
+			to: end.toISOString(),
+			events: result.events,
+			invalidLines: result.invalidLines
+		}, () => `${result.events.length} events (${result.invalidLines} invalid lines skipped)`);
+	}));
+	const forecast = Command.make("forecast", {
+		provider,
+		window: windowOpt,
+		mode: Options.withDefault(Options.text("mode"), "all-window"),
+		json
+	}, ({ provider: p, window: w, mode, json: asJson }) => Effect.gen(function* () {
+		const selected = provSelector(p, asJson);
+		if (selected === "bad") return;
+		if (mode !== "all-window" && mode !== "recent-activity") return fail(asJson, "INVALID_MODE");
+		const end = now();
+		const result = yield* Effect.promise(() => journal().readAll({
+			from: (/* @__PURE__ */ new Date(end.getTime() - 30 * DAY)).toISOString(),
+			to: end.toISOString(),
+			...selected ? { provider: selected } : {},
+			...Option.isSome(w) ? { windowId: w.value } : {}
+		}));
+		const keys = /* @__PURE__ */ new Map();
+		for (const e of result.events) if (e.kind === "quota_observed") keys.set(`${e.provider}\u0000${e.windowId}`, e);
+		const forecasts = [...keys.values()].sort((a, b) => a.provider.localeCompare(b.provider) || a.windowId.localeCompare(b.windowId)).map((k) => buildForecastV1({
+			now: end,
+			provider: k.provider,
+			windowId: k.windowId,
+			observations: result.events,
+			mode
+		}));
+		emit(asJson, {
+			forecasts,
+			invalidLines: result.invalidLines
+		}, () => forecasts.map((f) => `${f.provider}/${f.windowId}: ${f.quality}${f.exhaustedAt ? `, exhausts ${f.exhaustedAt}` : ""}`).join("\n") || "no history");
+	}));
+	const pace = Command.make("pace", {
+		provider,
+		json
+	}, ({ provider: p, json: asJson }) => Effect.gen(function* () {
+		const selected = provSelector(p, asJson);
+		if (selected === "bad") return;
+		const snapshots = yield* readAll(selected ? [selected] : PROVIDER_METADATA.map((m) => m.id), providers);
+		const at = now();
+		const rows = snapshots.flatMap((snapshot) => snapshot.windows.map((window) => {
+			const profile = windowProfile(snapshot.provider, window.windowId, window.resetAt, at);
+			const reset = window.resetAt ? new Date(window.resetAt) : null;
+			const start = reset && profile.durationMs !== null ? new Date(reset.getTime() - profile.durationMs) : null;
+			const result = calculatePace({
+				now: at,
+				startAt: start,
+				resetAt: reset,
+				usedPercent: window.usedPercent,
+				semantics: profile.semantics,
+				startSource: start ? "inferred" : "unknown"
+			});
+			return {
+				provider: snapshot.provider,
+				windowId: window.windowId,
+				semantics: profile.semantics,
+				pace: result,
+				reason: result ? null : "WINDOW_NOT_PROVEN_FIXED"
+			};
+		}));
+		emit(asJson, { pace: rows }, () => rows.map((r) => `${r.provider}/${r.windowId}: ${r.pace ? `ideal ${r.pace.idealUsedPercent.toFixed(1)}% used, actual ${r.pace.actualUsedPercent}%` : r.reason}`).join("\n"));
+	}));
+	const inspectOpt = Options.boolean("inspect");
+	const limitOpt = Options.withDefault(Options.integer("limit"), 20);
+	return [
+		collect,
+		history,
+		forecast,
+		pace,
+		Command.make("snapshot", {
+			provider,
+			inspect: inspectOpt,
+			json
+		}, ({ provider: p, inspect: asInspect, json: asJson }) => Effect.gen(function* () {
+			const selected = provSelector(p, asJson);
+			if (selected === "bad") return;
+			const snapshots = yield* readAll(selected ? [selected] : PROVIDER_METADATA.map((m) => m.id), providers);
+			if (asJson) {
+				emit(true, {
+					...asInspect ? { inspect: true } : {},
+					snapshots
+				}, () => "");
+				return;
+			}
+			const lines = [];
+			for (const s of snapshots) {
+				lines.push(`Provider: ${s.provider} [${s.status}]`);
+				lines.push(`  Source: ${s.source} · Fetched: ${s.fetchedAt}`);
+				if (s.errorCode) lines.push(`  Error Code: ${s.errorCode}`);
+				for (const w of s.windows) {
+					lines.push(`  - Window: ${w.windowId} · ${w.usedPercent !== null ? `${w.usedPercent}% used` : "unknown"} (${w.remainingPercent !== null ? `${w.remainingPercent}% remaining` : "unknown"})${w.resetAt ? ` · resets ${w.resetAt}` : ""}`);
+					if (asInspect) {
+						const profile = windowProfile(s.provider, w.windowId, w.resetAt);
+						lines.push(`      [inspect] semantics: ${profile.semantics} | duration: ${profile.durationMs ? `${profile.durationMs / 36e5}h` : "unspecified"}`);
+					}
+				}
+			}
+			output.writeStdout(lines.join("\n"));
+		})),
+		Command.make("snapshots", {
+			limit: limitOpt,
+			provider,
+			window: windowOpt,
+			json
+		}, ({ limit, provider: p, window: w, json: asJson }) => Effect.gen(function* () {
+			const selected = provSelector(p, asJson);
+			if (selected === "bad") return;
+			const end = now();
+			const sorted = [...(yield* Effect.promise(() => journal().readAll({
+				from: (/* @__PURE__ */ new Date(end.getTime() - 30 * DAY)).toISOString(),
+				to: end.toISOString(),
+				...selected ? { provider: selected } : {},
+				...Option.isSome(w) ? { windowId: w.value } : {}
+			}))).events].sort((a, b) => new Date(b.recordedAt).getTime() - new Date(a.recordedAt).getTime()).slice(0, Math.max(1, limit));
+			if (asJson) {
+				emit(true, {
+					total: sorted.length,
+					snapshots: sorted
+				}, () => "");
+				return;
+			}
+			if (sorted.length === 0) {
+				output.writeStdout("No recorded snapshot events found.");
+				return;
+			}
+			const lines = [
+				"RECORDED AT (UTC)          PROVIDER     WINDOW       USED %    KIND",
+				"-------------------------------------------------------------------------",
+				...sorted.map((e) => {
+					return `${e.recordedAt.padEnd(26)} ${e.provider.padEnd(12)} ${("windowId" in e ? e.windowId : "-").padEnd(12)} ${("usedPercent" in e && e.usedPercent !== null ? `${e.usedPercent}%` : "-").padEnd(9)} ${e.kind}`;
+				})
+			];
+			output.writeStdout(lines.join("\n"));
+		}))
+	];
+}
+// ../cli/src/commands.ts
+const processOutput = {
+	writeStdout: (value) => process.stdout.write(`${value}\n`),
+	writeStderr: (value) => process.stderr.write(`${value}\n`)
+};
+function envelope(providers, errors = []) {
+	return {
+		schemaVersion: 1,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		providers,
+		errors
+	};
+}
+function showHuman(snapshot) {
+	if (snapshot.status !== "ok" && snapshot.status !== "partial") return `${snapshot.provider}: ${snapshot.status} (${snapshot.errorCode ?? "unknown"})`;
+	const windows = snapshot.windows.map((window) => `${window.windowId}: ${window.remainingPercent === null ? "unknown" : `${window.remainingPercent}% remaining`}${window.resetAt ? ` · resets ${window.resetAt}` : ""}`);
+	return `${snapshot.provider}: ${snapshot.status}\n  ${windows.join("\n  ") || "quota unknown"}`;
+}
+/** An executable presence check, not a logged-in/account-readiness claim. */
+function hasBinary(name) {
+	for (const folder of (process.env.PATH ?? "").split(delimiter)) {
+		if (!folder) continue;
+		try {
+			accessSync(join(folder, name), constants.X_OK);
+			return true;
+		} catch {}
+	}
+	return false;
+}
+async function runCli(args, output = processOutput, providers = builtInProviders(), startTui = async () => {
+	return (await import("./main-B-hZbKK1.mjs")).startTui();
+}, runtime = {}) {
+	let exitCode = 0;
+	const status = Command.make("status", {
+		provider: Options.optional(Options.text("provider")),
+		json: Options.boolean("json")
+	}, ({ provider, json }) => Effect.gen(function* () {
+		const selector = Option.getOrUndefined(provider);
+		if (selector !== void 0 && !isProviderId(selector)) {
+			exitCode = 2;
+			if (json) output.writeStdout(JSON.stringify(envelope([], [{ code: "UNKNOWN_PROVIDER" }])));
+			else output.writeStderr("Unknown provider. Run `kuota providers` to see supported IDs.");
+			return;
+		}
+		const snapshots = yield* readAll(selector ? [selector] : PROVIDER_METADATA.map((item) => item.id), providers);
+		if (json) output.writeStdout(JSON.stringify(envelope(snapshots)));
+		else output.writeStdout(snapshots.map(showHuman).join("\n"));
+	}));
+	const providerList = Command.make("providers", { json: Options.boolean("json") }, ({ json }) => Effect.sync(() => {
+		if (json) output.writeStdout(JSON.stringify({
+			schemaVersion: 1,
+			providers: PROVIDER_METADATA
+		}));
+		else output.writeStdout(PROVIDER_METADATA.map((item) => `${item.id.padEnd(12)} ${item.label} ${item.implemented ? "implemented" : "planned"}`).join("\n"));
+	}));
+	const doctor = Command.make("doctor", { json: Options.boolean("json") }, ({ json }) => Effect.sync(() => {
+		const tools = PROVIDER_METADATA.map((item) => ({
+			provider: item.id,
+			executable: item.id === "antigravity" ? "agy" : item.id,
+			installed: hasBinary(item.id === "antigravity" ? "agy" : item.id),
+			adapterImplemented: item.implemented
+		}));
+		if (json) output.writeStdout(JSON.stringify({
+			schemaVersion: 1,
+			tools
+		}));
+		else output.writeStdout(tools.map((tool) => `${tool.provider}: executable ${tool.installed ? "present" : "not found"}, adapter ${tool.adapterImplemented ? "ready" : "planned"}`).join("\n"));
+	}));
+	const tui = Command.make("tui", {}, () => Effect.promise(startTui));
+	const makeWebCommand = (name) => Command.make(name, {
+		port: Options.optional(Options.integer("port")),
+		host: Options.optional(Options.text("host")),
+		noOpen: Options.boolean("no-open")
+	}, ({ port, host, noOpen }) => Effect.promise(async () => {
+		const { startWebServer } = await import("./web-server-DkdA5Ixj.mjs");
+		await startWebServer({
+			port: Option.getOrUndefined(port),
+			host: Option.getOrUndefined(host),
+			open: !noOpen
+		}, output, providers);
+	}));
+	const web = makeWebCommand("web");
+	const serve = makeWebCommand("serve");
+	const root = Command.make("kuota", {}, () => Effect.promise(async () => {
+		if (process.stdout.isTTY) await startTui();
+		else output.writeStdout("Kuota — Multi-provider AI Quota & Usage Monitor\nRun `kuota --help` for available commands, or `kuota web` to launch the web UI.");
+	})).pipe(Command.withSubcommands([
+		status,
+		providerList,
+		doctor,
+		tui,
+		web,
+		serve,
+		...historyCommands(output, providers, runtime, (code) => {
+			exitCode = code;
+		})
+	]));
+	const cli = Command.run(root, {
+		name: "Kuota",
+		version: "0.1.0"
+	});
+	try {
+		await Effect.runPromise(cli([
+			process.execPath,
+			"kuota",
+			...args
+		]).pipe(Effect.provide(NodeContext.layer)));
+	} catch (error) {
+		exitCode = 1;
+		if (args.includes("--json")) output.writeStdout(JSON.stringify(envelope([], [{ code: "CLI_ERROR" }])));
+		else if (args[0] === "tui" && String(error).includes("TUI requires an interactive terminal")) output.writeStderr("Kuota TUI requires an interactive terminal; use `kuota status --json` in non-TTY contexts.");
+		else output.writeStderr("Unable to execute command. Run `kuota --help` for usage.");
+	}
+	return exitCode;
+}
+// src/bin.ts
+runCli(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+});
+export { createLocalJsonlJournal as a, readAll as i, builtInProviders as n, defaultHistoryDirectory as o, createQuotaService as r, PROVIDER_METADATA as t };