openmeld 0.3.206 → 0.3.207

package/dist/control-plane-D9jDcbMZ.js

@@ -0,0 +1,1211 @@
+#!/usr/bin/env node
+
+import { c as agentControllerConversationRefSchema, s as runtimeTransportModeSchema } from "./controller-contract-pe3_Re-c.js";
+import * as z$1 from "zod/v4";
+//#region ../../packages/schemas/dist/schemas/protocol/shared.js
+const trimmedStringFromUnknown = (value) => String(value ?? "").trim();
+const nonEmptyTrimmedStringFromUnknown = z$1.preprocess(trimmedStringFromUnknown, z$1.string().min(1));
+const finiteIntegerNumber = z$1.number().int().finite();
+const optionalBooleanQuerySchema = z$1.preprocess((value) => {
+	if (value === void 0 || value === null || value === "") return;
+	if (typeof value === "boolean") return value;
+	const normalized = String(value).trim().toLowerCase();
+	if (normalized === "true" || normalized === "1") return true;
+	if (normalized === "false" || normalized === "0") return false;
+	return value;
+}, z$1.boolean().optional());
+//#endregion
+//#region ../../packages/schemas/dist/schemas/protocol/profile.js
+const PROFILE_KIND_VALUES = [
+	"human",
+	"agent",
+	"system"
+];
+const PROFILE_HANDLE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const UUID_PROFILE_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const AGENT_PROFILE_ID_PATTERN = /^agt_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const normalizeOptionalProfileLabel = (value) => {
+	const normalized = trimmedStringFromUnknown(value);
+	if (normalized.length === 0) return;
+	return normalized.slice(0, 64);
+};
+const normalizeOptionalProfileHandle = (value) => {
+	const normalized = trimmedStringFromUnknown(value);
+	if (normalized.length === 0) return;
+	return profileHandleSchema.safeParse(normalized).success ? normalized : void 0;
+};
+const MAX_PROFILE_WORKING_DIRECTORY_LENGTH = 4096;
+const profileWorkspaceModeSchema = z$1.enum(["openmeld_managed", "custom"]);
+const profileWorkingDirectorySchema = z$1.string().min(1).max(MAX_PROFILE_WORKING_DIRECTORY_LENGTH).refine((value) => !value.includes("\0"), { message: "workingDirectory must not contain NUL bytes" });
+const normalizeOptionalWorkingDirectory = (value) => {
+	if (typeof value !== "string") return;
+	const parsed = profileWorkingDirectorySchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+};
+const HTTPS_URL_PATTERN = /^https?:\/\//i;
+/**
+* Avatar URLs are a public identity field that travels with the Profile across
+* domains. Only http(s) URLs are accepted so the value is safe to render as an
+* `<img src>` on web clients (rejects javascript:/data: injection vectors).
+*/
+const normalizeOptionalAvatarUrl = (value) => {
+	const normalized = trimmedStringFromUnknown(value);
+	if (normalized.length === 0 || normalized.length > 2048) return;
+	return HTTPS_URL_PATTERN.test(normalized) ? normalized : void 0;
+};
+/** Unknown or invalid kinds are normalized to "agent" for wire compatibility. */
+const profileKindWithFallbackSchema = z$1.preprocess((value) => {
+	const parsed = z$1.enum(PROFILE_KIND_VALUES).safeParse(value);
+	return parsed.success ? parsed.data : "agent";
+}, z$1.enum(PROFILE_KIND_VALUES));
+const profileKindSchema = z$1.enum(PROFILE_KIND_VALUES);
+const profileLabelSchema = z$1.string().min(1).max(64);
+const profileHandleSchema = z$1.string().min(1).max(128).regex(PROFILE_HANDLE_PATTERN);
+const genericProfileIdSchema = z$1.preprocess(trimmedStringFromUnknown, z$1.string().min(1).max(64));
+const uuidProfileIdSchema = z$1.preprocess(trimmedStringFromUnknown, z$1.string().min(1).max(64).regex(UUID_PROFILE_ID_PATTERN));
+const agentProfileIdSchema = z$1.preprocess(trimmedStringFromUnknown, z$1.string().min(1).max(64).regex(AGENT_PROFILE_ID_PATTERN));
+/**
+* Runtime OpenMeld profile IDs are auth-backed and follow these rules:
+* - human/system profiles use a UUID
+* - agent profiles use agt_<UUID>
+*
+* Generic test fixtures or legacy intermediary strings should not reuse this
+* schema unless they represent a real runtime profile identity.
+*/
+const openMeldRuntimeProfileIdSchema = z$1.preprocess(trimmedStringFromUnknown, z$1.string().min(1).max(64).refine((value) => UUID_PROFILE_ID_PATTERN.test(value) || AGENT_PROFILE_ID_PATTERN.test(value), "Invalid OpenMeld runtime profile ID"));
+/**
+* Generic wire/profile normalization rules:
+* - trims and validates profileId as a non-empty string
+* - defaults missing/invalid kind to "agent"
+* - truncates profileName/owner labels to max length
+* - preserves agent workingDirectory verbatim when it is a valid string
+* - keeps owner only for agent profiles
+*
+* This schema intentionally stays broader than auth-backed runtime IDs because
+* protocol/system messages may still use internal synthetic profile IDs such as
+* `openmeld-system`.
+*/
+const profileSchema = z$1.object({
+	kind: profileKindWithFallbackSchema.optional(),
+	profileId: genericProfileIdSchema,
+	profileHandle: z$1.unknown().optional(),
+	profileName: z$1.unknown().optional(),
+	owner: z$1.unknown().optional(),
+	ownerName: z$1.unknown().optional(),
+	agentControllerRef: z$1.unknown().optional(),
+	agentControllerConversationId: z$1.unknown().optional(),
+	workingDirectory: z$1.unknown().optional(),
+	avatarUrl: z$1.unknown().optional()
+}).transform((value) => {
+	const kind = value.kind ?? "agent";
+	const profileHandle = normalizeOptionalProfileHandle(value.profileHandle);
+	const profileName = normalizeOptionalProfileLabel(value.profileName);
+	const owner = kind === "agent" ? normalizeOptionalProfileLabel(value.owner) : void 0;
+	const ownerName = kind === "agent" ? normalizeOptionalProfileLabel(value.ownerName) : void 0;
+	const agentControllerRef = kind === "agent" ? normalizeOptionalProfileLabel(value.agentControllerRef) : void 0;
+	const agentControllerConversationId = kind === "agent" ? normalizeOptionalProfileLabel(value.agentControllerConversationId) : void 0;
+	const workingDirectory = kind === "agent" ? normalizeOptionalWorkingDirectory(value.workingDirectory) : void 0;
+	const avatarUrl = normalizeOptionalAvatarUrl(value.avatarUrl);
+	return {
+		kind,
+		profileId: value.profileId,
+		...profileHandle ? { profileHandle } : {},
+		...profileName ? { profileName } : {},
+		...owner ? { owner } : {},
+		...ownerName ? { ownerName } : {},
+		...agentControllerRef ? { agentControllerRef } : {},
+		...agentControllerConversationId ? { agentControllerConversationId } : {},
+		...workingDirectory ? { workingDirectory } : {},
+		...avatarUrl ? { avatarUrl } : {}
+	};
+});
+//#endregion
+//#region ../../packages/schemas/dist/lazy-zod.js
+const NEVER = z$1.NEVER;
+const ZodIssueCode = z$1.ZodIssueCode;
+const DEFERRED_SCHEMA_METHODS = /* @__PURE__ */ new Set([
+	"and",
+	"array",
+	"base64",
+	"base64url",
+	"catch",
+	"catchall",
+	"check",
+	"cidrv4",
+	"cidrv6",
+	"clone",
+	"cuid",
+	"cuid2",
+	"date",
+	"datetime",
+	"default",
+	"duration",
+	"e164",
+	"email",
+	"emoji",
+	"endsWith",
+	"exactOptional",
+	"exclude",
+	"extend",
+	"extract",
+	"gt",
+	"gte",
+	"guid",
+	"includes",
+	"input",
+	"int",
+	"ipv4",
+	"ipv6",
+	"jwt",
+	"keyof",
+	"ksuid",
+	"length",
+	"loose",
+	"lowercase",
+	"lt",
+	"lte",
+	"max",
+	"merge",
+	"mime",
+	"min",
+	"multipleOf",
+	"nanoid",
+	"negative",
+	"nonempty",
+	"nonnegative",
+	"nonoptional",
+	"nonpositive",
+	"normalize",
+	"nullable",
+	"nullish",
+	"omit",
+	"optional",
+	"or",
+	"output",
+	"overwrite",
+	"partial",
+	"passthrough",
+	"pick",
+	"pipe",
+	"positive",
+	"prefault",
+	"readonly",
+	"refine",
+	"regex",
+	"removeCatch",
+	"removeDefault",
+	"required",
+	"rest",
+	"safe",
+	"safeExtend",
+	"size",
+	"slugify",
+	"startsWith",
+	"step",
+	"strict",
+	"strip",
+	"superRefine",
+	"time",
+	"toLowerCase",
+	"toUpperCase",
+	"transform",
+	"trim",
+	"ulid",
+	"unwrap",
+	"uppercase",
+	"url",
+	"uuid",
+	"uuidv4",
+	"uuidv6",
+	"uuidv7",
+	"with",
+	"xid"
+]);
+const SELF_RETURNING_METHODS = /* @__PURE__ */ new Set(["brand", "finite"]);
+const UNHANDLED_PROPERTY = Symbol("unhandled lazy Zod property");
+const globalRegistry = z$1.globalRegistry;
+function lazySchema(createSchema) {
+	let schema;
+	let proxy;
+	const target = Object.create(null);
+	let targetIsMaterialized = false;
+	const resolveSchema = () => {
+		schema ??= createSchema();
+		return schema;
+	};
+	const readResolvedProperty = (property) => {
+		const resolved = resolveSchema();
+		const value = Reflect.get(resolved, property, resolved);
+		return typeof value === "function" ? value.bind(resolved) : value;
+	};
+	const deferSchemaMethod = (property, args) => lazySchema(() => {
+		const resolved = resolveSchema();
+		const method = Reflect.get(resolved, property, resolved);
+		if (typeof method !== "function") throw new TypeError(`Lazy Zod property ${String(property)} is not callable`);
+		const result = Reflect.apply(method, resolved, args);
+		if (!(result instanceof z$1.ZodType)) throw new TypeError(`Lazy Zod method ${String(property)} did not return a schema`);
+		return result;
+	});
+	const materializeTarget = () => {
+		const resolved = resolveSchema();
+		if (targetIsMaterialized) return resolved;
+		Reflect.setPrototypeOf(target, Reflect.getPrototypeOf(resolved));
+		for (const property of Reflect.ownKeys(resolved)) {
+			const descriptor = Reflect.getOwnPropertyDescriptor(resolved, property);
+			if (descriptor) Reflect.defineProperty(target, property, descriptor);
+		}
+		targetIsMaterialized = true;
+		return resolved;
+	};
+	const readSpecialProperty = (property) => {
+		switch (property) {
+			case "description": {
+				const metadata = globalRegistry.get(proxy);
+				return metadata && typeof metadata === "object" ? Reflect.get(metadata, "description") : void 0;
+			}
+			case "apply": return (operation) => operation(proxy);
+			case "register": return (registry, ...metadata) => {
+				registry.add(proxy, ...metadata);
+				return proxy;
+			};
+			case "meta": return (...metadata) => {
+				if (metadata.length === 0) return globalRegistry.get(proxy);
+				const registered = deferSchemaMethod(property, withoutRegistryIdentity(metadata));
+				globalRegistry.add(registered, ...metadata);
+				return registered;
+			};
+			case "describe": return (description) => {
+				const described = deferSchemaMethod(property, [description]);
+				globalRegistry.add(described, { description });
+				return described;
+			};
+			case "toJSONSchema": return (...args) => Reflect.apply(z$1.toJSONSchema, z$1, [proxy, ...args]);
+			default: return UNHANDLED_PROPERTY;
+		}
+	};
+	proxy = new Proxy(target, {
+		deleteProperty(_target, property) {
+			const deletedFromTarget = Reflect.deleteProperty(target, property);
+			const deletedFromSchema = Reflect.deleteProperty(resolveSchema(), property);
+			return deletedFromTarget && deletedFromSchema;
+		},
+		get(_target, property, receiver) {
+			const specialProperty = readSpecialProperty(property);
+			if (specialProperty !== UNHANDLED_PROPERTY) return specialProperty;
+			if (SELF_RETURNING_METHODS.has(property)) return () => proxy;
+			if (DEFERRED_SCHEMA_METHODS.has(property)) return (...args) => deferSchemaMethod(property, args);
+			return Reflect.getOwnPropertyDescriptor(target, property) ? Reflect.get(target, property, receiver) : readResolvedProperty(property);
+		},
+		getOwnPropertyDescriptor(_target, property) {
+			const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, property);
+			if (targetDescriptor || targetIsMaterialized) return targetDescriptor;
+			const descriptor = Reflect.getOwnPropertyDescriptor(resolveSchema(), property);
+			return descriptor ? {
+				...descriptor,
+				configurable: true
+			} : void 0;
+		},
+		getPrototypeOf() {
+			return targetIsMaterialized ? Reflect.getPrototypeOf(target) : Reflect.getPrototypeOf(resolveSchema());
+		},
+		has(_target, property) {
+			return Reflect.has(target, property) || Reflect.has(resolveSchema(), property);
+		},
+		ownKeys() {
+			if (targetIsMaterialized) return Reflect.ownKeys(target);
+			return [.../* @__PURE__ */ new Set([...Reflect.ownKeys(target), ...Reflect.ownKeys(resolveSchema())])];
+		},
+		preventExtensions() {
+			const resolved = materializeTarget();
+			return Reflect.preventExtensions(resolved) && Reflect.preventExtensions(target);
+		},
+		set(_target, property, value) {
+			const resolved = resolveSchema();
+			if (!targetIsMaterialized) return Reflect.set(resolved, property, value);
+			return Reflect.set(resolved, property, value) && Reflect.set(target, property, value);
+		}
+	});
+	return proxy;
+}
+function withoutRegistryIdentity(metadata) {
+	const [firstMetadata] = metadata;
+	if (!(firstMetadata && typeof firstMetadata === "object" && "id" in firstMetadata)) return metadata;
+	return [Object.fromEntries(Object.entries(firstMetadata).filter(([key]) => key !== "id")), ...metadata.slice(1)];
+}
+function snapshotFactoryArgument(value) {
+	return Array.isArray(value) ? [...value] : value;
+}
+function lazyFactory(factory) {
+	const invoke = factory;
+	return ((...args) => {
+		const declaredArgs = args.map(snapshotFactoryArgument);
+		return lazySchema(() => invoke(...declaredArgs));
+	});
+}
+const array = lazyFactory(z$1.array);
+const boolean = lazyFactory(z$1.boolean);
+const discriminatedUnion = lazyFactory(z$1.discriminatedUnion);
+const email = lazyFactory(z$1.email);
+const enumFactory = lazyFactory(z$1.enum);
+const int = lazyFactory(z$1.int);
+const literal = lazyFactory(z$1.literal);
+const neverFactory = lazyFactory(z$1.never);
+const nullFactory = lazyFactory(z$1.null);
+const number = lazyFactory(z$1.number);
+const object = lazyFactory(z$1.object);
+const preprocess = lazyFactory(z$1.preprocess);
+const record = lazyFactory(z$1.record);
+const strictObject = lazyFactory(z$1.strictObject);
+const string = lazyFactory(z$1.string);
+const tuple = lazyFactory(z$1.tuple);
+const union = lazyFactory(z$1.union);
+const undefinedFactory = lazyFactory(z$1.undefined);
+const unknown = lazyFactory(z$1.unknown);
+const url = lazyFactory(z$1.url);
+const coerce = {
+	...z$1.coerce,
+	bigint: lazyFactory(z$1.coerce.bigint),
+	boolean: lazyFactory(z$1.coerce.boolean),
+	date: lazyFactory(z$1.coerce.date),
+	number: lazyFactory(z$1.coerce.number),
+	string: lazyFactory(z$1.coerce.string)
+};
+const iso = {
+	...z$1.iso,
+	date: lazyFactory(z$1.iso.date),
+	datetime: lazyFactory(z$1.iso.datetime),
+	duration: lazyFactory(z$1.iso.duration),
+	time: lazyFactory(z$1.iso.time)
+};
+//#endregion
+//#region ../../packages/schemas/dist/schemas/local-components.js
+const nonEmptyStringSchema = string().trim().min(1);
+const nullableNonEmptyStringSchema$1 = nonEmptyStringSchema.nullable();
+const localComponentStatusSchema = enumFactory([
+	"ok",
+	"update_available",
+	"update_required"
+]);
+const localComponentUpdatePolicySchema = enumFactory([
+	"ok",
+	"available",
+	"required"
+]);
+const localComponentUpdateStatusSchema = enumFactory([
+	"current",
+	"update_available",
+	"update_required",
+	"unknown"
+]);
+const openMeldToolsUpdateOperationPhaseSchema = enumFactory([
+	"waiting_for_work",
+	"updating",
+	"updated",
+	"restored",
+	"needs_help"
+]);
+const openMeldToolsUpdateRequestSourceSchema = enumFactory([
+	"automatic",
+	"center_agent",
+	"cli",
+	"web"
+]);
+const openMeldToolsUpdateOperationSchema = strictObject({
+	operationId: nonEmptyStringSchema,
+	phase: openMeldToolsUpdateOperationPhaseSchema,
+	requestSource: openMeldToolsUpdateRequestSourceSchema,
+	requestedAt: iso.datetime({ offset: true }),
+	targetVersion: nonEmptyStringSchema,
+	updatedAt: iso.datetime({ offset: true }),
+	urgency: enumFactory(["available", "required"])
+});
+const openMeldToolsMaintenanceProjectionSchema = strictObject({
+	automaticUpdatesEnabled: boolean(),
+	status: enumFactory(["ready", "needs_help"])
+});
+const openMeldToolsControlCapabilitySchema = strictObject({
+	requestAutomaticUpdate: literal(true).optional(),
+	requestUpdate: literal(true).optional(),
+	setAutomaticUpdates: literal(true).optional()
+});
+const openMeldToolsUpdateRequestResultSchema = discriminatedUnion("status", [
+	strictObject({ status: literal("disabled") }),
+	strictObject({ status: literal("unavailable") }),
+	strictObject({
+		currentVersion: nonEmptyStringSchema,
+		status: literal("current")
+	}),
+	strictObject({
+		operation: openMeldToolsUpdateOperationSchema,
+		status: enumFactory(["started", "already_running"])
+	})
+]);
+const openMeldToolsMaintenanceMutationResultSchema = strictObject({
+	automaticUpdatesEnabled: boolean(),
+	status: enumFactory(["updated", "unchanged"])
+});
+const openMeldToolsControlRequestSchema = discriminatedUnion("operation", [strictObject({
+	operation: literal("request_update"),
+	requestSource: enumFactory([
+		"automatic",
+		"center_agent",
+		"web"
+	])
+}), strictObject({
+	automaticUpdatesEnabled: boolean(),
+	operation: literal("set_automatic_updates"),
+	requestSource: enumFactory(["center_agent", "web"])
+})]);
+const openMeldToolsControlResultSchema = discriminatedUnion("operation", [strictObject({
+	operation: literal("request_update"),
+	result: openMeldToolsUpdateRequestResultSchema
+}), strictObject({
+	operation: literal("set_automatic_updates"),
+	result: openMeldToolsMaintenanceMutationResultSchema
+})]);
+const openMeldToolsUpdateAttemptSchema = strictObject({
+	v: literal(1),
+	attempts: number().int().nonnegative(),
+	errorMessage: nullableNonEmptyStringSchema$1,
+	operation: openMeldToolsUpdateOperationSchema
+});
+const localSetupActionSchema = enumFactory([
+	"none",
+	"connect_service",
+	"reconnect_service",
+	"update_service",
+	"connect_local_agent",
+	"update_skills",
+	"update_cli"
+]);
+const localSetupEntrypointSchema = literal("setup");
+const localComponentsManifestSchema = strictObject({
+	schemaVersion: literal(1),
+	openMeldReleaseVersion: nonEmptyStringSchema,
+	cli: strictObject({
+		packageVersion: nonEmptyStringSchema,
+		commandContractVersion: nonEmptyStringSchema
+	}),
+	service: strictObject({
+		bundleHash: nullableNonEmptyStringSchema$1,
+		bundleVersion: nonEmptyStringSchema,
+		runtimeContractEpoch: nonEmptyStringSchema,
+		serviceContractVersion: nonEmptyStringSchema
+	}),
+	skills: strictObject({
+		bundleHash: nullableNonEmptyStringSchema$1,
+		skillContractVersion: nonEmptyStringSchema,
+		skillIds: array(nonEmptyStringSchema)
+	})
+});
+strictObject({
+	schemaVersion: literal(1),
+	updatedAt: iso.datetime({ offset: true }),
+	components: strictObject({
+		cli: strictObject({
+			packageVersion: nonEmptyStringSchema,
+			commandContractVersion: nonEmptyStringSchema,
+			updatePolicy: localComponentUpdatePolicySchema,
+			reason: nonEmptyStringSchema
+		}),
+		service: strictObject({
+			bundleHash: nullableNonEmptyStringSchema$1,
+			bundleVersion: nonEmptyStringSchema,
+			runtimeContractEpoch: nonEmptyStringSchema,
+			serviceContractVersion: nonEmptyStringSchema,
+			updatePolicy: localComponentUpdatePolicySchema,
+			reason: nonEmptyStringSchema
+		}),
+		skills: strictObject({
+			bundleHash: nullableNonEmptyStringSchema$1,
+			skillContractVersion: nonEmptyStringSchema,
+			skillIds: array(nonEmptyStringSchema),
+			updatePolicy: localComponentUpdatePolicySchema,
+			reason: nonEmptyStringSchema
+		})
+	})
+});
+const installedLocalComponentsSnapshotSchema = strictObject({
+	schemaVersion: literal(1),
+	installedAt: iso.datetime({ offset: true }),
+	source: enumFactory([
+		"setup",
+		"repair",
+		"manual"
+	]),
+	manifest: localComponentsManifestSchema
+});
+const localComponentProjectionSchema = strictObject({
+	reasonCodes: array(nonEmptyStringSchema),
+	status: localComponentStatusSchema
+});
+const localCliComponentProjectionSchema = localComponentProjectionSchema.extend({
+	commandContractVersion: nonEmptyStringSchema,
+	latestPackageVersion: nullableNonEmptyStringSchema$1,
+	packageVersion: nonEmptyStringSchema,
+	requiredCommandContractVersion: nullableNonEmptyStringSchema$1
+});
+const localServiceComponentProjectionSchema = localComponentProjectionSchema.extend({
+	expectedBundleHash: nullableNonEmptyStringSchema$1,
+	expectedBundleVersion: nonEmptyStringSchema,
+	installedBundleHash: nullableNonEmptyStringSchema$1,
+	installedBundleVersion: nullableNonEmptyStringSchema$1,
+	runtimeContractEpoch: nonEmptyStringSchema,
+	serviceContractVersion: nonEmptyStringSchema
+});
+const localSkillsComponentProjectionSchema = localComponentProjectionSchema.extend({
+	contentRelease: strictObject({
+		revision: number().int().positive(),
+		minimumCliVersion: string().regex(/^\d+\.\d+\.\d+$/)
+	}).optional(),
+	expectedBundleHash: nullableNonEmptyStringSchema$1,
+	installedBundleHash: nullableNonEmptyStringSchema$1,
+	skillContractVersion: nonEmptyStringSchema,
+	targetCount: number().int().nonnegative()
+});
+const localComponentsStatusSchema = strictObject({
+	schemaVersion: literal(1),
+	generatedAt: iso.datetime({ offset: true }),
+	entrypoint: localSetupEntrypointSchema,
+	summaryLabel: nonEmptyStringSchema,
+	summaryDescription: nonEmptyStringSchema,
+	setupAction: localSetupActionSchema,
+	setupActionLabel: nonEmptyStringSchema,
+	setupActionDescription: nonEmptyStringSchema,
+	maintenance: openMeldToolsMaintenanceProjectionSchema.optional(),
+	updateOperation: openMeldToolsUpdateOperationSchema.optional(),
+	cli: localCliComponentProjectionSchema,
+	service: localServiceComponentProjectionSchema,
+	skills: localSkillsComponentProjectionSchema
+});
+const localServiceComponentUpdateProjectionSchema = strictObject({
+	installedVersion: nullableNonEmptyStringSchema$1,
+	latestVersion: nullableNonEmptyStringSchema$1,
+	reasonCodes: array(nonEmptyStringSchema),
+	requiredVersion: nullableNonEmptyStringSchema$1,
+	status: localComponentUpdateStatusSchema,
+	updatePolicy: localComponentUpdatePolicySchema,
+	wakeBlocked: boolean()
+});
+const localCliComponentUpdateProjectionSchema = strictObject({
+	commandContractVersion: nullableNonEmptyStringSchema$1,
+	installedPackageVersion: nullableNonEmptyStringSchema$1,
+	latestPackageVersion: nullableNonEmptyStringSchema$1,
+	reasonCodes: array(nonEmptyStringSchema),
+	requiredCommandContractVersion: nullableNonEmptyStringSchema$1,
+	status: localComponentUpdateStatusSchema,
+	updatePolicy: localComponentUpdatePolicySchema,
+	wakeBlocked: boolean()
+});
+const localSkillsComponentUpdateProjectionSchema = strictObject({
+	expectedBundleHash: nullableNonEmptyStringSchema$1,
+	expectedTargetCount: number().int().nonnegative(),
+	installedBundleHash: nullableNonEmptyStringSchema$1,
+	reasonCodes: array(nonEmptyStringSchema),
+	skillContractVersion: nullableNonEmptyStringSchema$1,
+	status: localComponentUpdateStatusSchema,
+	targetCount: number().int().nonnegative().nullable(),
+	updatePolicy: localComponentUpdatePolicySchema,
+	wakeBlocked: boolean()
+});
+const localComponentUpdateProjectionSchema = strictObject({
+	schemaVersion: literal(1),
+	generatedAt: iso.datetime({ offset: true }),
+	setupAction: localSetupActionSchema,
+	setupActionLabel: nonEmptyStringSchema,
+	setupActionDescription: nonEmptyStringSchema,
+	humanSetupCommand: nonEmptyStringSchema,
+	agentSetupCommand: nonEmptyStringSchema,
+	maintenance: openMeldToolsMaintenanceProjectionSchema.optional(),
+	updateOperation: openMeldToolsUpdateOperationSchema.optional(),
+	cli: localCliComponentUpdateProjectionSchema,
+	service: localServiceComponentUpdateProjectionSchema,
+	skills: localSkillsComponentUpdateProjectionSchema
+});
+function formatLocalSetupActionLabel(action) {
+	switch (action) {
+		case "connect_service": return "Connect Computer";
+		case "reconnect_service": return "Reconnect Computer";
+		case "update_service": return "Update OpenMeld on Computer";
+		case "connect_local_agent": return "Connect local agent";
+		case "update_skills": return "Update OpenMeld skills";
+		case "update_cli": return "Update OpenMeld CLI";
+		case "none": return "Everything is up to date";
+		default: return action;
+	}
+}
+function formatLocalComponentsSummaryLabel(input) {
+	if (input.setupAction !== "none") return formatLocalSetupActionLabel(input.setupAction);
+	switch (input.cliStatus) {
+		case "update_required": return "Update OpenMeld CLI";
+		case "update_available": return "OpenMeld CLI update available";
+		case "ok": return "Everything is up to date";
+		default: return input.cliStatus;
+	}
+}
+function formatLocalComponentsSummaryDescription(input) {
+	if (input.setupAction !== "none") return formatLocalSetupActionDescription(input.setupAction);
+	switch (input.cliStatus) {
+		case "update_required": return "Update OpenMeld CLI before running this setup flow.";
+		case "update_available": return "OpenMeld CLI can be updated, but this setup flow can continue.";
+		case "ok": return "OpenMeld local components are aligned for this computer.";
+		default: return input.cliStatus;
+	}
+}
+function formatLocalSetupActionDescription(action) {
+	switch (action) {
+		case "connect_service": return "Connect this computer to OpenMeld so local agents can reply in Spaces.";
+		case "reconnect_service": return "Reconnect this computer to the current OpenMeld account.";
+		case "update_service": return "Update OpenMeld on this computer.";
+		case "connect_local_agent": return "Connect this Agent Profile to a local agent runtime on this computer.";
+		case "update_skills": return "Update OpenMeld skills through setup on this computer.";
+		case "update_cli": return "Update OpenMeld CLI before running this setup flow.";
+		case "none": return "OpenMeld local components are aligned for this computer.";
+		default: return action;
+	}
+}
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/conversation-lifecycle.js
+const conversationBootstrapReasonSchema = z$1.enum([
+	"missing_bootstrap_state",
+	"compatibility_recreate",
+	"template_changed",
+	"idle_stale",
+	"dispatch_count_stale",
+	"context_healed",
+	"context_replaced"
+]);
+const localRuntimeContextReasonSchema = z$1.enum([
+	"first_local_runtime_context",
+	"workspace_changed",
+	"transport_mode_changed",
+	"policy_changed",
+	"execution_state_missing",
+	"controller_changed"
+]);
+const agentControllerConversationResumePlanBlockedReasonSchema = z$1.enum(["controller_changed"]);
+const agentControllerConversationResumePlanSchema = z$1.discriminatedUnion("status", [
+	z$1.strictObject({ status: z$1.literal("not_bound") }),
+	z$1.strictObject({ status: z$1.literal("continue_existing") }),
+	z$1.strictObject({
+		status: z$1.literal("blocked"),
+		reason: agentControllerConversationResumePlanBlockedReasonSchema
+	})
+]);
+const localRuntimeContextPlanSchema = z$1.strictObject({
+	status: z$1.enum(["reuse", "recreate"]),
+	reason: z$1.union([localRuntimeContextReasonSchema, z$1.null()])
+});
+const conversationBootstrapSchema = z$1.discriminatedUnion("status", [z$1.strictObject({
+	reason: z$1.null(),
+	status: z$1.literal("applied")
+}), z$1.strictObject({
+	reason: conversationBootstrapReasonSchema,
+	status: z$1.literal("pending")
+})]);
+z$1.strictObject({
+	agentControllerConversationResume: agentControllerConversationResumePlanSchema,
+	localRuntimeContext: localRuntimeContextPlanSchema,
+	bootstrap: conversationBootstrapSchema
+});
+const agentControllerConversationResumeSchema = z$1.discriminatedUnion("status", [
+	z$1.strictObject({ status: z$1.literal("not_bound") }),
+	z$1.strictObject({ status: z$1.literal("continued") }),
+	z$1.strictObject({ status: z$1.literal("replaced_by_provider") })
+]);
+const localRuntimeContextExecutionSchema = z$1.strictObject({
+	status: z$1.enum(["reused", "recreated"]),
+	reason: z$1.union([localRuntimeContextReasonSchema, z$1.null()])
+});
+const dispatchExecutionSchema = z$1.strictObject({
+	agentControllerConversationResume: agentControllerConversationResumeSchema,
+	localRuntimeContext: localRuntimeContextExecutionSchema,
+	bootstrap: conversationBootstrapSchema
+});
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/conversation-execution-state.js
+const ISO_DATE_TIME_SCHEMA = z$1.iso.datetime({ offset: true });
+const bootstrapTemplateFactsSchema = z$1.strictObject({
+	templateVersion: z$1.string().min(1),
+	contentFingerprint: z$1.string().min(1)
+});
+const conversationExecutionStateSchema = z$1.strictObject({
+	agentContextLookupKey: z$1.string().min(1),
+	activeContextId: z$1.string().min(1).nullable(),
+	lastResolvedAgentControllerConversation: agentControllerConversationRefSchema.optional(),
+	lastRuntimeWorkspacePath: profileWorkingDirectorySchema.optional(),
+	runtimeWorkspaceFingerprint: z$1.string().min(1),
+	bootstrapLastAppliedAt: ISO_DATE_TIME_SCHEMA.optional(),
+	bootstrapLastActivatedAt: ISO_DATE_TIME_SCHEMA.optional(),
+	dispatchesSinceBootstrapApplied: z$1.number().int().min(0),
+	lastAppliedTemplateVersion: z$1.string().min(1).optional(),
+	lastAppliedContentFingerprint: z$1.string().min(1).optional(),
+	pendingBootstrapReason: conversationBootstrapReasonSchema.optional(),
+	updatedAt: ISO_DATE_TIME_SCHEMA
+});
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/provider-runtime-context.js
+const providerDispatchRuntimeContextSchema = z$1.strictObject({ providerRuntimeWorkingDirectory: z$1.string().trim().min(1).max(MAX_PROFILE_WORKING_DIRECTORY_LENGTH).refine((value) => !value.includes("\0"), { message: "providerRuntimeWorkingDirectory must not contain NUL bytes" }) });
+enumFactory([
+	"status",
+	"health",
+	"history",
+	"interrupt",
+	"cancel",
+	"conversation_execution_status",
+	"request_agent_activity_sync",
+	"sync_route_catalog",
+	"set_local_agent_enabled",
+	"set_profile_workspace",
+	"service_update_readiness",
+	"account_control_capabilities",
+	"shutdown"
+]);
+const openMeldDaemonHealthStateSchema = enumFactory([
+	"ok",
+	"degraded",
+	"down"
+]);
+const openMeldDaemonRuntimeHealthStateSchema = enumFactory([
+	"healthy",
+	"idle",
+	"suspect",
+	"down"
+]);
+const openMeldDaemonControlTargetSelectorSchema = discriminatedUnion("by", [strictObject({
+	by: literal("dispatch"),
+	dispatchId: string().min(1)
+}), strictObject({
+	by: literal("task"),
+	taskId: string().min(1)
+})]);
+const openMeldDaemonInterruptRequestPayloadSchema = strictObject({
+	runtimeCoordinatorExecutionId: string().min(1).optional(),
+	target: openMeldDaemonControlTargetSelectorSchema,
+	mode: enumFactory(["graceful", "force"]).optional(),
+	reason: string().min(1).optional()
+});
+const openMeldDaemonCancelRequestPayloadSchema = strictObject({
+	runtimeCoordinatorExecutionId: string().min(1).optional(),
+	target: openMeldDaemonControlTargetSelectorSchema,
+	reason: string().min(1).optional()
+});
+const openMeldDaemonShutdownRequestPayloadSchema = strictObject({
+	accountAdmissionId: string().uuid().optional(),
+	mode: enumFactory(["graceful", "force"]).default("graceful"),
+	gracePeriodMs: number().int().nonnegative().default(5e3)
+});
+const openMeldDaemonServiceUpdateReadinessPayloadSchema = strictObject({
+	acceptedWakeCount: number().int().nonnegative(),
+	safeToSwitch: boolean(),
+	unacknowledgedResultCount: number().int().nonnegative()
+});
+const openMeldDaemonConversationExecutionControllerLaunchStatusSchema = enumFactory([
+	"missing",
+	"disabled",
+	"repair_required",
+	"ready"
+]);
+const nullableAgentControllerRefSchema = union([string().min(1), nullFactory()]);
+const nullableNonEmptyStringSchema = union([string().min(1), nullFactory()]);
+const openMeldDaemonConversationExecutionStatusRequestPayloadSchema = strictObject({
+	boundAgentControllerRef: nullableAgentControllerRefSchema,
+	agentControllerConversationId: nullableNonEmptyStringSchema,
+	agentControllerRef: string().min(1),
+	spaceId: nonEmptyTrimmedStringFromUnknown,
+	targetProfileId: agentProfileIdSchema,
+	transportMode: runtimeTransportModeSchema,
+	validate: boolean()
+});
+const openMeldDaemonSyncRouteCatalogRequestPayloadSchema = strictObject({ reason: string().min(1) });
+const openMeldDaemonRequestAgentActivitySyncRequestPayloadSchema = strictObject({ reason: string().trim().min(1).max(128) });
+const openMeldDaemonSetLocalAgentEnabledRequestPayloadSchema = strictObject({
+	agentId: string().trim().min(1).max(256),
+	enabled: boolean()
+});
+const localAgentInstallationOptionSchema = strictObject({
+	installationId: string().trim().min(1).max(256),
+	name: string().trim().min(1).max(256),
+	details: string().trim().min(1).max(256),
+	selected: boolean()
+});
+const openMeldDaemonManageLocalAgentInstallationRequestPayloadSchema = discriminatedUnion("operation", [strictObject({
+	agentId: string().trim().min(1).max(256),
+	operation: literal("list")
+}), strictObject({
+	agentId: string().trim().min(1).max(256),
+	installationId: string().trim().min(1).max(256),
+	operation: literal("select")
+})]);
+const openMeldDaemonSetProfileWorkspaceRequestPayloadSchema = strictObject({
+	targetProfileId: agentProfileIdSchema,
+	workspaceMode: profileWorkspaceModeSchema,
+	workspacePath: profileWorkingDirectorySchema.optional()
+}).superRefine((value, context) => {
+	if (value.workspaceMode === "custom" && !value.workspacePath) context.addIssue({
+		code: "custom",
+		message: "workspacePath is required for a custom profile workspace",
+		path: ["workspacePath"]
+	});
+	if (value.workspaceMode === "openmeld_managed" && value.workspacePath) context.addIssue({
+		code: "custom",
+		message: "workspacePath must be omitted for an OpenMeld-managed profile workspace",
+		path: ["workspacePath"]
+	});
+});
+const openMeldDaemonConversationExecutionRuntimeWorkspaceSchema = discriminatedUnion("status", [
+	strictObject({
+		configPath: string().min(1),
+		configuredWorkspacePath: string().min(1),
+		fingerprint: string().min(1),
+		path: string().min(1),
+		reasonCode: nullFactory(),
+		reasonText: nullFactory(),
+		runtimeContext: providerDispatchRuntimeContextSchema,
+		status: literal("ready"),
+		workspaceMode: profileWorkspaceModeSchema
+	}),
+	strictObject({
+		configPath: string().min(1),
+		configuredWorkspacePath: nullFactory(),
+		fingerprint: nullFactory(),
+		path: nullFactory(),
+		reasonCode: literal("workspace.missing"),
+		reasonText: string().min(1),
+		runtimeContext: nullFactory(),
+		status: literal("missing"),
+		workspaceMode: nullFactory()
+	}),
+	strictObject({
+		configPath: string().min(1),
+		configuredWorkspacePath: union([string().min(1), nullFactory()]),
+		fingerprint: nullFactory(),
+		path: nullFactory(),
+		reasonCode: literal("workspace.invalid"),
+		reasonText: string().min(1),
+		runtimeContext: nullFactory(),
+		status: literal("invalid"),
+		workspaceMode: union([profileWorkspaceModeSchema, nullFactory()])
+	})
+]);
+const openMeldDaemonConversationExecutionLocalRuntimeContextStatusSchema = enumFactory([
+	"missing",
+	"mismatch",
+	"ready"
+]);
+const openMeldDaemonProviderConversationProofStatusSchema = enumFactory([
+	"failed",
+	"not_applicable",
+	"not_run",
+	"passed"
+]);
+const openMeldDaemonProviderConversationProofProviderSchema = enumFactory([
+	"codex",
+	"claude-code",
+	"openclaw"
+]);
+const openMeldDaemonProviderConversationProofMethodSchema = enumFactory(["codex_app_server_thread_resume"]);
+const openMeldDaemonProviderConversationProofSchema = strictObject({
+	agentControllerConversationId: nullableNonEmptyStringSchema,
+	checkedAt: union([iso.datetime({ offset: true }), nullFactory()]),
+	errorCode: nullableNonEmptyStringSchema,
+	errorMessage: nullableNonEmptyStringSchema,
+	errorType: nullableNonEmptyStringSchema,
+	expiresAt: union([iso.datetime({ offset: true }), nullFactory()]),
+	intrusive: literal(false),
+	method: union([openMeldDaemonProviderConversationProofMethodSchema, nullFactory()]),
+	provider: union([openMeldDaemonProviderConversationProofProviderSchema, nullFactory()]),
+	status: openMeldDaemonProviderConversationProofStatusSchema,
+	transportMode: union([runtimeTransportModeSchema, nullFactory()])
+});
+const openMeldDaemonConversationExecutionStatusPayloadSchema = strictObject({
+	agentContextLookupKey: string().min(1),
+	controllerLaunchStatus: openMeldDaemonConversationExecutionControllerLaunchStatusSchema,
+	executionState: conversationExecutionStateSchema.nullable(),
+	localRuntimeContext: strictObject({
+		agentContextLookupKey: string().min(1),
+		runtimeWorkspaceFingerprint: nullableNonEmptyStringSchema,
+		status: openMeldDaemonConversationExecutionLocalRuntimeContextStatusSchema
+	}),
+	providerConversationProof: openMeldDaemonProviderConversationProofSchema,
+	runtimeWorkspace: openMeldDaemonConversationExecutionRuntimeWorkspaceSchema
+});
+const openMeldDaemonSyncRouteCatalogStatusSchema = enumFactory([
+	"changed",
+	"registered",
+	"unchanged",
+	"failed",
+	"deferred"
+]);
+const skippedDaemonProfileSchema = strictObject({
+	profileId: agentProfileIdSchema,
+	profileName: nullableNonEmptyStringSchema,
+	skipReason: enumFactory([
+		"projection.missing",
+		"controller.registry.disabled",
+		"controller.launch.needs_repair",
+		"runtime.adapter.unsupported",
+		"controller.binding.disabled",
+		"controller.binding.incomplete",
+		"profile.status.inactive",
+		"profile.binding.read_unavailable",
+		"profile.binding.unbound",
+		"workspace.missing",
+		"workspace.invalid"
+	])
+});
+const openMeldDaemonSyncRouteCatalogPayloadSchema = strictObject({
+	accepted: boolean(),
+	syncStatus: openMeldDaemonSyncRouteCatalogStatusSchema,
+	profileIds: array(agentProfileIdSchema),
+	addedProfileIds: array(agentProfileIdSchema).optional(),
+	keptProfileIds: array(agentProfileIdSchema).optional(),
+	removedProfileIds: array(agentProfileIdSchema).optional(),
+	skippedProfiles: array(skippedDaemonProfileSchema).optional(),
+	note: string().min(1).optional(),
+	errorMessage: string().min(1).optional()
+});
+const openMeldDaemonRequestAgentActivitySyncPayloadSchema = strictObject({ accepted: boolean() });
+const openMeldDaemonSetLocalAgentEnabledPayloadSchema = strictObject({
+	accepted: boolean(),
+	agentControllerRef: string().min(1).optional(),
+	agentId: string().trim().min(1).max(256),
+	changed: boolean(),
+	enabled: boolean(),
+	message: string().min(1).optional(),
+	reasonCode: string().min(1).optional(),
+	reportSyncStatus: enumFactory([
+		"submitted",
+		"skipped",
+		"failed"
+	]),
+	status: enumFactory([
+		"updated",
+		"unchanged",
+		"rejected"
+	])
+});
+const openMeldDaemonManageLocalAgentInstallationPayloadSchema = discriminatedUnion("accepted", [strictObject({
+	accepted: literal(true),
+	agentControllerRef: string().min(1),
+	agentId: string().trim().min(1).max(256),
+	changed: boolean(),
+	installations: array(localAgentInstallationOptionSchema),
+	reportSyncStatus: enumFactory([
+		"submitted",
+		"skipped",
+		"failed"
+	]),
+	selectionStatus: enumFactory([
+		"available",
+		"blocked_by_work",
+		"operation_in_progress"
+	]).optional(),
+	selectedInstallationId: string().trim().min(1).max(256).nullable(),
+	status: enumFactory([
+		"listed",
+		"updated",
+		"unchanged"
+	])
+}), strictObject({
+	accepted: literal(false),
+	agentId: string().trim().min(1).max(256),
+	changed: literal(false),
+	installations: array(localAgentInstallationOptionSchema),
+	message: string().min(1).optional(),
+	reasonCode: string().min(1).optional(),
+	reportSyncStatus: literal("failed"),
+	selectionStatus: enumFactory([
+		"available",
+		"blocked_by_work",
+		"operation_in_progress"
+	]).optional(),
+	selectedInstallationId: string().trim().min(1).max(256).nullable(),
+	status: literal("rejected")
+})]);
+const openMeldDaemonSetProfileWorkspacePayloadSchema = discriminatedUnion("accepted", [strictObject({
+	accepted: literal(true),
+	targetProfileId: agentProfileIdSchema,
+	status: literal("updated"),
+	workspaceMode: profileWorkspaceModeSchema,
+	workspacePath: string().min(1)
+}), strictObject({
+	accepted: literal(false),
+	targetProfileId: agentProfileIdSchema,
+	message: string().min(1).optional(),
+	reasonCode: string().min(1).optional(),
+	status: literal("rejected")
+})]);
+const openMeldDaemonControlPlaneRequestBaseSchema = strictObject({
+	v: literal(1),
+	requestId: string().min(1).optional(),
+	authToken: string().min(1).optional()
+});
+const openMeldDaemonControlPlaneRequestSchema = discriminatedUnion("command", [
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({ command: literal("account_control_capabilities") }),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({ command: literal("status") }),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({ command: literal("health") }),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({ command: literal("history") }),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("interrupt"),
+		payload: openMeldDaemonInterruptRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("cancel"),
+		payload: openMeldDaemonCancelRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("conversation_execution_status"),
+		payload: openMeldDaemonConversationExecutionStatusRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("sync_route_catalog"),
+		payload: openMeldDaemonSyncRouteCatalogRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("request_agent_activity_sync"),
+		payload: openMeldDaemonRequestAgentActivitySyncRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("set_local_agent_enabled"),
+		payload: openMeldDaemonSetLocalAgentEnabledRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("set_profile_workspace"),
+		payload: openMeldDaemonSetProfileWorkspaceRequestPayloadSchema
+	}),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({ command: literal("service_update_readiness") }),
+	openMeldDaemonControlPlaneRequestBaseSchema.extend({
+		command: literal("shutdown"),
+		payload: openMeldDaemonShutdownRequestPayloadSchema.optional()
+	})
+]);
+const openMeldDaemonStatusPayloadSchema = strictObject({
+	installed: boolean(),
+	running: boolean(),
+	daemonVersion: string().min(1),
+	runtimeRoot: string().min(1),
+	checkedAt: string().min(1)
+});
+const openMeldDaemonHealthPayloadSchema = strictObject({
+	state: openMeldDaemonHealthStateSchema,
+	runtimeState: openMeldDaemonRuntimeHealthStateSchema.optional(),
+	reasonCode: string().min(1),
+	checkedAt: string().min(1)
+});
+const openMeldDaemonHistoryPayloadSchema = strictObject({
+	entries: array(strictObject({
+		id: string().min(1),
+		ts: string().min(1),
+		code: string().min(1),
+		message: string().min(1)
+	})),
+	nextCursor: string().min(1).optional()
+});
+const openMeldDaemonInterruptPayloadSchema = strictObject({
+	accepted: boolean(),
+	target: openMeldDaemonControlTargetSelectorSchema,
+	resolvedDispatchId: string().min(1).optional(),
+	resolvedRuntimeCoordinatorExecutionId: string().min(1).optional(),
+	resolvedTaskId: string().min(1).optional(),
+	note: string().min(1).optional(),
+	reasonCode: string().min(1).optional()
+});
+const openMeldDaemonCancelPayloadSchema = strictObject({
+	accepted: boolean(),
+	target: openMeldDaemonControlTargetSelectorSchema,
+	resolvedDispatchId: string().min(1).optional(),
+	resolvedRuntimeCoordinatorExecutionId: string().min(1).optional(),
+	resolvedTaskId: string().min(1).optional(),
+	note: string().min(1).optional(),
+	reasonCode: string().min(1).optional()
+});
+const openMeldDaemonControlPlaneErrorPayloadSchema = strictObject({
+	errorCode: string().min(1),
+	errorMessage: string().min(1),
+	note: string().min(1).optional()
+});
+const openMeldDaemonShutdownPayloadSchema = strictObject({
+	accepted: boolean(),
+	mode: enumFactory(["graceful", "force"]),
+	gracePeriodMs: number().int().nonnegative()
+});
+const openMeldDaemonControlPlaneResponseBaseSchema = strictObject({
+	v: literal(1),
+	requestId: string().min(1).optional()
+});
+const openMeldDaemonStatusResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.status"),
+	payload: openMeldDaemonStatusPayloadSchema
+});
+const openMeldDaemonHealthResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.health"),
+	payload: openMeldDaemonHealthPayloadSchema
+});
+const openMeldDaemonHistoryResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.history"),
+	payload: openMeldDaemonHistoryPayloadSchema
+});
+const openMeldDaemonInterruptResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.interrupt"),
+	payload: openMeldDaemonInterruptPayloadSchema
+});
+const openMeldDaemonCancelResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.cancel"),
+	payload: openMeldDaemonCancelPayloadSchema
+});
+const openMeldDaemonConversationExecutionStatusResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.conversation_execution_status"),
+	payload: openMeldDaemonConversationExecutionStatusPayloadSchema
+});
+const openMeldDaemonSyncRouteCatalogResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.sync_route_catalog"),
+	payload: openMeldDaemonSyncRouteCatalogPayloadSchema
+});
+const openMeldDaemonRequestAgentActivitySyncResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.agent_activity_sync_requested"),
+	payload: openMeldDaemonRequestAgentActivitySyncPayloadSchema
+});
+const openMeldDaemonSetLocalAgentEnabledResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.set_local_agent_enabled"),
+	payload: openMeldDaemonSetLocalAgentEnabledPayloadSchema
+});
+const openMeldDaemonSetProfileWorkspaceResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.set_profile_workspace"),
+	payload: openMeldDaemonSetProfileWorkspacePayloadSchema
+});
+const openMeldDaemonShutdownResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.shutdown"),
+	payload: openMeldDaemonShutdownPayloadSchema
+});
+const openMeldDaemonServiceUpdateReadinessResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.update_readiness"),
+	payload: openMeldDaemonServiceUpdateReadinessPayloadSchema
+});
+const openMeldDaemonControlPlaneErrorResponseSchema = openMeldDaemonControlPlaneResponseBaseSchema.extend({
+	code: literal("service.error"),
+	payload: openMeldDaemonControlPlaneErrorPayloadSchema
+});
+const openMeldDaemonControlPlaneResponseSchema = discriminatedUnion("code", [
+	openMeldDaemonControlPlaneResponseBaseSchema.extend({
+		code: literal("service.account_control_capabilities"),
+		payload: strictObject({ supported: boolean() })
+	}),
+	openMeldDaemonStatusResponseSchema,
+	openMeldDaemonHealthResponseSchema,
+	openMeldDaemonHistoryResponseSchema,
+	openMeldDaemonInterruptResponseSchema,
+	openMeldDaemonCancelResponseSchema,
+	openMeldDaemonConversationExecutionStatusResponseSchema,
+	openMeldDaemonSyncRouteCatalogResponseSchema,
+	openMeldDaemonRequestAgentActivitySyncResponseSchema,
+	openMeldDaemonSetLocalAgentEnabledResponseSchema,
+	openMeldDaemonSetProfileWorkspaceResponseSchema,
+	openMeldDaemonServiceUpdateReadinessResponseSchema,
+	openMeldDaemonShutdownResponseSchema,
+	openMeldDaemonControlPlaneErrorResponseSchema
+]);
+//#endregion
+export { literal as $, localComponentsStatusSchema as A, openMeldToolsUpdateRequestResultSchema as B, formatLocalSetupActionDescription as C, uuidProfileIdSchema as Ct, localComponentUpdatePolicySchema as D, trimmedStringFromUnknown as Dt, localCliComponentUpdateProjectionSchema as E, optionalBooleanQuerySchema as Et, openMeldToolsMaintenanceMutationResultSchema as F, boolean as G, NEVER as H, openMeldToolsMaintenanceProjectionSchema as I, email as J, coerce as K, openMeldToolsUpdateAttemptSchema as L, openMeldToolsControlCapabilitySchema as M, openMeldToolsControlRequestSchema as N, localComponentUpdateProjectionSchema as O, openMeldToolsControlResultSchema as P, lazySchema as Q, openMeldToolsUpdateOperationPhaseSchema as R, formatLocalComponentsSummaryLabel as S, profileWorkspaceModeSchema as St, installedLocalComponentsSnapshotSchema as T, nonEmptyTrimmedStringFromUnknown as Tt, ZodIssueCode as U, openMeldToolsUpdateRequestSourceSchema as V, array as W, int as X, enumFactory as Y, iso as Z, providerDispatchRuntimeContextSchema as _, profileHandleSchema as _t, openMeldDaemonControlPlaneResponseSchema as a, record as at, dispatchExecutionSchema as b, profileSchema as bt, openMeldDaemonManageLocalAgentInstallationPayloadSchema as c, tuple as ct, openMeldDaemonSetLocalAgentEnabledRequestPayloadSchema as d, unknown as dt, neverFactory as et, openMeldDaemonSetProfileWorkspacePayloadSchema as f, url as ft, skippedDaemonProfileSchema as g, openMeldRuntimeProfileIdSchema as gt, openMeldDaemonSyncRouteCatalogRequestPayloadSchema as h, normalizeOptionalWorkingDirectory as ht, openMeldDaemonControlPlaneRequestSchema as i, preprocess as it, localServiceComponentUpdateProjectionSchema as j, localComponentUpdateStatusSchema as k, openMeldDaemonManageLocalAgentInstallationRequestPayloadSchema as l, undefinedFactory as lt, openMeldDaemonSyncRouteCatalogPayloadSchema as m, agentProfileIdSchema as mt, openMeldDaemonCancelPayloadSchema as n, number as nt, openMeldDaemonInterruptPayloadSchema as o, strictObject as ot, openMeldDaemonSetProfileWorkspaceRequestPayloadSchema as p, MAX_PROFILE_WORKING_DIRECTORY_LENGTH as pt, discriminatedUnion as q, openMeldDaemonCancelRequestPayloadSchema as r, object as rt, openMeldDaemonInterruptRequestPayloadSchema as s, string as st, localAgentInstallationOptionSchema as t, nullFactory as tt, openMeldDaemonSetLocalAgentEnabledPayloadSchema as u, union as ut, bootstrapTemplateFactsSchema as v, profileKindSchema as vt, formatLocalSetupActionLabel as w, finiteIntegerNumber as wt, formatLocalComponentsSummaryDescription as x, profileWorkingDirectorySchema as xt, conversationExecutionStateSchema as y, profileLabelSchema as yt, openMeldToolsUpdateOperationSchema as z };
+
+//# sourceMappingURL=control-plane-D9jDcbMZ.js.map