openmeld 0.3.213 → 0.3.214

package/dist/{daemon-service-update-coordinator-BcbbIDzC.js → daemon-service-update-coordinator--xLHNqDT.js}

@@ -2,39 +2,41 @@
 
 import { n as toDaemonRouteObservationUrl } from "./urls-CY2uzH2-.js";
 import { t as isLoopbackHostname } from "./loopback-hostname-DHQPKq8N.js";
-import { B as deviceOpenClawProfileBootstrapPath, C as isProcessIdentityAlive, H as deviceOpenClawProfileWorkspaceDir, I as accountProfileViewPath, L as accountProfileWorkspacePath, N as OPENMELD_HOME_ENV_KEY, P as accountProfileLocalMetaPath, Q as openMeldBackupsDir, S as CURRENT_PROCESS_START_IDENTITY, V as deviceOpenClawProfileDir, X as normalizeAccountKey, Z as normalizeOpenMeldProfileId, _ as resolveCliContext, a as isOpenMeldOrphanedLockError, d as runWithHeldLock, dt as resolveOpenMeldEnvPreset, ft as resolveOpenMeldRootDir, g as readCliContextState, h as listCliContextStates, ht as runtimeDir, i as isOpenMeldLockError, q as isPublishedOpenMeldHome, rt as openMeldRootDir, t as acquireLock, tt as openMeldManagedVersionBinaryPath, y as writeCliContextState, yt as systemDir } from "./lock-Dxp6o_t_.js";
-import { Ar as modelCatalogSchema, Ci as agentControllerCollaborationModeSchema, Gn as OPENMELD_HEADER_PROFILE_ID, Kt as createLocalRuntimeExpectedRoutesApi, Mt as createAgentProfileBindingApi, Si as agentControllerPermissionModeSchema, Xn as toErrorMessage$24, jn as toStructuredApiClientFailure, t as OpenMeldApiClientHttpError, xi as openCodePermissionConfigSchema, zt as createCurrentDeviceApi } from "./dist-CAx_kxvt.js";
+import { A as OPENMELD_HOME_ENV_KEY, J as normalizeOpenMeldProfileId, L as deviceOpenClawProfileBootstrapPath, N as accountProfileViewPath, P as accountProfileWorkspacePath, Q as openMeldManagedVersionBinaryPath, R as deviceOpenClawProfileDir, W as isPublishedOpenMeldHome, Y as openMeldBackupsDir, _ as resolveCliContext, a as isOpenMeldOrphanedLockError, ct as resolveOpenMeldEnvPreset, d as runWithHeldLock, et as openMeldRootDir, ft as runtimeDir, g as readCliContextState, gt as systemDir, h as listCliContextStates, i as isOpenMeldLockError, j as accountProfileLocalMetaPath, lt as resolveOpenMeldRootDir, q as normalizeAccountKey, t as acquireLock, y as writeCliContextState, z as deviceOpenClawProfileWorkspaceDir } from "./lock-CAt9uTnZ.js";
+import { Ci as openCodePermissionConfigSchema, Kt as createLocalRuntimeExpectedRoutesApi, Mr as modelCatalogSchema, Mt as createAgentProfileBindingApi, Nn as toStructuredApiClientFailure, Qn as toErrorMessage$24, Ti as agentControllerCollaborationModeSchema, qn as OPENMELD_HEADER_PROFILE_ID, t as OpenMeldApiClientHttpError, wi as agentControllerPermissionModeSchema, zt as createCurrentDeviceApi } from "./dist-Dj3TOx03.js";
 import { _ as canonicalizeAgentControllerRef, b as normalizeKnownBuiltinAgentControllerId, d as resolveBuiltinAgentControllerConversationKind, f as HOSTED_CENTER_AGENT_CONTROLLER_REF, g as buildAgentControllerRoutingKey, l as buildAgentControllerConversationRef, m as HOSTED_REMOTE_AGENT_CONTROLLER_REF, n as runtimeAgentControllerConversationIdMappingSpecSchema, o as runtimeStreamingModeSchema, p as HOSTED_CENTER_AGENT_CONTROLLER_REF_ID, r as runtimeAgentControllerLaunchContractSchema, s as runtimeTransportModeSchema, u as conversationPolicySchema, v as canonicalizeBuiltinAgentControllerRef, x as parseAgentControllerRef$1 } from "./controller-contract-pe3_Re-c.js";
-import { An as normalizeMessageEnvelope, B as isOriginalErrorSafeForMessageDetails, Br as ADDITIONAL_HUMAN_PROFILE_CREATION_DISABLED_MESSAGE, Dn as formatCanonicalMentionLiteral, G as openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema, Gr as profileErrorResponseSchema, Hr as authProfileManagedRoleSchema, Jn as agentInteractionResolutionSchema, Lr as localAgentCatalogSchema, N as runtimeTransportRejectedProfileRegistrationSchema, O as runtimeTransportLookupRouteOwnerServiceEvidenceSchema, Qr as resolveCommandAgentWorkActivity, U as openMeldDaemonProviderAccessEvidenceSchema, W as openMeldDaemonTaskResultEnvelopeWriteSchema, Wr as profileCapabilitiesResponseSchema, X as resolvePublicAgentAvailabilityCopy, Yr as openMeldProfileIdSchema, Z as resolvePublicAgentFailureRecovery, _ as runtimeTransportErrorCodeSchema, i as localWakeRouteReportSchema, n as daemonExecutionCompatibilitySchema, o as runtimeTransportCapabilitiesSchema, t as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, z as OPENMELD_ORIGINAL_ERROR_MAX_LENGTH, zr as ADDITIONAL_HUMAN_PROFILE_CREATION_DISABLED_CODE } from "./runtime-transport-DxISZdzf.js";
-import { $ as RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_RETRY_INTERVAL_MS$1, B as DEFAULT_HEARTBEAT_INTERVAL_MS$1, F as DAEMON_RUNTIME_CONTRACT_EPOCH$1, G as MIN_HEARTBEAT_INTERVAL_MS$2, H as HEARTBEAT_RESPONSE_TIMEOUT_MS$1, I as DAEMON_STREAM_CONNECT_TIMEOUT_MS$1, J as PROVIDER_CONVERSATION_PROOF_SYNC_INTERVAL_MS$1, L as DAEMON_STREAM_KEEPALIVE_INTERVAL_MS$1, N as CATALOG_SYNC_RETRY_INTERVAL_MS$1, P as CATALOG_SYNC_SIGNAL_POLL_INTERVAL_MS$1, Q as RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_INTERVAL_MS$1, R as DAEMON_STREAM_KEEPALIVE_PONG_TIMEOUT_MS$1, U as MAX_HEARTBEAT_INTERVAL_MS$2, X as REGISTER_RESPONSE_TIMEOUT_MS$1, Y as PROVIDER_CONVERSATION_PROOF_SYNC_RETRY_INTERVAL_MS$1, d as getAuthSessionState, et as RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS$1, m as hasPendingComputerSetupContinuation, q as OPENCLAW_CLI_TIMEOUT_MS$1, z as DEFAULT_GATEWAY_CHAIN_TIMEOUT_MS$1 } from "./auth-session-DgHvRt5i.js";
+import { B as isOriginalErrorSafeForMessageDetails, G as openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema, Kr as ADDITIONAL_HUMAN_PROFILE_CREATION_DISABLED_CODE, Ln as normalizeMessageEnvelope, N as runtimeTransportRejectedProfileRegistrationSchema, O as runtimeTransportLookupRouteOwnerServiceEvidenceSchema, Pn as formatCanonicalMentionLiteral, Qr as profileErrorResponseSchema, U as openMeldDaemonProviderAccessEvidenceSchema, W as openMeldDaemonTaskResultEnvelopeWriteSchema, Wr as localAgentCatalogSchema, X as resolvePublicAgentAvailabilityCopy, Yr as authProfileManagedRoleSchema, Z as resolvePublicAgentFailureRecovery, Zr as profileCapabilitiesResponseSchema, _ as runtimeTransportErrorCodeSchema, ai as resolveCommandAgentWorkActivity, i as localWakeRouteReportSchema, n as daemonExecutionCompatibilitySchema, ni as openMeldProfileIdSchema, o as runtimeTransportCapabilitiesSchema, qr as ADDITIONAL_HUMAN_PROFILE_CREATION_DISABLED_MESSAGE, t as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, tr as agentInteractionResolutionSchema, z as OPENMELD_ORIGINAL_ERROR_MAX_LENGTH } from "./runtime-transport-D8G8sANa.js";
+import { $ as RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_RETRY_INTERVAL_MS$1, B as DEFAULT_HEARTBEAT_INTERVAL_MS$1, F as DAEMON_RUNTIME_CONTRACT_EPOCH$1, G as MIN_HEARTBEAT_INTERVAL_MS$2, H as HEARTBEAT_RESPONSE_TIMEOUT_MS$1, I as DAEMON_STREAM_CONNECT_TIMEOUT_MS$1, J as PROVIDER_CONVERSATION_PROOF_SYNC_INTERVAL_MS$1, L as DAEMON_STREAM_KEEPALIVE_INTERVAL_MS$1, N as CATALOG_SYNC_RETRY_INTERVAL_MS$1, P as CATALOG_SYNC_SIGNAL_POLL_INTERVAL_MS$1, Q as RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_INTERVAL_MS$1, R as DAEMON_STREAM_KEEPALIVE_PONG_TIMEOUT_MS$1, U as MAX_HEARTBEAT_INTERVAL_MS$2, X as REGISTER_RESPONSE_TIMEOUT_MS$1, Y as PROVIDER_CONVERSATION_PROOF_SYNC_RETRY_INTERVAL_MS$1, d as getAuthSessionState, et as RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS$1, m as hasPendingComputerSetupContinuation, q as OPENCLAW_CLI_TIMEOUT_MS$1, z as DEFAULT_GATEWAY_CHAIN_TIMEOUT_MS$1 } from "./auth-session-gaLjWIKR.js";
 import { A as profileWorkspaceModeSchema, C as normalizeOptionalWorkingDirectory, S as agentProfileIdSchema, _ as providerDispatchRuntimeContextSchema, a as openMeldDaemonControlPlaneResponseSchema, g as skippedDaemonProfileSchema, i as openMeldDaemonControlPlaneRequestSchema, x as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, y as conversationExecutionStateSchema } from "./control-plane-Bpu7g9Av.js";
 import { v as openMeldToolsUpdateAttemptSchema, w as openMeldToolsUpdateRequestSourceSchema } from "./local-components-B6SCXZf9.js";
 import { r as daemonServiceLaneSchema } from "./service-contract-CRyDcIIf.js";
