openmeld 0.3.42

package/dist/base-url-Bdqmyw0D.js

@@ -0,0 +1,2327 @@
+#!/usr/bin/env node
+
+import "node:module";
+import { homedir } from "node:os";
+import { z } from "zod/v4";
+import { basename, dirname, join, normalize, parse, posix, resolve, win32 } from "node:path";
+import process$1 from "node:process";
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdir, open, readFile, readdir, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
+import { rmdirSync, unlinkSync } from "node:fs";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/agent-controller-conversation-capability.js
+const agentControllerConversationExternalImportCapabilitySchema = z.enum(["unsupported", "by_ref_id"]);
+const agentControllerConversationResumeCapabilitySchema = z.enum(["unsupported", "by_ref_id"]);
+const agentControllerConversationDiscoverCapabilitySchema = z.literal("unsupported");
+const agentControllerConversationTurnOverrideCapabilitySchema = z.enum([
+	"unsupported",
+	"stateless",
+	"persistent"
+]);
+z.strictObject({
+	discover: agentControllerConversationDiscoverCapabilitySchema,
+	externalImport: agentControllerConversationExternalImportCapabilitySchema,
+	resume: agentControllerConversationResumeCapabilitySchema,
+	turnOverride: agentControllerConversationTurnOverrideCapabilitySchema
+});
+const BUILTIN_AGENT_CONTROLLER_CONVERSATION_CAPABILITY_BY_CONTROLLER_ID = {
+	codex: {
+		discover: "unsupported",
+		externalImport: "by_ref_id",
+		resume: "by_ref_id",
+		turnOverride: "unsupported"
+	},
+	"claude-code": {
+		discover: "unsupported",
+		externalImport: "by_ref_id",
+		resume: "by_ref_id",
+		turnOverride: "unsupported"
+	},
+	cursor: {
+		discover: "unsupported",
+		externalImport: "by_ref_id",
+		resume: "by_ref_id",
+		turnOverride: "unsupported"
+	},
+	opencode: {
+		discover: "unsupported",
+		externalImport: "unsupported",
+		resume: "by_ref_id",
+		turnOverride: "unsupported"
+	},
+	openclaw: {
+		discover: "unsupported",
+		externalImport: "unsupported",
+		resume: "by_ref_id",
+		turnOverride: "unsupported"
+	}
+};
+const resolveBuiltinAgentControllerConversationCapability = (builtinControllerId) => {
+	const capability = BUILTIN_AGENT_CONTROLLER_CONVERSATION_CAPABILITY_BY_CONTROLLER_ID[builtinControllerId];
+	return capability ? { ...capability } : null;
+};
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/agent-controller-ref.js
+const BUILTIN_AGENT_CONTROLLER_REF_PREFIX = "builtin:";
+const AGENT_CONTROLLER_REF_SEPARATOR = ":";
+const HOSTED_CENTER_AGENT_CONTROLLER_REF = "hosted:center-agent";
+const HOSTED_CENTER_AGENT_CONTROLLER_REF_ID = "center-agent";
+const agentControllerRefSchema = z.string().transform((value, context) => {
+	const parsed = parseAgentControllerRef(value);
+	if (!parsed) {
+		context.addIssue({
+			code: "custom",
+			message: "Agent Controller ref is invalid"
+		});
+		return z.NEVER;
+	}
+	return parsed.ref;
+});
+function normalizeOptionalText(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function normalizeBuiltinControllerId(agentControllerRef) {
+	const normalized = normalizeOptionalText(agentControllerRef);
+	if (!normalized) return null;
+	if (normalized.includes(":") && !normalized.startsWith(BUILTIN_AGENT_CONTROLLER_REF_PREFIX)) return null;
+	const builtinId = normalized.startsWith(BUILTIN_AGENT_CONTROLLER_REF_PREFIX) ? normalized.slice(8) : normalized;
+	if (builtinId.length === 0 || builtinId.includes(":")) return null;
+	return builtinId;
+}
+function normalizeKnownBuiltinAgentControllerId(agentControllerRef) {
+	const builtinId = normalizeBuiltinControllerId(agentControllerRef);
+	return builtinId && resolveBuiltinAgentControllerConversationCapability(builtinId) ? builtinId : null;
+}
+function normalizeBuiltinAgentControllerId(agentControllerRef) {
+	return normalizeBuiltinControllerId(agentControllerRef);
+}
+function parseAgentControllerRef(agentControllerRef) {
+	const normalized = normalizeOptionalText(agentControllerRef);
+	if (!normalized) return null;
+	if (normalized === "hosted:center-agent") return {
+		kind: HOSTED_CENTER_AGENT_CONTROLLER_REF,
+		id: HOSTED_CENTER_AGENT_CONTROLLER_REF_ID,
+		ref: HOSTED_CENTER_AGENT_CONTROLLER_REF
+	};
+	for (const kind of ["builtin", "custom"]) {
+		const prefix = `${kind}${AGENT_CONTROLLER_REF_SEPARATOR}`;
+		if (!normalized.startsWith(prefix)) continue;
+		const id = normalized.slice(prefix.length).trim();
+		if (id.length === 0 || id.includes(AGENT_CONTROLLER_REF_SEPARATOR)) return null;
+		return {
+			kind,
+			id,
+			ref: `${kind}${AGENT_CONTROLLER_REF_SEPARATOR}${id}`
+		};
+	}
+	return null;
+}
+function canonicalizeAgentControllerRef(agentControllerRef) {
+	return parseAgentControllerRef(agentControllerRef)?.ref ?? null;
+}
+function buildAgentControllerRoutingKey(agentControllerRef) {
+	return canonicalizeAgentControllerRef(agentControllerRef);
+}
+function canonicalizeBuiltinAgentControllerRef(agentControllerRef) {
+	const builtinId = normalizeBuiltinControllerId(agentControllerRef);
+	return builtinId ? `${BUILTIN_AGENT_CONTROLLER_REF_PREFIX}${builtinId}` : null;
+}
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/conversation-contract.js
+const agentControllerConversationKindSchema = z.enum([
+	"session",
+	"thread",
+	"context"
+]);
+const trimmedNonEmptyStringSchema = z.string().trim().min(1);
+const agentControllerConversationRefSchema = z.strictObject({
+	agentControllerRef: trimmedNonEmptyStringSchema,
+	agentControllerConversationKind: agentControllerConversationKindSchema,
+	agentControllerConversationId: trimmedNonEmptyStringSchema
+});
+const conversationPolicySchema = z.strictObject({
+	collaborationMode: z.enum(["default", "plan"]).optional(),
+	fallbackModel: z.string().min(1).optional(),
+	model: z.string().min(1).optional(),
+	reasoningLevel: z.string().min(1).optional()
+});
+const BUILTIN_AGENT_CONTROLLER_CONVERSATION_KIND_BY_CONTROLLER_ID = {
+	codex: "thread",
+	"claude-code": "session",
+	cursor: "session",
+	openclaw: "session",
+	opencode: "session"
+};
+const resolveBuiltinAgentControllerConversationKind = (agentControllerRef) => {
+	const canonical = canonicalizeBuiltinAgentControllerRef(agentControllerRef);
+	if (!canonical) return null;
+	const builtinControllerId = canonical.slice(8);
+	return BUILTIN_AGENT_CONTROLLER_CONVERSATION_KIND_BY_CONTROLLER_ID[builtinControllerId] ?? null;
+};
+const buildAgentControllerConversationRef = (input) => ({
+	agentControllerRef: input.agentControllerRef,
+	agentControllerConversationKind: input.agentControllerConversationKind,
+	agentControllerConversationId: input.agentControllerConversationId
+});
+//#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/controller-contract.js
+const LEGACY_RUNTIME_DISPATCH_POLICY = "mention_only";
+const runtimeDispatchPolicySchema = z.enum([LEGACY_RUNTIME_DISPATCH_POLICY, "listen_all"]);
+const runtimeTransportModeSchema = z.enum([
+	"local-cli",
+	"codex-app-server",
+	"acp"
+]);
+const runtimeStreamingModeSchema = z.enum(["final", "stream"]);
+const runtimeAgentControllerConversationIdMappingSpecSchema = z.strictObject({
+	sourceField: z.string().min(1),
+	mappingVersion: z.number().int().min(1)
+});
+const runtimeAgentExecutableLaunchContractSchema = z.strictObject({
+	kind: z.literal("executable"),
+	commandPath: z.string().min(1),
+	argsPrefix: z.array(z.string().min(1)).optional()
+});
+const runtimeAgentNodeScriptLaunchContractSchema = z.strictObject({
+	kind: z.literal("node_script"),
+	nodePath: z.string().min(1),
+	scriptPath: z.string().min(1),
+	argsPrefix: z.array(z.string().min(1)).optional()
+});
+const runtimeAgentControllerLaunchContractSchema = z.discriminatedUnion("kind", [runtimeAgentExecutableLaunchContractSchema, runtimeAgentNodeScriptLaunchContractSchema]);
+z.strictObject({
+	installId: z.string().min(1),
+	label: z.string().min(1),
+	detail: z.string().min(1),
+	commandPath: z.string().min(1),
+	launchContract: runtimeAgentControllerLaunchContractSchema
+});
+const runtimeAgentControllerSettingsSchema = z.strictObject({
+	dispatch_policy: runtimeDispatchPolicySchema.default(LEGACY_RUNTIME_DISPATCH_POLICY),
+	transport_mode: runtimeTransportModeSchema,
+	streaming_mode: runtimeStreamingModeSchema.default("final"),
+	timeout_ms: z.number().int().positive().nullable().default(null),
+	retry: z.number().int().min(0).default(0),
+	context_id_mapping_spec: runtimeAgentControllerConversationIdMappingSpecSchema
+});
+z.strictObject({
+	agentControllerConversationId: z.string().min(1).nullable(),
+	agentControllerConversation: agentControllerConversationRefSchema.nullable().optional(),
+	sourceField: z.string().min(1),
+	mappingVersion: z.number().int().min(1)
+});
+//#endregion
+//#region ../../packages/schemas/dist/schemas/local-machine/recovery.js
+const localMachineIssueCodeSchema = z.enum([
+	"local_machine.storage.exhausted",
+	"local_machine.storage.not_writable",
+	"local_machine.permission.denied",
+	"local_machine.resources.exhausted",
+	"local_machine.background_execution.blocked",
+	"local_machine.concurrency.active",
+	"local_machine.concurrency.orphaned",
+	"local_machine.failure.unknown"
+]);
+const localMachineOperationSchema = z.enum([
+	"create_lock",
+	"read_local_state",
+	"write_local_state",
+	"start_background_service",
+	"start_process",
+	"unknown"
+]);
+const localMachineRecoveryPolicySchema = z.enum([
+	"automatic",
+	"retry_with_backoff",
+	"user_action",
+	"diagnostics"
+]);
+const LOCAL_MACHINE_RECOVERY_POLICY_BY_CODE = {
+	"local_machine.storage.exhausted": "user_action",
+	"local_machine.storage.not_writable": "user_action",
+	"local_machine.permission.denied": "user_action",
+	"local_machine.resources.exhausted": "user_action",
+	"local_machine.background_execution.blocked": "user_action",
+	"local_machine.concurrency.active": "user_action",
+	"local_machine.concurrency.orphaned": "user_action",
+	"local_machine.failure.unknown": "diagnostics"
+};
+function resolveLocalMachineRecoveryPolicy(code) {
+	if (!Object.hasOwn(LOCAL_MACHINE_RECOVERY_POLICY_BY_CODE, code)) return null;
+	return LOCAL_MACHINE_RECOVERY_POLICY_BY_CODE[code];
+}
+const localMachineUserMessageSchema = z.string().trim().min(1).max(512);
+const localMachineDiagnosticTextSchema = z.string().trim().min(1).max(2048);
+const localMachineAgentMessageSchema = z.string().trim().min(1).max(1025);
+function formatLocalMachineIssueMessage(issue) {
+	return issue.primaryAction ? `${issue.summary} ${issue.primaryAction}` : issue.summary;
+}
+const localMachineIssueSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	code: localMachineIssueCodeSchema,
+	operation: localMachineOperationSchema,
+	recoveryPolicy: localMachineRecoveryPolicySchema,
+	summary: localMachineUserMessageSchema,
+	primaryAction: z.union([localMachineUserMessageSchema, z.null()]),
+	diagnostics: z.strictObject({
+		systemCode: z.union([z.string().trim().min(1).max(64), z.null()]),
+		detail: z.union([localMachineDiagnosticTextSchema, z.null()])
+	})
+}).superRefine((value, context) => {
+	const expectedPolicy = resolveLocalMachineRecoveryPolicy(value.code);
+	if (value.recoveryPolicy !== expectedPolicy) context.addIssue({
+		code: "custom",
+		message: `recovery policy must be ${expectedPolicy} for ${value.code}`,
+		path: ["recoveryPolicy"]
+	});
+});
+z.strictObject({
+	type: z.literal("error"),
+	code: localMachineIssueCodeSchema,
+	message: localMachineAgentMessageSchema,
+	requestId: z.string().trim().min(1).max(256).optional(),
+	payload: z.strictObject({ localMachineIssue: localMachineIssueSchema })
+}).superRefine((value, context) => {
+	if (value.code !== value.payload.localMachineIssue.code) context.addIssue({
+		code: "custom",
+		message: "agent event code must match local machine issue code",
+		path: ["code"]
+	});
+	const expectedMessage = formatLocalMachineIssueMessage(value.payload.localMachineIssue);
+	if (value.message !== expectedMessage) context.addIssue({
+		code: "custom",
+		message: "agent event message must match local machine issue copy",
+		path: ["message"]
+	});
+});
+//#endregion
+//#region src/config/paths.ts
+const MAX_ACCOUNT_PATH_SEGMENT_LENGTH = 128;
+const OPAQUE_CACHE_PATH_SEGMENT_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/u;
+const FALLBACK_ACCOUNT_HOST_KEY = "unauthenticated";
+const FALLBACK_ACCOUNT_USER_KEY = "local";
+const OPENMELD_HOME_ENV_KEY = "OPENMELD_HOME";
+const OPENMELD_ENV_PRESET_ENV_KEY = "OPENMELD_ENV_PRESET";
+const DEFAULT_OPENMELD_ENV_PRESET = "prod";
+const OPENMELD_DEFAULT_HOME_DIR_BY_PRESET = {
+	prod: ".openmeld",
+	"dev-local": ".openmeld-dev",
+	canary: ".openmeld-canary"
+};
+const OPENMELD_ENV_PRESET_BY_ENTRY_NAME = {
+	openmeld: "prod",
+	"openmeld-dev": "dev-local",
+	"openmeld-canary": "canary"
+};
+function normalizeOpenMeldProfileId(value) {
+	const raw = String(value ?? "").trim();
+	if (raw.length === 0) throw new Error("openMeldProfileId is required");
+	const safe = raw.replace(/[^a-zA-Z0-9._-]+/g, "_").toLowerCase();
+	if (!safe || safe === "." || safe === "..") throw new Error("openMeldProfileId is invalid");
+	if (safe.length > MAX_ACCOUNT_PATH_SEGMENT_LENGTH) throw new Error("openMeldProfileId is too long");
+	return safe;
+}
+function resolveOpenMeldEnvPreset(input = {}) {
+	const fromEnv = normalizeOpenMeldEnvPreset((input.env ?? process.env)[OPENMELD_ENV_PRESET_ENV_KEY]);
+	if (fromEnv) return fromEnv;
+	return resolveOpenMeldEnvPresetFromArgv(input.argv ?? process.argv);
+}
+function resolveExplicitOpenMeldEnvPreset(input = {}) {
+	return normalizeOpenMeldEnvPreset((input.env ?? process.env)[OPENMELD_ENV_PRESET_ENV_KEY]);
+}
+function resolveDefaultOpenMeldHomeDirname(preset) {
+	return OPENMELD_DEFAULT_HOME_DIR_BY_PRESET[preset];
+}
+function resolveOpenMeldRootDir(input = {}) {
+	const env = input.env ?? process.env;
+	const fromEnv = String(env["OPENMELD_HOME"] ?? "").trim();
+	if (fromEnv) return fromEnv;
+	const preset = resolveOpenMeldEnvPreset(input);
+	return join(resolveHomeDirectory(input), resolveDefaultOpenMeldHomeDirname(preset));
+}
+/**
+* OS-level resources are shared by every process using the same environment
+* preset, even when a command uses an isolated OPENMELD_HOME. Their local
+* coordination files therefore live under the preset's canonical home.
+*/
+function resolveOpenMeldPresetOwnedPathInput(input = {}) {
+	const env = { ...input.env ?? process.env };
+	delete env[OPENMELD_HOME_ENV_KEY];
+	return {
+		...input,
+		env
+	};
+}
+function openMeldRootDir() {
+	return resolveOpenMeldRootDir();
+}
+/**
+* Whether the effective OpenMeld home is the published `~/.openmeld` user lane.
+* Lane-specific homes (`openmeld-dev`, `openmeld-canary`, isolated dev lanes,
+* and other `OPENMELD_HOME` overrides) resolve elsewhere and must not manage
+* shared real-user state that the published lane owns.
+*/
+function isPublishedOpenMeldHome(input = {}) {
+	const publishedRootDir = join(resolveHomeDirectory(input), OPENMELD_DEFAULT_HOME_DIR_BY_PRESET.prod);
+	return resolve(resolveOpenMeldRootDir(input)) === resolve(publishedRootDir);
+}
+function openMeldBackupsDir() {
+	const root = openMeldRootDir();
+	return join(dirname(root), `${basename(root)}-backups`);
+}
+function openMeldVersionsDir(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "versions");
+}
+function openMeldManagedVersionDir(version, input = {}) {
+	return join(openMeldVersionsDir(input), normalizePathSegment(version, "unknown"));
+}
+function openMeldManagedVersionBinaryPath(version, input = {}) {
+	return join(openMeldManagedVersionDir(version, input), "openmeld");
+}
+function openMeldBinDir(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "bin");
+}
+function openMeldManagedBinaryPath(input = {}) {
+	return join(openMeldBinDir(input), "openmeld");
+}
+function accountsDir() {
+	return join(openMeldRootDir(), "accounts");
+}
+function deviceDir(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "device");
+}
+function deviceSkillsDir(input = {}) {
+	return join(deviceDir(input), "skills");
+}
+function devicePreferencesPath(input = {}) {
+	return join(deviceDir(input), "preferences.json");
+}
+function deviceAgentRuntimePath(input = {}) {
+	return join(deviceDir(input), "agent-runtime.json");
+}
+function deviceProvidersDir(input = {}) {
+	return join(deviceDir(input), "providers");
+}
+function deviceProviderDir(providerId, input = {}) {
+	return join(deviceProvidersDir(input), normalizePathSegment(providerId, "unknown"));
+}
+function deviceProviderProfilesDir(providerId, input = {}) {
+	return join(deviceProviderDir(providerId, input), "profiles");
+}
+function deviceProviderProfileDir(providerId, profileId, input = {}) {
+	return join(deviceProviderProfilesDir(providerId, input), normalizePathSegment(profileId, "unknown"));
+}
+function deviceOpenClawProfileDir(profileId, input = {}) {
+	return deviceProviderProfileDir("openclaw", profileId, input);
+}
+function deviceOpenClawProfileWorkspaceDir(profileId, input = {}) {
+	return join(deviceOpenClawProfileDir(profileId, input), "workspace");
+}
+function deviceOpenClawProfileBootstrapPath(profileId, input = {}) {
+	return join(deviceOpenClawProfileDir(profileId, input), "bootstrap.json");
+}
+function deviceSkillsStorePath(input = {}) {
+	return join(deviceSkillsDir(input), "store.json");
+}
+function deviceSkillsCustomTargetsPath(input = {}) {
+	return join(deviceSkillsDir(input), "custom-targets.json");
+}
+function deviceSkillsInstallsPath(input = {}) {
+	return join(deviceSkillsDir(input), "installs.json");
+}
+function legacyRuntimeConfigPath(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "config.json");
+}
+function normalizeAccountHostKey(value) {
+	return normalizePathSegment(value, FALLBACK_ACCOUNT_HOST_KEY);
+}
+function normalizeAccountUserKey(value) {
+	return normalizePathSegment(value, FALLBACK_ACCOUNT_USER_KEY);
+}
+function normalizeAccountKey(input) {
+	return {
+		hostKey: normalizeAccountHostKey(input.hostKey),
+		userKey: normalizeAccountUserKey(input.userKey)
+	};
+}
+function accountDir(account) {
+	const normalized = normalizeAccountKey(account);
+	return join(accountsDir(), normalized.hostKey, normalized.userKey);
+}
+function accountProfilesDir(account) {
+	return join(accountDir(account), "profiles");
+}
+function accountProfileDir(account, openMeldProfileId) {
+	return join(accountProfilesDir(account), normalizeOpenMeldProfileId(openMeldProfileId));
+}
+function accountProfileViewPath(account, openMeldProfileId) {
+	return join(accountProfileDir(account, openMeldProfileId), "view.json");
+}
+function accountProfileLocalMetaPath(account, openMeldProfileId) {
+	return join(accountProfileDir(account, openMeldProfileId), "local-meta.json");
+}
+function accountProfileWorkspacePath(account, openMeldProfileId) {
+	return join(accountProfileDir(account, openMeldProfileId), "workspace");
+}
+function accountProfileSpaceCacheDir(account, openMeldProfileId) {
+	return join(accountProfileDir(account, openMeldProfileId), "space-cache");
+}
+function legacyAccountProfileSpacesDir(account, openMeldProfileId) {
+	return join(accountProfileDir(account, openMeldProfileId), "spaces");
+}
+function profileDir(openMeldProfileId) {
+	return join(openMeldRootDir(), "profiles", openMeldProfileId);
+}
+function runtimeDir(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "runtime");
+}
+function runtimeLogsDir() {
+	return join(runtimeDir(), "logs");
+}
+function sessionsDir() {
+	return join(runtimeDir(), "sessions");
+}
+function systemDir(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "system");
+}
+function skillsDir() {
+	return join(openMeldRootDir(), "skills");
+}
+function organizationSkillsDir(input = {}) {
+	return join(resolveOpenMeldRootDir(input), "organization-skills");
+}
+function organizationSkillReleaseDir(organizationId, skillId, releaseId, input = {}) {
+	return join(organizationSkillsDir(input), requireOpaqueCachePathSegment(organizationId, "organizationId"), requireOpaqueCachePathSegment(skillId, "skillId"), requireOpaqueCachePathSegment(releaseId, "releaseId"));
+}
+function spacesDir(openMeldProfileId) {
+	return join(profileDir(openMeldProfileId), "spaces");
+}
+function locksDir(openMeldProfileId, input = {}) {
+	return join(runtimeDir(input), "locks", openMeldProfileId);
+}
+function profileViewPath(openMeldProfileId) {
+	return join(profileDir(openMeldProfileId), "view.json");
+}
+function normalizePathSegment(value, fallback) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	if (!normalized) return fallback;
+	const safe = normalized.replace(/[^a-z0-9._-]+/g, "_");
+	if (!safe) return fallback;
+	if (safe === "." || safe === "..") return fallback;
+	return safe.slice(0, MAX_ACCOUNT_PATH_SEGMENT_LENGTH);
+}
+function requireOpaqueCachePathSegment(value, label) {
+	const normalized = String(value ?? "").trim();
+	if (normalized.length === 0 || normalized.length > 256 || normalized === "." || normalized === ".." || !OPAQUE_CACHE_PATH_SEGMENT_RE.test(normalized)) throw new Error(`${label} is not safe for the Organization Skills cache`);
+	return normalized;
+}
+function resolveOpenMeldEnvPresetFromArgv(argv) {
+	return resolveKnownOpenMeldEnvPresetFromArgv(argv) ?? DEFAULT_OPENMELD_ENV_PRESET;
+}
+function resolveKnownOpenMeldEnvPresetFromArgv(argv) {
+	const entryName = resolveOpenMeldCliEntryNameFromArgv(argv);
+	if (!entryName) return null;
+	return OPENMELD_ENV_PRESET_BY_ENTRY_NAME[entryName] ?? null;
+}
+function resolveOpenMeldCliEntryNameFromArgv(argv) {
+	return resolveCliEntryName(argv[1]);
+}
+function resolveCliEntryName(value) {
+	const raw = String(value ?? "").trim();
+	if (!raw) return null;
+	const normalizedName = parse(raw).name.trim().toLowerCase();
+	if (!normalizedName) return null;
+	if (!isOpenMeldCliEntryName(normalizedName)) return null;
+	return normalizedName;
+}
+function isOpenMeldCliEntryName(value) {
+	return value in OPENMELD_ENV_PRESET_BY_ENTRY_NAME;
+}
+function normalizeOpenMeldEnvPreset(value) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	if (normalized === "prod" || normalized === "dev-local" || normalized === "canary") return normalized;
+	return null;
+}
+function resolveHomeDirectory(input) {
+	if (input.homeDir) return input.homeDir;
+	const env = input.env ?? process.env;
+	const fromEnv = String(env.HOME ?? "").trim();
+	if (fromEnv) return fromEnv;
+	return homedir();
+}
+//#endregion
+//#region src/system/local-machine-recovery/index.ts
+var LocalMachineFailureError = class extends Error {
+	code;
+	issue;
+	constructor(input) {
+		super(formatLocalMachineIssueMessage(input.issue), { cause: input.cause });
+		this.name = "LocalMachineFailureError";
+		this.code = input.issue.code;
+		this.issue = input.issue;
+	}
+};
+function isLocalMachineFailureError(error) {
+	return error instanceof LocalMachineFailureError;
+}
+function toRecognizedLocalMachineFailureError(input) {
+	if (isLocalMachineFailureError(input.error)) return input.error;
+	const issue = assessLocalMachineFailure(input);
+	return issue.code === "local_machine.failure.unknown" ? null : new LocalMachineFailureError({
+		issue,
+		cause: input.error
+	});
+}
+function assessLocalMachineFailure(input) {
+	const systemCode = readSystemErrorCode(input.error);
+	const detail = readErrorMessage(input.error);
+	if (systemCode === "ENOSPC" || systemCode === "EDQUOT") return {
+		schemaVersion: 1,
+		code: "local_machine.storage.exhausted",
+		operation: input.operation,
+		recoveryPolicy: "user_action",
+		summary: "Your computer is out of storage space. OpenMeld can't save the local files it needs.",
+		primaryAction: "Free up storage, then try again.",
+		diagnostics: {
+			systemCode,
+			detail
+		}
+	};
+	if (systemCode === "EROFS" || (input.operation === "create_lock" || input.operation === "write_local_state") && (systemCode === "EACCES" || systemCode === "EPERM")) return {
+		schemaVersion: 1,
+		code: "local_machine.storage.not_writable",
+		operation: input.operation,
+		recoveryPolicy: "user_action",
+		summary: "OpenMeld can't write to its local data folder.",
+		primaryAction: "Make sure the folder is writable, then try again.",
+		diagnostics: {
+			systemCode,
+			detail
+		}
+	};
+	if (systemCode === "EACCES" || systemCode === "EPERM" || systemCode === "EROFS") return {
+		schemaVersion: 1,
+		code: "local_machine.permission.denied",
+		operation: input.operation,
+		recoveryPolicy: "user_action",
+		summary: "OpenMeld doesn't have permission to complete local setup on this computer.",
+		primaryAction: "Allow OpenMeld to access its local files and background services, then try again.",
+		diagnostics: {
+			systemCode,
+			detail
+		}
+	};
+	if (systemCode === "EMFILE" || systemCode === "ENFILE" || systemCode === "ENOMEM") return {
+		schemaVersion: 1,
+		code: "local_machine.resources.exhausted",
+		operation: input.operation,
+		recoveryPolicy: "user_action",
+		summary: "Your computer doesn't have enough available system resources for OpenMeld to continue.",
+		primaryAction: "Restart your computer, then try again.",
+		diagnostics: {
+			systemCode,
+			detail
+		}
+	};
+	return {
+		schemaVersion: 1,
+		code: "local_machine.failure.unknown",
+		operation: input.operation,
+		recoveryPolicy: "diagnostics",
+		summary: "OpenMeld couldn't complete a required action on this computer.",
+		primaryAction: "Try again. If it still fails, open diagnostics.",
+		diagnostics: {
+			systemCode,
+			detail
+		}
+	};
+}
+function createBackgroundExecutionBlockedIssue(input) {
+	return {
+		schemaVersion: 1,
+		code: "local_machine.background_execution.blocked",
+		operation: "start_background_service",
+		recoveryPolicy: "user_action",
+		summary: "macOS blocked OpenMeld Service from running in the background.",
+		primaryAction: "Open System Settings > General > Login Items & Extensions, enable OpenMeld, then try again.",
+		diagnostics: {
+			systemCode: "BACKGROUND_EXECUTION_BLOCKED",
+			detail: input.detail?.trim().slice(0, 2048) || null
+		}
+	};
+}
+function createActiveSetupConcurrencyIssue(input) {
+	return {
+		schemaVersion: 1,
+		code: "local_machine.concurrency.active",
+		operation: "create_lock",
+		recoveryPolicy: "user_action",
+		summary: "Another OpenMeld setup is already running on this computer.",
+		primaryAction: input.primaryAction,
+		diagnostics: {
+			systemCode: "OPENMELD_LOCK_ACTIVE",
+			detail: input.detail?.trim().slice(0, 2048) || null
+		}
+	};
+}
+function createOrphanedSetupConcurrencyIssue(input) {
+	return createOrphanedLocalConcurrencyIssue({
+		...input,
+		summary: "OpenMeld found a setup lock left by an older version."
+	});
+}
+function createOrphanedLocalConcurrencyIssue(input) {
+	return {
+		schemaVersion: 1,
+		code: "local_machine.concurrency.orphaned",
+		operation: "create_lock",
+		recoveryPolicy: "user_action",
+		summary: input.summary,
+		primaryAction: input.primaryAction,
+		diagnostics: {
+			systemCode: "OPENMELD_LOCK_ORPHANED",
+			detail: input.detail?.trim().slice(0, 2048) || null
+		}
+	};
+}
+function readSystemErrorCode(error) {
+	if (!error || typeof error !== "object") return null;
+	const code = error.code;
+	return typeof code === "string" && code.trim().length > 0 ? code : null;
+}
+function readErrorMessage(error) {
+	if (error instanceof Error && error.message.trim().length > 0) return error.message.trim().slice(0, 2048);
+	if (typeof error === "string" && error.trim().length > 0) return error.trim().slice(0, 2048);
+	return null;
+}
+//#endregion
+//#region src/config/openmeld-lane-descriptor.ts
+function resolveOpenMeldLaneDescriptor(input) {
+	const env = input?.env ?? process.env;
+	const preset = resolveOpenMeldEnvPreset({
+		argv: input?.argv,
+		env,
+		homeDir: input?.homeDir
+	});
+	const command = resolveLaneCommand(preset);
+	return {
+		command,
+		preset,
+		openMeldHome: resolveOpenMeldRootDir({
+			argv: input?.argv,
+			env,
+			homeDir: input?.homeDir
+		}),
+		destructiveResetAllowed: true,
+		repairCommand: `${command} repair local-state`,
+		removeCommand: preset === "canary" ? "pnpm openmeld:canary:remove" : null,
+		resetCommand: `${command} reset --yes`
+	};
+}
+function formatLaneScopeSentence(lane) {
+	return `This only affects the ${lane.command} lane at ${lane.openMeldHome}.`;
+}
+function resolveLaneCommand(preset) {
+	if (preset === "dev-local") return "openmeld-dev";
+	if (preset === "canary") return "openmeld-canary";
+	return "openmeld";
+}
+//#endregion
+//#region src/config/session-profile.ts
+const OPENMELD_CLI_CONTEXT_ENV_KEY = "OPENMELD_CLI_CONTEXT_ID";
+const LEGACY_OPENMELD_AGENT_SESSION_ENV_KEY = "OPENMELD_AGENT_SESSION_ID";
+const CLI_CONTEXT_ENV_KEYS = [OPENMELD_CLI_CONTEXT_ENV_KEY, LEGACY_OPENMELD_AGENT_SESSION_ENV_KEY];
+const SESSION_FILE_MAX_LENGTH = 128;
+const SESSION_FILE_HASH_LENGTH = 8;
+function resolveCliContext(profileIdInput) {
+	const explicit = normalizeSessionId(profileIdInput);
+	if (explicit) return {
+		cliContextId: explicit,
+		source: "manual"
+	};
+	for (const key of CLI_CONTEXT_ENV_KEYS) {
+		const sessionId = normalizeSessionId(process.env[key]);
+		if (sessionId) return {
+			cliContextId: sessionId,
+			source: `environment:${key}`
+		};
+	}
+	return resolveTerminalSessionId();
+}
+function resolveCliContextId(profileIdInput) {
+	return resolveCliContext(profileIdInput)?.cliContextId ?? null;
+}
+function normalizeSessionSource(raw) {
+	const value = String(raw ?? "").trim();
+	if (!value) return null;
+	return value;
+}
+async function readCliContextState(input) {
+	const cliContextId = resolveSessionStateId(input?.sessionId);
+	if (!cliContextId) return null;
+	const raw = await readFile(cliContextStatePath(cliContextId), "utf8").catch(() => null);
+	if (!raw) return null;
+	return parseCliContextState(raw);
+}
+async function listCliContextStates() {
+	const entryNames = await readdir(sessionsDir()).catch(() => []);
+	const states = [];
+	for (const entryName of entryNames) {
+		if (!entryName.endsWith(".json")) continue;
+		const raw = await readFile(join(sessionsDir(), entryName), "utf8").catch(() => null);
+		if (!raw) continue;
+		const parsed = parseCliContextState(raw);
+		if (!parsed) continue;
+		states.push(parsed);
+	}
+	return states.sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+}
+async function writeCliContextState(input) {
+	const cliContext = resolveCliContextStateInput(input) ?? resolveCliContext();
+	if (!cliContext) return false;
+	await mkdir(sessionsDir(), { recursive: true });
+	const existing = await readCliContextState({ sessionId: cliContext.cliContextId });
+	const nextOpenMeldProfileId = resolveNextSessionOpenMeldProfileId(existing, input);
+	const nextSelectedOpenMeldProfileId = resolveNextSelectedOpenMeldProfileId(existing, input);
+	const outputPath = cliContextStatePath(cliContext.cliContextId);
+	if (!(nextOpenMeldProfileId || nextSelectedOpenMeldProfileId)) {
+		await rm(outputPath, { force: true });
+		return true;
+	}
+	await writeCliContextStateFile(outputPath, {
+		v: 1,
+		sessionId: cliContext.cliContextId,
+		cliContextSource: cliContext.source ?? existing?.cliContextSource ?? "manual",
+		...nextOpenMeldProfileId ? { openMeldProfileId: nextOpenMeldProfileId } : {},
+		...nextSelectedOpenMeldProfileId ? { selectedOpenMeldProfileId: nextSelectedOpenMeldProfileId } : {},
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return true;
+}
+function cliContextStatePath(sessionId) {
+	return join(sessionsDir(), `${toSafeSessionFile(sessionId)}.json`);
+}
+function toSafeSessionFile(value) {
+	const hash = createHash("sha1").update(value, "utf8").digest("hex").slice(0, SESSION_FILE_HASH_LENGTH);
+	const safeBaseRaw = value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	const safeBase = safeBaseRaw.length > 0 ? safeBaseRaw : "session";
+	const maxBaseLength = Math.max(1, SESSION_FILE_MAX_LENGTH - SESSION_FILE_HASH_LENGTH - 1);
+	return `${safeBase.slice(0, maxBaseLength)}-${hash}`;
+}
+function resolveCliContextStateInput(input) {
+	const sessionId = normalizeSessionId(input.sessionId);
+	if (!sessionId) return null;
+	return {
+		cliContextId: sessionId,
+		source: normalizeSessionSource(input.sessionSource) ?? "manual"
+	};
+}
+function resolveSessionStateId(sessionId) {
+	const explicit = normalizeSessionId(sessionId);
+	if (explicit) return explicit;
+	return resolveCliContext()?.cliContextId ?? null;
+}
+function parseCliContextState(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (parsed.v !== 1) return null;
+	const sessionId = normalizeSessionId(parsed.sessionId);
+	if (!sessionId) return null;
+	const openMeldProfileId = resolveStoredSessionOpenMeldProfileId(parsed);
+	const selectedOpenMeldProfileId = resolveStoredSelectedOpenMeldProfileId(parsed);
+	if (!(openMeldProfileId || selectedOpenMeldProfileId)) return null;
+	const cliContextSource = normalizeSessionSource(parsed.cliContextSource);
+	return {
+		v: 1,
+		sessionId,
+		...cliContextSource ? { cliContextSource } : {},
+		...openMeldProfileId ? { openMeldProfileId } : {},
+		...selectedOpenMeldProfileId ? { selectedOpenMeldProfileId } : {},
+		updatedAt: typeof parsed.updatedAt === "string" && parsed.updatedAt.trim().length > 0 ? parsed.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+	};
+}
+function resolveNextSessionOpenMeldProfileId(existing, input) {
+	if (!("openMeldProfileId" in input)) return existing?.openMeldProfileId;
+	return normalizeOptionalOpenMeldProfileId(input.openMeldProfileId) ?? void 0;
+}
+function resolveNextSelectedOpenMeldProfileId(existing, input) {
+	if (!("selectedOpenMeldProfileId" in input)) return existing?.selectedOpenMeldProfileId;
+	return normalizeOptionalOpenMeldProfileId(input.selectedOpenMeldProfileId) ?? void 0;
+}
+async function writeCliContextStateFile(outputPath, payload) {
+	const tempPath = `${outputPath}.tmp-${process.pid}-${Date.now()}`;
+	const file = await open(tempPath, "w");
+	let writeFailure = null;
+	try {
+		await file.writeFile(`${JSON.stringify(payload, null, 2)}\n`, "utf8");
+		await file.sync();
+	} catch (error) {
+		writeFailure = error;
+	}
+	try {
+		await file.close();
+	} catch (error) {
+		if (!writeFailure) writeFailure = error;
+	}
+	if (writeFailure) {
+		await rm(tempPath, { force: true }).catch(() => void 0);
+		throw writeFailure;
+	}
+	try {
+		await rename(tempPath, outputPath);
+	} catch (error) {
+		await rm(tempPath, { force: true }).catch(() => void 0);
+		throw error;
+	}
+}
+function normalizeSessionId(value) {
+	const raw = String(value ?? "").trim();
+	if (!raw) return null;
+	return raw.slice(0, 256);
+}
+function resolveTerminalSessionId() {
+	if (!(process.stdin.isTTY || process.stdout.isTTY)) return null;
+	const parentPid = Number(process.ppid);
+	if (!Number.isInteger(parentPid) || parentPid <= 1) return null;
+	return {
+		cliContextId: `terminal-ppid-${parentPid}`,
+		source: `terminal:ppid-${parentPid}`
+	};
+}
+function resolveStoredSessionOpenMeldProfileId(input) {
+	const openMeldProfileId = normalizeOptionalOpenMeldProfileId(input.openMeldProfileId);
+	const legacyProfile = normalizeOptionalOpenMeldProfileId(input.profile);
+	if (openMeldProfileId && legacyProfile && openMeldProfileId !== legacyProfile) throw new Error(`conflicting stored OpenMeld profile identity: openMeldProfileId=${openMeldProfileId}, profile=${legacyProfile}. Remove or reconcile the legacy profile field so it matches openMeldProfileId.`);
+	return openMeldProfileId ?? legacyProfile;
+}
+function resolveStoredSelectedOpenMeldProfileId(input) {
+	return normalizeOptionalOpenMeldProfileId(input.selectedOpenMeldProfileId);
+}
+function normalizeOptionalOpenMeldProfileId(value) {
+	if (typeof value !== "string") return null;
+	try {
+		return normalizeOpenMeldProfileId(value);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/config/lock.ts
+const MALFORMED_LOCK_RECOVERY_GRACE_MS = 3e4;
+const OPENMELD_ORPHANED_LOCK_SUMMARY = "OpenMeld found a local command lock left by an older version.";
+var OpenMeldLockError = class extends Error {
+	code = "openmeld.locked";
+	lockPath;
+	lockKey;
+	metaRaw;
+	meta;
+	contentionState;
+	constructor(input) {
+		const normalizedMetaRaw = normalizeMetaRaw(input.metaRaw);
+		const contentionState = input.contentionState ?? "unknown";
+		super(buildOpenMeldLockErrorMessage(input.path, normalizedMetaRaw, contentionState));
+		this.name = "OpenMeldLockError";
+		this.lockPath = input.path;
+		this.lockKey = input.key;
+		this.metaRaw = normalizedMetaRaw;
+		this.meta = parseOpenMeldLockMeta(normalizedMetaRaw);
+		this.contentionState = contentionState;
+	}
+};
+function isOpenMeldLockError(error) {
+	return error instanceof OpenMeldLockError;
+}
+function isOpenMeldOrphanedLockError(error) {
+	return isOpenMeldLockError(error) && error.contentionState === "orphaned";
+}
+function resolveOpenMeldOrphanedLockIssue(error) {
+	if (!isOpenMeldOrphanedLockError(error)) return null;
+	return createOrphanedLocalConcurrencyIssue({
+		summary: OPENMELD_ORPHANED_LOCK_SUMMARY,
+		primaryAction: buildOpenMeldOrphanedLockAction(),
+		detail: error.message
+	});
+}
+function buildOpenMeldOrphanedLockAction() {
+	return `Close any other OpenMeld commands, then run \`${resolveOpenMeldLaneDescriptor().repairCommand}\` and try again.`;
+}
+async function acquireLock(input) {
+	const openMeldProfileId = normalizeOpenMeldProfileId(input.openMeldProfileId);
+	const sessionId = resolveCliContextId();
+	const dir = locksDir(openMeldProfileId, input.pathResolution);
+	const path = resolveLockPath({
+		openMeldProfileId,
+		key: input.key,
+		pathResolution: input.pathResolution
+	});
+	const ownerId = randomUUID();
+	try {
+		await mkdir(dir, { recursive: true });
+	} catch (error) {
+		throwRecognizedLocalMachineFailure({
+			operation: "create_lock",
+			error
+		});
+	}
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const contents = `${JSON.stringify({
+			...input.meta ? { ...input.meta } : {},
+			pid: process$1.pid,
+			openMeldProfileId,
+			...sessionId ? { sessionId } : {},
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			ownerId
+		})}\n`;
+		let published;
+		try {
+			published = await tryPublishLock(path, ownerId, contents);
+		} catch (error) {
+			throwRecognizedLocalMachineFailure({
+				operation: "create_lock",
+				error
+			});
+		}
+		if (published) return {
+			ownerId,
+			path
+		};
+		try {
+			const existingLock = await readLockSnapshot(path);
+			if (!existingLock.exists || await tryCleanupStaleLockPath(path, existingLock)) continue;
+			throw new OpenMeldLockError({
+				path,
+				key: input.key,
+				metaRaw: existingLock.metaRaw ?? void 0,
+				contentionState: resolveLockContentionState(existingLock)
+			});
+		} catch (error) {
+			if (isOpenMeldLockError(error)) throw error;
+			throwRecognizedLocalMachineFailure({
+				operation: "create_lock",
+				error
+			});
+		}
+	}
+	throw new OpenMeldLockError({
+		path,
+		key: input.key
+	});
+}
+async function releaseLock(lock) {
+	if (!await unlinkOwnedDirectoryEntry(lock)) return;
+	await rmdir(lock.path);
+}
+function releaseLockSync(lock) {
+	try {
+		unlinkSync(resolveOwnerEntryPath(lock.path, lock.ownerId));
+	} catch (error) {
+		if (getErrorCode(error) === "ENOENT" || getErrorCode(error) === "ENOTDIR") return;
+		throw error;
+	}
+	try {
+		rmdirSync(lock.path);
+	} catch (error) {
+		if (getErrorCode(error) === "ENOENT") return;
+		throw error;
+	}
+}
+async function runWithCleanupPreservingRunError(input) {
+	let runResult;
+	let runSucceeded = false;
+	let runError;
+	try {
+		runResult = await input.run();
+		runSucceeded = true;
+	} catch (error) {
+		runError = error;
+	}
+	try {
+		await input.cleanup();
+	} catch (cleanupError) {
+		if (!runSucceeded) {
+			input.onCleanupErrorAfterRunFailure?.(cleanupError);
+			throw runError;
+		}
+		throw cleanupError;
+	}
+	if (!runSucceeded) throw runError;
+	return runResult;
+}
+async function runWithHeldLock(input) {
+	return await runWithCleanupPreservingRunError({
+		run: input.run,
+		cleanup: () => releaseLock(input.lock),
+		onCleanupErrorAfterRunFailure: (releaseError) => {
+			warnLockReleaseFailure({
+				error: releaseError,
+				lock: input.lock,
+				releaseContext: input.releaseContext
+			});
+		}
+	});
+}
+async function readLockMeta(input) {
+	return (await readLockSnapshot(resolveLockPath({
+		openMeldProfileId: input.openMeldProfileId,
+		key: input.key,
+		pathResolution: input.pathResolution
+	}))).meta;
+}
+async function tryCleanupStaleLock(input) {
+	return await tryCleanupStaleLockPath(resolveLockPath({
+		openMeldProfileId: input.openMeldProfileId,
+		key: input.key,
+		pathResolution: input.pathResolution
+	}));
+}
+async function repairOrphanedLegacyLocks() {
+	const locksRootPath = join(runtimeDir(), "locks");
+	const profileEntries = await readDirectoryEntries(locksRootPath);
+	let removedOrphanedLegacyLocks = 0;
+	for (const profileEntry of profileEntries.sort((left, right) => left.name.localeCompare(right.name))) {
+		if (!profileEntry.isDirectory()) continue;
+		const profileLocksPath = join(locksRootPath, profileEntry.name);
+		const lockEntries = await readDirectoryEntries(profileLocksPath);
+		for (const lockEntry of lockEntries.sort((left, right) => left.name.localeCompare(right.name))) {
+			if (!(lockEntry.isFile() && lockEntry.name.endsWith(".lock"))) continue;
+			if (await repairOrphanedLegacyLockPath(join(profileLocksPath, lockEntry.name))) removedOrphanedLegacyLocks += 1;
+		}
+	}
+	return { removedOrphanedLegacyLocks };
+}
+async function repairOrphanedLegacyLockPath(path) {
+	const firstSnapshot = await readLockSnapshot(path);
+	if (firstSnapshot.storageKind !== "legacy_file" || !isRecoverableStaleLock(firstSnapshot)) return false;
+	if (!isSameRecoverableLockSnapshot(firstSnapshot, await readLockSnapshot(path))) return false;
+	try {
+		await unlink(path);
+		return true;
+	} catch (error) {
+		if (getErrorCode(error) === "ENOENT" || getErrorCode(error) === "EISDIR") return false;
+		throw error;
+	}
+}
+async function readDirectoryEntries(path) {
+	return await readdir(path, { withFileTypes: true }).catch((error) => {
+		if (getErrorCode(error) === "ENOENT") return [];
+		throw error;
+	});
+}
+function resolveLockPath(input) {
+	return join(locksDir(normalizeOpenMeldProfileId(input.openMeldProfileId), input.pathResolution), `${sanitizeFilename(input.key)}.lock`);
+}
+function sanitizeFilename(value) {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function safeParse(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+function normalizeMetaRaw(metaRaw) {
+	if (typeof metaRaw !== "string") return null;
+	const normalized = metaRaw.trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function parseOpenMeldLockMeta(metaRaw) {
+	if (!metaRaw) return null;
+	const parsed = safeParse(metaRaw);
+	if (!parsed || typeof parsed !== "object") return null;
+	return parsed;
+}
+function buildOpenMeldLockErrorMessage(path, metaRaw, contentionState) {
+	const lockDetail = metaRaw ? `space is locked (${path}). Meta: ${metaRaw}` : `space is locked (${path})`;
+	if (contentionState !== "orphaned") return lockDetail;
+	return `${lockDetail}. ${OPENMELD_ORPHANED_LOCK_SUMMARY} ${buildOpenMeldOrphanedLockAction()}`;
+}
+function getPidFromMeta(meta) {
+	if (!meta || typeof meta !== "object") return null;
+	const pid = meta.pid;
+	return typeof pid === "number" ? pid : null;
+}
+function missingLockSnapshot() {
+	return {
+		exists: false,
+		fileIdentity: null,
+		ownerEntryName: null,
+		modifiedAtMs: null,
+		metaRaw: null,
+		meta: null,
+		pid: null,
+		hasStalePid: false,
+		storageKind: null
+	};
+}
+async function readLockSnapshot(path, remainingRaceRetries = 2) {
+	const pathStats = await lstat(path).catch((error) => {
+		if (getErrorCode(error) === "ENOENT") return null;
+		throw error;
+	});
+	if (!pathStats) return missingLockSnapshot();
+	if (pathStats.isDirectory()) try {
+		return await readDirectoryLockSnapshot(path, pathStats);
+	} catch (error) {
+		if (remainingRaceRetries > 0 && (getErrorCode(error) === "ENOENT" || getErrorCode(error) === "ENOTDIR")) return await readLockSnapshot(path, remainingRaceRetries - 1);
+		throw error;
+	}
+	const handle = await open(path, "r").catch((error) => {
+		if (getErrorCode(error) === "ENOENT") return null;
+		if (remainingRaceRetries > 0 && getErrorCode(error) === "EISDIR") return "retry";
+		throw error;
+	});
+	if (handle === "retry") return await readLockSnapshot(path, remainingRaceRetries - 1);
+	if (!handle) return missingLockSnapshot();
+	try {
+		const [metaRaw, stats] = await Promise.all([handle.readFile("utf8"), handle.stat()]);
+		const normalizedMetaRaw = normalizeMetaRaw(metaRaw);
+		const meta = parseOpenMeldLockMeta(normalizedMetaRaw);
+		const pid = getPidFromMeta(meta);
+		return {
+			exists: true,
+			fileIdentity: `${stats.dev}:${stats.ino}:${stats.mtimeMs}:${stats.size}`,
+			ownerEntryName: null,
+			modifiedAtMs: stats.mtimeMs,
+			metaRaw: normalizedMetaRaw,
+			meta,
+			pid,
+			hasStalePid: pid !== null && !isPidAlive(pid),
+			storageKind: "legacy_file"
+		};
+	} finally {
+		await handle.close();
+	}
+}
+async function readDirectoryLockSnapshot(path, pathStats) {
+	const ownerEntries = (await readdir(path, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".owner.json")).map((entry) => entry.name).sort();
+	const ownerEntryName = ownerEntries.length === 1 ? ownerEntries[0] : null;
+	const directoryIdentity = `${pathStats.dev}:${pathStats.ino}:${pathStats.mtimeMs}`;
+	if (!ownerEntryName) return {
+		exists: true,
+		fileIdentity: `${directoryIdentity}:empty-or-malformed`,
+		ownerEntryName: null,
+		modifiedAtMs: Number(pathStats.mtimeMs),
+		metaRaw: null,
+		meta: null,
+		pid: null,
+		hasStalePid: false,
+		storageKind: "directory"
+	};
+	const handle = await open(join(path, ownerEntryName), "r");
+	try {
+		const [metaRaw, stats] = await Promise.all([handle.readFile("utf8"), handle.stat()]);
+		const normalizedMetaRaw = normalizeMetaRaw(metaRaw);
+		const meta = parseOpenMeldLockMeta(normalizedMetaRaw);
+		const pid = getPidFromMeta(meta);
+		return {
+			exists: true,
+			fileIdentity: `${directoryIdentity}:${ownerEntryName}:${stats.dev}:${stats.ino}:${stats.mtimeMs}:${stats.size}`,
+			ownerEntryName,
+			modifiedAtMs: stats.mtimeMs,
+			metaRaw: normalizedMetaRaw,
+			meta,
+			pid,
+			hasStalePid: pid !== null && !isPidAlive(pid),
+			storageKind: "directory"
+		};
+	} finally {
+		await handle.close();
+	}
+}
+async function tryCleanupStaleLockPath(path, initialSnapshot) {
+	const firstSnapshot = initialSnapshot ?? await readLockSnapshot(path);
+	if (!isRecoverableStaleLock(firstSnapshot)) return false;
+	if (firstSnapshot.storageKind === "legacy_file") return false;
+	const confirmedSnapshot = await readLockSnapshot(path);
+	if (!isSameRecoverableLockSnapshot(firstSnapshot, confirmedSnapshot)) return false;
+	if (confirmedSnapshot.storageKind === "directory") return await cleanupStaleDirectoryLock(path, confirmedSnapshot);
+	return false;
+}
+function isSameRecoverableLockSnapshot(firstSnapshot, confirmedSnapshot) {
+	return confirmedSnapshot.exists && confirmedSnapshot.fileIdentity === firstSnapshot.fileIdentity && confirmedSnapshot.ownerEntryName === firstSnapshot.ownerEntryName && confirmedSnapshot.metaRaw === firstSnapshot.metaRaw && confirmedSnapshot.pid === firstSnapshot.pid && confirmedSnapshot.storageKind === firstSnapshot.storageKind && isRecoverableStaleLock(confirmedSnapshot);
+}
+function resolveLockContentionState(snapshot) {
+	if (snapshot.storageKind === "legacy_file" && isRecoverableStaleLock(snapshot)) return "orphaned";
+	if (snapshot.storageKind !== null && (snapshot.pid === null || !snapshot.hasStalePid)) return "active";
+	return "unknown";
+}
+async function cleanupStaleDirectoryLock(path, snapshot) {
+	if (snapshot.ownerEntryName) try {
+		await unlink(join(path, snapshot.ownerEntryName));
+	} catch (error) {
+		if (getErrorCode(error) === "ENOENT") return false;
+		throw error;
+	}
+	try {
+		await rmdir(path);
+		return true;
+	} catch (error) {
+		if (getErrorCode(error) === "ENOENT") return true;
+		if (getErrorCode(error) === "ENOTEMPTY") return false;
+		throw error;
+	}
+}
+async function tryPublishLock(path, ownerId, contents) {
+	try {
+		await mkdir(path);
+	} catch (error) {
+		if (getErrorCode(error) === "EEXIST") return false;
+		throw error;
+	}
+	const ownerEntryPath = resolveOwnerEntryPath(path, ownerId);
+	try {
+		await writeFile(ownerEntryPath, contents, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		return true;
+	} catch (error) {
+		await unlink(ownerEntryPath).catch((cleanupError) => {
+			if (getErrorCode(cleanupError) !== "ENOENT") console.warn("[openmeld.lock.owner_entry_cleanup_warning]", {
+				ownerEntryPath,
+				cleanupError: toErrorMessage$1(cleanupError)
+			});
+		});
+		await rmdir(path).catch((cleanupError) => {
+			if (getErrorCode(cleanupError) !== "ENOENT") console.warn("[openmeld.lock.directory_cleanup_warning]", {
+				lockPath: path,
+				cleanupError: toErrorMessage$1(cleanupError)
+			});
+		});
+		throw error;
+	}
+}
+async function unlinkOwnedDirectoryEntry(lock) {
+	try {
+		await unlink(resolveOwnerEntryPath(lock.path, lock.ownerId));
+		return true;
+	} catch (error) {
+		if (getErrorCode(error) === "ENOENT" || getErrorCode(error) === "ENOTDIR") return false;
+		throw error;
+	}
+}
+function resolveOwnerEntryPath(path, ownerId) {
+	return join(path, `${encodeURIComponent(ownerId)}.owner.json`);
+}
+function isRecoverableStaleLock(snapshot) {
+	if (!snapshot.exists) return false;
+	if (snapshot.pid !== null) return snapshot.hasStalePid;
+	return snapshot.modifiedAtMs !== null && Date.now() - snapshot.modifiedAtMs >= MALFORMED_LOCK_RECOVERY_GRACE_MS;
+}
+function isPidAlive(pid) {
+	try {
+		process$1.kill(pid, 0);
+		return true;
+	} catch (err) {
+		if (getErrorCode(err) === "ESRCH") return false;
+		return true;
+	}
+}
+function getErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const code = err.code;
+	return typeof code === "string" ? code : void 0;
+}
+function throwRecognizedLocalMachineFailure(input) {
+	throw toRecognizedLocalMachineFailureError(input) ?? input.error;
+}
+function warnLockReleaseFailure(input) {
+	console.warn("[openmeld.lock.release.warning]", {
+		lockPath: input.lock.path,
+		releaseError: toErrorMessage$1(input.error),
+		releaseContext: input.releaseContext ?? {}
+	});
+}
+function toErrorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/protocol/urls.ts
+const TRAILING_SLASHES_REGEX = /\/+$/;
+const ROOT_PATH_REGEX = /^\/+$/;
+function normalizeBaseUrl(baseUrl) {
+	const url = new URL(baseUrl);
+	if (!ROOT_PATH_REGEX.test(url.pathname)) throw new Error("baseUrl must be origin-only (no path prefix)");
+	if (url.search || url.hash) throw new Error("baseUrl must be origin-only (no query or hash)");
+	url.pathname = "";
+	url.search = "";
+	url.hash = "";
+	return url.toString().replace(TRAILING_SLASHES_REGEX, "");
+}
+function toSpaceCreateUrl(baseUrl) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = "/v1/spaces";
+	return url.toString();
+}
+function toSpaceDeleteUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}`;
+	return url.toString();
+}
+function toSpaceMetaUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/meta`;
+	return url.toString();
+}
+function toSpaceContractUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/contract`;
+	return url.toString();
+}
+function toSpaceBoardUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/board`;
+	return url.toString();
+}
+function toSpaceUpdatesUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/updates`;
+	return url.toString();
+}
+function toSpaceResultUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/result`;
+	return url.toString();
+}
+function toSpaceMembersUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/members`;
+	return url.toString();
+}
+function toSpaceRemoveMembersUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/members/remove`;
+	return url.toString();
+}
+function toSpaceLeaveUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/leave`;
+	return url.toString();
+}
+function toSpaceDispatchTraceUrl(baseUrl, space, dispatchId) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/dispatches/${encodeURIComponent(dispatchId)}/trace`;
+	return url.toString();
+}
+function toSpaceDispatchLookupUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/dispatches/lookup`;
+	return url.toString();
+}
+function toDaemonRouteObservationUrl(baseUrl, profileId) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/daemon/routes/${encodeURIComponent(profileId)}`;
+	return url.toString();
+}
+function toSpacePasswordUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/password`;
+	return url.toString();
+}
+function toSpaceCursorUrl(baseUrl, space, profileId) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/cursors/${encodeURIComponent(profileId)}`;
+	return url.toString();
+}
+function toSpaceWsUrl(baseUrl, space) {
+	const http = new URL(normalizeBaseUrl(baseUrl));
+	let wsScheme;
+	if (http.protocol === "http:") wsScheme = "ws:";
+	else if (http.protocol === "https:") wsScheme = "wss:";
+	else if (http.protocol === "ws:" || http.protocol === "wss:") wsScheme = http.protocol;
+	else throw new Error(`unsupported baseUrl protocol for websocket URL: ${http.protocol}`);
+	return `${wsScheme}//${http.host}/v1/spaces/${encodeURIComponent(space)}/stream`;
+}
+//#endregion
+//#region src/config/runtime-config.ts
+const DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE = "local-cli";
+const DEFAULT_RUNTIME_AGENT_STREAMING_MODE = "final";
+const DEFAULT_RUNTIME_AGENT_CONTEXT_SOURCE_FIELD = "OPENMELD_CLI_CONTEXT_ID";
+const CUSTOM_TARGET_ID_PREFIX = "custom-";
+const CUSTOM_TARGET_ID_LENGTH = 12;
+const RUNTIME_CONFIG_LOCK_PROFILE = "__system__";
+const RUNTIME_CONFIG_LOCK_KEY = "runtime-config";
+const RUNTIME_CONFIG_LOCK_MAX_ATTEMPTS = 40;
+const RUNTIME_CONFIG_LOCK_RETRY_DELAY_MS = 25;
+const WINDOWS_DRIVE_ONLY_RE = /^[a-zA-Z]:$/;
+const WINDOWS_DRIVE_PREFIX_RE = /^[a-zA-Z]:[\\/]/;
+const WINDOWS_UNC_RE = /^[/\\]{2}[^/\\]+[/\\]+[^/\\]+/;
+const WINDOWS_DRIVE_ANY_RE = /^[a-zA-Z]:/;
+const TRAILING_PATH_SEPARATORS_RE = /[\\/]+$/;
+function resolveRuntimeSkillsCustomTargetId(input) {
+	const existingId = typeof input.id === "string" && input.id.trim().length > 0 ? input.id.trim() : "";
+	if (existingId) return existingId;
+	const normalizedDir = normalizeCustomTargetDir(input.dir);
+	const digest = createHash("sha256").update(normalizedDir).digest("hex");
+	return `${CUSTOM_TARGET_ID_PREFIX}${digest.slice(0, CUSTOM_TARGET_ID_LENGTH)}`;
+}
+function resolveDefaultAgentContextSourceField(_agentId) {
+	return DEFAULT_RUNTIME_AGENT_CONTEXT_SOURCE_FIELD;
+}
+function createDefaultRuntimeAgentControllerSettings(agentId) {
+	return {
+		transportMode: DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE,
+		streamingMode: resolveDefaultRuntimeAgentStreamingMode(),
+		timeoutMs: null,
+		retry: 0,
+		contextIdMappingSpec: {
+			sourceField: resolveDefaultAgentContextSourceField(agentId),
+			mappingVersion: 1
+		}
+	};
+}
+const resolveDefaultRuntimeAgentStreamingMode = () => {
+	const preset = resolveOpenMeldEnvPreset();
+	if (preset === "dev-local" || preset === "canary") return "stream";
+	return DEFAULT_RUNTIME_AGENT_STREAMING_MODE;
+};
+async function getConfiguredBaseUrl() {
+	const config = await readRuntimeConfig();
+	if (!config?.baseUrl) return null;
+	return normalizeGatewayBaseUrl(config.baseUrl);
+}
+async function getConfiguredViewCustomization() {
+	return (await readRuntimeConfig())?.viewCustomization ?? null;
+}
+async function getConfiguredSkillsConfig() {
+	return (await readRuntimeConfig())?.skills ?? null;
+}
+async function getConfiguredDeviceRuntimeState() {
+	return (await readRuntimeConfig())?.deviceRuntimeState ?? null;
+}
+async function getConfiguredDaemonDispatchLimits() {
+	return resolveRuntimeDaemonDispatchLimits((await readRuntimeConfig())?.daemon?.dispatch);
+}
+async function getConfiguredOnboardingConfig() {
+	return (await readRuntimeConfig())?.onboarding ?? null;
+}
+async function getConfiguredOnboardingDisclaimerAcceptedAt() {
+	return (await getConfiguredOnboardingConfig())?.disclaimerAcceptedAt ?? null;
+}
+async function getRuntimeConfigReadHealth() {
+	return (await readRuntimeConfigDetailed()).health;
+}
+async function alignRuntimeConfigStorage() {
+	return await withRuntimeConfigLock(async () => {
+		const split = await readSplitRuntimeConfigDetailed();
+		const legacy = await readLegacyRuntimeConfigDetailed();
+		const hasLegacyConfig = await pathExists(legacyRuntimeConfigPath());
+		if (legacy.config && (!split.hasFiles || split.health.parseFallback)) {
+			await writeRuntimeConfig(legacy.config);
+			return {
+				migratedLegacyConfig: true,
+				removedLegacyConfig: hasLegacyConfig
+			};
+		}
+		if (hasLegacyConfig && split.hasFiles) {
+			await rm(legacyRuntimeConfigPath(), { force: true });
+			return {
+				migratedLegacyConfig: false,
+				removedLegacyConfig: true
+			};
+		}
+		return {
+			migratedLegacyConfig: false,
+			removedLegacyConfig: false
+		};
+	});
+}
+async function setConfiguredBaseUrl(baseUrl) {
+	await withRuntimeConfigLock(async () => {
+		const normalized = normalizeGatewayBaseUrl(baseUrl);
+		await writeRuntimeConfig(buildNextConfig(await readRuntimeConfig(), { baseUrl: normalized }));
+	});
+}
+async function setConfiguredSkillsConfig(skills) {
+	await withRuntimeConfigLock(async () => {
+		await writeRuntimeConfig(buildNextConfig(await readRuntimeConfig(), { skills }));
+	});
+}
+async function updateConfiguredSkillsConfig(updater) {
+	await withRuntimeConfigLock(async () => {
+		const previous = await readRuntimeConfig();
+		const previousSkills = previous?.skills ?? null;
+		const nextSkills = updater(previousSkills);
+		if (JSON.stringify(previousSkills) === JSON.stringify(nextSkills)) return;
+		await writeRuntimeConfig(buildNextConfig(previous, { skills: nextSkills }));
+	});
+}
+async function updateConfiguredDeviceRuntimeState(updater) {
+	await withRuntimeConfigLock(async () => {
+		const previous = await readRuntimeConfig();
+		const previousDeviceRuntimeState = previous?.deviceRuntimeState ?? null;
+		const nextDeviceRuntimeState = updater(previousDeviceRuntimeState);
+		if (JSON.stringify(previousDeviceRuntimeState) === JSON.stringify(nextDeviceRuntimeState)) return;
+		await writeRuntimeConfig(buildNextConfig(previous, { deviceRuntimeState: nextDeviceRuntimeState }));
+	});
+}
+async function updateConfiguredStartV1OnboardingState(updater) {
+	await withRuntimeConfigLock(async () => {
+		const previous = await readRuntimeConfig();
+		const previousOnboarding = previous?.onboarding ?? null;
+		const previousStartV1 = previousOnboarding?.startV1 ?? null;
+		const nextStartV1 = updater(previousStartV1);
+		if (JSON.stringify(previousStartV1) === JSON.stringify(nextStartV1)) return;
+		await writeRuntimeConfig(buildNextConfig(previous, { onboarding: nextStartV1 || previousOnboarding?.disclaimerAcceptedAt ? {
+			...previousOnboarding?.disclaimerAcceptedAt ? { disclaimerAcceptedAt: previousOnboarding.disclaimerAcceptedAt } : {},
+			...nextStartV1 ? { startV1: nextStartV1 } : {}
+		} : null }));
+	});
+}
+async function updateConfiguredOnboardingConfig(updater) {
+	await withRuntimeConfigLock(async () => {
+		const previous = await readRuntimeConfig();
+		const previousOnboarding = previous?.onboarding ?? null;
+		const nextOnboarding = updater(previousOnboarding);
+		if (JSON.stringify(previousOnboarding) === JSON.stringify(nextOnboarding)) return;
+		await writeRuntimeConfig(buildNextConfig(previous, { onboarding: nextOnboarding }));
+	});
+}
+function buildNextConfig(previous, overrides) {
+	const baseUrl = resolveBaseUrlOverride(previous?.baseUrl, overrides);
+	const viewCustomization = resolveConfigOverride("viewCustomization", previous?.viewCustomization, overrides);
+	const skills = resolveConfigOverride("skills", previous?.skills, overrides);
+	const daemon = resolveConfigOverride("daemon", previous?.daemon, overrides);
+	const deviceRuntimeState = resolveConfigOverride("deviceRuntimeState", previous?.deviceRuntimeState, overrides);
+	const onboarding = resolveConfigOverride("onboarding", previous?.onboarding, overrides);
+	return {
+		v: 1,
+		...baseUrl ? { baseUrl } : {},
+		...viewCustomization ? { viewCustomization } : {},
+		...skills ? { skills } : {},
+		...daemon ? { daemon } : {},
+		...deviceRuntimeState ? { deviceRuntimeState } : {},
+		...onboarding ? { onboarding } : {},
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function resolveBaseUrlOverride(previous, overrides) {
+	if (!("baseUrl" in overrides)) return previous;
+	if (typeof overrides.baseUrl !== "string" || overrides.baseUrl.length === 0) return;
+	return overrides.baseUrl;
+}
+function resolveConfigOverride(key, previous, overrides) {
+	if (!(key in overrides)) return previous;
+	return overrides[key] ?? void 0;
+}
+async function acquireRuntimeConfigLock() {
+	for (let attempt = 0; attempt < RUNTIME_CONFIG_LOCK_MAX_ATTEMPTS; attempt += 1) try {
+		return await acquireLock({
+			openMeldProfileId: RUNTIME_CONFIG_LOCK_PROFILE,
+			key: RUNTIME_CONFIG_LOCK_KEY
+		});
+	} catch (error) {
+		if (!isOpenMeldLockError(error) || isOpenMeldOrphanedLockError(error) || attempt === RUNTIME_CONFIG_LOCK_MAX_ATTEMPTS - 1) throw error;
+		await delay(RUNTIME_CONFIG_LOCK_RETRY_DELAY_MS);
+	}
+	throw new Error("runtime config lock retries exhausted");
+}
+async function withRuntimeConfigLock(run) {
+	return await runWithHeldLock({
+		lock: await acquireRuntimeConfigLock(),
+		run,
+		releaseContext: {
+			component: "runtime_config",
+			lockKey: RUNTIME_CONFIG_LOCK_KEY,
+			openMeldProfileId: RUNTIME_CONFIG_LOCK_PROFILE
+		}
+	});
+}
+async function readRuntimeConfig() {
+	return (await readRuntimeConfigDetailed()).config;
+}
+async function readRuntimeConfigDetailed() {
+	const split = await readSplitRuntimeConfigDetailed();
+	if (split.hasFiles) return {
+		config: split.config,
+		health: split.health
+	};
+	return await readLegacyRuntimeConfigDetailed();
+}
+function parseConfiguredBaseUrl(value) {
+	if (typeof value !== "string") return;
+	try {
+		return normalizeGatewayBaseUrl(value);
+	} catch {
+		return;
+	}
+}
+function parseRuntimeViewCustomization(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const messages = parseMessageCustomization(obj.messages);
+	const render = parseRenderCustomization(obj.render);
+	if (!(messages || render)) return;
+	return {
+		...messages ? { messages } : {},
+		...render ? { render } : {}
+	};
+}
+function parseRuntimeSkillsConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const storeDir = typeof obj.storeDir === "string" && obj.storeDir.trim().length > 0 ? obj.storeDir.trim() : void 0;
+	const agents = parseRuntimeSkillsAgents(obj.agents);
+	const installs = parseRuntimeSkillsInstallRecords(obj.installs);
+	const customTargets = parseRuntimeSkillsCustomTargets(obj.customTargets, buildLegacyCustomTargetIdByDir(installs));
+	if (!(storeDir || agents || customTargets || installs)) return;
+	return {
+		...storeDir ? { storeDir } : {},
+		...agents ? { agents } : {},
+		...customTargets ? { customTargets } : {},
+		...installs ? { installs } : {}
+	};
+}
+function parseRuntimeDaemonConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const dispatch = parseRuntimeDaemonDispatchConfig(value.dispatch);
+	if (!dispatch) return;
+	return { dispatch };
+}
+function parseRuntimeDaemonDispatchConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const globalConcurrency = parsePositiveInteger(obj.globalConcurrency);
+	const queueMax = parsePositiveInteger(obj.queueMax);
+	if (globalConcurrency === void 0 && queueMax === void 0) return;
+	return {
+		...globalConcurrency === void 0 ? {} : { globalConcurrency },
+		...queueMax === void 0 ? {} : { queueMax }
+	};
+}
+function parseRuntimeDeviceRuntimeState(value) {
+	return parseRuntimeDeviceRuntimeStateObject(value);
+}
+function parseRuntimeDeviceRuntimeStateObject(value) {
+	if (!value || typeof value !== "object") return;
+	const controllers = parseRuntimeAgentControllerStates(value.controllers);
+	if (!controllers) return;
+	return { controllers };
+}
+function parseRuntimeOnboardingConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const disclaimerAcceptedAt = toTrimmedStringOrUndefined(obj.disclaimerAcceptedAt);
+	const startV1 = parseRuntimeStartV1OnboardingState(obj.startV1);
+	if (!(disclaimerAcceptedAt || startV1)) return;
+	return {
+		...disclaimerAcceptedAt ? { disclaimerAcceptedAt } : {},
+		...startV1 ? { startV1 } : {}
+	};
+}
+function parseRuntimeStartV1OnboardingState(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const disclaimerAcceptedVersion = toTrimmedStringOrUndefined(obj.disclaimerAcceptedVersion);
+	const lastCompletedAt = toTrimmedStringOrUndefined(obj.lastCompletedAt);
+	const localAgentsSetupCompletedAt = toTrimmedStringOrUndefined(obj.localAgentsSetupCompletedAt);
+	if (!(disclaimerAcceptedVersion || lastCompletedAt || localAgentsSetupCompletedAt)) return;
+	return {
+		...disclaimerAcceptedVersion ? { disclaimerAcceptedVersion } : {},
+		...lastCompletedAt ? { lastCompletedAt } : {},
+		...localAgentsSetupCompletedAt ? { localAgentsSetupCompletedAt } : {}
+	};
+}
+async function writeRuntimeConfig(next) {
+	await mkdir(deviceDir(), { recursive: true });
+	await mkdir(deviceSkillsDir(), { recursive: true });
+	const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeJsonFileOrRemove(devicePreferencesPath(), buildDevicePreferencesState(next, updatedAt));
+	await writeJsonFileOrRemove(deviceAgentRuntimePath(), buildDeviceAgentRuntimeState(next, updatedAt));
+	await writeJsonFileOrRemove(deviceSkillsStorePath(), buildDeviceSkillsStoreState(next, updatedAt));
+	await writeJsonFileOrRemove(deviceSkillsCustomTargetsPath(), buildDeviceSkillsCustomTargetsState(next, updatedAt));
+	await writeJsonFileOrRemove(deviceSkillsInstallsPath(), buildDeviceSkillsInstallsState(next, updatedAt));
+	await rm(legacyRuntimeConfigPath(), { force: true }).catch(() => void 0);
+}
+function delay(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function parseMessageCustomization(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const human = toStringMap(obj.human);
+	const agent = toStringMap(obj.agent);
+	if (!(human || agent)) return;
+	return {
+		...human ? { human } : {},
+		...agent ? { agent } : {}
+	};
+}
+function parseRenderCustomization(value) {
+	if (!value || typeof value !== "object") return;
+	const obj = value;
+	const humanRaw = obj.human;
+	const agentRaw = obj.agent;
+	const human = humanRaw?.dataMode === "payload" || humanRaw?.dataMode === "envelope" ? { dataMode: humanRaw.dataMode } : void 0;
+	const agent = agentRaw?.envelopeMode === "verbose" || agentRaw?.envelopeMode === "compact" ? { envelopeMode: agentRaw.envelopeMode } : void 0;
+	if (!(human || agent)) return;
+	return {
+		...human ? { human } : {},
+		...agent ? { agent } : {}
+	};
+}
+function parseRuntimeSkillsAgents(value) {
+	if (!value || typeof value !== "object") return;
+	const entries = Object.entries(value).flatMap(([agentName, agentValue]) => {
+		if (!agentValue || typeof agentValue !== "object") return [];
+		const agentObj = agentValue;
+		const skillsDir = typeof agentObj.skillsDir === "string" && agentObj.skillsDir.trim().length > 0 ? agentObj.skillsDir.trim() : void 0;
+		const globalSkillsDir = typeof agentObj.globalSkillsDir === "string" && agentObj.globalSkillsDir.trim().length > 0 ? agentObj.globalSkillsDir.trim() : void 0;
+		if (!(skillsDir || globalSkillsDir)) return [];
+		return [[agentName, {
+			...skillsDir ? { skillsDir } : {},
+			...globalSkillsDir ? { globalSkillsDir } : {}
+		}]];
+	});
+	if (entries.length === 0) return;
+	return Object.fromEntries(entries);
+}
+function parseRuntimeSkillsCustomTargets(value, legacyCustomTargetIdByDir) {
+	if (!Array.isArray(value)) return;
+	const targets = value.flatMap((item) => {
+		if (!item || typeof item !== "object") return [];
+		const obj = item;
+		const name = typeof obj.name === "string" && obj.name.trim().length > 0 ? obj.name.trim() : "";
+		const dir = typeof obj.dir === "string" && obj.dir.trim().length > 0 ? normalizeCustomTargetDir(obj.dir) : "";
+		if (!(name && dir)) return [];
+		const explicitId = toTrimmedStringOrUndefined(obj.id);
+		const fallbackLegacyId = legacyCustomTargetIdByDir?.get(dir);
+		return [{
+			id: resolveRuntimeSkillsCustomTargetId({
+				dir,
+				...explicitId ? { id: explicitId } : {},
+				...!explicitId && fallbackLegacyId ? { id: fallbackLegacyId } : {}
+			}),
+			name,
+			dir
+		}];
+	});
+	if (targets.length === 0) return;
+	return targets;
+}
+function parseRuntimeSkillsInstallRecords(value) {
+	if (!Array.isArray(value)) return;
+	const records = value.map((item) => parseRuntimeSkillsInstallRecord(item)).filter((record) => record !== null);
+	if (records.length === 0) return;
+	return records;
+}
+function buildLegacyCustomTargetIdByDir(installs) {
+	const byDir = /* @__PURE__ */ new Map();
+	for (const install of installs ?? []) {
+		if (!install.targetId.startsWith(CUSTOM_TARGET_ID_PREFIX)) continue;
+		const normalizedTargetDir = normalizeCustomTargetDir(install.targetDir);
+		if (!normalizedTargetDir) continue;
+		byDir.set(normalizedTargetDir, install.targetId);
+	}
+	return byDir;
+}
+function parseRuntimeSkillsInstallRecord(value) {
+	if (!value || typeof value !== "object") return null;
+	const obj = value;
+	const targetId = toTrimmedStringOrEmpty(obj.targetId);
+	const targetDir = toTrimmedStringOrEmpty(obj.targetDir);
+	const mode = parseSkillsInstallMode(obj.mode);
+	const status = parseSkillsInstallStatus(obj.status);
+	const skillIds = Array.isArray(obj.skillIds) ? obj.skillIds.map((skill) => typeof skill === "string" ? skill.trim() : "").filter((skill) => skill.length > 0) : [];
+	const updatedAt = toTrimmedStringOrEmpty(obj.updatedAt);
+	const reason = toTrimmedStringOrUndefined(obj.reason);
+	if (!(targetId && targetDir && mode && status && updatedAt)) return null;
+	return {
+		targetId,
+		targetDir,
+		mode,
+		status,
+		skillIds,
+		...reason ? { reason } : {},
+		updatedAt
+	};
+}
+function parseRuntimeAgentControllerStates(value) {
+	if (!Array.isArray(value)) return;
+	const parsed = value.map((entry) => parseRuntimeAgentControllerState(entry)).filter((entry) => entry !== null);
+	if (parsed.length === 0) return;
+	const deduped = /* @__PURE__ */ new Map();
+	for (const entry of parsed) deduped.set(entry.agentId, entry);
+	return [...deduped.values()].sort((a, b) => a.agentId.localeCompare(b.agentId));
+}
+function parseRuntimeAgentControllerState(value) {
+	if (!value || typeof value !== "object") return null;
+	const obj = value;
+	const agentId = toTrimmedStringOrEmpty(obj.agentId);
+	const displayName = toTrimmedStringOrEmpty(obj.displayName);
+	const enabled = typeof obj.enabled === "boolean" ? obj.enabled : null;
+	const launchContract = parseRuntimeAgentControllerLaunchContract(obj.launchContract);
+	const defaults = createDefaultRuntimeAgentControllerSettings(agentId);
+	const controllerSettings = parseRuntimeAgentControllerSettings({
+		transportMode: obj.transportMode,
+		streamingMode: obj.streamingMode,
+		timeoutMs: obj.timeoutMs,
+		retry: obj.retry,
+		contextIdMappingSpec: obj.contextIdMappingSpec
+	}, defaults);
+	const registeredAt = toTrimmedStringOrEmpty(obj.registeredAt);
+	const updatedAt = toTrimmedStringOrEmpty(obj.updatedAt);
+	if (!(agentId && displayName && enabled !== null && controllerSettings && registeredAt && updatedAt)) return null;
+	return {
+		agentId,
+		displayName,
+		enabled,
+		...launchContract ? { launchContract } : {},
+		transportMode: controllerSettings.transportMode,
+		streamingMode: controllerSettings.streamingMode,
+		timeoutMs: controllerSettings.timeoutMs,
+		retry: controllerSettings.retry,
+		contextIdMappingSpec: controllerSettings.contextIdMappingSpec,
+		registeredAt,
+		updatedAt
+	};
+}
+function parseRuntimeAgentControllerLaunchContract(value) {
+	if (!(value && typeof value === "object")) return;
+	const parsed = runtimeAgentControllerLaunchContractSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+function parseRuntimeAgentControllerSettings(raw, defaults) {
+	const normalizedStreamingMode = normalizeRuntimeStreamingMode(raw.streamingMode);
+	const parsed = runtimeAgentControllerSettingsSchema.safeParse({
+		transport_mode: raw.transportMode ?? defaults.transportMode,
+		streaming_mode: normalizedStreamingMode ?? defaults.streamingMode,
+		timeout_ms: raw.timeoutMs === void 0 ? defaults.timeoutMs : raw.timeoutMs,
+		retry: raw.retry ?? defaults.retry,
+		context_id_mapping_spec: raw.contextIdMappingSpec ?? defaults.contextIdMappingSpec
+	});
+	if (!parsed.success) return null;
+	return {
+		transportMode: parsed.data.transport_mode,
+		streamingMode: parsed.data.streaming_mode,
+		timeoutMs: normalizeRuntimeAgentTimeoutMs({
+			defaults,
+			timeoutMs: parsed.data.timeout_ms
+		}),
+		retry: parsed.data.retry,
+		contextIdMappingSpec: normalizeRuntimeAgentControllerConversationIdMappingSpec({
+			contextIdMappingSpec: parsed.data.context_id_mapping_spec,
+			defaults
+		})
+	};
+}
+function normalizeRuntimeAgentTimeoutMs(input) {
+	if (input.timeoutMs === 12e4) return input.defaults.timeoutMs;
+	return input.timeoutMs;
+}
+function normalizeRuntimeAgentControllerConversationIdMappingSpec(input) {
+	if (input.contextIdMappingSpec.sourceField !== "OPENMELD_CLI_CONTEXT_ID") return input.defaults.contextIdMappingSpec;
+	return input.contextIdMappingSpec;
+}
+function resolveRuntimeDaemonDispatchLimits(config) {
+	return {
+		globalConcurrency: parsePositiveInteger(config?.globalConcurrency) ?? 10,
+		queueMax: parsePositiveInteger(config?.queueMax) ?? 50
+	};
+}
+function normalizeRuntimeStreamingMode(value) {
+	if (value === "final" || value === "stream") return value;
+	return null;
+}
+function parseSkillsInstallMode(value) {
+	if (value === "symlink" || value === "copy") return value;
+	return null;
+}
+function parseSkillsInstallStatus(value) {
+	if (value === "installed" || value === "skipped" || value === "failed") return value;
+	return null;
+}
+function parsePositiveInteger(value) {
+	if (!Number.isInteger(value)) return;
+	const numericValue = Number(value);
+	if (numericValue <= 0) return;
+	return numericValue;
+}
+function toTrimmedStringOrEmpty(value) {
+	if (typeof value !== "string") return "";
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : "";
+}
+function toTrimmedStringOrUndefined(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeCustomTargetDir(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return "";
+	if (WINDOWS_DRIVE_ONLY_RE.test(trimmed)) return `${trimmed[0]?.toUpperCase() ?? ""}:`;
+	const normalizedPath = WINDOWS_DRIVE_PREFIX_RE.test(trimmed) || WINDOWS_UNC_RE.test(trimmed) ? (() => {
+		const normalizedWindowsPath = win32.normalize(trimmed);
+		if (WINDOWS_DRIVE_ANY_RE.test(normalizedWindowsPath)) return `${normalizedWindowsPath[0]?.toUpperCase() ?? ""}${normalizedWindowsPath.slice(1)}`;
+		return normalizedWindowsPath;
+	})() : normalize(trimmed);
+	const isPosixRoot = normalizedPath === posix.parse(normalizedPath).root;
+	const isWindowsRoot = normalizedPath === win32.parse(normalizedPath).root;
+	if (isPosixRoot || isWindowsRoot) return normalizedPath;
+	return normalizedPath.replace(TRAILING_PATH_SEPARATORS_RE, "");
+}
+function toStringMap(value) {
+	if (!value || typeof value !== "object") return;
+	const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+	if (entries.length === 0) return;
+	return Object.fromEntries(entries);
+}
+function isFileNotFoundError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readSplitRuntimeConfigDetailed() {
+	const [preferencesFile, agentRuntimeFile, skillsStoreFile, customTargetsFile, installsFile] = await Promise.all([
+		readOptionalJsonFile(devicePreferencesPath()),
+		readOptionalJsonFile(deviceAgentRuntimePath()),
+		readOptionalJsonFile(deviceSkillsStorePath()),
+		readOptionalJsonFile(deviceSkillsCustomTargetsPath()),
+		readOptionalJsonFile(deviceSkillsInstallsPath())
+	]);
+	const files = [
+		preferencesFile,
+		agentRuntimeFile,
+		skillsStoreFile,
+		customTargetsFile,
+		installsFile
+	];
+	if (!files.some((file) => file.found)) return {
+		config: null,
+		hasFiles: false,
+		health: { parseFallback: false }
+	};
+	const invalidFile = files.find((file) => file.error);
+	const preferences = parseDevicePreferencesConfig(preferencesFile.value);
+	const agentRuntime = parseDeviceAgentRuntimeConfig(agentRuntimeFile.value);
+	const skills = mergeRuntimeSkillsConfig({
+		store: parseDeviceSkillsStoreConfig(skillsStoreFile.value),
+		customTargets: parseDeviceSkillsCustomTargetsConfig(customTargetsFile.value),
+		installs: parseDeviceSkillsInstallsConfig(installsFile.value)
+	});
+	return {
+		config: buildRuntimeConfigFromParts({
+			baseUrl: preferences.baseUrl,
+			viewCustomization: preferences.viewCustomization,
+			daemon: preferences.daemon,
+			onboarding: preferences.onboarding,
+			deviceRuntimeState: agentRuntime,
+			skills
+		}),
+		hasFiles: true,
+		health: invalidFile ? {
+			parseFallback: true,
+			reason: invalidFile.error ?? "invalid_json"
+		} : { parseFallback: false }
+	};
+}
+async function readLegacyRuntimeConfigDetailed() {
+	let raw;
+	try {
+		raw = await readFile(legacyRuntimeConfigPath(), "utf8");
+	} catch (error) {
+		if (isFileNotFoundError(error)) return {
+			config: null,
+			health: { parseFallback: false }
+		};
+		throw error;
+	}
+	if (raw.trim().length === 0) return {
+		config: null,
+		health: { parseFallback: false }
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {
+			config: null,
+			health: {
+				parseFallback: true,
+				reason: "invalid_json"
+			}
+		};
+	}
+	if (parsed.v !== 1) return {
+		config: null,
+		health: {
+			parseFallback: true,
+			reason: "invalid_version"
+		}
+	};
+	if (parsed.agents !== void 0) throw new Error("runtime.config.legacy_agents_unsupported: key 'agents.registrations' is no longer supported. Use 'deviceRuntimeState.controllers' or run 'openmeld reset --yes'.");
+	return {
+		config: buildRuntimeConfigFromParts({
+			baseUrl: parseConfiguredBaseUrl(parsed.baseUrl),
+			viewCustomization: parseRuntimeViewCustomization(parsed.viewCustomization),
+			skills: parseRuntimeSkillsConfig(parsed.skills),
+			daemon: parseRuntimeDaemonConfig(parsed.daemon),
+			deviceRuntimeState: parseRuntimeDeviceRuntimeState(parsed.deviceRuntimeState),
+			onboarding: parseRuntimeOnboardingConfig(parsed.onboarding),
+			updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+		}),
+		health: { parseFallback: false }
+	};
+}
+function buildRuntimeConfigFromParts(input) {
+	const updatedAt = input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	if (!(input.baseUrl || input.viewCustomization || input.skills || input.daemon || input.deviceRuntimeState || input.onboarding)) return null;
+	return {
+		v: 1,
+		...input.baseUrl ? { baseUrl: input.baseUrl } : {},
+		...input.viewCustomization ? { viewCustomization: input.viewCustomization } : {},
+		...input.skills ? { skills: input.skills } : {},
+		...input.daemon ? { daemon: input.daemon } : {},
+		...input.deviceRuntimeState ? { deviceRuntimeState: input.deviceRuntimeState } : {},
+		...input.onboarding ? { onboarding: input.onboarding } : {},
+		updatedAt
+	};
+}
+function parseDevicePreferencesConfig(value) {
+	if (!value || typeof value !== "object") return {};
+	const parsed = value;
+	if (parsed.v !== 1) return {};
+	return {
+		...parseConfiguredBaseUrl(parsed.baseUrl) ? { baseUrl: parseConfiguredBaseUrl(parsed.baseUrl) } : {},
+		...parseRuntimeViewCustomization(parsed.viewCustomization) ? { viewCustomization: parseRuntimeViewCustomization(parsed.viewCustomization) } : {},
+		...parseRuntimeDaemonConfig(parsed.daemon) ? { daemon: parseRuntimeDaemonConfig(parsed.daemon) } : {},
+		...parseRuntimeOnboardingConfig(parsed.onboarding) ? { onboarding: parseRuntimeOnboardingConfig(parsed.onboarding) } : {}
+	};
+}
+function parseDeviceAgentRuntimeConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const parsed = value;
+	if (parsed.v !== 1) return;
+	return parseRuntimeDeviceRuntimeState(parsed.deviceRuntimeState);
+}
+function parseDeviceSkillsStoreConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const parsed = value;
+	if (parsed.v !== 1) return;
+	const storeDir = typeof parsed.storeDir === "string" && parsed.storeDir.trim().length > 0 ? parsed.storeDir.trim() : void 0;
+	const agents = parseRuntimeSkillsAgents(parsed.agents);
+	if (!(storeDir || agents)) return;
+	return {
+		...storeDir ? { storeDir } : {},
+		...agents ? { agents } : {}
+	};
+}
+function parseDeviceSkillsCustomTargetsConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const parsed = value;
+	if (parsed.v !== 1) return;
+	return parseRuntimeSkillsCustomTargets(parsed.customTargets, void 0);
+}
+function parseDeviceSkillsInstallsConfig(value) {
+	if (!value || typeof value !== "object") return;
+	const parsed = value;
+	if (parsed.v !== 1) return;
+	return parseRuntimeSkillsInstallRecords(parsed.installs);
+}
+function mergeRuntimeSkillsConfig(input) {
+	if (!(input.store || input.customTargets || input.installs)) return;
+	return {
+		...input.store?.storeDir ? { storeDir: input.store.storeDir } : {},
+		...input.store?.agents ? { agents: input.store.agents } : {},
+		...input.customTargets ? { customTargets: input.customTargets } : {},
+		...input.installs ? { installs: input.installs } : {}
+	};
+}
+function buildDevicePreferencesState(next, updatedAt) {
+	if (!(next.baseUrl || next.viewCustomization || next.daemon || next.onboarding)) return null;
+	return {
+		v: 1,
+		...next.baseUrl ? { baseUrl: next.baseUrl } : {},
+		...next.viewCustomization ? { viewCustomization: next.viewCustomization } : {},
+		...next.daemon ? { daemon: next.daemon } : {},
+		...next.onboarding ? { onboarding: next.onboarding } : {},
+		updatedAt
+	};
+}
+function buildDeviceAgentRuntimeState(next, updatedAt) {
+	if (!next.deviceRuntimeState) return null;
+	return {
+		v: 1,
+		deviceRuntimeState: next.deviceRuntimeState,
+		updatedAt
+	};
+}
+function buildDeviceSkillsStoreState(next, updatedAt) {
+	if (!(next.skills?.storeDir || next.skills?.agents)) return null;
+	return {
+		v: 1,
+		...next.skills?.storeDir ? { storeDir: next.skills.storeDir } : {},
+		...next.skills?.agents ? { agents: next.skills.agents } : {},
+		updatedAt
+	};
+}
+function buildDeviceSkillsCustomTargetsState(next, updatedAt) {
+	if (!(next.skills?.customTargets && next.skills.customTargets.length > 0)) return null;
+	return {
+		v: 1,
+		customTargets: next.skills.customTargets,
+		updatedAt
+	};
+}
+function buildDeviceSkillsInstallsState(next, updatedAt) {
+	if (!(next.skills?.installs && next.skills.installs.length > 0)) return null;
+	return {
+		v: 1,
+		installs: next.skills.installs,
+		updatedAt
+	};
+}
+async function writeJsonFileOrRemove(path, payload) {
+	if (!payload) {
+		await rm(path, { force: true }).catch(() => void 0);
+		return;
+	}
+	await mkdir(dirname(path), { recursive: true });
+	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+	await writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+	try {
+		await rename(tempPath, path);
+	} catch (error) {
+		await rm(tempPath, { force: true }).catch(() => void 0);
+		throw error;
+	}
+}
+async function readOptionalJsonFile(path) {
+	const raw = await readFile(path, "utf8").catch((error) => {
+		if (isFileNotFoundError(error)) return null;
+		throw error;
+	});
+	if (raw === null) return {
+		found: false,
+		value: null
+	};
+	if (raw.trim().length === 0) return {
+		found: true,
+		value: null
+	};
+	try {
+		return {
+			found: true,
+			value: JSON.parse(raw)
+		};
+	} catch {
+		return {
+			found: true,
+			value: null,
+			error: "invalid_json"
+		};
+	}
+}
+async function pathExists(path) {
+	return await readFile(path, "utf8").then(() => true).catch((error) => {
+		if (isFileNotFoundError(error)) return false;
+		throw error;
+	});
+}
+//#endregion
+//#region src/config/base-url.ts
+var base_url_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_GATEWAY_BASE_URL: () => DEFAULT_GATEWAY_BASE_URL,
+	DEV_LOCAL_GATEWAY_BASE_URL: () => DEV_LOCAL_GATEWAY_BASE_URL,
+	normalizeGatewayBaseUrl: () => normalizeGatewayBaseUrl,
+	normalizeGatewayBaseUrlOrNull: () => normalizeGatewayBaseUrlOrNull,
+	resolveBaseUrl: () => resolveBaseUrl,
+	resolveBaseUrlOrNull: () => resolveBaseUrlOrNull,
+	resolveDefaultGatewayBaseUrl: () => resolveDefaultGatewayBaseUrl,
+	resolveExplicitGatewayUrlOrThrow: () => resolveExplicitGatewayUrlOrThrow
+});
+const DEFAULT_GATEWAY_BASE_URL = "https://gateway.openmeld.ai";
+const DEV_LOCAL_GATEWAY_BASE_URL = "http://localhost:8080";
+const AUTH_HOST_LABEL = "auth";
+const AUTH_HOST_PREFIX = "auth-";
+const LOCAL_AUTH_PORT = "8788";
+async function resolveBaseUrl(cliValue, input = {}) {
+	const env = input.env ?? process.env;
+	const fromCli = String(cliValue ?? "").trim();
+	if (fromCli) return normalizeGatewayBaseUrl(fromCli);
+	const fromEnv = String(env.OPENMELD_GATEWAY_URL ?? "").trim();
+	if (fromEnv) return normalizeGatewayBaseUrl(fromEnv);
+	const fromConfig = await getConfiguredBaseUrl();
+	if (fromConfig) return normalizeGatewayBaseUrl(fromConfig);
+	return normalizeGatewayBaseUrl(resolveDefaultGatewayBaseUrl({ env }));
+}
+async function resolveBaseUrlOrNull(cliValue) {
+	try {
+		return await resolveBaseUrl(cliValue);
+	} catch {
+		return null;
+	}
+}
+async function resolveExplicitGatewayUrlOrThrow(cliValue) {
+	const explicitGatewayUrl = normalizeOptionalString(cliValue);
+	if (!explicitGatewayUrl) return;
+	try {
+		return await Promise.resolve().then(() => normalizeGatewayBaseUrl(explicitGatewayUrl));
+	} catch (error) {
+		throw new Error(`Invalid explicit gateway URL "${explicitGatewayUrl}": ${toErrorMessage(error)}`);
+	}
+}
+function normalizeGatewayBaseUrl(gatewayUrl) {
+	const normalizedGatewayUrl = normalizeBaseUrl(gatewayUrl);
+	if (isAuthWorkerUrl(new URL(normalizedGatewayUrl))) throw new Error("gateway URL must point to the OpenMeld gateway, not the OpenMeld auth worker");
+	return normalizedGatewayUrl;
+}
+function normalizeGatewayBaseUrlOrNull(gatewayUrl) {
+	const normalizedGatewayUrl = normalizeOptionalString(gatewayUrl);
+	if (!normalizedGatewayUrl) return null;
+	try {
+		return normalizeGatewayBaseUrl(normalizedGatewayUrl);
+	} catch {
+		return null;
+	}
+}
+function normalizeOptionalString(value) {
+	const normalized = String(value ?? "").trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function resolveDefaultGatewayBaseUrl(input = {}) {
+	const preset = resolveOpenMeldEnvPreset(input);
+	if (preset === "dev-local" || preset === "canary") return DEV_LOCAL_GATEWAY_BASE_URL;
+	return DEFAULT_GATEWAY_BASE_URL;
+}
+function isAuthWorkerUrl(url) {
+	if (isLoopbackHostname(url.hostname)) return resolveUrlPort(url) === LOCAL_AUTH_PORT;
+	const [firstLabel = ""] = url.hostname.toLowerCase().split(".");
+	return firstLabel === AUTH_HOST_LABEL || firstLabel.startsWith(AUTH_HOST_PREFIX);
+}
+function isLoopbackHostname(hostname) {
+	const normalizedHostname = hostname.toLowerCase();
+	return normalizedHostname === "localhost" || normalizedHostname === "127.0.0.1" || normalizedHostname === "::1";
+}
+function resolveUrlPort(url) {
+	if (url.port) return url.port;
+	if (url.protocol === "http:" || url.protocol === "ws:") return "80";
+	if (url.protocol === "https:" || url.protocol === "wss:") return "443";
+	return "";
+}
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { LEGACY_OPENMELD_AGENT_SESSION_ENV_KEY as $, runtimeDispatchPolicySchema as $t, toSpaceCursorUrl as A, openMeldManagedBinaryPath as At, toSpaceUpdatesUrl as B, resolveOpenMeldCliEntryNameFromArgv as Bt, updateConfiguredSkillsConfig as C, deviceOpenClawProfileWorkspaceDir as Ct, toSpaceBoardUrl as D, normalizeOpenMeldProfileId as Dt, toDaemonRouteObservationUrl as E, normalizeAccountKey as Et, toSpaceMembersUrl as F, organizationSkillReleaseDir as Ft, isOpenMeldOrphanedLockError as G, runtimeLogsDir as Gt, acquireLock as H, resolveOpenMeldPresetOwnedPathInput as Ht, toSpaceMetaUrl as I, profileDir as It, releaseLockSync as J, systemDir as Jt, readLockMeta as K, skillsDir as Kt, toSpacePasswordUrl as L, profileViewPath as Lt, toSpaceDispatchLookupUrl as M, openMeldManagedVersionDir as Mt, toSpaceDispatchTraceUrl as N, openMeldRootDir as Nt, toSpaceContractUrl as O, openMeldBackupsDir as Ot, toSpaceLeaveUrl as P, openMeldVersionsDir as Pt, tryCleanupStaleLock as Q, runtimeAgentControllerLaunchContractSchema as Qt, toSpaceRemoveMembersUrl as R, resolveDefaultOpenMeldHomeDirname as Rt, updateConfiguredOnboardingConfig as S, deviceOpenClawProfileDir as St, normalizeBaseUrl as T, legacyAccountProfileSpacesDir as Tt, buildOpenMeldOrphanedLockAction as U, resolveOpenMeldRootDir as Ut, toSpaceWsUrl as V, resolveOpenMeldEnvPreset as Vt, isOpenMeldLockError as W, runtimeDir as Wt, resolveOpenMeldOrphanedLockIssue as X, LEGACY_RUNTIME_DISPATCH_POLICY as Xt, repairOrphanedLegacyLocks as Y, formatLocalMachineIssueMessage as Yt, runWithHeldLock as Z, runtimeAgentControllerConversationIdMappingSpecSchema as Zt, getRuntimeConfigReadHealth as _, accountProfileSpaceCacheDir as _t, resolveBaseUrl as a, resolveBuiltinAgentControllerConversationKind as an, writeCliContextState as at, setConfiguredSkillsConfig as b, accountsDir as bt, resolveExplicitGatewayUrlOrThrow as c, agentControllerRefSchema as cn, LocalMachineFailureError as ct, createDefaultRuntimeAgentControllerSettings as d, canonicalizeBuiltinAgentControllerRef as dn, createBackgroundExecutionBlockedIssue as dt, runtimeStreamingModeSchema as en, OPENMELD_CLI_CONTEXT_ENV_KEY as et, getConfiguredDaemonDispatchLimits as f, normalizeBuiltinAgentControllerId as fn, createOrphanedSetupConcurrencyIssue as ft, getConfiguredViewCustomization as g, accountProfileLocalMetaPath as gt, getConfiguredSkillsConfig as h, __exportAll as hn, OPENMELD_HOME_ENV_KEY as ht, normalizeGatewayBaseUrlOrNull as i, conversationPolicySchema as in, resolveCliContextId as it, toSpaceDeleteUrl as j, openMeldManagedVersionBinaryPath as jt, toSpaceCreateUrl as k, openMeldBinDir as kt, DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE as l, buildAgentControllerRoutingKey as ln, assessLocalMachineFailure as lt, getConfiguredOnboardingDisclaimerAcceptedAt as m, parseAgentControllerRef as mn, toRecognizedLocalMachineFailureError as mt, base_url_exports as n, agentControllerConversationRefSchema as nn, readCliContextState as nt, resolveBaseUrlOrNull as o, HOSTED_CENTER_AGENT_CONTROLLER_REF as on, formatLaneScopeSentence as ot, getConfiguredDeviceRuntimeState as p, normalizeKnownBuiltinAgentControllerId as pn, isLocalMachineFailureError as pt, releaseLock as q, spacesDir as qt, normalizeGatewayBaseUrl as r, buildAgentControllerConversationRef as rn, resolveCliContext as rt, resolveDefaultGatewayBaseUrl as s, HOSTED_CENTER_AGENT_CONTROLLER_REF_ID as sn, resolveOpenMeldLaneDescriptor as st, DEV_LOCAL_GATEWAY_BASE_URL as t, runtimeTransportModeSchema as tn, listCliContextStates as tt, alignRuntimeConfigStorage as u, canonicalizeAgentControllerRef as un, createActiveSetupConcurrencyIssue as ut, resolveRuntimeSkillsCustomTargetId as v, accountProfileViewPath as vt, updateConfiguredStartV1OnboardingState as w, isPublishedOpenMeldHome as wt, updateConfiguredDeviceRuntimeState as x, deviceOpenClawProfileBootstrapPath as xt, setConfiguredBaseUrl as y, accountProfileWorkspacePath as yt, toSpaceResultUrl as z, resolveExplicitOpenMeldEnvPreset as zt };
+
+//# sourceMappingURL=base-url-Bdqmyw0D.js.map