@usecontextlayer/ctxe 0.4.3 → 0.4.5

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="59a42f57-145c-5f77-afb2-f1f76467783d")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1a858cd0-cb9a-550b-a3f9-5ca9387cf7df")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as Sentry from "@sentry/node";
 import * as xi from "node:fs";
@@ -59,7 +59,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version$1 = "0.4.3";
+var version$1 = "0.4.5";
 
 //#endregion
 //#region sentry.ts
@@ -7895,6 +7895,7 @@ const string$1 = (params) => {
 };
 const integer = /^-?\d+$/;
 const number$1 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 
@@ -8693,6 +8694,24 @@ const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, d
 	$ZodCheckNumberFormat.init(inst, def);
 	$ZodNumber.init(inst, def);
 });
+const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -9264,6 +9283,24 @@ const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
 		return payload;
 	};
 });
+const $ZodLiteral = /*@__PURE__*/ $constructor("$ZodLiteral", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
+	const values = new Set(def.values);
+	inst._zod.values = values;
+	inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (values.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values: def.values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.optin = "optional";
@@ -9837,6 +9874,13 @@ function _int(Class, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -10384,6 +10428,9 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 	else if (typeof maximum === "number") json.maximum = maximum;
 	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
 };
+const booleanProcessor = (_schema, _ctx, json, _params) => {
+	json.type = "boolean";
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -10395,6 +10442,27 @@ const enumProcessor = (schema, _ctx, json, _params) => {
 	if (values.every((v) => typeof v === "string")) json.type = "string";
 	json.enum = values;
 };
+const literalProcessor = (schema, ctx, json, _params) => {
+	const def = schema._zod.def;
+	const vals = [];
+	for (const val of def.values) if (val === void 0) {
+		if (ctx.unrepresentable === "throw") throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+	} else if (typeof val === "bigint") if (ctx.unrepresentable === "throw") throw new Error("BigInt literals cannot be represented in JSON Schema");
+	else vals.push(Number(val));
+	else vals.push(val);
+	if (vals.length === 0) {} else if (vals.length === 1) {
+		const val = vals[0];
+		json.type = val === null ? "null" : typeof val;
+		if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") json.enum = [val];
+		else json.const = val;
+	} else {
+		if (vals.every((v) => typeof v === "number")) json.type = "number";
+		if (vals.every((v) => typeof v === "string")) json.type = "string";
+		if (vals.every((v) => typeof v === "boolean")) json.type = "boolean";
+		if (vals.every((v) => v === null)) json.type = "null";
+		json.enum = vals;
+	}
+};
 const customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
@@ -11050,6 +11118,14 @@ const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def
 function int(params) {
 	return _int(ZodNumberFormat, params);
 }
+const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
+});
+function boolean(params) {
+	return _boolean(ZodBoolean, params);
+}
 const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -11254,6 +11330,23 @@ function _enum(values, params) {
 		...normalizeParams(params)
 	});
 }
+const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
+	inst.values = new Set(def.values);
+	Object.defineProperty(inst, "value", { get() {
+		if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+		return def.values[0];
+	} });
+});
+function literal(value, params) {
+	return new ZodLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
+		...normalizeParams(params)
+	});
+}
 const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