-import { n as resolveOpenMeldDistribution, t as isBinaryDistribution } from "./distribution-DY2fBeSW.js";
-import { r as readDaemonRuntimeLease } from "./daemon-runtime-lease-Dd4hdHNo.js";
-import { $ as readManagedCliInstallation, A as prepareDaemonServiceBundle, B as resolveDaemonServiceArtifact, Bt as isUnsafeProductionDeviceId, C as daemonServiceExecutableWrapperPath, Ct as resolveDaemonServiceUpdateWorkerLaunchdPlistPath, D as ensureDaemonServiceStableBinaryExecutable, Dt as resolveDaemonServiceUpdateWorkerWindowsScriptPath, E as discardPreparedDaemonServiceBundle, Et as resolveDaemonServiceUpdateWorkerSystemdUnitPath, F as restoreDaemonActiveBundleStateSnapshot, Ft as requestLocalDaemonShutdown, Ht as upsertDaemonServiceContract, I as runAuditedServiceManagerCarrierMutation, It as requestLocalSyncRouteCatalog, L as verifyDaemonActiveBundleIntegrity, Mt as LocalDaemonControlPlaneClientError, N as resolveDaemonBundleEntryPathFromState, O as ensureDaemonServiceUpdateWorkerBinaryExecutable, P as resolveInstalledDaemonBundleFingerprint, Pt as requestLocalDaemonServiceUpdateReadiness, Q as pruneManagedInstallVersions, R as writeDaemonServiceExecutableWrapper, Rt as clearDaemonServiceContract, S as daemonServiceBinaryExecutablePath, St as resolveDaemonServiceUpdateWorkerIdentity, T as daemonServiceUpdateWorkerBinaryPath, Tt as resolveDaemonServiceUpdateWorkerSystemdTimerUnitPath, U as readLatestDaemonLifecycleConnectionStateEvent, V as emitDaemonLifecycleEvent, Vt as readDaemonServiceContract, W as readLatestDaemonLifecycleOriginEvent, _ as matchesExpectedDaemonServiceManagerDefinition, a as resolveDaemonRuntimeState, at as persistPendingDaemonServiceUpdate, bt as daemonServiceUpdateWorkerNpmEntryPath, c as resolveObservedDaemonRuntimeStatus, ct as buildNextVersionState, d as inspectLegacySharedDaemonService, et as resolveCliSelfVersion, f as listDaemonOwnedProcesses, ft as fetchLatestPackageInfo, g as assertDaemonMaintenanceInstallationOwnership, gt as resolveBundledServiceRelease, ht as writeVersionState, i as readCurrentObservedDaemonRuntimeStatus, it as completePendingDaemonServiceUpdate, j as readDaemonActiveBundleState, k as isDaemonBundleSourceAllowedForLane, l as resolveObservedRuntimeCommandEntryPath, lt as compareSemver, m as normalizeDaemonCommandPath, mt as readVersionState, n as getEffectiveDaemonRuntimeStatus, nt as OPENMELD_VERSION, o as resolveDaemonServiceManagerForRuntimeState, pt as isPlainReleaseVersion, q as runDaemonServiceManagerAction, r as readCurrentDaemonRuntimeContext, rt as DAEMON_SERVICE_UPDATE_JOB_SCHEMA, s as waitForDaemonSystemServiceToStop, st as readPendingDaemonServiceUpdate, t as clearDaemonRuntimeStateIfDefinitelyStopped, tt as withManagedInstallTransaction, u as cleanupLegacySharedDaemonServiceState, vt as INDEPENDENT_MAINTENANCE_REGISTRATION, w as daemonServiceLauncherPath, wt as resolveDaemonServiceUpdateWorkerSystemdPathUnitPath, x as clearDaemonServiceUpdateWorkerBinaryExecutable, xt as hasIndependentMaintenanceRegistration, y as activateDaemonServiceBundle, yt as configureDaemonMaintenanceEnvironment, z as writeDaemonServiceLauncher, zt as isDaemonServiceContractIdentityReusable } from "./daemon-service-runtime-CY6wdBe1.js";
-import { i as windowsTaskActionArguments, n as runWindowsUserTask, r as windowsPowerShellPath } from "./windows-user-task-DqJWtlAm.js";
-import { C as updateConfiguredDeviceRuntimeState, T as updateConfiguredSkillsConfig, _ as getConfiguredViewCustomization, a as resolveBaseUrl, c as resolveExplicitGatewayUrlOrThrow, d as createDefaultRuntimeAgentControllerSettings, g as getConfiguredSkillsConfig, h as getConfiguredOpenMeldToolsMaintenance, i as normalizeGatewayBaseUrlOrNull, o as resolveBaseUrlOrNull, p as getConfiguredDeviceRuntimeState, v as getRuntimeConfigReadHealth, x as setConfiguredOpenMeldToolsMaintenance, y as resolveRuntimeSkillsCustomTargetId } from "./base-url-C6sHRNGu.js";
+import { r as readDaemonRuntimeLease } from "./daemon-runtime-lease-CIzOT1zx.js";
+import { $ as readManagedCliInstallation, A as prepareDaemonServiceBundle, B as resolveDaemonServiceArtifact, Bt as isUnsafeProductionDeviceId, C as daemonServiceExecutableWrapperPath, Ct as resolveDaemonServiceUpdateWorkerLaunchdPlistPath, D as ensureDaemonServiceStableBinaryExecutable, Dt as resolveDaemonServiceUpdateWorkerWindowsScriptPath, E as discardPreparedDaemonServiceBundle, Et as resolveDaemonServiceUpdateWorkerSystemdUnitPath, F as restoreDaemonActiveBundleStateSnapshot, Ft as requestLocalDaemonShutdown, Ht as upsertDaemonServiceContract, I as runAuditedServiceManagerCarrierMutation, It as requestLocalSyncRouteCatalog, L as verifyDaemonActiveBundleIntegrity, Mt as LocalDaemonControlPlaneClientError, N as resolveDaemonBundleEntryPathFromState, O as ensureDaemonServiceUpdateWorkerBinaryExecutable, P as resolveInstalledDaemonBundleFingerprint, Pt as requestLocalDaemonServiceUpdateReadiness, Q as pruneManagedInstallVersions, R as writeDaemonServiceExecutableWrapper, Rt as clearDaemonServiceContract, S as daemonServiceBinaryExecutablePath, St as resolveDaemonServiceUpdateWorkerIdentity, T as daemonServiceUpdateWorkerBinaryPath, Tt as resolveDaemonServiceUpdateWorkerSystemdTimerUnitPath, U as readLatestDaemonLifecycleConnectionStateEvent, V as emitDaemonLifecycleEvent, Vt as readDaemonServiceContract, W as readLatestDaemonLifecycleOriginEvent, _ as matchesExpectedDaemonServiceManagerDefinition, a as resolveDaemonRuntimeState, at as persistPendingDaemonServiceUpdate, bt as daemonServiceUpdateWorkerNpmEntryPath, c as resolveObservedDaemonRuntimeStatus, ct as buildNextVersionState, d as inspectLegacySharedDaemonService, et as resolveCliSelfVersion, f as listDaemonOwnedProcesses, ft as fetchLatestPackageInfo, g as assertDaemonMaintenanceInstallationOwnership, gt as resolveBundledServiceRelease, ht as writeVersionState, i as readCurrentObservedDaemonRuntimeStatus, it as completePendingDaemonServiceUpdate, j as readDaemonActiveBundleState, k as isDaemonBundleSourceAllowedForLane, l as resolveObservedRuntimeCommandEntryPath, lt as compareSemver, m as normalizeDaemonCommandPath, mt as readVersionState, n as getEffectiveDaemonRuntimeStatus, nt as OPENMELD_VERSION, o as resolveDaemonServiceManagerForRuntimeState, pt as isPlainReleaseVersion, q as runDaemonServiceManagerAction, r as readCurrentDaemonRuntimeContext, rt as DAEMON_SERVICE_UPDATE_JOB_SCHEMA, s as waitForDaemonSystemServiceToStop, st as readPendingDaemonServiceUpdate, t as clearDaemonRuntimeStateIfDefinitelyStopped, tt as withManagedInstallTransaction, u as cleanupLegacySharedDaemonServiceState, vt as INDEPENDENT_MAINTENANCE_REGISTRATION, w as daemonServiceLauncherPath, wt as resolveDaemonServiceUpdateWorkerSystemdPathUnitPath, x as clearDaemonServiceUpdateWorkerBinaryExecutable, xt as hasIndependentMaintenanceRegistration, y as activateDaemonServiceBundle, yt as configureDaemonMaintenanceEnvironment, z as writeDaemonServiceLauncher, zt as isDaemonServiceContractIdentityReusable } from "./daemon-service-runtime-CGT3yVOs.js";
+import { i as windowsTaskActionArguments, n as runWindowsUserTask, r as windowsPowerShellPath } from "./windows-user-task-i0oHCBc0.js";
+import { C as updateConfiguredDeviceRuntimeState, T as updateConfiguredSkillsConfig, _ as getConfiguredViewCustomization, a as resolveBaseUrl, c as resolveExplicitGatewayUrlOrThrow, d as createDefaultRuntimeAgentControllerSettings, g as getConfiguredSkillsConfig, h as getConfiguredOpenMeldToolsMaintenance, i as normalizeGatewayBaseUrlOrNull, o as resolveBaseUrlOrNull, p as getConfiguredDeviceRuntimeState, v as getRuntimeConfigReadHealth, x as setConfiguredOpenMeldToolsMaintenance, y as resolveRuntimeSkillsCustomTargetId } from "./base-url-BczddvzH.js";
+import { a as powerShellEncodedArguments, c as WINDOWS_RUNTIME_ENV_KEYS, l as normalizeCommandEnvironment, o as readWindowsProcessStartFileTime, r as isProcessIdentityAlive, s as resolveWindowsPowerShellPath, t as CURRENT_PROCESS_START_IDENTITY } from "./process-identity-Clby123a.js";
 import { n as writeDaemonLocalStateFile, t as readDaemonLocalStateFile } from "./daemon-local-state-file-jOXuXrky.js";
