@usecontextlayer/ctxe 0.5.4 → 0.5.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]="6317e92d-f910-5336-9f6a-2445ebdf6ed8")}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]="507e416d-f409-5878-9327-a3aaeaedfd78")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as Sentry from "@sentry/node";
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -59,7 +59,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version$2 = "0.5.4";
+var version$2 = "0.5.6";
 
 //#endregion
 //#region sentry.ts
@@ -363,6 +363,22 @@ async function drainExecStream(handle, options) {
 		signal?.removeEventListener("abort", onAbort);
 	}
 }
+const MICROSANDBOX_HOST_ALIAS = "host.microsandbox.internal";
+const HOST_LOOPBACK_HOSTNAMES = new Set([
+	"localhost",
+	"127.0.0.1",
+	"0.0.0.0"
+]);
+const IPV6_LOOPBACK_HOSTNAMES = new Set(["[::1]", "[::]"]);
+function rewriteHostUrlForGuest(url) {
+	const parsed = new URL(url);
+	const hostname = parsed.hostname.toLowerCase();
+	if (HOST_LOOPBACK_HOSTNAMES.has(hostname) || IPV6_LOOPBACK_HOSTNAMES.has(hostname)) {
+		parsed.hostname = MICROSANDBOX_HOST_ALIAS;
+		return parsed.toString();
+	}
+	return url;
+}
 const DEBUG_SANDBOX_NAME = "ctx-sandbox-debug";
 const DEFAULT_BOOT_COMMAND = ["uname", "-a"];
 async function runSandbox(input) {
@@ -4129,6 +4145,63 @@ function refine$1(fn, _params = {}) {
 function superRefine$1(fn, params) {
 	return /* @__PURE__ */ _superRefine$1(fn, params);
 }
+`${JSON.stringify({ render: {
+	elements: {
+		body: {
+			props: { text: { $item: "body" } },
+			type: "Text"
+		},
+		card: {
+			children: ["body"],
+			props: { title: { $item: "title" } },
+			type: "Card"
+		},
+		detail: {
+			children: ["card"],
+			props: {
+				className: "mx-auto max-w-md p-8",
+				direction: "vertical",
+				gap: "md"
+			},
+			repeat: {
+				key: "path",
+				statePath: "/items"
+			},
+			type: "Stack"
+		}
+	},
+	root: "detail"
+} }, null, "	")}`, `${JSON.stringify({ render: {
+	elements: {
+		card: {
+			props: { title: { $item: "title" } },
+			type: "Card"
+		},
+		list: {
+			children: ["row"],
+			props: {
+				className: "mx-auto max-w-md p-8",
+				direction: "vertical",
+				gap: "md"
+			},
+			repeat: {
+				key: "path",
+				statePath: "/items"
+			},
+			type: "Stack"
+		},
+		row: {
+			children: ["card"],
+			on: { press: {
+				action: "navigate",
+				params: { path: { $template: "${path}" } }
+			} },
+			props: { className: null },
+			type: "Pressable"
+		}
+	},
+	root: "list"
+} }, null, "	")}`;
 const segmentSchema = string$4().min(1, "a repoId segment must be non-empty").refine((s) => s !== "." && s !== ".." && !s.includes("/"), { message: "a repoId segment must not be '.'/'..' or contain '/'" });
 const sessionMetaSchema = object$3({
 	created: string$4().nullable(),
@@ -30553,9 +30626,7 @@ async function inspectWorkingTree(repo) {
 		paths: parsePorcelainV1Z(result.stdout)
 	};
 }
-async function assertSynthesizerTransactionReady(repo) {
-	const branch = await inspectBranchReadiness(repo);
-	if (branch.kind !== "ready" && branch.kind !== "ready_empty") throw new Error(formatBranchReadinessError(repo, branch));
+async function assertCleanWorkingTree(repo) {
 	const tree = await inspectWorkingTree(repo);
 	if (!tree.clean) throw new Error(formatDirtyTreeError(repo, tree.paths));
 }
@@ -30572,10 +30643,15 @@ async function fastForwardRoot(repo) {
 	if (remoteSha === null) throw new Error(`Remote ${repo.branch} did not exist after 'git fetch origin ${repo.branch}'; nothing to fast-forward.`);
 	if (fromSha === remoteSha) return {
 		from: fromSha,
+		kind: "fast_forwarded",
 		to: remoteSha
 	};
 	if (fromSha !== null) {
-		if (!await isAncestorRef(repo, fromSha, remoteSha)) throw new Error(`Local HEAD ${fromSha} is not an ancestor of ${repo.branch} (${remoteSha}); fast-forward refused (no merge, rebase, or reset).`);
+		if (!await isAncestorRef(repo, fromSha, remoteSha)) return {
+			kind: "diverged",
+			localSha: fromSha,
+			remoteSha
+		};
 		await runGit(repo, [
 			"merge",
 			"--ff-only",
@@ -30600,6 +30676,7 @@ async function fastForwardRoot(repo) {
 	}
 	return {
 		from: fromSha,
+		kind: "fast_forwarded",
 		to: remoteSha
 	};
 }
@@ -30625,11 +30702,39 @@ async function commitRootReset(repo, input) {
 	return await createCommit(repo, buildRootResetCommitMessage(input));
 }
 async function pushToOrigin(repo) {
-	await runGit(repo, [
+	const result = await runGit(repo, [
 		"push",
 		"origin",
 		`HEAD:${repo.branch}`
+	], {
+		auth: true,
+		throwOnNonZero: false
+	});
+	if (result.exitCode === 0) return "pushed";
+	if (classifyPushFailure(result.stderr) === "rejected") return "rejected";
+	throw new Error(`git push origin HEAD:${repo.branch} (exit ${result.exitCode}) in ${repo.rootDir}\n${result.stderr.trim()}`);
+}
+function classifyPushFailure(stderr) {
+	return /\[(rejected|remote rejected)\]/.test(stderr) ? "rejected" : "transport";
+}
+async function discardToOrigin(repo) {
+	const discardedSha = await readLocalHeadSha(repo);
+	await runGit(repo, [
+		"fetch",
+		"origin",
+		repo.branch
 	], { auth: true });
+	const originSha = await readFetchHeadSha(repo);
+	if (originSha === null) throw new Error(`Remote ${repo.branch} did not exist after 'git fetch origin ${repo.branch}'; nothing to discard to.`);
+	await runGit(repo, [
+		"reset",
+		"--hard",
+		originSha
+	]);
+	return {
+		discardedSha,
+		originSha
+	};
 }
 async function runGit(repo, args, options = {}) {
 	const throwOnNonZero = options.throwOnNonZero ?? true;
@@ -30778,17 +30883,6 @@ function parsePorcelainV1Z(stdout) {
 	}
 	return paths;
 }
-function formatBranchReadinessError(repo, branch) {
-	const prefix = `Engine root '${repo.rootDir}' is not transaction-ready (branch state)`;
-	switch (branch.kind) {
-		case "no_origin": return `${prefix}: 'origin' remote is not configured. Provisioning must configure origin.`;
-		case "local_unborn_remote_has_main": return `${prefix}: local checkout has no commits but origin/${repo.branch} exists at ${branch.remoteSha}. Run 'ctxe repair' to fast-forward.`;
-		case "local_head_without_remote_main": return `${prefix}: local HEAD is at ${branch.localSha} but origin/${repo.branch} does not exist. Operator must reconcile.`;
-		case "remote_mismatch": return `${prefix}: local HEAD ${branch.localSha} does not match origin/${repo.branch} ${branch.remoteSha}. Run 'ctxe repair' if local can fast-forward; otherwise reconcile manually.`;
-		case "ready":
-		case "ready_empty": return `${prefix}: state '${branch.kind}' is unexpectedly being treated as not ready (this is a bug).`;
-	}
-}
 function formatDirtyTreeError(repo, paths) {
 	const list = formatWorkingTreePaths(paths);
 	return `Engine root '${repo.rootDir}' has uncommitted or untracked changes:\n${list}`;
@@ -30861,11 +30955,11 @@ function branchIssueFor(branch) {
 		};
 		case "local_head_without_remote_main": return {
 			code: "local_head_without_remote_main",
-			message: `Local HEAD is at ${branch.localSha} but origin/main does not exist. Operator must reconcile manually.`
+			message: `Local HEAD is at ${branch.localSha} but origin/main does not exist. Run 'ctxe repair' (publishes the local commits, or discards them if origin was created meanwhile).`
 		};
 		case "remote_mismatch": return {
 			code: "remote_mismatch",
-			message: `Local HEAD ${branch.localSha} does not match origin/main ${branch.remoteSha}. If local is behind, run 'ctxe repair'; otherwise reconcile manually.`
+			message: `Local HEAD ${branch.localSha} does not match origin/main ${branch.remoteSha}. Run 'ctxe repair' (fast-forwards when behind; publishes or discards own commits when ahead/diverged).`
 		};
 	}
 }
@@ -30884,7 +30978,8 @@ _enum([
 	"success",
 	"failed",
 	"timed_out",
-	"rate_limited"
+	"rate_limited",
+	"stale"
 ]);
 const runStatusSchema = _enum([
 	"starting",
@@ -30893,6 +30988,7 @@ const runStatusSchema = _enum([
 	"failed",
 	"timed_out",
 	"rate_limited",
+	"stale",
 	"interrupted"
 ]);
 const claudeResultSchema = strictObject({
@@ -31058,23 +31154,35 @@ function compareRunRecordEntries(left, right) {
 	if (timeCompare !== 0) return timeCompare;
 	return right.runId.localeCompare(left.runId);
 }
-async function runRootFastForward(repo) {
+async function runRootReconcile(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. 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 (branch.kind === "ready" || branch.kind === "ready_empty") return { kind: "no_op" };
+	if (!tree.clean) throw new Error(formatCombinedRepairError(repo, branch, tree));
+	if (branch.kind === "local_head_without_remote_main") return await publishOrDiscard(repo, branch.localSha);
+	const ff = await fastForwardRoot(repo);
+	if (ff.kind === "fast_forwarded") return {
+		from: ff.from,
+		kind: "fast_forwarded",
+		to: ff.to
+	};
+	return await publishOrDiscard(repo, ff.localSha);
+}
+async function publishOrDiscard(repo, localSha) {
+	if (await pushToOrigin(repo) === "pushed") return {
+		kind: "published",
+		sha: localSha
+	};
+	return {
+		kind: "discarded_to_origin",
+		...await discardToOrigin(repo)
 	};
-	return { kind: "no_op" };
 }
 async function runRootRepair(repo) {
-	const fastForward = await runRootFastForward(repo);
-	if (fastForward.kind === "fast_forward") return fastForward;
+	const reconciled = await runRootReconcile(repo);
+	if (reconciled.kind !== "no_op") return reconciled;
 	if (!(await inspectWorkingTree(repo)).clean) return await runDirtyRootRepair(repo);
 	return { kind: "no_op" };
 }
@@ -31090,7 +31198,14 @@ async function runDirtyRootRepair(repo) {
 		interruptedRunIds,
 		repairId: v7()
 	});
-	await pushToOrigin(repo);
+	if (await pushToOrigin(repo) === "rejected") {
+		await discardToOrigin(repo);
+		return {
+			commit: null,
+			interruptedRunIds,
+			kind: "dirty_root_repair"
+		};
+	}
 	return {
 		commit: { sha },
 		interruptedRunIds,
@@ -31100,7 +31215,7 @@ async function runDirtyRootRepair(repo) {
 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.",
+		"RootRepair refuses to combine branch reconcile 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,
@@ -31250,22 +31365,6 @@ function fromParseError(error) {
 		sourcePath: error.sourcePath
 	};
 }
-const MICROSANDBOX_HOST_ALIAS = "host.microsandbox.internal";
-const HOST_LOOPBACK_HOSTNAMES = new Set([
-	"localhost",
-	"127.0.0.1",
-	"0.0.0.0"
-]);
-const IPV6_LOOPBACK_HOSTNAMES = new Set(["[::1]", "[::]"]);
-function rewriteHostUrlForGuest(url) {
-	const parsed = new URL(url);
-	const hostname = parsed.hostname.toLowerCase();
-	if (HOST_LOOPBACK_HOSTNAMES.has(hostname) || IPV6_LOOPBACK_HOSTNAMES.has(hostname)) {
-		parsed.hostname = MICROSANDBOX_HOST_ALIAS;
-		return parsed.toString();
-	}
-	return url;
-}
 function assembleGuestEnv(input) {
 	return {
 		...input.contextEngineEnv,
@@ -31514,7 +31613,13 @@ async function finalizeSuccessfulSynthesizerTransaction(input) {
 		await rollbackAfterTransactionCommitFailure(input.repo);
 		throw commitError;
 	}
-	await pushToOrigin(input.repo);
+	if (await pushToOrigin(input.repo) === "rejected") {
+		await discardToOrigin(input.repo);
+		return {
+			...input.record,
+			status: "stale"
+		};
+	}
 	return input.record;
 }
 async function finalizeFailedSynthesizerTransaction(input) {
@@ -31526,7 +31631,7 @@ async function finalizeFailedSynthesizerTransaction(input) {
 		synthesizerName: input.ctx.synthesizer.name,
 		trigger: input.ctx.trigger
 	});
-	await pushToOrigin(input.repo);
+	if (await pushToOrigin(input.repo) === "rejected") await discardToOrigin(input.repo);
 	return input.record;
 }
 function buildTerminalRecord(input) {
@@ -31602,8 +31707,8 @@ var Engine = class {
 		try {
 			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}`);
+				const repaired = await runRootReconcile(this.repo);
+				if (repaired.kind !== "no_op") this.logger.info(`[engine] startup reconcile: ${describeReconcile(repaired)}`);
 				report = await runRootPreflight(this.repo);
 			}
 			if (!report.ready) throw new Error(formatPreflightFailure(this.repo.rootDir, report.issues));
@@ -31766,7 +31871,9 @@ var Engine = class {
 	async runSynthesizerTransaction(request) {
 		const releaseLock = await acquireTransactionLock(this.repo.rootDir);
 		try {
-			await assertSynthesizerTransactionReady(this.repo);
+			await assertCleanWorkingTree(this.repo);
+			const reconciled = await runRootReconcile(this.repo);
+			if (reconciled.kind !== "no_op") this.logger.info(`[engine] pre-run reconcile: ${describeReconcile(reconciled)}`);
 			await this.refreshSynthesizers();
 			const synthesizer = this.synthesizers.get(request.synthesizerName);
 			if (!synthesizer) throw new Error(`Synthesizer '${request.synthesizerName}' was not found after refresh; no run record manufactured.`);
@@ -31851,6 +31958,14 @@ function sleepAbortable(ms, signal) {
 function formatPreflightFailure(rootDir, issues) {
 	return `Engine root '${rootDir}' is not ready:\n${issues.map((issue) => `  [${issue.code}] ${issue.message}`).join("\n")}`;
 }
+function describeReconcile(result) {
+	switch (result.kind) {
+		case "no_op": return "no-op";
+		case "fast_forwarded": return `fast-forwarded ${result.from ?? "(unborn)"} → ${result.to}`;
+		case "published": return `published own unpushed commit ${result.sha}`;
+		case "discarded_to_origin": return `discarded own commit ${result.discardedSha ?? "(none)"} to origin ${result.originSha} (someone else advanced)`;
+	}
+}
 function assembleEngineStatus(input) {
 	const observation = input.syncHorizon;
 	const horizon = observation.kind === "captured" ? observation.horizon : null;
@@ -32220,7 +32335,7 @@ async function runRootReset(repo, options = {}) {
 	});
 	if ((await inspectWorkingTree(repo)).clean) return { kind: "no_op" };
 	const { sha } = await commitRootReset(repo, { resetId: v7() });
-	await pushToOrigin(repo);
+	if (await pushToOrigin(repo) === "rejected") throw new Error(`Reset commit ${sha} was not pushed: origin/${repo.branch} advanced during the reset (non-fast-forward). Nothing was reset on origin. Re-run 'ctxe reset' against the new head.`);
 	return {
 		commit: { sha },
 		kind: "reset",
@@ -32397,6 +32512,19 @@ var ForbiddenError$1 = class extends BaseAPIError {
 		this.name = "ForbiddenError";
 	}
 };
+var NotFoundError$1 = class extends BaseAPIError {
+	constructor(body, rawResponse) {
+		super({
+			message: "NotFoundError",
+			statusCode: 404,
+			body,
+			rawResponse
+		});
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		this.name = "NotFoundError";
+	}
+};
 function mergeHeaders$1(...headersArray) {
 	const result = {};
 	for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
@@ -33616,7 +33744,7 @@ function createIdentitySchemaCreator$1(schemaType, validate) {
 		};
 	};
 }
-function enum_(values) {
+function enum_$1(values) {
 	const validValues = new Set(values);
 	return createIdentitySchemaCreator$1(SchemaType$1.ENUM, (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
 		if (typeof value !== "string") return {
@@ -34182,7 +34310,7 @@ const _hasOwn$4 = Object.prototype.hasOwnProperty;
 function union(discriminant, union) {
 	const rawDiscriminant = typeof discriminant === "string" ? discriminant : discriminant.rawDiscriminant;
 	const parsedDiscriminant = typeof discriminant === "string" ? discriminant : discriminant.parsedDiscriminant;
-	const discriminantValueSchema = enum_(keys$1(union));
+	const discriminantValueSchema = enum_$1(keys$1(union));
 	const baseSchema = {
 		parse: (raw, opts) => {
 			return transformAndValidateUnion({
@@ -34435,7 +34563,7 @@ const Binding = object$1({
 	updatedAt: property$1("updated_at", date$1())
 });
 const ListBindingsResponse = object$1({ bindings: list$1(Binding) });
-const RunStatus = enum_([
+const RunStatus = enum_$1([
 	"QUEUED",
 	"NOT_STARTED",
 	"MANAGED",
@@ -34484,7 +34612,7 @@ const BindingStateResponse = object$1({
 	bindings: record(string$1(), BindingState),
 	version: number$1()
 });
-const DagsterAllPlanBindingMode = enum_(["dagster"]);
+const DagsterAllPlanBindingMode = enum_$1(["dagster"]);
 const DagsterAllPlanBinding = object$1({
 	auth: BindingAuth,
 	bindingId: property$1("binding_id", string$1()),
@@ -34666,6 +34794,62 @@ var BasesClient = class {
 		}
 		return handleNonStatusCodeError$1(_response.error, _response.rawResponse, "GET", "/base/bases/{base_id}");
 	}
+	/**
+	* @param {BaseAPI.DeleteBaseRequest} request
+	* @param {BasesClient.RequestOptions} requestOptions - Request-specific configuration.
+	*
+	* @throws {@link BaseAPI.ForbiddenError}
+	* @throws {@link BaseAPI.NotFoundError}
+	*
+	* @example
+	*     await client.bases.deleteBase({
+	*         baseId: "base_id"
+	*     })
+	*/
+	deleteBase(request, requestOptions) {
+		return HttpResponsePromise$1.fromPromise(this.__deleteBase(request, requestOptions));
+	}
+	async __deleteBase(request, requestOptions) {
+		const { baseId } = request;
+		const _headers = mergeHeaders$1(this._options?.headers, requestOptions?.headers);
+		const _response = await fetcher$1({
+			url: join$1(await Supplier$1.get(this._options.baseUrl) ?? await Supplier$1.get(this._options.environment), `base/bases/${encodePathParam$1(baseId)}`),
+			method: "DELETE",
+			headers: _headers,
+			queryString: queryBuilder$1().mergeAdditional(requestOptions?.queryParams).build(),
+			timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+			maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+			abortSignal: requestOptions?.abortSignal,
+			fetchFn: this._options?.fetch,
+			logging: this._options.logging
+		});
+		if (_response.ok) return {
+			data: void 0,
+			rawResponse: _response.rawResponse
+		};
+		if (_response.error.reason === "status-code") switch (_response.error.statusCode) {
+			case 403: throw new ForbiddenError$1(Error_$1.parseOrThrow(_response.error.body, {
+				unrecognizedObjectKeys: "passthrough",
+				allowUnrecognizedUnionMembers: true,
+				allowUnrecognizedEnumValues: true,
+				skipValidation: true,
+				breadcrumbsPrefix: ["response"]
+			}), _response.rawResponse);
+			case 404: throw new NotFoundError$1(Error_$1.parseOrThrow(_response.error.body, {
+				unrecognizedObjectKeys: "passthrough",
+				allowUnrecognizedUnionMembers: true,
+				allowUnrecognizedEnumValues: true,
+				skipValidation: true,
+				breadcrumbsPrefix: ["response"]
+			}), _response.rawResponse);
+			default: throw new BaseAPIError({
+				statusCode: _response.error.statusCode,
+				body: _response.error.body,
+				rawResponse: _response.rawResponse
+			});
+		}
+		return handleNonStatusCodeError$1(_response.error, _response.rawResponse, "DELETE", "/base/bases/{base_id}");
+	}
 };
 var BindingPlanClient = class {
 	_options;
@@ -35230,6 +35414,19 @@ var ForbiddenError = class extends SlateAPIError {
 		this.name = "ForbiddenError";
 	}
 };
+var NotFoundError = class extends SlateAPIError {
+	constructor(body, rawResponse) {
+		super({
+			message: "NotFoundError",
+			statusCode: 404,
+			body,
+			rawResponse
+		});
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		this.name = "NotFoundError";
+	}
+};
 function mergeHeaders(...headersArray) {
 	const result = {};
 	for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
@@ -36449,6 +36646,29 @@ function createIdentitySchemaCreator(schemaType, validate) {
 		};
 	};
 }
+function enum_(values) {
+	const validValues = new Set(values);
+	return createIdentitySchemaCreator(SchemaType.ENUM, (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
+		if (typeof value !== "string") return {
+			ok: false,
+			errors: [{
+				path: breadcrumbsPrefix,
+				message: getErrorMessageForIncorrectType(value, "string")
+			}]
+		};
+		if (!validValues.has(value) && !allowUnrecognizedEnumValues) return {
+			ok: false,
+			errors: [{
+				path: breadcrumbsPrefix,
+				message: getErrorMessageForIncorrectType(value, "enum")
+			}]
+		};
+		return {
+			ok: true,
+			value
+		};
+	})();
+}
 function entries(object) {
 	return Object.entries(object);
 }
@@ -37023,6 +37243,8 @@ const CreateWorkspaceInput = object({
 	synthesizerImage: property("synthesizer_image", string().optional()),
 	tick: string().optional()
 });
+const DeleteWorkspaceRequestDeleteBases = enum_(["true", "false"]);
+const DeleteWorkspaceRequestDeleteRepos = enum_(["true", "false"]);
 const BridgePlan = object({
 	baseIds: property("base_ids", list(string())),
 	claudeOauthToken: property("claude_oauth_token", string().nullable()),
@@ -37464,6 +37686,72 @@ var WorkspacesClient = class {
 		}
 		return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/slate/workspaces");
 	}
+	/**
+	* @param {SlateAPI.DeleteWorkspaceRequest} request
+	* @param {WorkspacesClient.RequestOptions} requestOptions - Request-specific configuration.
+	*
+	* @throws {@link SlateAPI.ForbiddenError}
+	* @throws {@link SlateAPI.NotFoundError}
+	*
+	* @example
+	*     await client.workspaces.deleteWorkspace({
+	*         workspaceId: "workspace_id"
+	*     })
+	*/
+	deleteWorkspace(request, requestOptions) {
+		return HttpResponsePromise.fromPromise(this.__deleteWorkspace(request, requestOptions));
+	}
+	async __deleteWorkspace(request, requestOptions) {
+		const { workspaceId, deleteBases, deleteRepos } = request;
+		const _queryParams = {
+			delete_bases: deleteBases != null ? DeleteWorkspaceRequestDeleteBases.jsonOrThrow(deleteBases, {
+				unrecognizedObjectKeys: "strip",
+				omitUndefined: true
+			}) : void 0,
+			delete_repos: deleteRepos != null ? DeleteWorkspaceRequestDeleteRepos.jsonOrThrow(deleteRepos, {
+				unrecognizedObjectKeys: "strip",
+				omitUndefined: true
+			}) : void 0
+		};
+		const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+		const _response = await fetcher({
+			url: join(await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment), `slate/workspaces/${encodePathParam(workspaceId)}`),
+			method: "DELETE",
+			headers: _headers,
+			queryString: queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+			timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+			maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+			abortSignal: requestOptions?.abortSignal,
+			fetchFn: this._options?.fetch,
+			logging: this._options.logging
+		});
+		if (_response.ok) return {
+			data: void 0,
+			rawResponse: _response.rawResponse
+		};
+		if (_response.error.reason === "status-code") switch (_response.error.statusCode) {
+			case 403: throw new ForbiddenError(Error_.parseOrThrow(_response.error.body, {
+				unrecognizedObjectKeys: "passthrough",
+				allowUnrecognizedUnionMembers: true,
+				allowUnrecognizedEnumValues: true,
+				skipValidation: true,
+				breadcrumbsPrefix: ["response"]
+			}), _response.rawResponse);
+			case 404: throw new NotFoundError(Error_.parseOrThrow(_response.error.body, {
+				unrecognizedObjectKeys: "passthrough",
+				allowUnrecognizedUnionMembers: true,
+				allowUnrecognizedEnumValues: true,
+				skipValidation: true,
+				breadcrumbsPrefix: ["response"]
+			}), _response.rawResponse);
+			default: throw new SlateAPIError({
+				statusCode: _response.error.statusCode,
+				body: _response.error.body,
+				rawResponse: _response.rawResponse
+			});
+		}
+		return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/slate/workspaces/{workspace_id}");
+	}
 };
 var SlateAPIClient = class {
 	_options;
@@ -38586,7 +38874,7 @@ function createProgram() {
 	program.command("preflight").description("Report whether the ContextEngine root is ready to run. Validation-only; never mutates the checkout. Exits non-zero when not ready.").action(async function() {
 		await runPreflightCommand(resolveRepoContext(this));
 	});
-	program.command("repair").description("Explicit out-of-band root repair: safe fast-forward when clean and stale, or dirty-root rollback that preserves .engine/runs/**. Refuses local-ahead state, divergence, and the combined stale-plus-dirty case.").action(async function() {
+	program.command("repair").description("Explicit out-of-band root repair: reconciles the root against origin (fast-forward when behind; publish own unpushed commits, or discard them to origin when the push is rejected) and rolls back a dirty tree preserving .engine/runs/**.").action(async function() {
 		await runRepairCommand(resolveRepoContext(this));
 	});
 	program.command("reset").option("--yes", "Execute the reset (delete cursors + wipe synthesized content, then commit). Without it, prints the plan and exits without mutating.").option("--force", "Reset even when the root is not preflight-ready (e.g. a dirty working tree). Use with care; normally you commit authored config or run 'ctxe repair' first.").description("Reset the whole workspace to a clean pre-synthesis state so it can be rebuilt from scratch: delete every synthesizer cursor (the next run bootstraps from the configured oldestConsideredPoint) and wipe all synthesized content under output/ except the authored types/ and views/, in one commit. Whole-workspace by design — output/ is not partitioned by synthesizer. Preserves .engine/runs/**. Default is a dry run; pass --yes to execute, then rebuild with 'ctxe backfill <synthesizer>' or 'ctxe daemon start'.").action(async function(options) {
@@ -38646,4 +38934,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, resolveRepoContext, resolveRuntimePaths, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=6317e92d-f910-5336-9f6a-2445ebdf6ed8
+//# debugId=507e416d-f409-5878-9327-a3aaeaedfd78