@@ -29490,7 +29583,7 @@ function validate(raw, sourcePath) {
 }
 function applyDefaults(input) {
 	return {
-		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.3",
+		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.5",
 		...input.microsandbox !== void 0 ? { microsandbox: input.microsandbox } : {},
 		...input.oldestConsideredPoint !== void 0 ? { oldestConsideredPoint: input.oldestConsideredPoint } : {},
 		maxSliceSize: input.maxSliceSize ?? 864e5,
@@ -29507,14 +29600,18 @@ function formatZodError$1(error) {
 	}).join("; ");
 }
 function planLoopPass(input) {
-	const due = input.synthesizers.filter((synthesizer) => input.now - synthesizer.frontier >= input.tick);
+	const frontierDue = input.synthesizers.filter((synthesizer) => input.now - synthesizer.frontier >= input.tick);
+	const due = frontierDue.filter((synthesizer) => synthesizer.notBefore === void 0 || synthesizer.notBefore <= input.now);
 	if (due.length > 0) return {
 		kind: "run",
 		order: due.map((synthesizer) => synthesizer.name).sort()
 	};
+	const gates = frontierDue.map((synthesizer) => synthesizer.notBefore).filter((notBefore) => notBefore !== void 0);
+	const gatedUntil = gates.length > 0 ? Math.min(...gates) : void 0;
 	return {
 		kind: "idle",
-		wakeAt: input.synthesizers.length === 0 ? input.now + input.tick : Math.min(...input.synthesizers.map((synthesizer) => synthesizer.frontier + input.tick))
+		wakeAt: input.synthesizers.length === 0 ? input.now + input.tick : Math.min(...input.synthesizers.map((synthesizer) => Math.max(synthesizer.frontier + input.tick, synthesizer.notBefore ?? 0))),
+		...gatedUntil !== void 0 && { gatedUntil }
 	};
 }
 async function runEngineLoop(deps, options) {
@@ -29527,17 +29624,20 @@ async function runEngineLoop(deps, options) {
 			tick: options.tick
 		});
 		if (pass.kind === "idle") {
-			if (options.mode === "backfill") return { stopReason: "caught_up" };
+			if (options.mode === "backfill") return { stopReason: pass.gatedUntil !== void 0 ? "rate_limited" : "caught_up" };
 			await deps.sleep(Math.max(0, pass.wakeAt - deps.now()));
 			continue;
 		}
 		let advancedAny = false;
+		let rateLimitedAny = false;
 		for (const name of pass.order) {
 			if (options.signal?.aborted) return { stopReason: "aborted" };
-			if ((await deps.runSlice(name)).advanced) advancedAny = true;
+			const outcome = await deps.runSlice(name);
+			if (outcome.advanced) advancedAny = true;
+			if (outcome.rateLimited) rateLimitedAny = true;
 		}
 		if (!advancedAny) {
-			if (options.mode === "backfill") return { stopReason: "stalled" };
+			if (options.mode === "backfill") return { stopReason: rateLimitedAny ? "rate_limited" : "stalled" };
 			await deps.sleep(options.tick);
 		}
 	}
@@ -29904,6 +30004,189 @@ function dirtyWorkingTreeIssue(paths) {
 		message: `Working tree is dirty:\n${formatWorkingTreePaths(paths)}\nRun 'ctxe repair' to roll back to HEAD (preserves .engine/runs/**).`
 	};
 }
