@usecontextlayer/ctxe 0.4.5 → 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]="1a858cd0-cb9a-550b-a3f9-5ca9387cf7df")}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.5";
+var version$1 = "0.4.6";
 
 //#endregion
 //#region sentry.ts
@@ -7894,7 +7894,7 @@ 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]*$/;
@@ -8672,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);
@@ -9057,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) => {
@@ -9227,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: []
@@ -9864,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",
@@ -11108,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) => {
@@ -11247,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);
@@ -11260,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);
@@ -11513,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) {
@@ -17835,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) => {
@@ -26061,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) => {
@@ -27490,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 {
@@ -29583,7 +29778,7 @@ function validate(raw, sourcePath) {
 }
 function applyDefaults(input) {
 	return {
-		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.5",
+		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,
@@ -29599,45 +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 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 {
+	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 gates = frontierDue.map((synthesizer) => synthesizer.notBefore).filter((notBefore) => notBefore !== void 0);
-	const gatedUntil = gates.length > 0 ? Math.min(...gates) : void 0;
+	const held = new Set(horizonDue);
 	return {
 		kind: "idle",
-		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 }
+		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: pass.gatedUntil !== void 0 ? "rate_limited" : "caught_up" };
+			if (options.mode === "backfill") return { stopReason: pass.reason };
 			await deps.sleep(Math.max(0, pass.wakeAt - deps.now()));
 			continue;
 		}
-		let advancedAny = false;
-		let rateLimitedAny = false;
+		const results = [];
 		for (const name of pass.order) {
 			if (options.signal?.aborted) return { stopReason: "aborted" };
-			const outcome = await deps.runSlice(name);
-			if (outcome.advanced) advancedAny = true;
-			if (outcome.rateLimited) rateLimitedAny = true;
+			results.push(await deps.runSlice(name, pass.syncHorizon));
 		}
-		if (!advancedAny) {
-			if (options.mode === "backfill") return { stopReason: rateLimitedAny ? "rate_limited" : "stalled" };
+		const conclusion = concludeLoopPass(results);
+		if (conclusion.kind === "blocked") {
+			if (options.mode === "backfill") return { stopReason: conclusion.reason };
 			await deps.sleep(options.tick);
 		}
 	}
@@ -29961,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);
@@ -30025,18 +30252,18 @@ const runStatusSchema = _enum([
 	"interrupted"
 ]);
 const claudeResultSchema = strictObject({
-	api_error_status: number().int().optional(),
+	api_error_status: number$1().int().optional(),
 	is_error: boolean(),
-	num_turns: number().int(),
+	num_turns: number$1().int(),
 	subtype: string().min(1),
 	terminal_reason: string().min(1).optional(),
-	total_cost_usd: number()
+	total_cost_usd: number$1()
 });
 const runRecordSchema = strictObject({
 	claude_result: claudeResultSchema.optional(),
 	completed_at: string().min(1).optional(),
-	duration_ms: number().int().nonnegative().optional(),
-	exit_code: number().int().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),
@@ -30098,6 +30325,24 @@ 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 = [];
@@ -30187,6 +30432,58 @@ function compareRunRecordEntries(left, right) {
 	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)
@@ -30806,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 = {};
@@ -30835,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
@@ -30879,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,
@@ -30903,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),
@@ -31028,6 +31327,7 @@ var Engine = class {
 	now;
 	runIdFactory;
 	repo;
+	syncHorizonCapture;
 	watermarkCapture;
 	synthesizers = /* @__PURE__ */ new Map();
 	config = null;
@@ -31045,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({
@@ -31068,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);
@@ -31105,42 +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);
+				const passNowMs = this.nowDate().getTime();
+				const config = this.requireConfig();
 				return Promise.all(specs.map(async (spec) => {
-					const notBefore = await this.readRateLimitGate(spec.name, clock().getTime());
+					const notBefore = await this.readRateLimitGate(spec.name, passNowMs);
 					return {
-						frontier: (await readCursor(rootDir, spec.name))?.frontier ?? 0,
+						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",
-						rateLimited: outcome.record.status === "rate_limited"
-					};
+					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,
-							rateLimited: false
-						};
+						return "failed";
 					}
 					throw error;
 				}
@@ -31149,10 +31470,10 @@ var Engine = class {
 		};
 	}
 	async readRateLimitGate(synthesizerName, nowMs) {
-		const latest = (await listRunRecords({
+		const latest = await readLatestRunRecord({
 			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");
@@ -31165,8 +31486,7 @@ var Engine = class {
 			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);
@@ -31191,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
@@ -31217,7 +31538,6 @@ var Engine = class {
 			});
 			return {
 				frontier: ctx.next.frontier,
-				reachedWallclock: ctx.reachedWallclock,
 				record
 			};
 		} finally {
@@ -31267,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,
@@ -31279,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) {
@@ -31303,7 +31653,7 @@ function latestRunByName(entries) {
 }
 const rateLimitEventSchema = object({
 	rate_limit_info: object({
-		resetsAt: number().optional(),
+		resetsAt: number$1().optional(),
 		status: string().min(1)
 	}),
 	type: literal("rate_limit_event")
@@ -31575,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";
@@ -31669,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);
@@ -31733,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);
 }
@@ -31745,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({
@@ -31752,6 +32088,7 @@ function buildEngine(input) {
 		executor: new MicrosandboxClaudeExecutor(),
 		git: { mode: env.CTXE_GIT_MODE },
 		rootDir: input.paths.rootDir,
+		syncHorizonCapture: buildSyncHorizonCapture(input.paths),
 		watermarkCapture
 	});
 }
@@ -31792,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`);
@@ -31870,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
@@ -31957,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));
@@ -31976,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),
@@ -32019,4 +32362,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, resolveRepoContext, resolveRuntimePaths, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=1a858cd0-cb9a-550b-a3f9-5ca9387cf7df
+//# debugId=ee0e5987-2fbc-50ed-9038-a0c4541b7548