-import { A as getDaemonStatus, B as restoreDaemonInstallStateSnapshot, F as readDaemonServiceLifecycleLockMetaWithCleanup, I as readDaemonServiceRuntimeSnapshot, V as rotateDaemonControlPlaneTokenIfExpired, W as withDaemonServiceReconcileLock, _ as daemonRuntimeStateRootPath, a as DAEMON_SERVICE_RUNTIME_MODE_ENV, f as daemonLifecycleJournalPath, h as daemonRuntimeRootPath, i as DAEMON_SERVICE_RUNTIME_DETACHED_ENV, j as installDaemon, m as daemonRuntimeDataPath, n as DAEMON_SERVICE_RUNTIME_AUTO_START_ENV, r as DAEMON_SERVICE_RUNTIME_CONTROLLER_ENV, s as DAEMON_SERVICE_RUNTIME_SYSTEM_SERVICE_ENV } from "./daemon-state-C37ZtIZK.js";
-import { O as assertSafePublishedProductionServiceRegistrationMutation, S as resolveDaemonServiceManager, T as waitForLaunchdJobUnloaded, a as disableDaemonServiceAutostartIfConfigured, c as getDaemonSystemServiceLogPath, o as formatDaemonServiceJobDiagnosticsEvidence, s as getDaemonServiceLaunchdLabel, v as readDaemonServiceStartupPolicyCurrent, w as startLaunchdService } from "./daemon-service-manager-GiMCiTmu.js";
-import { a as formatOpenMeldCliCommand, c as formatOpenMeldCliTextBlock, i as formatInlineOpenMeldCliCommands, n as resolveOpenMeldEnvironmentTargetFromEnv, o as formatOpenMeldCliCommands, r as resolveAuthBaseUrl, t as resolveOpenMeldEnvironmentTarget } from "./openmeld-environment-target-NtJYJe1D.js";
+import { n as resolveOpenMeldDistribution, t as isBinaryDistribution } from "./distribution-BDQT2ilb.js";
+import { A as getDaemonStatus, B as restoreDaemonInstallStateSnapshot, F as readDaemonServiceLifecycleLockMetaWithCleanup, I as readDaemonServiceRuntimeSnapshot, V as rotateDaemonControlPlaneTokenIfExpired, W as withDaemonServiceReconcileLock, _ as daemonRuntimeStateRootPath, a as DAEMON_SERVICE_RUNTIME_MODE_ENV, f as daemonLifecycleJournalPath, h as daemonRuntimeRootPath, i as DAEMON_SERVICE_RUNTIME_DETACHED_ENV, j as installDaemon, m as daemonRuntimeDataPath, n as DAEMON_SERVICE_RUNTIME_AUTO_START_ENV, r as DAEMON_SERVICE_RUNTIME_CONTROLLER_ENV, s as DAEMON_SERVICE_RUNTIME_SYSTEM_SERVICE_ENV } from "./daemon-state-CoAZLwpi.js";
+import { O as assertSafePublishedProductionServiceRegistrationMutation, S as resolveDaemonServiceManager, T as waitForLaunchdJobUnloaded, a as disableDaemonServiceAutostartIfConfigured, c as getDaemonSystemServiceLogPath, o as formatDaemonServiceJobDiagnosticsEvidence, s as getDaemonServiceLaunchdLabel, v as readDaemonServiceStartupPolicyCurrent, w as startLaunchdService } from "./daemon-service-manager-DxS5eH_N.js";
+import { a as formatOpenMeldCliCommand, c as formatOpenMeldCliTextBlock, i as formatInlineOpenMeldCliCommands, n as resolveOpenMeldEnvironmentTargetFromEnv, o as formatOpenMeldCliCommands, r as resolveAuthBaseUrl, t as resolveOpenMeldEnvironmentTarget } from "./openmeld-environment-target-BWI2adGw.js";
 import { n as toErrorMessage$25, t as sleep } from "./dist-o3UL1EGQ.js";
-import { c as buildRequestAuthHeaders, d as buildOpenMeldRequestContextFromProfile, n as fetchSpaceRequestWithTimeout, s as buildOpenMeldRequestContextHeadersWithAuth, t as createCliApiClientFoundation } from "./api-client-foundation-km8Ol1P4.js";
+import { c as buildRequestAuthHeaders, d as buildOpenMeldRequestContextFromProfile, n as fetchSpaceRequestWithTimeout, s as buildOpenMeldRequestContextHeadersWithAuth, t as createCliApiClientFoundation } from "./api-client-foundation-CKRP7Ymg.js";
 import { a as encodePersistedOpenMeldToolsUpdateFailure, i as OpenMeldToolsUpdateFailureError, o as resolveOpenMeldToolsUpdateFailure, r as parseOpenMeldToolsUpdateFailureFrame, t as appendBoundedOpenMeldToolsUpdateProcessOutput } from "./openmeld-tools-update-process-frame-0X-t0Kjv.js";
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
 import { homedir, loadavg, tmpdir, userInfo } from "node:os";
-import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, parse, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, parse, relative, resolve, sep, win32 } from "node:path";
 import { access, chmod, copyFile, cp, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import * as z$1 from "zod/v4";
-import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync, watch, write } from "node:fs";
+import { accessSync, closeSync, constants, existsSync, openSync, readFileSync, readSync, realpathSync, statSync, watch, write } from "node:fs";
 import process$1 from "node:process";
 import { execFile, spawn } from "node:child_process";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
 import { connect, createServer } from "node:net";
+import { gzipSync } from "node:zlib";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { createOpencodeClient } from "@opencode-ai/sdk/v2";
 //#region ../../packages/schemas/dist/agent-controller-brand.js
@@ -177,6 +179,22 @@ const daemonRouteCatalogCacheSchema = z$1.discriminatedUnion("v", [
 	});
 });
 //#endregion