+const runTriggerSchema = _enum([
+	"backfill",
+	"daemon",
+	"manual"
+]);
+_enum([
+	"success",
+	"failed",
+	"timed_out",
+	"rate_limited"
+]);
+const runStatusSchema = _enum([
+	"starting",
+	"running",
+	"success",
+	"failed",
+	"timed_out",
+	"rate_limited",
+	"interrupted"
+]);
+const claudeResultSchema = strictObject({
+	api_error_status: number().int().optional(),
+	is_error: boolean(),
+	num_turns: number().int(),
+	subtype: string().min(1),
+	terminal_reason: string().min(1).optional(),
+	total_cost_usd: number()
+});
+const runRecordSchema = strictObject({
+	claude_result: claudeResultSchema.optional(),
+	completed_at: string().min(1).optional(),
+	duration_ms: number().int().nonnegative().optional(),
+	exit_code: number().int().optional(),
+	rate_limit_resets_at: string().min(1).optional(),
+	run_id: string().min(1),
+	started_at: string().min(1),
+	status: runStatusSchema,
+	synthesizer: string().min(1),
+	triggered_by: runTriggerSchema
+});
+const RECORD_FILE_NAME = "record.json";
+const STDERR_FILE_NAME = "stderr";
+function buildStartingRunRecord(input) {
+	return {
+		run_id: input.runId,
+		started_at: input.startedAt,
+		status: "starting",
+		synthesizer: input.synthesizerName,
+		triggered_by: input.trigger
+	};
+}
+function buildRunningRunRecord(record) {
+	return {
+		...record,
+		status: "running"
+	};
+}
+function buildTerminalRunRecord(input) {
+	return {
+		...input.claudeResult !== void 0 && { claude_result: input.claudeResult },
+		completed_at: input.completedAt,
+		duration_ms: input.durationMs,
+		exit_code: input.exitCode,
+		...input.rateLimitResetsAt !== void 0 && { rate_limit_resets_at: input.rateLimitResetsAt },
+		run_id: input.runId,
+		started_at: input.startedAt,
+		status: input.status,
+		synthesizer: input.synthesizerName,
+		triggered_by: input.trigger
+	};
+}
+function buildInterruptedRunRecord(record, completedAt) {
+	return {
+		...record,
+		completed_at: completedAt,
+		status: "interrupted"
+	};
+}
+function getRunDir(input) {
+	return runDirPath(input.rootDir, input.synthesizerName, input.runId);
+}
+async function ensureRunDir(input) {
+	const runDir = getRunDir(input);
+	await mkdir(runDir, { recursive: true });
+	return runDir;
+}
+async function writeRunRecord(runDir, record) {
+	await mkdir(runDir, { recursive: true });
+	await writeJsonFileAtomic(path.join(runDir, RECORD_FILE_NAME), runRecordSchema.parse(record));
+}
+async function readRunRecord(runDir) {
+	const raw = await readFile(path.join(runDir, RECORD_FILE_NAME), "utf8");
+	return runRecordSchema.parse(JSON.parse(raw));
+}
+async function listRunRecords(input) {
+	const synthesizerNames = input.synthesizerName !== void 0 ? [input.synthesizerName] : await listSynthesizerRunDirNames(input.rootDir);
+	const entries = [];
+	for (const synthesizerName of synthesizerNames) {
+		const synthesizerDir = synthesizerRunsDirPath(input.rootDir, synthesizerName);
+		let runIds;
+		try {
+			runIds = await listDirectoryNames(synthesizerDir);
+		} catch (error) {
+			if (isNodeError(error) && error.code === "ENOENT") continue;
+			throw error;
+		}
+		for (const runId of runIds) {
+			const runDir = path.join(synthesizerDir, runId);
+			try {
+				entries.push({
+					record: await readRunRecord(runDir),
+					runDir,
+					runId
+				});
+			} catch (error) {
+				if (isNodeError(error) && error.code === "ENOENT") continue;
+				throw error;
+			}
+		}
+	}
+	return entries.sort(compareRunRecordEntries);
+}
+async function readRunStderr(runDir) {
+	return await readOptionalTextFile(path.join(runDir, STDERR_FILE_NAME));
+}
+async function writeRunStderr(input) {
+	await mkdir(input.runDir, { recursive: true });
+	await writeFileAtomic(path.join(input.runDir, STDERR_FILE_NAME), input.stderr);
+}
+async function markInterruptedRuns(rootDir) {
+	const interrupted = [];
+	const engineRunsDir = runsDirPath(rootDir);
+	let synthesizerDirs;
+	try {
+		synthesizerDirs = await listDirectoryNames(engineRunsDir);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return [];
+		throw error;
+	}
+	for (const synthesizerName of synthesizerDirs) {
+		const synthesizerDir = path.join(engineRunsDir, synthesizerName);
+		for (const runId of await listDirectoryNames(synthesizerDir)) {
+			const runDir = path.join(synthesizerDir, runId);
+			let record;
+			try {
+				record = await readRunRecord(runDir);
+			} catch (error) {
+				if (isNodeError(error) && error.code === "ENOENT") continue;
+				throw error;
+			}
+			if (record.status !== "starting" && record.status !== "running") continue;
+			const nextRecord = buildInterruptedRunRecord(record, (/* @__PURE__ */ new Date()).toISOString());
+			await writeRunRecord(runDir, nextRecord);
+			interrupted.push(nextRecord);
+		}
+	}
+	return interrupted;
+}
+async function listDirectoryNames(dirPath) {
+	return (await readdir$1(dirPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+async function listSynthesizerRunDirNames(rootDir) {
+	const engineRunsDir = runsDirPath(rootDir);
+	try {
+		return await listDirectoryNames(engineRunsDir);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+async function readOptionalTextFile(filePath) {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function compareRunRecordEntries(left, right) {
+	const timeCompare = Date.parse(right.record.started_at) - Date.parse(left.record.started_at);
+	if (timeCompare !== 0) return timeCompare;
+	return right.runId.localeCompare(left.runId);
+}
 const synthesizerSpecFrontmatterSchema = strictObject({
 	description: string().optional(),
 	name: string().trim().min(1)
@@ -30461,12 +30744,15 @@ async function executeSynthesizerRun(input) {
 		const result = await input.executor.run(executorInput);
 		const completedAtMs = now().getTime();
 		const durationMs = Math.max(0, completedAtMs - startedAtMs);
-		const status = exitCodeToStatus(result.exitCode);
+		const status = classifyOutcome(result.exitCode, result.observation);
+		const rateLimitResetsAt = observedRateLimitResetsAt(result.observation);
 		return {
 			outcome: {
 				durationMs,
 				exitCode: result.exitCode,
-				status
+				status,
+				...result.observation.result !== void 0 && { claudeResult: result.observation.result },
+				...rateLimitResetsAt !== void 0 && { rateLimitResetsAt }
 			},
 			stderr: result.stderr
 		};
@@ -30482,11 +30768,19 @@ async function executeSynthesizerRun(input) {
 		};
 	}
 }
-function exitCodeToStatus(exitCode) {
+function classifyOutcome(exitCode, observation) {
 	if (exitCode === 0) return "success";
 	if (exitCode === 124) return "timed_out";
+	if (observation.result?.api_error_status === 429) return "rate_limited";
+	if (observation.lastRateLimit?.status === "rejected") return "rate_limited";
 	return "failed";
 }
+function observedRateLimitResetsAt(observation) {
+	const rateLimit = observation.lastRateLimit;
+	if (rateLimit === void 0) return void 0;
+	if (rateLimit.status !== "rejected" || rateLimit.resetsAt === void 0) return;
+	return msToIso(rateLimit.resetsAt * 1e3);
+}
 function buildExecutorInput(input) {
 	return {
 		image: input.synthesizerImage,
@@ -30576,175 +30870,6 @@ function reconcileCursor(input) {
 		frontier: input.prevCursor.frontier
 	};
 }
-const runTriggerSchema = _enum([
-	"backfill",
-	"daemon",
-	"manual"
-]);
-_enum([
-	"success",
-	"failed",
-	"timed_out"
-]);
-const runStatusSchema = _enum([
-	"starting",
-	"running",
-	"success",
-	"failed",
-	"timed_out",
-	"interrupted"
-]);
-const runRecordSchema = strictObject({
-	completed_at: string().min(1).optional(),
-	duration_ms: number().int().nonnegative().optional(),
-	exit_code: number().int().optional(),
-	run_id: string().min(1),
-	started_at: string().min(1),
-	status: runStatusSchema,
-	synthesizer: string().min(1),
-	triggered_by: runTriggerSchema
-});
-const RECORD_FILE_NAME = "record.json";
-const STDERR_FILE_NAME = "stderr";
-function buildStartingRunRecord(input) {
-	return {
-		run_id: input.runId,
-		started_at: input.startedAt,
-		status: "starting",
-		synthesizer: input.synthesizerName,
-		triggered_by: input.trigger
-	};
-}
-function buildRunningRunRecord(record) {
-	return {
-		...record,
-		status: "running"
-	};
-}
-function buildTerminalRunRecord(input) {
-	return {
-		completed_at: input.completedAt,
-		duration_ms: input.durationMs,
-		exit_code: input.exitCode,
-		run_id: input.runId,
-		started_at: input.startedAt,
-		status: input.status,
-		synthesizer: input.synthesizerName,
-		triggered_by: input.trigger
-	};
-}
-function buildInterruptedRunRecord(record, completedAt) {
-	return {
-		...record,
-		completed_at: completedAt,
-		status: "interrupted"
-	};
-}
-function getRunDir(input) {
-	return runDirPath(input.rootDir, input.synthesizerName, input.runId);
-}
-async function ensureRunDir(input) {
-	const runDir = getRunDir(input);
-	await mkdir(runDir, { recursive: true });
-	return runDir;
-}
-async function writeRunRecord(runDir, record) {
-	await mkdir(runDir, { recursive: true });
-	await writeJsonFileAtomic(path.join(runDir, RECORD_FILE_NAME), runRecordSchema.parse(record));
-}
-async function readRunRecord(runDir) {
-	const raw = await readFile(path.join(runDir, RECORD_FILE_NAME), "utf8");
-	return runRecordSchema.parse(JSON.parse(raw));
-}
-async function listRunRecords(input) {
-	const synthesizerNames = input.synthesizerName !== void 0 ? [input.synthesizerName] : await listSynthesizerRunDirNames(input.rootDir);
-	const entries = [];
-	for (const synthesizerName of synthesizerNames) {
-		const synthesizerDir = synthesizerRunsDirPath(input.rootDir, synthesizerName);
-		let runIds;
-		try {
-			runIds = await listDirectoryNames(synthesizerDir);
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") continue;
-			throw error;
-		}
-		for (const runId of runIds) {
-			const runDir = path.join(synthesizerDir, runId);
-			try {
-				entries.push({
-					record: await readRunRecord(runDir),
-					runDir,
-					runId
-				});
-			} catch (error) {
-				if (isNodeError(error) && error.code === "ENOENT") continue;
-				throw error;
-			}
-		}
-	}
-	return entries.sort(compareRunRecordEntries);
-}
-async function readRunStderr(runDir) {
-	return await readOptionalTextFile(path.join(runDir, STDERR_FILE_NAME));
-}
-async function writeRunStderr(input) {
-	await mkdir(input.runDir, { recursive: true });
-	await writeFileAtomic(path.join(input.runDir, STDERR_FILE_NAME), input.stderr);
-}
-async function markInterruptedRuns(rootDir) {
-	const interrupted = [];
-	const engineRunsDir = runsDirPath(rootDir);
-	let synthesizerDirs;
-	try {
-		synthesizerDirs = await listDirectoryNames(engineRunsDir);
-	} catch (error) {
-		if (isNodeError(error) && error.code === "ENOENT") return [];
-		throw error;
-	}
-	for (const synthesizerName of synthesizerDirs) {
-		const synthesizerDir = path.join(engineRunsDir, synthesizerName);
-		for (const runId of await listDirectoryNames(synthesizerDir)) {
-			const runDir = path.join(synthesizerDir, runId);
-			let record;
-			try {
-				record = await readRunRecord(runDir);
-			} catch (error) {
-				if (isNodeError(error) && error.code === "ENOENT") continue;
-				throw error;
-			}
-			if (record.status !== "starting" && record.status !== "running") continue;
-			const nextRecord = buildInterruptedRunRecord(record, (/* @__PURE__ */ new Date()).toISOString());
-			await writeRunRecord(runDir, nextRecord);
-			interrupted.push(nextRecord);
-		}
-	}
-	return interrupted;
-}
-async function listDirectoryNames(dirPath) {
-	return (await readdir$1(dirPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-}
-async function listSynthesizerRunDirNames(rootDir) {
-	const engineRunsDir = runsDirPath(rootDir);
-	try {
-		return await listDirectoryNames(engineRunsDir);
-	} catch (error) {
-		if (isNodeError(error) && error.code === "ENOENT") return [];
-		throw error;
-	}
-}
-async function readOptionalTextFile(filePath) {
-	try {
-		return await readFile(filePath, "utf8");
-	} catch (error) {
-		if (isNodeError(error) && error.code === "ENOENT") return null;
-		throw error;
-	}
-}
-function compareRunRecordEntries(left, right) {
-	const timeCompare = Date.parse(right.record.started_at) - Date.parse(left.record.started_at);
-	if (timeCompare !== 0) return timeCompare;
-	return right.runId.localeCompare(left.runId);
-}
 function renderSliceJson(slice) {
 	const windows = {};
 	for (const [table, window] of Object.entries(slice)) windows[table] = {
@@ -30859,9 +30984,11 @@ async function finalizeFailedSynthesizerTransaction(input) {
 function buildTerminalRecord(input) {
 	const { ctx, runResult, completedAt } = input;
 	return buildTerminalRunRecord({
+		...runResult.outcome.claudeResult !== void 0 && { claudeResult: runResult.outcome.claudeResult },
 		completedAt,
 		durationMs: runResult.outcome.durationMs,
 		exitCode: runResult.outcome.exitCode,
+		...runResult.outcome.rateLimitResetsAt !== void 0 && { rateLimitResetsAt: runResult.outcome.rateLimitResetsAt },
 		runId: ctx.runId,
 		startedAt: ctx.startedAt,
 		status: runResult.outcome.status,
@@ -30985,10 +31112,14 @@ var Engine = class {
 			listSynthesizers: async () => {
 				await this.refreshSynthesizers();
 				const specs = this.listSynthesizers().filter((spec) => options.scopeTo === void 0 || spec.name === options.scopeTo);
-				return Promise.all(specs.map(async (spec) => ({
-					frontier: (await readCursor(rootDir, spec.name))?.frontier ?? 0,
-					name: spec.name
-				})));
+				return Promise.all(specs.map(async (spec) => {
+					const notBefore = await this.readRateLimitGate(spec.name, clock().getTime());
+					return {
+						frontier: (await readCursor(rootDir, spec.name))?.frontier ?? 0,
+						name: spec.name,
+						...notBefore !== void 0 && { notBefore }
+					};
+				}));
 			},
 			now: () => clock().getTime(),
 			runSlice: async (name) => {
@@ -30999,11 +31130,17 @@ var Engine = class {
 					});
 					options.onSlice?.(outcome);
 					this.logSliceLag(name, outcome);
-					return { advanced: outcome.record.status === "success" };
+					return {
+						advanced: outcome.record.status === "success",
+						rateLimited: outcome.record.status === "rate_limited"
+					};
 				} catch (error) {
 					if (error instanceof TransactionLockHeldError) {
 						this.logger.warn(`[engine] skipping '${name}': ${error.message}`);
-						return { advanced: false };
+						return {
+							advanced: false,
+							rateLimited: false
+						};
 					}
 					throw error;
 				}
@@ -31011,6 +31148,18 @@ var Engine = class {
 			sleep: (ms) => sleepAbortable(ms, options.signal)
 		};
 	}
+	async readRateLimitGate(synthesizerName, nowMs) {
+		const latest = (await listRunRecords({
+			rootDir: this.repo.rootDir,
+			synthesizerName
+		}))[0]?.record;
+		if (latest?.status !== "rate_limited") return void 0;
+		if (latest.rate_limit_resets_at === void 0) return void 0;
+		const resetsAt = isoToMs(latest.rate_limit_resets_at, "rate_limit_resets_at");
+		if (resetsAt <= nowMs) return void 0;
+		this.logger.info(`[engine] '${synthesizerName}' rate limited — usage window resets ${latest.rate_limit_resets_at}; holding runs until then`);
+		return resetsAt;
+	}
 	logSliceLag(name, outcome) {
 		if (outcome.record.status !== "success") {
 			this.logger.warn(`[engine] '${name}' slice did not advance (status=${outcome.record.status})`);
@@ -31152,17 +31301,83 @@ function latestRunByName(entries) {
 	for (const { record } of entries) if (!latest.has(record.synthesizer)) latest.set(record.synthesizer, record);
 	return latest;
 }
+const rateLimitEventSchema = object({
+	rate_limit_info: object({
+		resetsAt: number().optional(),
+		status: string().min(1)
+	}),
+	type: literal("rate_limit_event")
+});
+const resultEventSchema = object({
+	...claudeResultSchema.shape,
+	type: literal("result")
+});
+var ClaudeStreamObserver = class {
+	decoder = new TextDecoder("utf-8", { fatal: false });
+	pendingLine = "";
+	lastRateLimit;
+	result;
+	feed(chunk) {
+		this.pendingLine += this.decoder.decode(chunk, { stream: true });
+		for (;;) {
+			const newlineAt = this.pendingLine.indexOf("\n");
+			if (newlineAt === -1) return;
+			const line = this.pendingLine.slice(0, newlineAt);
+			this.pendingLine = this.pendingLine.slice(newlineAt + 1);
+			this.observeLine(line);
+		}
+	}
+	get resultSeen() {
+		return this.result !== void 0;
+	}
+	observation() {
+		const trailing = this.pendingLine + this.decoder.decode();
+		this.pendingLine = "";
+		if (trailing.length > 0) this.observeLine(trailing);
+		return {
+			...this.lastRateLimit !== void 0 && { lastRateLimit: this.lastRateLimit },
+			...this.result !== void 0 && { result: this.result }
+		};
+	}
+	observeLine(line) {
+		if (line.trim().length === 0) return;
+		let event;
+		try {
+			event = JSON.parse(line);
+		} catch {
+			return;
+		}
+		const rateLimit = rateLimitEventSchema.safeParse(event);
+		if (rateLimit.success) {
+			const { status, resetsAt } = rateLimit.data.rate_limit_info;
+			this.lastRateLimit = {
+				status,
+				...resetsAt !== void 0 && { resetsAt }
+			};
+			return;
+		}
+		const result = resultEventSchema.safeParse(event);
+		if (result.success) {
+			const { type: _type, ...fields } = result.data;
+			this.result = fields;
+		}
+	}
+};
 const GUEST_MEMORY_MIB = 2048;
 const EXEC_INACTIVITY_TIMEOUT_MS = 600 * 1e3;
 const EXEC_MAX_DURATION_MS = 7200 * 1e3;
+const EXEC_RESULT_GRACE_MS = 60 * 1e3;
 const DRAIN_TIMED_OUT = Symbol("drain-timed-out");
 async function drainExecStream(handle, options) {
+	const observer = new ClaudeStreamObserver();
 	const startedAt = Date.now();
 	let lastEventAt = startedAt;
+	let resultSeenAt;
 	for (;;) {
 		const ceilingDeadline = startedAt + options.maxDurationMs;
 		const inactivityDeadline = lastEventAt + options.inactivityMs;
-		const deadline = Math.min(ceilingDeadline, inactivityDeadline);
+		const graceDeadline = resultSeenAt === void 0 ? Number.POSITIVE_INFINITY : resultSeenAt + options.resultGraceMs;
+		const deadline = Math.min(ceilingDeadline, inactivityDeadline, graceDeadline);
 		let timer;
 		const timedOut = new Promise((resolve) => {
 			timer = setTimeout(() => resolve(DRAIN_TIMED_OUT), Math.max(0, deadline - Date.now()));
@@ -31176,17 +31391,31 @@ async function drainExecStream(handle, options) {
 		}
 		if (settled === DRAIN_TIMED_OUT) {
 			pending.catch(() => {});
+			const observation = observer.observation();
+			if (observation.result !== void 0) return {
+				kind: "result_no_exit",
+				observation,
+				result: observation.result
+			};
 			return {
 				kind: "timed_out",
+				observation,
 				reason: ceilingDeadline <= inactivityDeadline ? "max_duration" : "inactivity"
 			};
 		}
-		if (settled === null) return { kind: "ended" };
+		if (settled === null) return {
+			kind: "ended",
+			observation: observer.observation()
+		};
 		lastEventAt = Date.now();
 		if (settled.kind === "stderr") options.onStderr(settled.data);
-		else if (settled.kind === "exited") return {
+		else if (settled.kind === "stdout") {
+			observer.feed(settled.data);
+			if (resultSeenAt === void 0 && observer.resultSeen) resultSeenAt = lastEventAt;
+		} else if (settled.kind === "exited") return {
 			exitCode: settled.code,
-			kind: "exited"
+			kind: "exited",
+			observation: observer.observation()
 		};
 	}
 }
@@ -31196,6 +31425,7 @@ var MicrosandboxClaudeExecutor = class {
 		const runPlan = buildMicrosandboxClaudeRunPlan(input);
 		const stderrParts = [];
 		let exitCode = 1;
+		let observation = {};
 		let sandbox = null;
 		let authMaterial = null;
 		try {
@@ -31222,11 +31452,16 @@ var MicrosandboxClaudeExecutor = class {
 				const drained = await drainExecStream(await sandbox.execStreamWith(cmd, (e) => e.args(args)), {
 					inactivityMs: EXEC_INACTIVITY_TIMEOUT_MS,
 					maxDurationMs: EXEC_MAX_DURATION_MS,
-					onStderr: (data) => stderrParts.push(stderrDecoder.decode(data, { stream: true }))
+					onStderr: (data) => stderrParts.push(stderrDecoder.decode(data, { stream: true })),
+					resultGraceMs: EXEC_RESULT_GRACE_MS
 				});
 				stderrParts.push(stderrDecoder.decode());
+				observation = drained.observation;
 				if (drained.kind === "exited") exitCode = drained.exitCode;
-				else if (drained.kind === "timed_out") {
+				else if (drained.kind === "result_no_exit") {
+					exitCode = drained.result.is_error ? 1 : 0;
+					stderrParts.push(`claude emitted its terminal result (is_error: ${drained.result.is_error}) but never exited within ${EXEC_RESULT_GRACE_MS / 1e3}s; concluding the run from the result event and tearing the sandbox down\n`);
+				} else if (drained.kind === "timed_out") {
 					exitCode = 124;
 					stderrParts.push(drained.reason === "inactivity" ? `exec stream timed out: no events for ${EXEC_INACTIVITY_TIMEOUT_MS / 6e4} minutes; abandoning the run and tearing the sandbox down\n` : `exec stream timed out: run exceeded the ${EXEC_MAX_DURATION_MS / 6e4}-minute ceiling; abandoning the run and tearing the sandbox down\n`);
 				}
@@ -31254,6 +31489,7 @@ var MicrosandboxClaudeExecutor = class {
 		}
 		return {
 			exitCode,
+			observation,
 			stderr: stderrParts.join("")
 		};
 	}
@@ -31590,7 +31826,7 @@ async function runBackfillCommand(input) {
 		...summary,
 		finalFrontier: summary.finalFrontier === null ? null : msToIso(summary.finalFrontier)
 	})}\n`);
-	if (summary.stopReason === "stalled") process.exitCode = 1;
+	if (summary.stopReason === "stalled" || summary.stopReason === "rate_limited") process.exitCode = 1;
 }
 
 //#endregion
@@ -31783,4 +32019,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, resolveRepoContext, resolveRuntimePaths, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=59a42f57-145c-5f77-afb2-f1f76467783d
+//# debugId=1a858cd0-cb9a-550b-a3f9-5ca9387cf7df