@usecontextlayer/ctxe 0.4.3 → 0.4.6

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]="ee0e5987-2fbc-50ed-9038-a0c4541b7548")}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.6";
 
 //#endregion
 //#region sentry.ts
@@ -7894,7 +7894,8 @@ const string$1 = (params) => {
 	return new RegExp(`^${regex}$`);
 };
 const integer = /^-?\d+$/;
-const number$1 = /^-?\d+(?:\.\d+)?$/;
+const number$2 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 
@@ -8671,7 +8672,7 @@ const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def) => {
 });
 const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
 	inst._zod.parse = (payload, _ctx) => {
 		if (def.coerce) try {
 			payload.value = Number(payload.value);
@@ -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;
@@ -9038,6 +9057,62 @@ const $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def) => {
 		});
 	};
 });
+const $ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+	def.inclusive = false;
+	$ZodUnion.init(inst, def);
+	const _super = inst._zod.parse;
+	defineLazy(inst._zod, "propValues", () => {
+		const propValues = {};
+		for (const option of def.options) {
+			const pv = option._zod.propValues;
+			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+			for (const [k, v] of Object.entries(pv)) {
+				if (!propValues[k]) propValues[k] = /* @__PURE__ */ new Set();
+				for (const val of v) propValues[k].add(val);
+			}
+		}
+		return propValues;
+	});
+	const disc = cached(() => {
+		const opts = def.options;
+		const map = /* @__PURE__ */ new Map();
+		for (const o of opts) {
+			const values = o._zod.propValues?.[def.discriminator];
+			if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+			for (const v of values) {
+				if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
+				map.set(v, o);
+			}
+		}
+		return map;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				code: "invalid_type",
+				expected: "object",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const opt = disc.value.get(input?.[def.discriminator]);
+		if (opt) return opt._zod.run(payload, ctx);
+		if (def.unionFallback || ctx.direction === "backward") return _super(payload, ctx);
+		payload.issues.push({
+			code: "invalid_union",
+			errors: [],
+			note: "No matching discriminator",
+			discriminator: def.discriminator,
+			options: Array.from(disc.value.keys()),
+			input,
+			path: [def.discriminator],
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -9208,7 +9283,7 @@ const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
 					issues: []
 				}, ctx);
 				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+				if (typeof key === "string" && number$2.test(key) && keyResult.issues.length) {
 					const retryResult = def.keyType._zod.run({
 						value: Number(key),
 						issues: []
@@ -9264,6 +9339,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";
@@ -9827,6 +9920,15 @@ function _number(Class, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
+function _coercedNumber(Class, params) {
+	return new Class({
+		type: "number",
+		coerce: true,
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _int(Class, params) {
 	return new Class({
 		type: "number",
@@ -9837,6 +9939,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 +10493,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 +10507,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");
 };
@@ -11040,7 +11173,7 @@ const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
 	inst.isFinite = true;
 	inst.format = bag.format ?? null;
 });
-function number(params) {
+function number$1(params) {
 	return _number(ZodNumber, params);
 }
 const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def) => {
@@ -11050,6 +11183,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);
@@ -11171,6 +11312,14 @@ function strictObject(shape, params) {
 		...normalizeParams(params)
 	});
 }
+function looseObject(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape,
+		catchall: unknown(),
+		...normalizeParams(params)
+	});
+}
 const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
@@ -11184,6 +11333,18 @@ function union(options, params) {
 		...normalizeParams(params)
 	});
 }
+const ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
+	ZodUnion.init(inst, def);
+	$ZodDiscriminatedUnion.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+	return new ZodDiscriminatedUnion({
+		type: "union",
+		options,
+		discriminator,
+		...normalizeParams(params)
+	});
+}
 const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
@@ -11254,6 +11415,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);
@@ -11420,6 +11598,12 @@ function superRefine(fn, params) {
 	return _superRefine(fn, params);
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
+function number(params) {
+	return _coercedNumber(ZodNumber, params);
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
@@ -17742,6 +17926,74 @@ const execaNode = createExeca(mapNode);
 const $ = createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 const { sendMessage, getOneMessage, getEachMessage, getCancelSignal } = getIpcExport();
 
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@14.0.0/node_modules/uuid/dist-node/rng.js
+const rnds8 = new Uint8Array(16);
+function rng() {
+	return crypto.getRandomValues(rnds8);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@14.0.0/node_modules/uuid/dist-node/stringify.js
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+function unsafeStringify(arr, offset = 0) {
+	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@14.0.0/node_modules/uuid/dist-node/v7.js
+const _state = {};
+function v7(options, buf, offset) {
+	let bytes;
+	if (options) bytes = v7Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.seq, buf, offset);
+	else {
+		const now = Date.now();
+		const rnds = rng();
+		updateV7State(_state, now, rnds);
+		bytes = v7Bytes(rnds, _state.msecs, _state.seq, buf, offset);
+	}
+	return buf ?? unsafeStringify(bytes);
+}
+function updateV7State(state, now, rnds) {
+	state.msecs ??= -Infinity;
+	state.seq ??= 0;
+	if (now > state.msecs) {
+		state.seq = rnds[6] << 23 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
+		state.msecs = now;
+	} else {
+		state.seq = state.seq + 1 | 0;
+		if (state.seq === 0) state.msecs++;
+	}
+	return state;
+}
+function v7Bytes(rnds, msecs, seq, buf, offset = 0) {
+	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
+	if (!buf) {
+		buf = new Uint8Array(16);
+		offset = 0;
+	} else if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+	msecs ??= Date.now();
+	seq ??= rnds[6] * 127 << 24 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
+	buf[offset++] = msecs / 1099511627776 & 255;
+	buf[offset++] = msecs / 4294967296 & 255;
+	buf[offset++] = msecs / 16777216 & 255;
+	buf[offset++] = msecs / 65536 & 255;
+	buf[offset++] = msecs / 256 & 255;
+	buf[offset++] = msecs & 255;
+	buf[offset++] = 112 | seq >>> 28 & 15;
+	buf[offset++] = seq >>> 20 & 255;
+	buf[offset++] = 128 | seq >>> 14 & 63;
+	buf[offset++] = seq >>> 6 & 255;
+	buf[offset++] = seq << 2 & 255 | rnds[10] & 3;
+	buf[offset++] = rnds[11];
+	buf[offset++] = rnds[12];
+	buf[offset++] = rnds[13];
+	buf[offset++] = rnds[14];
+	buf[offset++] = rnds[15];
+	return buf;
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
 var require_kind_of = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -25968,74 +26220,6 @@ var require_gray_matter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = matter;
 }));
 
-//#endregion
-//#region ../../node_modules/.pnpm/uuid@14.0.0/node_modules/uuid/dist-node/rng.js
-const rnds8 = new Uint8Array(16);
-function rng() {
-	return crypto.getRandomValues(rnds8);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/uuid@14.0.0/node_modules/uuid/dist-node/stringify.js
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
-function unsafeStringify(arr, offset = 0) {
-	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/uuid@14.0.0/node_modules/uuid/dist-node/v7.js
-const _state = {};
-function v7(options, buf, offset) {
-	let bytes;
-	if (options) bytes = v7Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.seq, buf, offset);
-	else {
-		const now = Date.now();
-		const rnds = rng();
-		updateV7State(_state, now, rnds);
-		bytes = v7Bytes(rnds, _state.msecs, _state.seq, buf, offset);
-	}
-	return buf ?? unsafeStringify(bytes);
-}
-function updateV7State(state, now, rnds) {
-	state.msecs ??= -Infinity;
-	state.seq ??= 0;
-	if (now > state.msecs) {
-		state.seq = rnds[6] << 23 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
-		state.msecs = now;
-	} else {
-		state.seq = state.seq + 1 | 0;
-		if (state.seq === 0) state.msecs++;
-	}
-	return state;
-}
-function v7Bytes(rnds, msecs, seq, buf, offset = 0) {
-	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
-	if (!buf) {
-		buf = new Uint8Array(16);
-		offset = 0;
-	} else if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-	msecs ??= Date.now();
-	seq ??= rnds[6] * 127 << 24 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
-	buf[offset++] = msecs / 1099511627776 & 255;
-	buf[offset++] = msecs / 4294967296 & 255;
-	buf[offset++] = msecs / 16777216 & 255;
-	buf[offset++] = msecs / 65536 & 255;
-	buf[offset++] = msecs / 256 & 255;
-	buf[offset++] = msecs & 255;
-	buf[offset++] = 112 | seq >>> 28 & 15;
-	buf[offset++] = seq >>> 20 & 255;
-	buf[offset++] = 128 | seq >>> 14 & 63;
-	buf[offset++] = seq >>> 6 & 255;
-	buf[offset++] = seq << 2 & 255 | rnds[10] & 3;
-	buf[offset++] = rnds[11];
-	buf[offset++] = rnds[12];
-	buf[offset++] = rnds[13];
-	buf[offset++] = rnds[14];
-	buf[offset++] = rnds[15];
-	return buf;
-}
-
 //#endregion
 //#region ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -27397,9 +27581,113 @@ var require_proper_lockfile = /* @__PURE__ */ __commonJSMin(((exports, module) =
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/postgres@3.4.9/node_modules/postgres/src/query.js
+//#region ../base-schemas/dist/index.mjs
 var import_gray_matter = /* @__PURE__ */ __toESM(require_gray_matter(), 1);
 var import_proper_lockfile = /* @__PURE__ */ __toESM(require_proper_lockfile(), 1);
+const apiKeyAuthSchema = strictObject({
+	api_key: string().trim().min(1),
+	type: literal("api_key")
+}).meta({ title: "ApiKeyAuth" });
+const authenticatedAccountRefSchema = strictObject({
+	account_id: string().trim().min(1),
+	provider_id: string().trim().min(1),
+	type: literal("authenticated_account")
+}).meta({ title: "AuthenticatedAccountRef" });
+const authenticatedAccountIdentitySchema = authenticatedAccountRefSchema.omit({ type: true }).meta({ title: "AuthenticatedAccountIdentity" });
+const bindingAuthNoneSchema = strictObject({ type: literal("none") }).meta({ title: "BindingAuthNone" });
+const clientCredentialsAuthSchema = strictObject({
+	client_id: string().trim().min(1),
+	client_secret: string().trim().min(1),
+	type: literal("client_credentials")
+}).meta({ title: "ClientCredentialsAuth" });
+const bindingAuthSchema = discriminatedUnion("type", [
+	bindingAuthNoneSchema,
+	authenticatedAccountRefSchema,
+	apiKeyAuthSchema,
+	clientCredentialsAuthSchema
+]).meta({ title: "BindingAuth" });
+const MODES = ["dagster"];
+const modeSchema = _enum(MODES);
+const generatedAtSchema = string().datetime({ offset: true });
+const bindingModelNameSchema = string().trim().min(1).meta({ title: "BindingModelName" });
+const bindingModelsSchema = strictObject({
+	active: array(bindingModelNameSchema).optional(),
+	filter: string().trim().min(1).optional()
+}).meta({ title: "BindingModels" });
+const dagsterAllPlanBindingSchema = strictObject({
+	auth: bindingAuthSchema,
+	binding_id: string().uuid(),
+	config: record(string(), unknown()),
+	mode: modeSchema,
+	models: bindingModelsSchema.optional(),
+	plugin_id: string().trim().min(1)
+}).meta({ title: "PlanBinding" }).extend({ mode: literal("dagster") }).meta({ title: "DagsterAllPlanBinding" });
+const dagsterBindingPlanAllSchema = strictObject({
+	bindings: array(dagsterAllPlanBindingSchema),
+	generated_at: generatedAtSchema,
+	version: literal(1)
+}).meta({ title: "DagsterBindingPlanAll" });
+const dagsterPluginPlanBindingSchema = dagsterAllPlanBindingSchema.omit({
+	mode: true,
+	plugin_id: true
+}).meta({ title: "DagsterPluginPlanBinding" });
+const dagsterBindingPlanPluginSchema = strictObject({
+	bindings: array(dagsterPluginPlanBindingSchema),
+	generated_at: generatedAtSchema,
+	mode: literal("dagster"),
+	plugin_id: string().trim().min(1),
+	version: literal(1)
+}).meta({ title: "DagsterBindingPlanPlugin" });
+const RUN_STATUSES = [
+	"QUEUED",
+	"NOT_STARTED",
+	"MANAGED",
+	"STARTING",
+	"STARTED",
+	"SUCCESS",
+	"FAILURE",
+	"CANCELING",
+	"CANCELED"
+];
+const runStatusSchema$1 = _enum(RUN_STATUSES).meta({ title: "RunStatus" });
+const stateTimestampSchema = string().datetime({ offset: true });
+const bindingStateSchema = strictObject({
+	frontier: stateTimestampSchema.nullable(),
+	last_run: stateTimestampSchema.nullable(),
+	last_run_status: runStatusSchema$1.nullable(),
+	plugin_id: string().trim().min(1)
+}).meta({ title: "BindingState" });
+const bindingStateResponseSchema = strictObject({
+	bindings: record(string().uuid(), bindingStateSchema),
+	version: literal(1)
+}).meta({ title: "BindingStateResponse" });
+const oauthAccessTokenSuccessSchema = looseObject({
+	accessToken: string().trim().min(1),
+	accessTokenExpiresAt: string().datetime({ offset: true })
+}).meta({ title: "OAuthAccessTokenSuccess" });
+const pluginAuthNoneSchema = strictObject({ type: literal("none") }).meta({ title: "PluginAuthNone" });
+const pluginAuthApiKeySchema = strictObject({ type: literal("api_key") }).meta({ title: "PluginAuthApiKey" });
+const pluginAuthClientCredentialsSchema = strictObject({ type: literal("client_credentials") }).meta({ title: "PluginAuthClientCredentials" });
+const pluginOAuthSchema = strictObject({
+	provider_id: string().trim().min(1),
+	scopes: array(string().trim().min(1)).min(1),
+	type: literal("oauth")
+}).meta({ title: "PluginOAuth" });
+const pluginAuthSchema = discriminatedUnion("type", [
+	pluginAuthNoneSchema,
+	pluginAuthApiKeySchema,
+	pluginAuthClientCredentialsSchema,
+	pluginOAuthSchema
+]).meta({ title: "PluginAuth" });
+const pluginManifestSchema = strictObject({
+	auth: pluginAuthSchema,
+	mode: modeSchema,
+	plugin_id: string().trim().min(1),
+	skill: string().optional()
+}).meta({ title: "PluginManifest" });
+
+//#endregion
+//#region ../../node_modules/.pnpm/postgres@3.4.9/node_modules/postgres/src/query.js
 const originCache = /* @__PURE__ */ new Map(), originStackCache = /* @__PURE__ */ new Map(), originError = Symbol("OriginError");
 const CLOSE = {};
 var Query = class extends Promise {
@@ -29490,7 +29778,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.6",
 		...input.microsandbox !== void 0 ? { microsandbox: input.microsandbox } : {},
 		...input.oldestConsideredPoint !== void 0 ? { oldestConsideredPoint: input.oldestConsideredPoint } : {},
 		maxSliceSize: input.maxSliceSize ?? 864e5,
@@ -29506,38 +29794,65 @@ function formatZodError$1(error) {
 		return `${issue.path.length > 0 ? issue.path.join(".") : "root"}: ${issue.message}`;
 	}).join("; ");
 }
+function gatePasses(input) {
+	if (input.syncHorizon === null) return false;
+	if (input.mode === "manual") return input.frontier < input.syncHorizon;
+	return input.syncHorizon - input.frontier >= input.tick;
+}
 function planLoopPass(input) {
-	const due = input.synthesizers.filter((synthesizer) => input.now - synthesizer.frontier >= input.tick);
-	if (due.length > 0) return {
+	const horizon = input.syncHorizon;
+	const horizonDue = horizon === null ? [] : input.synthesizers.filter((synthesizer) => gatePasses({
+		frontier: synthesizer.frontier,
+		mode: "loop",
+		syncHorizon: horizon,
+		tick: input.tick
+	}));
+	const due = horizonDue.filter((synthesizer) => (synthesizer.notBefore ?? 0) <= input.now);
+	if (horizon !== null && due.length > 0) return {
 		kind: "run",
-		order: due.map((synthesizer) => synthesizer.name).sort()
+		order: due.map((synthesizer) => synthesizer.name).sort(),
+		syncHorizon: horizon
 	};
+	const held = new Set(horizonDue);
 	return {
 		kind: "idle",
-		wakeAt: input.synthesizers.length === 0 ? input.now + input.tick : Math.min(...input.synthesizers.map((synthesizer) => synthesizer.frontier + input.tick))
+		reason: held.size > 0 ? "rate_limited" : "caught_up",
+		wakeAt: input.synthesizers.length === 0 ? input.now + input.tick : Math.min(...input.synthesizers.map((synthesizer) => {
+			if (held.has(synthesizer)) return synthesizer.notBefore ?? 0;
+			return Math.max(synthesizer.notBefore ?? 0, input.now + input.tick);
+		}))
+	};
+}
+function concludeLoopPass(results) {
+	if (results.includes("advanced")) return { kind: "progressed" };
+	return {
+		kind: "blocked",
+		reason: results.includes("rate_limited") ? "rate_limited" : "stalled"
 	};
 }
 async function runEngineLoop(deps, options) {
 	for (;;) {
 		if (options.signal?.aborted) return { stopReason: "aborted" };
-		const synthesizers = await deps.listSynthesizers();
+		const [syncHorizon, synthesizers] = await Promise.all([deps.captureSyncHorizon(), deps.listSynthesizers()]);
 		const pass = planLoopPass({
 			now: deps.now(),
+			syncHorizon,
 			synthesizers,
 			tick: options.tick
 		});
 		if (pass.kind === "idle") {
-			if (options.mode === "backfill") return { stopReason: "caught_up" };
+			if (options.mode === "backfill") return { stopReason: pass.reason };
 			await deps.sleep(Math.max(0, pass.wakeAt - deps.now()));
 			continue;
 		}
-		let advancedAny = false;
+		const results = [];
 		for (const name of pass.order) {
 			if (options.signal?.aborted) return { stopReason: "aborted" };
-			if ((await deps.runSlice(name)).advanced) advancedAny = true;
+			results.push(await deps.runSlice(name, pass.syncHorizon));
 		}
-		if (!advancedAny) {
-			if (options.mode === "backfill") return { stopReason: "stalled" };
+		const conclusion = concludeLoopPass(results);
+		if (conclusion.kind === "blocked") {
+			if (options.mode === "backfill") return { stopReason: conclusion.reason };
 			await deps.sleep(options.tick);
 		}
 	}
@@ -29861,6 +30176,18 @@ function formatRelativeAge(ms) {
 	}
 	return rtf.format(-Math.round(value), "year");
 }
+function formatDuration(ms) {
+	let value = Math.trunc(ms) / 1e3;
+	if (value < 1) return "under a second";
+	for (const [unit, perNext] of DIVISIONS) {
+		if (value < perNext) return pluralizeUnit(Math.round(value), unit);
+		value /= perNext;
+	}
+	return pluralizeUnit(Math.round(value), "year");
+}
+function pluralizeUnit(value, unit) {
+	return `${value} ${unit}${value === 1 ? "" : "s"}`;
+}
 async function runRootPreflight(repo) {
 	await assertGitCheckout(repo);
 	const branch = await inspectBranchReadiness(repo);
@@ -29904,13 +30231,266 @@ function dirtyWorkingTreeIssue(paths) {
 		message: `Working tree is dirty:\n${formatWorkingTreePaths(paths)}\nRun 'ctxe repair' to roll back to HEAD (preserves .engine/runs/**).`
 	};
 }
-const synthesizerSpecFrontmatterSchema = strictObject({
-	description: string().optional(),
-	name: string().trim().min(1)
-});
-function parseSynthesizerSpecMarkdown(content, sourcePath) {
-	if (!hasYamlFrontmatter(content)) return {
-		kind: "not_synthesizer",
+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$1().int().optional(),
+	is_error: boolean(),
+	num_turns: number$1().int(),
+	subtype: string().min(1),
+	terminal_reason: string().min(1).optional(),
+	total_cost_usd: number$1()
+});
+const runRecordSchema = strictObject({
+	claude_result: claudeResultSchema.optional(),
+	completed_at: string().min(1).optional(),
+	duration_ms: number$1().int().nonnegative().optional(),
+	exit_code: number$1().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 readLatestRunRecord(input) {
+	const synthesizerDir = synthesizerRunsDirPath(input.rootDir, input.synthesizerName);
+	let runIds;
+	try {
+		runIds = await listDirectoryNames(synthesizerDir);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return null;
+		throw error;
+	}
+	const latest = runIds.reduce((max, runId) => max === null || runId > max ? runId : max, null);
+	if (latest === null) return null;
+	try {
+		return await readRunRecord(path.join(synthesizerDir, latest));
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+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);
+}
+async function runRootFastForward(repo) {
+	await assertGitCheckout(repo);
+	const branch = await inspectBranchReadiness(repo);
+	const tree = await inspectWorkingTree(repo);
+	if (branch.kind === "no_origin") throw new Error("RootRepair requires 'origin' to be configured in remote mode. Provisioning must add origin before repair.");
+	if (branch.kind === "local_head_without_remote_main") throw new Error(`RootRepair refuses to act: local HEAD is at ${branch.localSha} but origin/${repo.branch} does not exist. Operator must reconcile manually.`);
+	const needsFastForward = branch.kind === "local_unborn_remote_has_main" || branch.kind === "remote_mismatch";
+	if (needsFastForward && !tree.clean) throw new Error(formatCombinedRepairError(repo, branch, tree));
+	if (needsFastForward) return {
+		kind: "fast_forward",
+		...await fastForwardRoot(repo)
+	};
+	return { kind: "no_op" };
+}
+async function runRootRepair(repo) {
+	const fastForward = await runRootFastForward(repo);
+	if (fastForward.kind === "fast_forward") return fastForward;
+	if (!(await inspectWorkingTree(repo)).clean) return await runDirtyRootRepair(repo);
+	return { kind: "no_op" };
+}
+async function runDirtyRootRepair(repo) {
+	await repairDirtyRoot(repo);
+	const interruptedRunIds = (await markInterruptedRuns(repo.rootDir)).map((record) => record.run_id);
+	if ((await inspectWorkingTree(repo)).clean) return {
+		commit: null,
+		interruptedRunIds,
+		kind: "dirty_root_repair"
+	};
+	const { sha } = await commitRootRepair(repo, {
+		interruptedRunIds,
+		repairId: v7()
+	});
+	await pushToOrigin(repo);
+	return {
+		commit: {
+			pushed: repo.mode === "remote",
+			sha
+		},
+		interruptedRunIds,
+		kind: "dirty_root_repair"
+	};
+}
+function formatCombinedRepairError(repo, branch, tree) {
+	const dirtyPaths = tree.clean ? "(clean)" : formatWorkingTreePaths(tree.paths);
+	return [
+		"RootRepair refuses to combine branch fast-forward with dirty-root repair in v1.",
+		`Branch: ${branch.kind === "local_unborn_remote_has_main" ? `local checkout is unborn but origin/${repo.branch} exists` : branch.kind === "remote_mismatch" ? `local HEAD does not match origin/${repo.branch}` : `branch state is '${branch.kind}'`}.`,
+		"Dirty paths:",
+		dirtyPaths,
+		"Operator must inspect and choose the order manually."
+	].join("\n");
+}
+const synthesizerSpecFrontmatterSchema = strictObject({
+	description: string().optional(),
+	name: string().trim().min(1)
+});
+function parseSynthesizerSpecMarkdown(content, sourcePath) {
+	if (!hasYamlFrontmatter(content)) return {
+		kind: "not_synthesizer",
 		reason: "missing_frontmatter",
 		sourcePath
 	};
@@ -30461,12 +31041,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 +31065,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,
@@ -30512,7 +31103,7 @@ function buildSandboxName(synthesizerName, runId) {
 	return `ctxe-${synthesizerName.slice(0, 24).toLowerCase()}-${runId.slice(-8).toLowerCase()}`;
 }
 function planCeiling(input) {
-	return Math.min(input.prevCursor.frontier + input.config.maxSliceSize, input.wallclock);
+	return Math.min(input.prevCursor.frontier + input.config.maxSliceSize, input.syncHorizon);
 }
 function buildSlice(input) {
 	const slice = {};
@@ -30541,11 +31132,11 @@ function nextCursor(input) {
 	};
 }
 function plan(input) {
-	const ceiling = planCeiling({
+	const ceiling = Math.max(planCeiling({
 		config: input.config,
 		prevCursor: input.prevCursor,
-		wallclock: input.wallclock
-	});
+		syncHorizon: input.syncHorizon
+	}), input.prevCursor.frontier);
 	const slice = buildSlice({
 		ceiling,
 		floors: input.prevCursor.floors
@@ -30576,175 +31167,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] = {
@@ -30754,10 +31176,13 @@ function renderSliceJson(slice) {
 	return `${JSON.stringify(windows, null, "	")}\n`;
 }
 const DEFAULT_OLDEST_LOOKBACK_MS = 720 * 60 * 60 * 1e3;
+function resolveOldest(config, beginMs) {
+	return config.oldestConsideredPoint ?? beginMs - DEFAULT_OLDEST_LOOKBACK_MS;
+}
 async function openSynthesizerTransaction(input) {
-	const now = input.now ?? (() => /* @__PURE__ */ new Date());
 	const runId = assertSafeEngineName((input.runIdFactory ?? v7)());
-	const startedAt = now().toISOString();
+	const begin = (input.now ?? (() => /* @__PURE__ */ new Date()))();
+	const startedAt = begin.toISOString();
 	const runDir = await ensureRunDir({
 		rootDir: input.repo.rootDir,
 		runId,
@@ -30778,25 +31203,24 @@ async function openSynthesizerTransaction(input) {
 		synthesizer: input.synthesizer,
 		trigger: input.trigger
 	});
-	const wallclock = isoToMs(startedAt, "transaction startedAt");
+	const persistedCursor = await readCursor(input.repo.rootDir, input.synthesizer.name);
 	const planConfig = {
 		maxSliceSize: input.config.maxSliceSize,
-		oldestConsideredPoint: input.config.oldestConsideredPoint ?? wallclock - DEFAULT_OLDEST_LOOKBACK_MS
+		oldestConsideredPoint: resolveOldest(input.config, begin.getTime())
 	};
 	const { next, slice } = plan({
 		config: planConfig,
 		prevCursor: reconcileCursor({
 			config: planConfig,
-			prevCursor: await readCursor(input.repo.rootDir, input.synthesizer.name),
+			prevCursor: persistedCursor,
 			tables: Object.keys(watermark)
 		}),
-		wallclock,
+		syncHorizon: input.syncHorizon,
 		watermark
 	});
 	await writeRunRecord(runDir, buildRunningRunRecord(startingRecord));
 	return {
 		next,
-		reachedWallclock: next.frontier === wallclock,
 		runDir,
 		runId,
 		sliceJson: renderSliceJson(slice),
@@ -30859,9 +31283,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,
@@ -30901,6 +31327,7 @@ var Engine = class {
 	now;
 	runIdFactory;
 	repo;
+	syncHorizonCapture;
 	watermarkCapture;
 	synthesizers = /* @__PURE__ */ new Map();
 	config = null;
@@ -30918,13 +31345,19 @@ var Engine = class {
 			mode: options.git?.mode ?? DEFAULT_GIT_MODE,
 			rootDir: path.resolve(options.rootDir)
 		};
+		this.syncHorizonCapture = options.syncHorizonCapture;
 		this.watermarkCapture = options.watermarkCapture;
 	}
 	async runDaemon(options = {}) {
 		if (this.daemonRunning) throw new Error("Engine.runDaemon is already running.");
 		this.daemonRunning = true;
 		try {
-			const report = await runRootPreflight(this.repo);
+			let report = await runRootPreflight(this.repo);
+			if (!report.ready) {
+				const repaired = await runRootFastForward(this.repo);
+				if (repaired.kind === "fast_forward") this.logger.info(`[engine] root was behind origin/${this.repo.branch} — fast-forwarded ${repaired.from ?? "(unborn)"} → ${repaired.to}`);
+				report = await runRootPreflight(this.repo);
+			}
 			if (!report.ready) throw new Error(formatPreflightFailure(this.repo.rootDir, report.issues));
 			await this.ensureLoaded();
 			await runEngineLoop(this.buildLoopDeps({
@@ -30941,10 +31374,24 @@ var Engine = class {
 	}
 	async runOnce(synthesizerName) {
 		await this.prepareSynthesizerRun(synthesizerName);
-		return (await this.runSynthesizerTransaction({
+		const config = this.requireConfig();
+		const syncHorizon = await this.syncHorizonCapture();
+		const frontier = (await readCursor(this.repo.rootDir, synthesizerName))?.frontier ?? resolveOldest(config, this.nowDate().getTime());
+		if (syncHorizon === null || !gatePasses({
+			frontier,
+			mode: "manual",
+			syncHorizon,
+			tick: config.tick
+		})) return { kind: "caught_up" };
+		const { record } = await this.runSynthesizerTransaction({
+			syncHorizon,
 			synthesizerName,
 			trigger: "manual"
-		})).record;
+		});
+		return {
+			kind: "ran",
+			record
+		};
 	}
 	async backfill(synthesizerName, options = {}) {
 		await this.prepareSynthesizerRun(synthesizerName);
@@ -30978,32 +31425,43 @@ var Engine = class {
 	getDiscoveryErrors() {
 		return [...this.discoveryErrors];
 	}
+	nowDate() {
+		return (this.now ?? (() => /* @__PURE__ */ new Date()))();
+	}
 	buildLoopDeps(options) {
 		const rootDir = this.repo.rootDir;
-		const clock = this.now ?? (() => /* @__PURE__ */ new Date());
 		return {
+			captureSyncHorizon: this.syncHorizonCapture,
 			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
-				})));
+				const passNowMs = this.nowDate().getTime();
+				const config = this.requireConfig();
+				return Promise.all(specs.map(async (spec) => {
+					const notBefore = await this.readRateLimitGate(spec.name, passNowMs);
+					return {
+						frontier: (await readCursor(rootDir, spec.name))?.frontier ?? resolveOldest(config, passNowMs),
+						name: spec.name,
+						...notBefore !== void 0 && { notBefore }
+					};
+				}));
 			},
-			now: () => clock().getTime(),
-			runSlice: async (name) => {
+			now: () => this.nowDate().getTime(),
+			runSlice: async (name, syncHorizon) => {
 				try {
 					const outcome = await this.runSynthesizerTransaction({
+						syncHorizon,
 						synthesizerName: name,
 						trigger: options.trigger
 					});
 					options.onSlice?.(outcome);
 					this.logSliceLag(name, outcome);
-					return { advanced: outcome.record.status === "success" };
+					const status = outcome.record.status;
+					return status === "success" ? "advanced" : status === "rate_limited" ? "rate_limited" : "failed";
 				} catch (error) {
 					if (error instanceof TransactionLockHeldError) {
 						this.logger.warn(`[engine] skipping '${name}': ${error.message}`);
-						return { advanced: false };
+						return "failed";
 					}
 					throw error;
 				}
@@ -31011,13 +31469,24 @@ var Engine = class {
 			sleep: (ms) => sleepAbortable(ms, options.signal)
 		};
 	}
+	async readRateLimitGate(synthesizerName, nowMs) {
+		const latest = await readLatestRunRecord({
+			rootDir: this.repo.rootDir,
+			synthesizerName
+		});
+		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})`);
 			return;
 		}
-		const clock = this.now ?? (() => /* @__PURE__ */ new Date());
-		const lagMs = Math.max(0, clock().getTime() - outcome.frontier);
+		const lagMs = Math.max(0, this.nowDate().getTime() - outcome.frontier);
 		const note = `[engine] '${name}' frontier ${formatRelativeAge(lagMs)}`;
 		if (lagMs > LAG_BEHIND_TICKS * this.requireConfig().tick) this.logger.warn(`${note} — behind`);
 		else this.logger.info(note);
@@ -31042,6 +31511,7 @@ var Engine = class {
 				now: this.now,
 				repo: this.repo,
 				runIdFactory: this.runIdFactory,
+				syncHorizon: request.syncHorizon,
 				synthesizer,
 				trigger: request.trigger,
 				watermarkCapture: this.watermarkCapture
@@ -31068,7 +31538,6 @@ var Engine = class {
 			});
 			return {
 				frontier: ctx.next.frontier,
-				reachedWallclock: ctx.reachedWallclock,
 				record
 			};
 		} finally {
@@ -31118,10 +31587,24 @@ function formatPreflightFailure(rootDir, issues) {
 	return `Engine root '${rootDir}' is not ready:\n${issues.map((issue) => `  [${issue.code}] ${issue.message}`).join("\n")}`;
 }
 function assembleEngineStatus(input) {
+	const observation = input.syncHorizon;
+	const horizon = observation.kind === "captured" ? observation.horizon : null;
 	const synthesizers = input.synthesizers.map((synthesizer) => {
-		const lagMs = synthesizer.frontier === null ? null : Math.max(0, input.now - synthesizer.frontier);
+		const frontier = synthesizer.frontier;
+		const lagMs = frontier === null ? null : Math.max(0, input.now - frontier);
+		let horizonGapMs = null;
+		let horizonGapText;
+		if (frontier === null) horizonGapText = "never run";
+		else if (observation.kind === "unavailable") horizonGapText = "control plane unavailable";
+		else if (horizon === null) horizonGapText = "no binding has synced";
+		else {
+			horizonGapMs = Math.max(0, horizon - frontier);
+			horizonGapText = horizonGapMs === 0 ? "caught up to the sync horizon" : `${formatDuration(horizonGapMs)} of synced ground pending`;
+		}
 		return {
-			frontier: synthesizer.frontier === null ? null : msToIso(synthesizer.frontier),
+			frontier: frontier === null ? null : msToIso(frontier),
+			horizonGapMs,
+			horizonGapText,
 			lagMs,
 			lagText: lagMs === null ? "never run" : formatRelativeAge(lagMs),
 			latestRun: synthesizer.latestRun,
@@ -31130,21 +31613,37 @@ function assembleEngineStatus(input) {
 	}).sort((left, right) => left.name.localeCompare(right.name));
 	return {
 		now: msToIso(input.now),
+		syncHorizon: horizon === null ? null : msToIso(horizon),
+		...observation.kind === "unavailable" && { syncHorizonError: `control plane unavailable: ${observation.error}` },
 		synthesizers
 	};
 }
 async function loadEngineStatus(input) {
 	const now = input.now ?? Date.now();
+	let syncHorizon;
+	try {
+		syncHorizon = {
+			horizon: await input.syncHorizonCapture(),
+			kind: "captured"
+		};
+	} catch (error) {
+		syncHorizon = {
+			error: error instanceof Error ? error.message : String(error),
+			kind: "unavailable"
+		};
+	}
 	const discovery = await discoverSynthesizers(path.resolve(input.rootDir, SYNTHESIZERS_DIR_RELATIVE));
 	const latestByName = latestRunByName(await listRunRecords({ rootDir: input.rootDir }));
 	const names = discovery.synthesizers.map((synthesizer) => synthesizer.name).filter((name) => input.synthesizerName === void 0 || name === input.synthesizerName);
+	const synthesizers = await Promise.all(names.map(async (name) => ({
+		frontier: (await readCursor(input.rootDir, name))?.frontier ?? null,
+		latestRun: latestByName.get(name) ?? null,
+		name
+	})));
 	return assembleEngineStatus({
 		now,
-		synthesizers: await Promise.all(names.map(async (name) => ({
-			frontier: (await readCursor(input.rootDir, name))?.frontier ?? null,
-			latestRun: latestByName.get(name) ?? null,
-			name
-		})))
+		syncHorizon,
+		synthesizers
 	});
 }
 function latestRunByName(entries) {
@@ -31152,17 +31651,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$1().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 +31741,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 +31775,7 @@ var MicrosandboxClaudeExecutor = class {
 		const runPlan = buildMicrosandboxClaudeRunPlan(input);
 		const stderrParts = [];
 		let exitCode = 1;
+		let observation = {};
 		let sandbox = null;
 		let authMaterial = null;
 		try {
@@ -31222,11 +31802,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 +31839,7 @@ var MicrosandboxClaudeExecutor = class {
 		}
 		return {
 			exitCode,
+			observation,
 			stderr: stderrParts.join("")
 		};
 	}
@@ -31339,53 +31925,6 @@ function applyRegistry(builder, value) {
 		return r;
 	});
 }
-async function runRootRepair(repo) {
-	await assertGitCheckout(repo);
-	const branch = await inspectBranchReadiness(repo);
-	const tree = await inspectWorkingTree(repo);
-	if (branch.kind === "no_origin") throw new Error("RootRepair requires 'origin' to be configured in remote mode. Provisioning must add origin before repair.");
-	if (branch.kind === "local_head_without_remote_main") throw new Error(`RootRepair refuses to act: local HEAD is at ${branch.localSha} but origin/${repo.branch} does not exist. Operator must reconcile manually.`);
-	const needsFastForward = branch.kind === "local_unborn_remote_has_main" || branch.kind === "remote_mismatch";
-	if (needsFastForward && !tree.clean) throw new Error(formatCombinedRepairError(repo, branch, tree));
-	if (needsFastForward) return {
-		kind: "fast_forward",
-		...await fastForwardRoot(repo)
-	};
-	if (!tree.clean) return await runDirtyRootRepair(repo);
-	return { kind: "no_op" };
-}
-async function runDirtyRootRepair(repo) {
-	await repairDirtyRoot(repo);
-	const interruptedRunIds = (await markInterruptedRuns(repo.rootDir)).map((record) => record.run_id);
-	if ((await inspectWorkingTree(repo)).clean) return {
-		commit: null,
-		interruptedRunIds,
-		kind: "dirty_root_repair"
-	};
-	const { sha } = await commitRootRepair(repo, {
-		interruptedRunIds,
-		repairId: v7()
-	});
-	await pushToOrigin(repo);
-	return {
-		commit: {
-			pushed: repo.mode === "remote",
-			sha
-		},
-		interruptedRunIds,
-		kind: "dirty_root_repair"
-	};
-}
-function formatCombinedRepairError(repo, branch, tree) {
-	const dirtyPaths = tree.clean ? "(clean)" : formatWorkingTreePaths(tree.paths);
-	return [
-		"RootRepair refuses to combine branch fast-forward with dirty-root repair in v1.",
-		`Branch: ${branch.kind === "local_unborn_remote_has_main" ? `local checkout is unborn but origin/${repo.branch} exists` : branch.kind === "remote_mismatch" ? `local HEAD does not match origin/${repo.branch}` : `branch state is '${branch.kind}'`}.`,
-		"Dirty paths:",
-		dirtyPaths,
-		"Operator must inspect and choose the order manually."
-	].join("\n");
-}
 const RESERVED_OUTPUT_SUBDIRS = new Set(["types", "views"]);
 const OUTPUT_DIR_RELATIVE = "output";
 const CURSORS_DIR_RELATIVE = ".engine/cursors";
@@ -31433,6 +31972,26 @@ function formatNotReadyError(repo, issues) {
 		"Commit your authored config (or run 'ctxe repair'), or pass --force to reset anyway."
 	].join("\n");
 }
+function foldSyncHorizon(response) {
+	let horizon = null;
+	for (const [bindingId, state] of Object.entries(response.bindings)) {
+		if (state.frontier === null) continue;
+		const ms = isoToMs(state.frontier, `binding ${bindingId} frontier`);
+		if (horizon === null || ms < horizon) horizon = ms;
+	}
+	return horizon;
+}
+async function captureSyncHorizon(input) {
+	const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+	const url = new URL("/api/v1/state", input.controlPlaneUrl);
+	url.searchParams.set("root_dir", input.contextBaseRootDir);
+	const response = await fetchImpl(url);
+	if (!response.ok) {
+		const body = await response.text();
+		throw new Error(`Sync horizon request to ${url.toString()} failed: ${response.status} ${response.statusText} — ${body}`);
+	}
+	return foldSyncHorizon(bindingStateResponseSchema.parse(await response.json()));
+}
 const SOURCE_UPDATED_AT_COLUMN = "_ctx_source_updated_at";
 async function captureWatermark(input) {
 	const sql = src_default(input.databaseUrl);
@@ -31497,11 +32056,17 @@ function quoteIdentifier(identifier) {
 //#endregion
 //#region env.ts
 const nonEmptyStringSchema = string().trim().min(1);
+const LOCAL_CONTROL_PLANE_HOST = "127.0.0.1";
 const envSchema = object({
+	CTXB_CONTROL_PLANE_PORT: number().int().min(1).max(65535).default(3999),
 	CTXB_DATABASE_URL: nonEmptyStringSchema.optional(),
+	CTXB_ROOT_DIR: nonEmptyStringSchema.optional(),
 	CTXE_GIT_MODE: _enum(["local", "remote"]).default("remote"),
 	CTXE_ROOT_DIR: nonEmptyStringSchema.optional()
-});
+}).transform((input) => ({
+	...input,
+	CTXB_CONTROL_PLANE_URL: new URL(`http://${LOCAL_CONTROL_PLANE_HOST}:${input.CTXB_CONTROL_PLANE_PORT}`).toString().replace(/\/+$/, "")
+}));
 function parseEngineCliEnv(rawEnv) {
 	return envSchema.parse(rawEnv);
 }
@@ -31509,6 +32074,13 @@ const env = parseEngineCliEnv(process.env);
 
 //#endregion
 //#region commands/build-engine.ts
+function buildSyncHorizonCapture(paths) {
+	const contextBaseRootDir = env.CTXB_ROOT_DIR ?? paths.rootDir;
+	return async () => captureSyncHorizon({
+		contextBaseRootDir,
+		controlPlaneUrl: env.CTXB_CONTROL_PLANE_URL
+	});
+}
 function buildEngine(input) {
 	const watermarkCapture = async () => captureWatermark({ databaseUrl: input.databaseUrl });
 	return new Engine({
@@ -31516,6 +32088,7 @@ function buildEngine(input) {
 		executor: new MicrosandboxClaudeExecutor(),
 		git: { mode: env.CTXE_GIT_MODE },
 		rootDir: input.paths.rootDir,
+		syncHorizonCapture: buildSyncHorizonCapture(input.paths),
 		watermarkCapture
 	});
 }
@@ -31556,9 +32129,10 @@ async function runEngineListCommand(paths) {
 	process.stdout.write(`${formatJsonOutput(output)}\n`);
 	if (output.errors.length > 0) process.exitCode = 1;
 }
-async function runEngineStatusCommand(synthesizerName, paths) {
+async function runEngineStatusCommand(synthesizerName, paths, syncHorizonCapture) {
 	const status = await loadEngineStatus({
 		rootDir: paths.rootDir,
+		syncHorizonCapture,
 		...synthesizerName ? { synthesizerName } : {}
 	});
 	process.stdout.write(`${formatJsonOutput(status)}\n`);
@@ -31590,7 +32164,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
@@ -31634,12 +32208,16 @@ async function runResetCommand(input) {
 //#endregion
 //#region commands/run.ts
 async function runRunCommand(input) {
-	const record = await buildEngine({
+	const outcome = await buildEngine({
 		databaseUrl: resolveDatabaseUrl({ cliValue: input.databaseUrl }),
 		paths: input.paths
 	}).runOnce(input.synthesizerName);
-	process.stdout.write(`${formatJsonOutput(record)}\n`);
-	if (record.status !== "success") process.exitCode = 1;
+	if (outcome.kind === "caught_up") {
+		process.stdout.write(`${formatJsonOutput({ status: "caught_up" })}\n`);
+		return;
+	}
+	process.stdout.write(`${formatJsonOutput(outcome.record)}\n`);
+	if (outcome.record.status !== "success") process.exitCode = 1;
 }
 
 //#endregion
@@ -31721,8 +32299,9 @@ function createProgram() {
 	program.command("list").description("List synthesizers").action(async function() {
 		await runEngineListCommand(resolveRuntimePaths(this));
 	});
-	program.command("status").argument("[synthesizer]", "Only show this synthesizer").description("Print each synthesizer's freshness as JSON: its frontier (the source-time its cursor has reached), how far that lags behind now, and its latest run.").action(async function(synthesizerName) {
-		await runEngineStatusCommand(synthesizerName, resolveRuntimePaths(this));
+	program.command("status").argument("[synthesizer]", "Only show this synthesizer").description("Print each synthesizer's freshness as JSON: its frontier (the source-time its cursor has reached), how far that lags behind now (output staleness), how much confirmed-synced ground is still pending below the sync horizon (whether the engine is keeping up — the planner's own measure), and its latest run.").action(async function(synthesizerName) {
+		const paths = resolveRuntimePaths(this);
+		await runEngineStatusCommand(synthesizerName, paths, buildSyncHorizonCapture(paths));
 	});
 	program.command("logs").argument("<synthesizer>", "Synthesizer name").option("--run-id <id>", "Print stderr for a specific run id").description("Print the engine's per-run stderr for a synthesizer run. The Claude session transcript is a separate file at <rootDir>/.claude/projects/<claude-encoded-rootDir>/<runId>.jsonl, where <claude-encoded-rootDir> is Claude Code's own cwd-derived project key (the guest workdir mirrors the host rootDir, so the key matches what host Claude produces in the same directory). The run id and the Claude --session-id are the same UUIDv7 value.").action(async function(synthesizerName, options) {
 		await runEngineLogsCommand(synthesizerName, options, resolveRuntimePaths(this));
@@ -31740,14 +32319,14 @@ function createProgram() {
 			yes: options.yes ?? false
 		});
 	});
-	program.command("run").argument("<synthesizer>", "Synthesizer name").option("--database-url <url>", "Postgres URL of the ContextBase database the synthesizer reads from. Falls back to CTXB_DATABASE_URL.").description("Run a single synthesizer once. Exits non-zero on a failed or timed-out run.").action(async function(synthesizerName, options) {
+	program.command("run").argument("<synthesizer>", "Synthesizer name").option("--database-url <url>", "Postgres URL of the ContextBase database the synthesizer reads from. Falls back to CTXB_DATABASE_URL.").description("Run a single synthesizer once. Prints caught_up and exits zero when there is no new synced ground; exits non-zero on any non-success run (failed, timed-out, or rate-limited).").action(async function(synthesizerName, options) {
 		await runRunCommand({
 			databaseUrl: options.databaseUrl,
 			paths: resolveRuntimePaths(this),
 			synthesizerName
 		});
 	});
-	program.command("backfill").argument("<synthesizer>", "Synthesizer name").option("--database-url <url>", "Postgres URL of the ContextBase database the synthesizer reads from. Falls back to CTXB_DATABASE_URL.").description("Walk a synthesizer's cursor forward slice-by-slice until it catches up to now. The same loop the daemon runs, without the sleep. Streams each slice's run record; prints a summary; exits non-zero only if a slice fails.").action(async function(synthesizerName, options) {
+	program.command("backfill").argument("<synthesizer>", "Synthesizer name").option("--database-url <url>", "Postgres URL of the ContextBase database the synthesizer reads from. Falls back to CTXB_DATABASE_URL.").description("Walk a synthesizer's cursor forward slice-by-slice until it catches up to the sync horizon. The same loop the daemon runs, without the sleep. Streams each slice's run record; prints a summary; exits non-zero if a slice fails or the usage window is rate-limited.").action(async function(synthesizerName, options) {
 		await runBackfillCommand({
 			databaseUrl: options.databaseUrl,
 			paths: resolveRuntimePaths(this),
@@ -31783,4 +32362,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, resolveRepoContext, resolveRuntimePaths, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=59a42f57-145c-5f77-afb2-f1f76467783d
+//# debugId=ee0e5987-2fbc-50ed-9038-a0c4541b7548