+//#region ../../packages/schemas/dist/schemas/daemon/windows-process-job.js
+const jobName = z$1.string().regex(/^Local\\OpenMeld-Process-[a-f0-9-]{36}$/u);
+const text = z$1.string().min(1).refine((value) => !value.includes("\0"));
+const windowsProcessJobRequestSchema = z$1.discriminatedUnion("operation", [z$1.strictObject({
+	operation: z$1.literal("launch"),
+	jobName,
+	executable: text,
+	commandLine: text.max(32766),
+	workingDirectory: text,
+	ownerPid: z$1.number().int().positive(),
+	ownerStartedAt: z$1.string().regex(/^\d{10,20}$/u)
+}), z$1.strictObject({
+	operation: z$1.literal("drain"),
+	jobName
+})]);
+//#endregion
 //#region ../../packages/schemas/dist/schemas/http/daemon-route-observation.js
 const daemonRouteObservationRouteSchema = z$1.discriminatedUnion("online", [z$1.strictObject({
 	online: z$1.literal(true),
@@ -231,7 +249,7 @@ function resolveOpenMeldAccountContext(input) {
 	};
 }
 async function resolveCurrentOpenMeldAccountContext() {
-	const { getAuthSessionMetadata } = await import("./auth-session-D6UDl3r3.js");
+	const { getAuthSessionMetadata } = await import("./auth-session-BWKfXWxl.js");
 	return resolveOpenMeldAccountContext({ session: await getAuthSessionMetadata().catch(() => null) });
 }
 function resolveHostKey(baseUrl) {
@@ -1511,7 +1529,7 @@ async function ensureDaemonSystemServiceCommandFiles(input) {
 function buildSystemServiceEnvironment() {
 	const env = {};
 	const runtimeUser = userInfo().username;
-	for (const [key, value] of Object.entries(process$1.env)) {
+	for (const [key, value] of Object.entries(normalizeCommandEnvironment(process$1.env))) {
 		if (typeof value !== "string" || value.length === 0 || !isDaemonServiceEnvironmentKey(key)) continue;
 		env[key] = sanitizeDaemonServiceEnvironmentValue(value);
 	}
@@ -1522,7 +1540,7 @@ function buildSystemServiceEnvironment() {
 	return env;
 }
 function isDaemonServiceEnvironmentKey(key) {
-	return DAEMON_SERVICE_ENV_KEY_WHITELIST.has(key);
+	return DAEMON_SERVICE_ENV_KEY_WHITELIST.has(key) || process$1.platform === "win32" && WINDOWS_RUNTIME_ENV_KEYS.some((candidate) => candidate === key);
 }
 function sanitizeDaemonServiceEnvironmentValue(value) {
 	let sanitized = "";
@@ -1947,6 +1965,460 @@ function createProviderOriginalError(value) {
 	return normalized.slice(0, OPENMELD_ORIGINAL_ERROR_MAX_LENGTH);
 }
 //#endregion
+//#region ../../runtime/adapters/core/dist/process-launch.js
+const CMD_META_CHARACTERS = /* @__PURE__ */ new Set("()[]%!^\"`<>&|;, *?");
+const BATCH_PATH_PATTERN = /\.(?:cmd|bat)$/iu;
+const NODE_SCRIPT_PATTERN = /\.(?:cjs|mjs|js)$/iu;
+const INVALID_BATCH_TEXT = /[\r\n\0]/u;
+const SCRIPT_LINES = /\r?\n/u;
+const NPM_NODE_SHIM_PREFIX = [
+	"@echo off",
+	"goto start",
+	":find_dp0",
+	"set dp0=%~dp0",
+	"exit /b",
+	":start",
+	"setlocal",
+	"call :find_dp0",
+	"if exist \"%dp0%\\node.exe\" (",
+	"set \"_prog=%dp0%\\node.exe\"",
+	") else (",
+	"set \"_prog=node\"",
+	"set pathext=%pathext:;.js;=;%",
+	")"
+];
+const NPM_NODE_SHIM_LAUNCH = /^endlocal & goto #_undefined_# 2>nul \|\| title %comspec% & "%_prog%"\s+"%dp0%[\\/]([^"\r\n]+)" %\*$/iu;
+/** Native argv at the process boundary; callers never interpolate args into a shell. */
+function resolvePlatformCommand(file, args, source = process.env, platform = process.platform) {
+	if (platform !== "win32") return {
+		bin: file,
+		args: [...args]
+	};
+	const env = normalizeCommandEnvironment(source, platform);
+	const command = resolveWindowsCommandPath(file, env);
+	const nodeScript = NODE_SCRIPT_PATTERN.test(command) ? command : readNpmNodeShimTarget(command);
+	if (nodeScript) return {
+		bin: resolveWindowsNodeExecutable(dirname(command), env),
+		args: [nodeScript, ...args]
+	};
+	if (!BATCH_PATH_PATTERN.test(command)) return {
+		bin: command,
+		args: [...args]
+	};
+	if ([command, ...args].some((value) => INVALID_BATCH_TEXT.test(value))) throw Object.assign(/* @__PURE__ */ new Error("This Windows batch wrapper cannot preserve multiline arguments. Select the native executable or Node script for this command."), { code: "WINDOWS_BATCH_ARGUMENT_UNSUPPORTED" });
+	const escapedArgs = args.map((value) => {
+		return escapeCmdText(escapeCmdText(quoteWindowsProcessArgument(value)));
+	});
+	const statement = [escapeCmdText(win32.normalize(command)), ...escapedArgs].join(" ");
+	if (statement.length > 8e3) throw Object.assign(/* @__PURE__ */ new Error("This Windows batch command is too long. Select its native executable or Node script instead."), { code: "WINDOWS_BATCH_ARGUMENT_UNSUPPORTED" });
+	const root = env.SystemRoot ?? env.WINDIR;
+	if (!(root && win32.isAbsolute(root))) throw new Error("Windows system directory is unavailable.");
+	return {
+		bin: win32.join(root, "System32", "cmd.exe"),
+		args: [
+			"/d",
+			"/v:off",
+			"/s",
+			"/c",
+			`"${statement}"`
+		],
+		windowsVerbatimArguments: true
+	};
+}
+/** Windows CRT argv quoting, also used when CreateProcessW receives native argv. */
+function quoteWindowsProcessArgument(value) {
+	if (value.includes("\0")) throw new Error("Process arguments must not contain a null byte.");
+	let quoted = "\"";
+	let slashes = 0;
+	for (const char of value) {
+		if (char === "\\") {
+			slashes += 1;
+			continue;
+		}
+		quoted += "\\".repeat(char === "\"" ? slashes * 2 + 1 : slashes) + char;
+		slashes = 0;
+	}
+	return `${quoted}${"\\".repeat(slashes * 2)}"`;
+}
+function escapeCmdText(value) {
+	return [...value].map((char) => CMD_META_CHARACTERS.has(char) ? `^${char}` : char).join("");
+}
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function resolveWindowsCommandPath(file, source = process.env) {
+	if (file.includes("/") || file.includes("\\") || win32.isAbsolute(file)) return file;
+	const env = normalizeCommandEnvironment(source, "win32");
+	const extensions = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean).map((item) => item.toLowerCase());
+	const names = extname(file) ? [file] : [...extensions.map((extension) => `${file}${extension}`), file];
+	for (const directory of (env.PATH ?? "").split(";").filter(Boolean)) for (const name of names) {
+		const candidate = join(directory, name);
+		if (isFile(candidate)) return candidate;
+	}
+	return file;
+}
+function resolveWindowsNodeExecutable(directory, env) {
+	const sibling = join(directory, "node.exe");
+	if (isFile(sibling)) return sibling;
+	const onPath = resolveWindowsCommandPath("node.exe", env);
+	if (onPath !== "node.exe" && isFile(onPath)) return onPath;
+	if (!process.versions.electron && basename(process.execPath).toLowerCase() === "node.exe") return process.execPath;
+	throw Object.assign(/* @__PURE__ */ new Error("Node.js is required to run this Windows CLI. Install the supported Node.js release, then try again."), { code: "NODE_RUNTIME_NOT_FOUND" });
+}
+function readNpmNodeShimTarget(file) {
+	if (!BATCH_PATH_PATTERN.test(file)) return null;
+	let descriptor;
+	try {
+		descriptor = openSync(file, "r");
+		const buffer = Buffer.alloc(65537);
+		const size = readSync(descriptor, buffer, 0, buffer.length, 0);
+		if (size > 65536) return null;
+		const lines = buffer.subarray(0, size).toString("utf8").split(SCRIPT_LINES).map((line) => line.trim()).filter(Boolean);
+		if (lines.length !== NPM_NODE_SHIM_PREFIX.length + 1 || !NPM_NODE_SHIM_PREFIX.every((line, index) => lines[index]?.toLowerCase() === line)) return null;
+		const target = lines.at(-1)?.match(NPM_NODE_SHIM_LAUNCH)?.[1];
+		if (!(target && NODE_SCRIPT_PATTERN.test(target)) || target.includes("%")) return null;
+		return resolve(dirname(file), target.replaceAll("\\", sep));
+	} catch {
+		return null;
+	} finally {
+		if (descriptor !== void 0) closeSync(descriptor);
+	}
+}
+function executePlatformFile(file, args, options, callback) {
+	try {
+		const env = normalizeCommandEnvironment(options.env ?? process.env);
+		const invocation = resolvePlatformCommand(file, args, env);
+		return execFile(invocation.bin, invocation.args, {
+			...options,
+			encoding: "utf8",
+			env,
+			...process.platform === "win32" ? {
+				shell: false,
+				windowsHide: true,
+				windowsVerbatimArguments: invocation.windowsVerbatimArguments ?? false
+			} : {}
+		}, callback);
+	} catch (error) {
+		const failure = error instanceof Error ? error : /* @__PURE__ */ new Error("The native command could not be prepared.");
+		queueMicrotask(() => callback(failure, "", ""));
+		return;
+	}
+}
+function executePlatformFileAsync(file, args, options = {}) {
+	if (process.platform !== "win32") return promisify(execFile)(file, [...args], {
+		...options,
+		encoding: "utf8"
+	});
+	return new Promise((resolveResult, reject) => {
+		executePlatformFile(file, args, options, (error, stdout, stderr) => {
+			if (error) reject(Object.assign(error, {
+				stdout,
+				stderr
+			}));
+			else resolveResult({
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+const execPlatformFile = Object.assign(executePlatformFile, { [promisify.custom]: executePlatformFileAsync });
+//#endregion
+//#region ../../runtime/adapters/core/dist/windows-process-job-native.js
+const WINDOWS_PROCESS_JOB_NATIVE_SOURCE = `
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+public static class OpenMeldProcessJobV1 {
+  const uint WaitTimeout = 258;
+  const uint WaitFailed = 0xffffffff;
+  const uint KillOnClose = 0x2000;
+  const uint ExtendedStartup = 0x00080000;
+  const uint NoWindow = 0x08000000;
+  const uint UnicodeEnvironment = 0x00000400;
+
+  [StructLayout(LayoutKind.Sequential)] struct BasicLimits {
+    public long ProcessTime, JobTime;
+    public uint Flags;
+    public UIntPtr MinWorkingSet, MaxWorkingSet;
+    public uint ActiveProcessLimit;
+    public UIntPtr Affinity;
+    public uint PriorityClass, SchedulingClass;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct IoCounters {
+    public ulong ReadOperations, WriteOperations, OtherOperations;
+    public ulong ReadBytes, WriteBytes, OtherBytes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ExtendedLimits {
+    public BasicLimits Basic;
+    public IoCounters Io;
+    public UIntPtr ProcessMemory, JobMemory, PeakProcessMemory, PeakJobMemory;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Accounting {
+    public long UserTime, KernelTime, PeriodUserTime, PeriodKernelTime;
+    public uint PageFaults, TotalProcesses, ActiveProcesses, TerminatedProcesses;
+  }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct StartupInfo {
+    public uint Size;
+    public string Reserved, Desktop, Title;
+    public uint X, Y, XSize, YSize, XCountChars, YCountChars, FillAttribute, Flags;
+    public ushort ShowWindow, ReservedBytes;
+    public IntPtr ReservedPointer, StandardInput, StandardOutput, StandardError;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct StartupInfoEx {
+    public StartupInfo Startup;
+    public IntPtr Attributes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ProcessInfo {
+    public IntPtr Process, Thread;
+    public uint ProcessId, ThreadId;
+  }
+
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateJobObjectW(IntPtr attributes, string name);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr OpenJobObjectW(uint access, bool inherit, string name);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetInformationJobObject(IntPtr job, int kind, ref ExtendedLimits limits, uint size);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool QueryInformationJobObject(IntPtr job, int kind, out Accounting info, uint size, IntPtr length);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool TerminateJobObject(IntPtr job, uint code);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, uint flags, ref IntPtr size);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr attribute, IntPtr value, IntPtr size, IntPtr previous, IntPtr returnedSize);
+  [DllImport("kernel32.dll")] static extern void DeleteProcThreadAttributeList(IntPtr list);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcessW(string application, StringBuilder command, IntPtr processAttributes, IntPtr threadAttributes, bool inherit, uint flags, IntPtr environment, string cwd, ref StartupInfoEx startup, out ProcessInfo process);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetExitCodeProcess(IntPtr process, out uint code);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetProcessTimes(IntPtr process, out long created, out long exited, out long kernel, out long user);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern uint WaitForSingleObject(IntPtr handle, uint timeout);
+  [DllImport("kernel32.dll")] static extern IntPtr GetCurrentProcess();
+  [DllImport("kernel32.dll", SetLastError=true)] static extern IntPtr GetStdHandle(int kind);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool DuplicateHandle(IntPtr sourceProcess, IntPtr source, IntPtr targetProcess, out IntPtr target, uint access, bool inherit, uint options);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool CloseHandle(IntPtr handle);
+
+  static void Check(bool ok, string operation) {
+    if (!ok) throw new Win32Exception(Marshal.GetLastWin32Error(), operation);
+  }
+  static IntPtr DuplicateStandard(int kind) {
+    IntPtr original = GetStdHandle(kind), copied;
+    if (original == IntPtr.Zero || original == new IntPtr(-1)) throw new InvalidOperationException("Standard stream unavailable");
+    Check(DuplicateHandle(GetCurrentProcess(), original, GetCurrentProcess(), out copied, 0, true, 2), "DuplicateHandle");
+    return copied;
+  }
+  static void WaitUntilEmpty(IntPtr job, bool terminate) {
+    if (terminate) Check(TerminateJobObject(job, 1223), "TerminateJobObject");
+    Stopwatch clock = Stopwatch.StartNew();
+    while (true) {
+      Accounting state;
+      Check(QueryInformationJobObject(job, 1, out state, (uint)Marshal.SizeOf(typeof(Accounting)), IntPtr.Zero), "QueryInformationJobObject");
+      if (state.ActiveProcesses == 0) return;
+      if (clock.ElapsedMilliseconds > 10000) throw new TimeoutException("Windows process cleanup was not confirmed");
+      Thread.Sleep(25);
+    }
+  }
+  public static void VerifyDrained(string name) {
+    IntPtr job = OpenJobObjectW(4, false, name);
+    if (job == IntPtr.Zero) {
+      int error = Marshal.GetLastWin32Error();
+      // After the supervisor exits, absence means no owner or associated process
+      // remains. No delayed launcher can subsequently create this Job.
+      if (error == 2) return;
+      throw new Win32Exception(error, "OpenJobObjectW");
+    }
+    try { WaitUntilEmpty(job, false); } finally { CloseHandle(job); }
+  }
+  public static int Run(string name, string executable, string command, string cwd, int ownerPid, string ownerStartedAt) {
+    IntPtr owner = IntPtr.Zero, job = IntPtr.Zero, attributes = IntPtr.Zero;
+    IntPtr jobs = IntPtr.Zero, handles = IntPtr.Zero;
+    IntPtr input = IntPtr.Zero, output = IntPtr.Zero, errorOutput = IntPtr.Zero;
+    ProcessInfo child = new ProcessInfo();
+    bool attributesInitialized = false;
+    try {
+      owner = OpenProcess(0x00101000, false, ownerPid);
+      Check(owner != IntPtr.Zero, "Open owner process");
+      long started, exited, kernel, user;
+      Check(GetProcessTimes(owner, out started, out exited, out kernel, out user), "GetProcessTimes");
+      if (started.ToString(CultureInfo.InvariantCulture) != ownerStartedAt || WaitForSingleObject(owner, 0) != WaitTimeout)
+        throw new InvalidOperationException("The launch owner is no longer alive");
+      job = CreateJobObjectW(IntPtr.Zero, name);
+      int createError = Marshal.GetLastWin32Error();
+      Check(job != IntPtr.Zero, "CreateJobObjectW");
+      if (createError == 183) throw new InvalidOperationException("Job identity collision");
+      ExtendedLimits limits = new ExtendedLimits();
+      limits.Basic.Flags = KillOnClose;
+      Check(SetInformationJobObject(job, 9, ref limits, (uint)Marshal.SizeOf(typeof(ExtendedLimits))), "SetInformationJobObject");
+
+      IntPtr size = IntPtr.Zero;
+      InitializeProcThreadAttributeList(IntPtr.Zero, 2, 0, ref size);
+      if (size == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error(), "Attribute list size");
+      attributes = Marshal.AllocHGlobal(size);
+      Check(InitializeProcThreadAttributeList(attributes, 2, 0, ref size), "InitializeProcThreadAttributeList");
+      attributesInitialized = true;
+      jobs = Marshal.AllocHGlobal(IntPtr.Size);
+      Marshal.WriteIntPtr(jobs, job);
+      // PROC_THREAD_ATTRIBUTE_JOB_LIST: no attach-after-spawn race, no breakaway.
+      Check(UpdateProcThreadAttribute(attributes, 0, new IntPtr(0x0002000d), jobs, new IntPtr(IntPtr.Size), IntPtr.Zero, IntPtr.Zero), "Set atomic Job assignment");
+      input = DuplicateStandard(-10); output = DuplicateStandard(-11); errorOutput = DuplicateStandard(-12);
+      handles = Marshal.AllocHGlobal(IntPtr.Size * 3);
+      Marshal.WriteIntPtr(handles, 0, input); Marshal.WriteIntPtr(handles, IntPtr.Size, output); Marshal.WriteIntPtr(handles, IntPtr.Size * 2, errorOutput);
+      Check(UpdateProcThreadAttribute(attributes, 0, new IntPtr(0x00020002), handles, new IntPtr(IntPtr.Size * 3), IntPtr.Zero, IntPtr.Zero), "Set inherited streams");
+      StartupInfoEx startup = new StartupInfoEx();
+      startup.Startup.Size = (uint)Marshal.SizeOf(typeof(StartupInfoEx));
+      startup.Startup.Flags = 0x100;
+      startup.Startup.StandardInput = input; startup.Startup.StandardOutput = output; startup.Startup.StandardError = errorOutput;
+      startup.Attributes = attributes;
+      Check(CreateProcessW(executable, new StringBuilder(command), IntPtr.Zero, IntPtr.Zero, true, ExtendedStartup | NoWindow | UnicodeEnvironment, IntPtr.Zero, cwd, ref startup, out child), "CreateProcessW in Job");
+      CloseHandle(input); input = IntPtr.Zero; CloseHandle(output); output = IntPtr.Zero; CloseHandle(errorOutput); errorOutput = IntPtr.Zero;
+      while (true) {
+        uint wait = WaitForSingleObject(child.Process, 100);
+        if (wait == 0) break;
+        Check(wait != WaitFailed, "Wait for controller");
+        if (WaitForSingleObject(owner, 0) != WaitTimeout) {
+          WaitUntilEmpty(job, true);
+          return 1223;
+        }
+      }
+      uint exitCode;
+      Check(GetExitCodeProcess(child.Process, out exitCode), "GetExitCodeProcess");
+      CloseHandle(child.Thread); child.Thread = IntPtr.Zero;
+      CloseHandle(child.Process); child.Process = IntPtr.Zero;
+      WaitUntilEmpty(job, true);
+      return unchecked((int)exitCode);
+    } finally {
+      if (child.Thread != IntPtr.Zero) CloseHandle(child.Thread);
+      if (child.Process != IntPtr.Zero) CloseHandle(child.Process);
+      if (job != IntPtr.Zero) CloseHandle(job);
+      if (owner != IntPtr.Zero) CloseHandle(owner);
+      if (input != IntPtr.Zero) CloseHandle(input);
+      if (output != IntPtr.Zero) CloseHandle(output);
+      if (errorOutput != IntPtr.Zero) CloseHandle(errorOutput);
+      if (attributesInitialized) DeleteProcThreadAttributeList(attributes);
+      if (attributes != IntPtr.Zero) Marshal.FreeHGlobal(attributes);
+      if (jobs != IntPtr.Zero) Marshal.FreeHGlobal(jobs);
+      if (handles != IntPtr.Zero) Marshal.FreeHGlobal(handles);
+    }
+  }
+}
+`;
+//#endregion
+//#region ../../runtime/adapters/core/dist/windows-process-job.js
+const REQUEST_ENV = "OPENMELD_NATIVE_JOB_REQUEST";
+const DRAIN_RECEIPT = "openmeld-windows-job-drained-v1";
+const CLEANUP_TIMEOUT_MS = 15e3;
+const WINDOWS_PROCESS_JOB_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+$WarningPreference = 'SilentlyContinue'
+try {
+  $raw = [Environment]::GetEnvironmentVariable('${REQUEST_ENV}', 'Process')
+  [Environment]::SetEnvironmentVariable('${REQUEST_ENV}', $null, 'Process')
+  $r = ConvertFrom-Json ([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($raw)))
+  $compressed = New-Object IO.MemoryStream(,([Convert]::FromBase64String('${gzipSync(Buffer.from(WINDOWS_PROCESS_JOB_NATIVE_SOURCE, "utf8")).toString("base64")}')))
+  $gzip = New-Object IO.Compression.GZipStream($compressed, [IO.Compression.CompressionMode]::Decompress)
+  $reader = New-Object IO.StreamReader($gzip, [Text.Encoding]::UTF8)
+  try { $source = $reader.ReadToEnd() } finally { $reader.Dispose(); $compressed.Dispose() }
+  Add-Type -TypeDefinition $source -ErrorAction Stop
+  if ($r.operation -eq 'drain') {
+    [OpenMeldProcessJobV1]::VerifyDrained($r.jobName)
+    [Console]::Write('${DRAIN_RECEIPT}')
+    exit 0
+  }
+  if ($r.operation -ne 'launch') { throw 'Unknown process operation' }
+  $exitCode = [OpenMeldProcessJobV1]::Run($r.jobName, $r.executable, $r.commandLine, $r.workingDirectory, $r.ownerPid, $r.ownerStartedAt)
+  exit $exitCode
+} catch {
+  $cause = $_.Exception.GetBaseException()
+  $code = $(if ($cause -is [ComponentModel.Win32Exception]) { $cause.NativeErrorCode } else { $cause.GetType().Name })
+  [Console]::Error.WriteLine('openmeld.windows_process.failed: ' + $code)
+  exit 125
+}
+`;
+function spawnWindowsJobProcess(input) {
+	const env = normalizeCommandEnvironment(input.env, "win32");
+	const executable = resolveWindowsCommandPath(input.invocation.bin, env);
+	if (!(win32.isAbsolute(executable) && win32.isAbsolute(input.cwd))) throw Object.assign(/* @__PURE__ */ new Error("The selected Windows controller needs an absolute executable and working directory."), { code: "ENOENT" });
+	const ownerStartedAt = readWindowsProcessStartFileTime(process.pid);
+	if (!ownerStartedAt) throw new Error("Windows could not verify the process that owns this invocation.");
+	const jobName = `Local\\OpenMeld-Process-${randomUUID()}`;
+	const commandLine = [quoteWindowsProcessArgument(executable), ...input.invocation.args.map((arg) => input.invocation.windowsVerbatimArguments ? arg : quoteWindowsProcessArgument(arg))].join(" ");
+	const request = windowsProcessJobRequestSchema.parse({
+		operation: "launch",
+		jobName,
+		executable,
+		commandLine,
+		workingDirectory: input.cwd,
+		ownerPid: process.pid,
+		ownerStartedAt
+	});
+	const payload = Buffer.from(JSON.stringify(request), "utf8").toString("base64");
+	if (payload.length > 32e3) throw new Error("The Windows controller arguments exceed the native launch envelope. Send large input through stdin instead.");
+	const powershell = resolveWindowsPowerShellPath(env);
+	const child = spawn(powershell, powerShellEncodedArguments(WINDOWS_PROCESS_JOB_SCRIPT), {
+		cwd: input.cwd,
+		env: {
+			...env,
+			[REQUEST_ENV]: payload
+		},
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	const closed = new Promise((resolve) => child.once("close", () => resolve()));
+	const terminate = (signal) => {
+		if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) return false;
+		return child.kill(signal);
+	};
+	return {
+		child,
+		terminate,
+		async cleanup() {
+			let timer;
+			let signalSent = false;
+			try {
+				signalSent = terminate("SIGKILL");
+				await Promise.race([closed, new Promise((_resolve, reject) => {
+					timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Windows supervisor exit could not be confirmed.")), CLEANUP_TIMEOUT_MS);
+				})]);
+				const drain = windowsProcessJobRequestSchema.parse({
+					operation: "drain",
+					jobName
+				});
+				const { stdout } = await promisify(execFile)(powershell, powerShellEncodedArguments(WINDOWS_PROCESS_JOB_SCRIPT), {
+					env: {
+						...env,
+						[REQUEST_ENV]: Buffer.from(JSON.stringify(drain), "utf8").toString("base64")
+					},
+					encoding: "utf8",
+					windowsHide: true,
+					timeout: CLEANUP_TIMEOUT_MS,
+					maxBuffer: 4096
+				});
+				if (stdout !== DRAIN_RECEIPT) throw new Error("Windows returned an invalid process cleanup receipt.");
+				return {
+					ok: true,
+					signalSent
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					signalSent,
+					error
+				};
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		}
+	};
+}
+//#endregion
 //#region ../../runtime/adapters/core/dist/agent-controller-process.js
 const PROCESS_TABLE_COLUMN_SEPARATOR = /\s+/u;
 const PROCESS_TABLE_LINE_SEPARATOR = /\r?\n/u;
@@ -2048,14 +2520,36 @@ const processDiscoveryDiagnostics = createAgentControllerProcessDiscoveryDiagnos
 function spawnAgentControllerProcess(input) {
 	const signalTarget = resolveAgentControllerProcessSignalTarget();
 	const supervisionId = input.supervisionId ?? randomUUID();
-	const child = spawn(input.bin, input.args, {
+	const env = {
+		...normalizeCommandEnvironment(input.env),
+		[PROCESS_SUPERVISION_ENV_KEY]: supervisionId
+	};
+	const invocation = resolvePlatformCommand(input.bin, input.args, env);
+	if (process.platform === "win32") {
+		const job = spawnWindowsJobProcess({
+			invocation,
+			env,
+			cwd: input.cwd
+		});
+		return {
+			child: job.child,
+			processId: job.child.pid ?? null,
+			signalTarget,
+			supervisionId,
+			terminate: job.terminate,
+			terminateRemainingDescendants: job.cleanup
+		};
+	}
+	const child = spawn(invocation.bin, invocation.args, {
 		cwd: input.cwd,
 		detached: signalTarget === "process_group",
 		env: {
-			...input.env,
+			...env,
 			[PROCESS_SUPERVISION_ENV_KEY]: supervisionId
 		},
 		shell: input.shell,
+		windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+		windowsHide: true,
 		stdio: [
 			"pipe",
 			"pipe",
@@ -4095,6 +4589,7 @@ const USER_FACING_CLI_COMMAND_ENV = "OPENMELD_USER_FACING_CLI_COMMAND";
 const SPACE_ACTION_TOOL_COMMAND_PATH_ENV = "OPENMELD_SPACE_ACTION_TOOL_COMMAND_PATH";
 const OPENMELD_SPACE_ACTION_MCP_SERVER_ID = "openmeld_internal_dispatch_space_action";
 const OPENMELD_SPACE_ACTION_MCP_TOOL_NAMES = [
+	"working_copy",
 	"read_file",
 	"read_history",
 	"list_tasks",
@@ -6020,6 +6515,67 @@ function normalizeOptionalText$40(value) {
 	return normalized.length > 0 ? normalized : null;
 }
 //#endregion
+//#region ../../runtime/adapters/claude-code/dist/transport/claude-windows-process.js
+/** Use the SDK's public spawn contract; its forwarded abort follows stdin-EOF grace. */
+function createClaudeWindowsProcessLauncher(command) {
+	const active = /* @__PURE__ */ new Map();
+	return {
+		spawn(options, onStderr) {
+			if (options.command !== command.bin) throw new Error("Claude SDK changed the selected controller executable.");
+			if (options.signal.aborted) throw new DOMException("Claude invocation was cancelled before launch.", "AbortError");
+			const runtime = spawnAgentControllerProcess({
+				bin: command.bin,
+				args: [...command.argsPrefix, ...options.args],
+				cwd: options.cwd ?? process.cwd(),
+				env: options.env,
+				shell: false
+			});
+			const { child } = runtime;
+			let killed = false;
+			const kill = (signal) => {
+				const sent = runtime.terminate(signal);
+				killed ||= sent;
+				return sent;
+			};
+			const abort = () => kill("SIGKILL");
+			const closed = new Promise((resolve) => {
+				child.once("close", () => {
+					options.signal.removeEventListener("abort", abort);
+					resolve();
+				});
+			});
+			active.set(runtime, closed);
+			child.stderr.setEncoding("utf8");
+			child.stderr.on("data", onStderr);
+			options.signal.addEventListener("abort", abort, { once: true });
+			if (options.signal.aborted) abort();
+			return {
+				stdin: child.stdin,
+				stdout: child.stdout,
+				get killed() {
+					return killed;
+				},
+				get exitCode() {
+					return child.exitCode;
+				},
+				kill,
+				on: child.on.bind(child),
+				once: child.once.bind(child),
+				off: child.off.bind(child)
+			};
+		},
+		async cleanup() {
+			await Promise.all([...active].map(async ([runtime, closed]) => {
+				runtime.terminate("SIGKILL");
+				const result = await runtime.terminateRemainingDescendants();
+				if (!result.ok) throw result.error;
+				await closed;
+				active.delete(runtime);
+			}));
+		}
+	};
+}
+//#endregion
 //#region ../../runtime/adapters/claude-code/dist/transport/claude-agent-sdk-transport.js
 var ClaudeAgentSdkTransportError = class extends Error {
 	code;
@@ -6114,6 +6670,7 @@ async function invokeClaudeAgentSdkTransport(input) {
 					stderrChunks.push(chunk);
 				},
 				pathToClaudeCodeExecutable: resources.executable.pathToClaudeCodeExecutable,
+				spawnProcess: resources.executable.spawnProcess,
 				planDirectory: resources.planCapture.directory,
 				sessionId: normalizeOptionalText$39(input.sessionId),
 				streamingMode: input.streamingMode
@@ -6335,20 +6892,30 @@ async function createClaudePlanCapture(enabled) {
 }
 async function resolveClaudeAgentSdkExecutable(input) {
 	const launchCommand = materializeCliLaunchCommand({ launchContract: input.launchContract });
+	if (process.platform === "win32") {
+		const invocation = resolvePlatformCommand(launchCommand.bin, launchCommand.argsPrefix);
+		const selected = invocation.windowsVerbatimArguments ? launchCommand : {
+			bin: invocation.bin,
+			argsPrefix: invocation.args
+		};
+		const launcher = createClaudeWindowsProcessLauncher(selected);
+		return {
+			cleanup: launcher.cleanup,
+			pathToClaudeCodeExecutable: selected.bin,
+			spawnProcess: launcher.spawn
+		};
+	}
 	if (launchCommand.argsPrefix.length === 0 && launchCommand.shell !== true) return {
 		cleanup: async () => void 0,
 		pathToClaudeCodeExecutable: launchCommand.bin
 	};
 	const wrapperDir = await mkdtemp(join(tmpdir(), "openmeld-claude-sdk-"));
-	const wrapperPath = process.platform === "win32" ? join(wrapperDir, "claude-code-wrapper.cmd") : join(wrapperDir, "claude-code-wrapper");
-	await writeFile(wrapperPath, process.platform === "win32" ? buildWindowsWrapperScript({
-		argsPrefix: launchCommand.argsPrefix,
-		bin: launchCommand.bin
-	}) : buildPosixWrapperScript({
+	const wrapperPath = join(wrapperDir, "claude-code-wrapper");
+	await writeFile(wrapperPath, buildPosixWrapperScript({
 		argsPrefix: launchCommand.argsPrefix,
 		bin: launchCommand.bin
 	}), "utf8");
-	if (process.platform !== "win32") await chmod(wrapperPath, 493);
+	await chmod(wrapperPath, 493);
 	return {
 		cleanup: async () => {
 			await rm(wrapperDir, {
@@ -6360,6 +6927,7 @@ async function resolveClaudeAgentSdkExecutable(input) {
 	};
 }
 function buildClaudeAgentSdkOptions(input) {
+	const spawnProcess = input.spawnProcess;
 	const spaceActionMcpServer = resolveDispatchSpaceActionMcpServer(input.env);
 	if (input.executionContext && input.executionContext.access !== "space_context") throw new Error("execution_context.file_access_unsupported");
 	const permissionMode = resolveClaudePermissionMode({
@@ -6378,6 +6946,7 @@ function buildClaudeAgentSdkOptions(input) {
 		},
 		includePartialMessages: input.onRuntimeEvent !== void 0 || input.streamingMode === "stream" || input.onInteractionRequest !== void 0,
 		pathToClaudeCodeExecutable: input.pathToClaudeCodeExecutable,
+		...spawnProcess ? { spawnClaudeCodeProcess: (options) => spawnProcess(options, input.onStderr) } : {},
 		...spaceActionMcpServer ? { mcpServers: { [spaceActionMcpServer.id]: {
 			args: [...spaceActionMcpServer.args],
 			command: spaceActionMcpServer.commandPath,
@@ -6593,23 +7162,9 @@ function buildPosixWrapperScript(input) {
 		""
 	].join("\n");
 }
-function buildWindowsWrapperScript(input) {
-	return [
-		"@echo off",
-		[
-			quoteWindowsArg(input.bin),
-			...input.argsPrefix.map(quoteWindowsArg),
-			"%*"
-		].join(" "),
-		""
-	].join("\r\n");
-}
 function shellQuote(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
-function quoteWindowsArg(value) {
-	return `"${value.replaceAll("\"", "\"\"")}"`;
-}
 function normalizeOptionalText$39(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
@@ -7326,7 +7881,8 @@ function isCodexExecutionContextFileAccessConfirmed(value, boundary, workingDire
 	return sandbox?.type === "workspaceWrite" && sandbox.excludeTmpdirEnvVar === true && sandbox.excludeSlashTmp === true && Array.isArray(sandbox.writableRoots) && sandbox.writableRoots.every((root) => typeof root === "string" && boundary.folders.includes(root));
 }
 function resolveCodexExecutionContextAccess(boundary, executionMode) {
-	return executionMode === "repair" && boundary.executionContextAccess === "workspace" ? "read_only" : boundary.executionContextAccess;
+	const access = boundary.executionContextAccess === "space_context" && boundary.workingCopyId ? "workspace" : boundary.executionContextAccess;
+	return executionMode === "repair" && access === "workspace" ? "read_only" : access;
 }
 function recordValue(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
@@ -7407,7 +7963,7 @@ function tomlString(value) {
 }
 //#endregion
 //#region ../../runtime/adapters/codex/dist/transport/codex-scoped-mcp.js
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$2 = promisify(execPlatformFile);
 const MCP_INVENTORY_TIMEOUT_MS = 15e3;
 const MCP_INVENTORY_MAX_BYTES = 1024 * 1024;
 const MCP_AUTH_STATUSES = /* @__PURE__ */ new Set([
@@ -7546,7 +8102,7 @@ printf '%s:%s:%s:%s' "$outside_read" "$outside_write" "$inside_read" "$inside_wr
 async function verifyCodexWorkspaceAccess(input) {
 	if (!input.boundary.executionContextAccess) return;
 	const boundaryRoot = input.boundary.folders[0];
-	if (process.platform === "win32" || input.boundary.folders.length !== 1 || !boundaryRoot) throw new Error("execution_context.workspace_probe_unsupported");
+	if (input.boundary.folders.length !== 1 || !boundaryRoot) throw new Error("execution_context.workspace_probe_unsupported");
 	const outsideDirectory = await mkdtemp(join(dirname(boundaryRoot), ".openmeld-access-probe-"));
 	const outsidePath = join(outsideDirectory, "sentinel");
 	const insidePath = join(input.workingDirectory, `.openmeld-access-probe-${randomUUID()}`);
@@ -7560,14 +8116,7 @@ async function verifyCodexWorkspaceAccess(input) {
 			mode: 384
 		});
 		const result = await input.execute({
-			command: [
-				"/bin/sh",
-				"-c",
-				PROBE_SCRIPT,
-				"openmeld-probe",
-				outsidePath,
-				insidePath
-			],
+			command: buildCodexWorkspaceProbeCommand(outsidePath, insidePath),
 			cwd: input.workingDirectory,
 			permissionProfile: CODEX_FILE_ACCESS_PERMISSION_PROFILE,
 			timeoutMs: 5e3,
@@ -7583,6 +8132,27 @@ async function verifyCodexWorkspaceAccess(input) {
 		});
 	}
 }
+function buildCodexWorkspaceProbeCommand(outsidePath, insidePath, platform = process.platform, env = process.env) {
+	if (platform !== "win32") return [
+		"/bin/sh",
+		"-c",
+		PROBE_SCRIPT,
+		"openmeld-probe",
+		outsidePath,
+		insidePath
+	];
+	const script = `
+$ErrorActionPreference = 'Stop'
+$paths = ConvertFrom-Json ([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${Buffer.from(JSON.stringify([outsidePath, insidePath]), "utf8").toString("base64")}')))
+$results = @()
+foreach ($path in $paths) {
+  try { $null = [IO.File]::ReadAllText($path); $results += 'allowed' } catch { $results += 'denied' }
+  try { [IO.File]::WriteAllText($path, ('changed' + [char]10)); $results += 'allowed' } catch { $results += 'denied' }
+}
+[Console]::Write(($results -join ':'))
+`;
+	return [resolveWindowsPowerShellPath(env), ...powerShellEncodedArguments(script)];
+}
 //#endregion
 //#region ../../runtime/adapters/codex/dist/transport/codex-app-server-transport.js
 const CODEX_APP_SERVER_VERSION_PATTERN = /\/([^\s]+)/u;
@@ -31138,9 +31708,9 @@ function createModelCatalogReadSession(input) {
 async function readModelCatalogOnce(baseUrl) {
 	try {
 		const [apiClient, baseUrlModule, clientFoundationModule] = await Promise.all([
-			import("./dist-Bsz_wafH.js"),
-			import("./base-url-BE3pFiOZ.js"),
-			import("./api-client-foundation-TEBOwWl1.js")
+			import("./dist-CABuqfdH.js"),
+			import("./base-url-CfyKRz89.js"),
+			import("./api-client-foundation-BYnU1pbS.js")
 		]);
 		if (typeof apiClient.createConfigApi !== "function") throw new Error("config api client is unavailable");
 		const resolvedBaseUrl = baseUrl ?? await baseUrlModule.resolveBaseUrl();
@@ -38071,4 +38641,4 @@ function isNewerTargetVersion(candidate, current) {
 //#endregion
 export { buildDaemonServiceDependencyTitle as $, readDaemonCatalogSyncSignal as $a, describeServerRequiredVersionUnavailableReason as $i, ProjectBindingStoreUpdateRequiredError as $n, settleInflightTask as $r, resolveCurrentDaemonExpectedVersion as $t, formatDeviceReplyReadinessLabel as A, HEARTBEAT_RESPONSE_TIMEOUT_MS as Aa, createLocalAdapterEntries as Ai, setAgentRegistrationEnabled as An, createInflightTaskControlRegistry as Ar, uninstallDaemonServiceUpdateWorker as At, resolveGatewayChainReadiness as B, resolveViewProfileKey as Ba, forkCodexAppServerThread as Bi, resolveSkillsAgentRegistry as Bn, resolveDispatchContinuityObservation as Br, toStartBackgroundHelperExecutionCompatibility as Bt, formatDaemonServiceRefreshReliabilityMessage as C, CONTROLLED_SHUTDOWN_RESULT_ACK_TIMEOUT_MS as Ca, resolveAgentExecutionStatus as Ci, listAgentTargetStates as Cn, buildDispatchReplyContextSummary as Cr, readLastOpenMeldToolsUpdateAttempt as Ct, writeDaemonStartFailureState as D, DAEMON_STREAM_KEEPALIVE_INTERVAL_MS as Da, resolveSelectableCandidates as Di, reconcileNewRunnableBuiltinAgentsForSetup as Dn, createLocalTaskInterruptSender as Dr, writeOpenMeldToolsMaintenancePolicy as Dt, clearDaemonStartFailureState as E, DAEMON_STREAM_CONNECT_TIMEOUT_MS as Ea, resolveNativeAgentControllerPermissionModeForController as Ei, reconcileNewRunnableBuiltinAgentRegistrations as En, mergeOpenClawGatewayVisibility as Er, resolveOpenMeldToolsMaintenanceProjection as Et, formatSpaceMemberCommandRecoveryCopy as F, RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_INTERVAL_MS as Fa, probeGrokBuildAcpInterface as Fi, parseAgentEnabledOption as Fn, applyIntervalJitterMs as Fr, readCurrentDaemonOwnerSnapshot as Ft, PREPARE_SESSION_RECONNECT_GRACE_MS as G, createOpenMeldHumanProfile as Ga, createUnsupportedProviderUsageLimits as Gi, EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES as Gn, buildRuntimeWorkspaceFingerprint as Gr, isVersionDowngrade as Gt, resolveGatewayChainRetryGuidance as H, requireOpenMeldProfile as Ha, verifyCodexAppServerThread as Hi, resolveRegistryOriginLaunchCommand as Hn, resolveCompatibleConversationExecutionState as Hr, readDaemonRuntimeContractRepairReport as Ht, resolveReplyReadinessAvailabilityReasonCopy as I, RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_RETRY_INTERVAL_MS as Ia, resolveInstalledGrokBuildLaunchCandidates as Ii, sortAgentRegistrations as In, pruneStaleLeases as Ir, resolveDaemonStopStrategy as It, getSetupFlowCopy as J, listOpenMeldProfiles as Ja, materializeCliLaunchCommand as Ji, isHomebrewCommandPath as Jn, commitResolvedAgentContext as Jr, DAEMON_SERVICE_FULL_ALIGNMENT_ANOMALIES as Jt, buildDaemonRouteObservationPresentation as K, deleteOpenMeldProfile as Ka, resolveDispatchSpaceActionMcpServer as Ki, resolveBuiltinAgentControllerDefinition as Kn, buildTaskResultEnvelope as Kr, resolveVersionChangeDirection as Kt, resolveReplyReadinessGuidanceSummaryCopy as L, RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS as La, projectCodexUsageLimits as Li, repairBuiltinControllerInstall as Ln, resolveAdaptiveHeartbeatIntervalMs as Lr, resolveStoppedContractWriteBlockedReason as Lt, formatReplyReadinessSummary as M, PROVIDER_CONVERSATION_PROOF_SYNC_INTERVAL_MS as Ma, forkOpenCodeServerSession as Mi, updateAgentRegistrations as Mn, MAX_HEARTBEAT_INTERVAL_MS as Mr, buildDaemonOwnerSnapshotFromObservedState as Mt, mapAgentReplyReadinessToLegacyAutoReply as N, PROVIDER_CONVERSATION_PROOF_SYNC_RETRY_INTERVAL_MS as Na, resolveInstalledOpenCodeLaunchCandidates as Ni, normalizeAgentId as Nn, MIN_HEARTBEAT_INTERVAL_MS as Nr, formatDaemonOwnerSummaryLabel as Nt, resolveCurrentReplyReadinessSnapshot as O, DAEMON_STREAM_KEEPALIVE_PONG_TIMEOUT_MS as Oa, resolveCatalogSyncSkippedProfilesLogState as Oi, removeAgentCustomTarget as On, buildLocalServiceDiagnosticsPayload as Or, ensureDaemonServiceMaintenanceInstalled as Ot, REPLY_READINESS_COPY as P, REGISTER_RESPONSE_TIMEOUT_MS as Pa, GrokBuildAcpTransportError as Pi, normalizeAgentIds as Pn, applyAcceptedLeases as Pr, hasActiveDaemonOwners as Pt, buildDaemonServiceDependencySummary as Q, assertAdditionalHumanProfileCreationEnabled as Qa, assessServerRequiredVersion as Qi, ProjectBindingOperationError as Qn, seedLegacyAgentContext as Qr, classifyDaemonServiceWakeability as Qt, resolveOpenClawDiagnosticsGuidance as R, parseCliViewMode as Ra, resolveCodexTimeoutMs as Ri, canManageRegistryAgentSkillTargets as Rn, resolveCatalogSyncIntervalMs as Rr, summarizeDaemonOwnerSnapshot as Rt, buildDaemonServiceUpdateRequiredNextStep as S, CONTROLLED_SHUTDOWN_REQUEST_TIMEOUT_MS as Sa, resolveAgentControllerPermissionModeForController as Si, listAgentRegistrations as Sn, createSerialAgentInteractionCallback as Sr, readOpenMeldToolsUpdateContextFromEnv as St, resolveDaemonServiceFreshnessWarning as T, DAEMON_RUNTIME_CONTRACT_EPOCH as Ta, resolveEvidenceSyncHealth as Ti, readAgentRuntimeConfigHealth as Tn, createPendingAgentInteractionRegistry as Tr, readOpenMeldToolsMaintenancePolicy as Tt, resolveOpenClawLocalDiagnosticsValue as U, resolveOpenMeldProfileOrNull as Ua, resolveInstalledClaudeCodeLaunchCandidates as Ui, resolveRegistryRuntimeAdapterCapabilitySnapshot as Un, resolveLatestScopedConversationExecutionState as Ur, buildDaemonServiceTargetSpec as Ut, resolveGatewayChainRepairGuidance as V, isSelectedOpenMeldProfileRequiredError as Va, resolveCodexAppServerCompletedTurn as Vi, listBuiltinAgentsRegistryEntries as Vn, resolveCompatibleAgentContextMatch as Vr, ensureDaemonRuntimeContractState as Vt, resolveLocalServiceDemand as W, createOpenMeldAgentProfile as Wa, createUnavailableProviderUsageLimits as Wi, resolveRegistryRuntimeAdapterContractByAgentControllerRef as Wn, runRuntimeTask as Wr, resolveDaemonServiceAlignmentDecision as Wt, buildDaemonServiceDependencyMeaning as X, resolveOpenMeldProfile as Xa, createProviderOriginalError as Xi, isPnpmGlobalCommandPath as Xn, removeConversationExecutionState as Xr, DAEMON_SERVICE_WAKEABILITY_ADVISORY_ANOMALIES as Xt, buildDaemonServiceDependencyDetails as Y, primeOpenMeldProfilesSessionCache as Ya, listAgentControllerSupervisedProcessIds as Yi, isNpmGlobalCommandPath as Yn, loadLedgerState as Yr, DAEMON_SERVICE_REPAIR_ANOMALIES as Yt, buildDaemonServiceDependencyNextStep as Z, updateOpenMeldProfile as Za, resolveServiceUpdateUrgency as Zi, notifyDaemonRouteCatalogChanged as Zn, resolveConversationExecutionStateByLookupKey as Zr, classifyDaemonServiceRunStartability as Zt, resolveServiceReadinessFromServiceStatus as _, isCliUpdateCheckApplicable as _a, parseAgentControllerRef as _i, validateCustomProfileWorkspacePath as _n, resolveCurrentOpenMeldAccountContext as _o, syncRuntimeEventToInflightTaskControlRegistry as _r, syncDeviceRuntimeStateProjection as _t, isDaemonInventoryRunningAndStartReady as a, resolvePreferredDaemonDeviceId as aa, DEFAULT_TASK_LIFECYCLE_HEARTBEAT_INTERVAL_MS as ai, readLocalEnabledControllers as an, buildAgentAuthenticationGuide as ao, removeAgentActivityBindingsWhileDeliveryLocked as ar, slugifyOpenClawNamePart as at, buildDaemonServiceRepairGuidance as b, CATALOG_SYNC_RETRY_INTERVAL_MS as ba, renderInformationProtectionPrompt as bi, createRegistrationFromCatalogTarget as bn, isDaemonReconcileInProgressError as br, resolveLocalRegistryAgentIdFromAgentControllerRef as bt, waitForSystemServiceStartup as c, emitRunLine as ca, buildInformationProtectionPromptPlan as ci, resolveProfileWorkspaceRuntime as cn, buildHumanAuthenticationCard as co, resolveProjectBindingForPath as cr, createMutableRouteCatalogState as ct, captureDaemonServiceEvidenceBestEffort as d, normalizeOptionalText$51 as da, createAgentExecutionStatusDisplayRows as di, readProfileWorkspaceConfig as dn, resolveAuthenticationGuidance as do, unbindProject as dr, summarizeSkippedDaemonProfiles as dt, buildLocalAgentCatalogFromReadiness as ea, upsertConversationExecutionState as ei, emitDriftDetectedEvidence as en, alignSelectedOpenMeldProfileStorage as eo, bindProject as er, resolveDaemonServiceDependencyDiagnostics as et, formatDaemonFailureContextText as f, normalizeText$11 as fa, createAuthorityOpenMeldServiceRuntimeId as fi, readProfileWorkspaceConfigForAccount as fn, resolveAuthenticationGuidanceFromError as fo, canonicalizeLocalProjectPath as fr, syncDaemonRouteCatalogState as ft, resolveServiceReadiness as g, assessCliUpdate as ga, listAgentControllerPermissionModeOptions as gi, setOpenMeldManagedProfileWorkspace as gn, setProfileDefaultView as go, normalizeDispatchThreadAction as gr, NO_LOCAL_AGENTS_NEED_OPENMELD_SERVICE_REASON as gt, resolveDaemonStatusAuthenticationAttention as h, warnDaemonEvent as ha, isAgentExecutionReadyOrConnecting as hi, setCustomProfileWorkspace as hn, getProfileDefaultView as ho, withAgentActivityLocalStateLock as hr, resolveCurrentEffectiveProfileWorkingFolderRuntime as ht, runDaemonServiceLifecycle as i, resolveDaemonDeviceId as ia, buildAgentContextLookupKey as ii, buildRuntimeRouteTargets as in, setSelectedOpenMeldProfileId as io, migrateProjectBindingStore as ir, normalizeOpenClawSpaceIdPrefix as it, formatHumanReplyReadinessReason as j, MAX_RECONNECT_DELAY_MS as ja, parseOpenCodeGoUsageResponse as ji, updateAgentCustomTarget as jn, ADAPTIVE_HEARTBEAT_JITTER_RATIO as jr, inspectDaemonServiceInventory as jt, formatAgentReplyReadinessLabel as k, DEFAULT_RECONNECT_DELAY_MS as ka, createLocalAdapterContainer as ki, resolveAgentTargetState as kn, createLocalExecutionSlots as kr, prepareDaemonServiceUpdateWorkerCarrier as kt, startDaemonSystemServiceWithAutoRepair as l, normalizeHeartbeatIntervalMs as la, buildWorkingLanguagePromptPlan as li, ensureOpenMeldManagedProfileWorkspace as ln, createAuthenticationError as lo, runIfAgentActivityBindingGenerationIsCurrent as lr, createRouteCatalogFromMutableState as lt, resolveDaemonStatusAttention as m, toErrorMessage$23 as ma, getAgentControllerPermissionModeFieldLabel as mi, resolveConfiguredProfileWorkspacePathForAccount as mn, resolveAuthenticationReasonFromState as mo, withAgentActivityDeliveryLock as mr, createModelCatalogReadSession as mt, scheduleDaemonServiceUpdate as n, buildLedgerPaths as na, buildAuthenticatedControlPlaneResponse as ni, emitReconcileStartedEvidence as nn, clearSelectedOpenMeldProfileId as no, listProjectBindings as nr, prepareProviderRuntime as nt, isSystemServiceStartupTimeoutError as o, asRecord as oa, areAgentControllerInterfaceAccountsSame as oi, resolveLocalController as on, buildAuthenticationStatusLabel as oo, removeMissingProjectConnections as or, readDaemonRouteCatalogCache as ot, resolveDaemonStatusSnapshot as p, nowIsoString as pa, getAgentControllerPermissionModeDisplayMetadata as pi, resolveConfiguredProfileWorkspacePath as pn, resolveAuthenticationGuidanceFromMessage as po, resolveLocalProjectConnectionForPath as pr, syncProfileWorkspaceState as pt, buildOnboardingPlan as q, getOpenMeldProfileCapabilities as qa, buildCliLaunchInvocation as qi, isBunGlobalCommandPath as qn, appendLedgerHistoryEntry as qr, DAEMON_SERVICE_AUTO_HEAL_ANOMALIES as qt, DaemonServiceLifecycleDrainTimeoutError as r, ensureDaemonRuntimePaths as ra, assertLegacyAgentContextAssociation as ri, DaemonServiceRunError as rn, getSelectedOpenMeldProfileId as ro, listProjectConnectionsWithStatus as rr, buildOpenClawSpaceSessionKey as rt, resolveSystemServiceStartupWaitMs as s, dirnamePath as sa, buildAgentControllerRef as si, resolveLocalRuntimeControllerSupport as sn, buildCommandAuthenticationPromptMessage as so, removeProjectConnection as sr, writeDaemonRouteCatalogCache as st, runPendingDaemonServiceUpdate as t, readCurrentLocalDeviceId as ta, withLedgerStateTransaction as ti, emitReconcileCompletedEvidence as tn, clearAllSelectedOpenMeldProfileIds as to, isProjectBound as tr, writeDaemonServiceContract as tt, captureDaemonServiceEvidence as u, normalizeNonNegativeInteger as ua, createAgentControllerInterfaceDisplayRows as ui, normalizeCustomProfileWorkspacePath as un, extractAuthenticationPromptAction as uo, setDefaultProjectConnection as ur, loadDaemonRouteCatalog as ut, buildDaemonServiceRefreshNextStep as v, buildDaemonSystemServiceCommandSpec as va, peopleComputerContainsDevice as vi, describeProfileWorkspacePathValidationFailure as vn, compareAgentControllerRefsForDisplay as vo, SPACE_ACTION_CONTEXT_GUIDANCE_LINES as vr, createPrimaryBindingReadSession as vt, formatDaemonServiceUpdateRequiredMessage as w, CONTROLLED_SHUTDOWN_SOCKET_CLOSE_TIMEOUT_MS as wa, resolveAgentProfileEditCapabilities as wi, manageAgentRegistrationInstallation as wn, normalizeDispatchPostMessageAction as wr, readPendingOpenMeldToolsUpdateAttempt as wt, buildDaemonServiceStatusReadOnlyDetail as x, CATALOG_SYNC_SIGNAL_POLL_INTERVAL_MS as xa, renderWorkingLanguagePrompt as xi, listAgentCustomTargets as xn, resolveRouteRegistrationReconcileDecision as xr, createOpenMeldToolsUpdateCoordinator as xt, buildDaemonServiceRefreshPromptMessage as y, ensureDaemonSystemServiceCommandFiles as ya, projectPeopleComputersToLegacyLocalRuntimes as yi, addAgentCustomTarget as yn, resolveBuiltinAgentControllerBrand as yo, SPACE_ACTION_TARGET_GUIDANCE_LINES as yr, resolveAgentProfilePrimaryAgentControllerReport as yt, classifyGatewayChainFailure as z, resolveRuntimeContext as za, resolveInstalledCodexLaunchCandidates as zi, detectInstalledSkillsAgents as zn, resolveDispatchQueueLogMeta as zr, resolveDaemonRuntimeContractCompatibility as zt };
 
-//# sourceMappingURL=daemon-service-update-coordinator-BcbbIDzC.js.map
+//# sourceMappingURL=daemon-service-update-coordinator--xLHNqDT.js.map