openmeld 0.3.212 → 0.3.214

package/dist/{daemon-service-update-coordinator-DcjOzGu1.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-jsWwS864.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-BQAmcHwF.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-PxntAyDq.js";
-import { v as openMeldToolsUpdateAttemptSchema, w as openMeldToolsUpdateRequestSourceSchema } from "./local-components-H3SkJMC1.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 { $ 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-Dqz9X4F0.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-CWTlAhZY.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-DjbtuE52.js";
-import { a as encodePersistedOpenMeldToolsUpdateFailure, i as OpenMeldToolsUpdateFailureError, o as resolveOpenMeldToolsUpdateFailure, r as parseOpenMeldToolsUpdateFailureFrame, t as appendBoundedOpenMeldToolsUpdateProcessOutput } from "./openmeld-tools-update-process-frame-CbZPpc7D.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-bRzDGlXy.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;
@@ -7125,6 +7680,7 @@ const CONTROL_REQUEST_TIMEOUT_MS_BY_OPERATION = {
 	"collaborationMode/list": FAST_METADATA_ADMISSION_TIMEOUT_MS,
 	"thread/fork": COLD_CONTROLLER_ADMISSION_TIMEOUT_MS,
 	"thread/name/set": FAST_METADATA_ADMISSION_TIMEOUT_MS,
+	"thread/read": FAST_METADATA_ADMISSION_TIMEOUT_MS,
 	"thread/resume": COLD_CONTROLLER_ADMISSION_TIMEOUT_MS,
 	"thread/start": COLD_CONTROLLER_ADMISSION_TIMEOUT_MS,
 	"turn/start": COLD_CONTROLLER_ADMISSION_TIMEOUT_MS
@@ -7325,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;
@@ -7406,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([
@@ -7545,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()}`);
@@ -7559,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,
@@ -7582,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;
@@ -7697,52 +8268,22 @@ async function invokeCodexAppServerTransport(input) {
 		session.emitProviderConversationObserved(continuityThreadId);
 		session.observeReasoningForThread(executionThreadId);
 		throwIfCodexDispatchCancelled(input.cancellationSignal);
-		const turn = readTurnStartResponse(await session.requestControl("turn/start", {
-			...permissionModeParams.turn,
-			...collaborationMode ? { collaborationMode } : {},
-			cwd: input.codexWorkdir,
-			...conversationPolicyParams,
-			...reasoningSummary,
-			input: [{
-				text: turnPrompt,
-				text_elements: [],
-				type: "text"
-			}],
-			threadId: executionThreadId
-		}, {
-			code: "runtime.turn_start_timeout",
-			operation: "turn/start"
-		}));
-		const turnId = readRequiredText(turn.id, "turn/start response turn.id");
-		session.emitProviderTurnAccepted({
-			threadId: executionThreadId,
-			turnId
-		});
-		session.setNewSessionTitleInBackground({
-			existingThreadId: input.threadId,
+		const completedTurn = await startAndAwaitAppServerTurn({
+			cancellationSignal: input.cancellationSignal,
+			collaborationMode,
+			conversationPolicyParams,
+			codexWorkdir: input.codexWorkdir,
 			executionMode: input.executionMode,
-			threadId: executionThreadId,
-			title: input.newSessionTitle
-		});
-		const unregisterActiveTurn = session.registerActiveTurn({
+			executionThreadId,
+			existingThreadId: input.threadId,
+			newSessionTitle: input.newSessionTitle,
 			onActiveTurn: input.onActiveTurn,
+			permissionModeParams: permissionModeParams.turn,
+			reasoningSummary,
+			session,
 			taskId: input.taskId,
-			threadId: executionThreadId,
-			turnId
-		});
-		if (input.cancellationSignal?.aborted && turn.status !== "completed") await session.request("turn/interrupt", {
-			threadId: executionThreadId,
-			turnId
+			turnPrompt
 		});
-		let completedTurn;
-		try {
-			completedTurn = turn.status === "completed" ? turn : await session.waitForTurnCompleted({
-				threadId: executionThreadId,
-				turnId
-			});
-		} finally {
-			unregisterActiveTurn?.();
-		}
 		const interactionFailure = session.readInteractionFailure();
 		if (interactionFailure) throw new CodexAppServerTransportError({
 			code: interactionFailure.code,
@@ -7769,6 +8310,69 @@ async function invokeCodexAppServerTransport(input) {
 		};
 	});
 }
+async function startAndAwaitAppServerTurn(input) {
+	const { session, executionThreadId } = input;
+	let activeTurnId = null;
+	let interruptRequested = false;
+	let interruptSent = false;
+	const sendInterruptIfActive = async (targetTurnId) => {
+		if (interruptSent) return;
+		interruptSent = true;
+		try {
+			await session.request("turn/interrupt", {
+				threadId: executionThreadId,
+				turnId: targetTurnId
+			});
+		} catch {}
+	};
+	const unregisterActiveTurn = session.registerActiveTurn({
+		interrupt: async () => {
+			interruptRequested = true;
+			if (activeTurnId) await sendInterruptIfActive(activeTurnId);
+		},
+		onActiveTurn: input.onActiveTurn,
+		taskId: input.taskId,
+		threadId: executionThreadId,
+		turnId: null
+	});
+	try {
+		const turn = readTurnStartResponse(await session.requestControl("turn/start", {
+			...input.permissionModeParams,
+			...input.collaborationMode ? { collaborationMode: input.collaborationMode } : {},
+			cwd: input.codexWorkdir,
+			...input.conversationPolicyParams,
+			...input.reasoningSummary,
+			input: [{
+				text: input.turnPrompt,
+				text_elements: [],
+				type: "text"
+			}],
+			threadId: executionThreadId
+		}, {
+			code: "runtime.turn_start_timeout",
+			operation: "turn/start"
+		}));
+		const turnId = readRequiredText(turn.id, "turn/start response turn.id");
+		activeTurnId = turnId;
+		session.emitProviderTurnAccepted({
+			threadId: executionThreadId,
+			turnId
+		});
+		session.setNewSessionTitleInBackground({
+			existingThreadId: input.existingThreadId ?? null,
+			executionMode: input.executionMode,
+			threadId: executionThreadId,
+			title: input.newSessionTitle ?? void 0
+		});
+		if ((interruptRequested || input.cancellationSignal?.aborted) && turn.status !== "completed") await sendInterruptIfActive(turnId);
+		return turn.status === "completed" ? turn : await session.waitForTurnCompleted({
+			threadId: executionThreadId,
+			turnId
+		});
+	} finally {
+		unregisterActiveTurn?.();
+	}
+}
 function requireSuccessfulCodexTurn(turn) {
 	if (turn.status !== "failed") return;
 	const failureMessage = readTurnFailureMessage(turn);
@@ -7824,6 +8428,38 @@ async function verifyCodexAppServerThread(input) {
 		})) };
 	});
 }
+async function resolveCodexAppServerCompletedTurn(input) {
+	const threadId = normalizeOptionalText$35(input.threadId);
+	if (!threadId) throw new CodexAppServerTransportError({
+		code: "schema.invalid",
+		errorType: "config",
+		message: "schema.invalid: threadId is required"
+	});
+	return await withCodexAppServerSession({
+		codexTimeoutMs: input.codexTimeoutMs,
+		codexWorkdir: input.codexWorkdir,
+		env: input.env,
+		launchContract: input.launchContract,
+		onRuntimeEvent: input.onRuntimeEvent
+	}, async (session) => {
+		const completedTurnId = readLastCompletedTurnId(await session.requestControl("thread/read", {
+			includeTurns: true,
+			threadId
+		}, {
+			code: "execution_context.history_unavailable",
+			operation: "thread/read"
+		}));
+		if (!completedTurnId) throw new CodexAppServerTransportError({
+			code: "execution_context.fork_checkpoint_unavailable",
+			errorType: "config",
+			message: "execution_context.fork_checkpoint_unavailable: thread/read found no completed turn on the source thread"
+		});
+		return {
+			completedTurnId,
+			threadId
+		};
+	});
+}
 async function forkCodexAppServerThread(input) {
 	const sourceThreadId = normalizeOptionalText$35(input.sourceThreadId);
 	if (!sourceThreadId) throw new CodexAppServerTransportError({
@@ -7831,10 +8467,17 @@ async function forkCodexAppServerThread(input) {
 		errorType: "config",
 		message: "schema.invalid: sourceThreadId is required"
 	});
-	if (input.computerFileAccessBoundary?.executionContextAccess && !normalizeOptionalText$35(input.sourceCompletedTurnId)) throw new CodexAppServerTransportError({
+	const sourceCompletedTurnId = normalizeOptionalText$35(input.sourceCompletedTurnId);
+	const executionContextScoped = input.computerFileAccessBoundary?.executionContextAccess !== void 0;
+	if (sourceCompletedTurnId && input.forkFullHistory) throw new CodexAppServerTransportError({
+		code: "schema.invalid",
+		errorType: "config",
+		message: "schema.invalid: a fork takes either sourceCompletedTurnId or forkFullHistory, not both"
+	});
+	if (!(sourceCompletedTurnId || input.forkFullHistory)) throw new CodexAppServerTransportError({
 		code: "execution_context.fork_checkpoint_unavailable",
 		errorType: "config",
-		message: "execution_context.fork_checkpoint_unavailable: a completed turn is required for a scoped fork"
+		message: executionContextScoped ? "execution_context.fork_checkpoint_unavailable: a completed turn is required for a scoped fork" : "execution_context.fork_checkpoint_unavailable: a completed turn is required, or forkFullHistory must be set to fork the source's entire history"
 	});
 	return await withCodexAppServerSession({
 		codexTimeoutMs: input.codexTimeoutMs,
@@ -7852,7 +8495,7 @@ async function forkCodexAppServerThread(input) {
 				approvalPolicy: "never",
 				runtimeWorkspaceRoots: [input.targetWorkingDirectory ?? input.codexWorkdir]
 			} : {},
-			...input.sourceCompletedTurnId ? { lastTurnId: input.sourceCompletedTurnId } : {},
+			...sourceCompletedTurnId ? { lastTurnId: sourceCompletedTurnId } : {},
 			...input.targetWorkingDirectory ? { cwd: input.targetWorkingDirectory } : {}
 		}, {
 			code: "context.fork_timeout",
@@ -8452,13 +9095,13 @@ var CodexAppServerSession = class {
 		return input.onActiveTurn({
 			taskId: input.taskId,
 			threadId: input.threadId,
-			turnId: input.turnId,
-			interrupt: async () => {
-				await this.request("turn/interrupt", {
+			turnId: input.turnId ?? "",
+			interrupt: input.interrupt ?? (async () => {
+				if (input.turnId) await this.request("turn/interrupt", {
 					threadId: input.threadId,
 					turnId: input.turnId
 				});
-			}
+			})
 		});
 	}
 	buildTelemetry(input) {
@@ -8729,6 +9372,17 @@ function readThreadContextFromResponse(value) {
 		threadSource: normalizeOptionalText$35(response?.thread?.threadSource)
 	};
 }
+function readLastCompletedTurnId(value) {
+	const response = toRecord$8(value);
+	const turns = Array.isArray(response?.thread?.turns) ? response.thread.turns : [];
+	for (let index = turns.length - 1; index >= 0; index -= 1) {
+		const turn = turns[index];
+		if (normalizeOptionalText$35(turn?.status) !== "completed") continue;
+		const turnId = normalizeOptionalText$35(turn?.id);
+		if (turnId) return turnId;
+	}
+	return null;
+}
 function readTurnStartResponse(value) {
 	const turn = toRecord$8(value)?.turn;
 	if (!turn || typeof turn !== "object") throw new CodexAppServerTransportError({
@@ -10378,12 +11032,25 @@ function toRecord$7(value) {
 //#region ../../runtime/adapters/codex/dist/index.js
 const CODEX_CONVERSATION_BRIDGE_SPEC = resolveBuiltinAdapterConversationBridgeSpec("codex");
 const TEST_DISABLE_DEFAULT_INVOKE = Symbol.for("openmeld.test.disableDefaultInvoke");
+/**
+* Reader for {@link CodexDispatchStopEvidence}, keyed off the adapter object the
+* way {@link TEST_DISABLE_DEFAULT_INVOKE} keys off runtime options.
+*
+* {@link RuntimeAdapter} is the adapter's whole surface, and the stop evidence
+* has to travel out of a `cancel` or `interrupt` call into the Core path that
+* decides whether a successor may take an occupied reservation. Widening that
+* shared type for one adapter's control-plane bookkeeping would put a Codex-only
+* field on every adapter, so the reader rides along as a symbol-keyed property
+* that only a caller holding this symbol can find.
+*/
+const READ_CODEX_DISPATCH_STOP_EVIDENCE = Symbol.for("openmeld.codex.readDispatchStopEvidence");
 const COMPUTER_FILE_ACCESS_ATTESTATION_TTL_MS = 300 * 1e3;
 const MAX_COMPUTER_FILE_ACCESS_ATTESTATIONS = 32;
 const createCodexAdapter = (options) => {
 	const activeAppServerTurns = /* @__PURE__ */ new Map();
 	const computerFileAccessAttestations = /* @__PURE__ */ new Map();
 	const occupiedDispatches = /* @__PURE__ */ new Map();
+	const stoppedDispatches = /* @__PURE__ */ new Map();
 	const registerAppServerTurn = (registration) => {
 		const activeTurn = {
 			interrupt: registration.interrupt,
@@ -10415,40 +11082,69 @@ const createCodexAdapter = (options) => {
 	});
 	const fallbackCancel = controlShell.cancel;
 	const cancel = async (request) => {
-		if (abortOccupiedCodexDispatch({
+		const occupiedDispatchAborted = abortOccupiedCodexDispatch({
 			occupiedDispatches,
 			request
-		}) && !activeAppServerTurns.has(request.taskId)) return {
-			accepted: true,
-			deliveryPath: "cancel",
-			reasonCode: "accepted",
-			signalDelivery: "sent",
-			taskId: request.taskId
-		};
-		if (!fallbackCancel) return {
+		});
+		if (occupiedDispatchAborted && !activeAppServerTurns.has(request.taskId)) {
+			recordStoppedCodexDispatch({
+				request,
+				stoppedDispatches,
+				turnWasRunning: false
+			});
+			return {
+				accepted: true,
+				deliveryPath: "cancel",
+				reasonCode: "accepted",
+				signalDelivery: "sent",
+				taskId: request.taskId
+			};
+		}
+		const turnWasRunning = activeAppServerTurns.has(request.taskId);
+		const result = fallbackCancel ? await fallbackCancel(request) : {
 			accepted: false,
 			reasonCode: "adapter.unsupported",
 			signalDelivery: "not_sent",
 			taskId: request.taskId
 		};
-		return await fallbackCancel(request);
+		if (occupiedDispatchAborted || turnWasRunning) recordStoppedCodexDispatch({
+			request,
+			stoppedDispatches,
+			turnWasRunning
+		});
+		return result;
 	};
 	const interrupt = async (request) => {
-		if (abortOccupiedCodexDispatch({
+		const occupiedDispatchAborted = abortOccupiedCodexDispatch({
 			occupiedDispatches,
 			request
-		}) && !activeAppServerTurns.has(request.taskId)) return {
-			accepted: true,
-			plan: buildInterruptPlan(request),
-			reasonCode: "accepted",
-			signalDelivery: "sent",
-			taskId: request.taskId
-		};
-		return await interruptCodexActiveAppServerTurn({
+		});
+		if (occupiedDispatchAborted && !activeAppServerTurns.has(request.taskId)) {
+			recordStoppedCodexDispatch({
+				request,
+				stoppedDispatches,
+				turnWasRunning: false
+			});
+			return {
+				accepted: true,
+				plan: buildInterruptPlan(request),
+				reasonCode: "accepted",
+				signalDelivery: "sent",
+				taskId: request.taskId
+			};
+		}
+		const turnWasRunning = activeAppServerTurns.has(request.taskId);
+		const result = await interruptCodexActiveAppServerTurn({
 			activeAppServerTurns,
 			request,
 			fallbackInterrupt: controlShell.interrupt
 		});
+		if (occupiedDispatchAborted || turnWasRunning) recordStoppedCodexDispatch({
+			request,
+			stoppedDispatches,
+			turnWasRunning
+		});
+		return result;
 	};
 	const sharedDispatch = createSharedDispatchShell({
 		adapterId: "codex",
@@ -10466,76 +11162,78 @@ const createCodexAdapter = (options) => {
 		occupiedDispatches,
 		request,
 		sharedDispatch,
+		stoppedDispatches,
 		waitForThreadWriterAvailability: options.waitForThreadWriterAvailability ?? waitForCodexThreadWriterAvailability
 	});
-	return {
-		adapterId: "codex",
-		cancel,
-		dispatch,
-		interrupt,
-		verifyComputerFileAccessBoundary: async (request) => {
-			if (request.agentControllerPermissionMode === "codex:customConfig" || request.transportMode !== "codex-app-server" && request.transportMode !== "local-cli") return {
-				reasonCode: "computer.file_access.controller_unsupported",
+	const verifyComputerFileAccessBoundary = async (request) => {
+		if (request.agentControllerPermissionMode === "codex:customConfig" || request.transportMode !== "codex-app-server" && request.transportMode !== "local-cli") return {
+			reasonCode: "computer.file_access.controller_unsupported",
+			supported: false
+		};
+		try {
+			const configuredLaunchContract = resolveConfiguredCodexLaunchContract({
+				codexBin: options.codexBin,
+				inputLaunchContract: request.launchContract,
+				optionLaunchContract: options.launchContract
+			});
+			if (!configuredLaunchContract) return {
+				reasonCode: "computer.file_access.capability_unverified",
+				supported: false
+			};
+			const probeArgs = [...buildCodexFileAccessBoundaryGlobalArgs({
+				boundary: request.boundary,
+				executionMode: request.executionMode,
+				permissionMode: request.agentControllerPermissionMode
+			}), "--version"];
+			const cacheKey = JSON.stringify({
+				launchContract: configuredLaunchContract,
+				probeArgs,
+				workingDirectory: request.workingDirectory
+			});
+			const nowMs = Date.now();
+			const cached = computerFileAccessAttestations.get(cacheKey);
+			if (cached && cached.expiresAtMs > nowMs) return await cached.result;
+			if (cached) computerFileAccessAttestations.delete(cacheKey);
+			const result = resolveCodexDispatchLaunchContract({
+				codexBin: options.codexBin,
+				inputLaunchContract: request.launchContract,
+				optionLaunchContract: options.launchContract
+			}).then((launchContract) => verifyCliLaunchContract({
+				cwd: request.workingDirectory,
+				displayName: "Codex file access boundary",
+				launchContract,
+				probeArgs,
+				timeoutMs: 5e3
+			})).then((verification) => verification.ok ? { supported: true } : {
+				reasonCode: "computer.file_access.capability_unverified",
+				supported: false
+			}).catch(() => ({
+				reasonCode: "computer.file_access.capability_unverified",
+				supported: false
+			}));
+			rememberComputerFileAccessAttestation({
+				attestations: computerFileAccessAttestations,
+				cacheKey,
+				value: {
+					expiresAtMs: nowMs + COMPUTER_FILE_ACCESS_ATTESTATION_TTL_MS,
+					result
+				}
+			});
+			return await result;
+		} catch {
+			return {
+				reasonCode: "computer.file_access.capability_unverified",
 				supported: false
 			};
-			try {
-				const configuredLaunchContract = resolveConfiguredCodexLaunchContract({
-					codexBin: options.codexBin,
-					inputLaunchContract: request.launchContract,
-					optionLaunchContract: options.launchContract
-				});
-				if (!configuredLaunchContract) return {
-					reasonCode: "computer.file_access.capability_unverified",
-					supported: false
-				};
-				const probeArgs = [...buildCodexFileAccessBoundaryGlobalArgs({
-					boundary: request.boundary,
-					executionMode: request.executionMode,
-					permissionMode: request.agentControllerPermissionMode
-				}), "--version"];
-				const cacheKey = JSON.stringify({
-					launchContract: configuredLaunchContract,
-					probeArgs,
-					workingDirectory: request.workingDirectory
-				});
-				const nowMs = Date.now();
-				const cached = computerFileAccessAttestations.get(cacheKey);
-				if (cached && cached.expiresAtMs > nowMs) return await cached.result;
-				if (cached) computerFileAccessAttestations.delete(cacheKey);
-				const result = resolveCodexDispatchLaunchContract({
-					codexBin: options.codexBin,
-					inputLaunchContract: request.launchContract,
-					optionLaunchContract: options.launchContract
-				}).then((launchContract) => verifyCliLaunchContract({
-					cwd: request.workingDirectory,
-					displayName: "Codex file access boundary",
-					launchContract,
-					probeArgs,
-					timeoutMs: 5e3
-				})).then((verification) => verification.ok ? { supported: true } : {
-					reasonCode: "computer.file_access.capability_unverified",
-					supported: false
-				}).catch(() => ({
-					reasonCode: "computer.file_access.capability_unverified",
-					supported: false
-				}));
-				rememberComputerFileAccessAttestation({
-					attestations: computerFileAccessAttestations,
-					cacheKey,
-					value: {
-						expiresAtMs: nowMs + COMPUTER_FILE_ACCESS_ATTESTATION_TTL_MS,
-						result
-					}
-				});
-				return await result;
-			} catch {
-				return {
-					reasonCode: "computer.file_access.capability_unverified",
-					supported: false
-				};
-			}
 		}
 	};
+	return Object.assign({
+		adapterId: "codex",
+		cancel,
+		dispatch,
+		interrupt,
+		verifyComputerFileAccessBoundary
+	}, { [READ_CODEX_DISPATCH_STOP_EVIDENCE]: (taskId) => stoppedDispatches.get(taskId) ?? null });
 };
 function readCodexConversationOccupancy(result, request) {
 	if (result.status !== "failed" || request.transportMode !== "codex-app-server" || !result.agentControllerConversationOccupancy) return null;
@@ -10547,6 +11245,25 @@ function abortOccupiedCodexDispatch(input) {
 	occupiedDispatch.abortController.abort();
 	return true;
 }
+/**
+* Records that a Stop ended a task, so no later attempt for it resumes the
+* thread.
+*
+* `turnWasRunning` is the part a caller must not drop: a Stop the adapter answers
+* without interrupting a native turn is evidence that nothing else in this
+* process holds the writer, while a Stop that lands on a running turn is only a
+* request. Both are recorded, because a record that hid the second kind would let
+* a later attempt read a running turn as a stopped one.
+*/
+function recordStoppedCodexDispatch(input) {
+	const existing = input.stoppedDispatches.get(input.request.taskId);
+	const turnWasRunning = existing ? existing.turnWasRunning || input.turnWasRunning : input.turnWasRunning;
+	input.stoppedDispatches.set(input.request.taskId, {
+		stoppedAtMs: existing?.stoppedAtMs ?? Date.now(),
+		taskId: input.request.taskId,
+		turnWasRunning
+	});
+}
 function buildCodexDispatchCancelledResult() {
 	return {
 		errorCode: "runtime.turn.cancelled",
@@ -10555,6 +11272,20 @@ function buildCodexDispatchCancelledResult() {
 		status: "failed"
 	};
 }
+/**
+* Whether a dispatch result proves the attempt never reached a native turn.
+*
+* A Stop that lands while a dispatch is in flight must not be reported as
+* `runtime.turn.cancelled`: the transport uses that code for "Codex was stopped
+* before starting a turn", so claiming it for an attempt that may have won the
+* thread writer lock would tell Core nothing ran while a turn is running, and
+* invite a second execution of the same work. Only the transport's own pre-turn
+* cancellation and a refused `thread/resume` prove nothing started; every other
+* result is reported exactly as it came back, output included.
+*/
+function codexDispatchStoppedBeforeTurn(result) {
+	return result.status === "failed" && (result.errorCode === "runtime.turn.cancelled" || result.agentControllerConversationOccupancy !== void 0);
+}
 async function emitCodexConversationAvailable(input) {
 	await input.request.onRuntimeEvent?.({
 		agentControllerConversationId: input.occupancy.agentControllerConversationId,
@@ -10578,13 +11309,14 @@ async function dispatchCodexWithConversationOccupancy(input) {
 	};
 	try {
 		while (true) {
+			if (input.stoppedDispatches.has(input.request.taskId)) return buildCodexDispatchCancelledResult();
 			const cancellationSignal = state.registration?.abortController.signal ?? void 0;
 			if (cancellationSignal?.aborted) return buildCodexDispatchCancelledResult();
 			const result = await input.sharedDispatch({
 				...input.request,
 				...cancellationSignal ? { cancellationSignal } : {}
 			});
-			if (state.registration?.abortController.signal.aborted) return buildCodexDispatchCancelledResult();
+			if (state.registration?.abortController.signal.aborted && codexDispatchStoppedBeforeTurn(result)) return buildCodexDispatchCancelledResult();
 			const occupancy = readCodexConversationOccupancy(result, input.request);
 			if (occupancy) {
 				if (await waitForOccupiedCodexConversation({
@@ -20269,6 +21001,7 @@ async function buildControlPlaneResponse(input) {
 		});
 		case "shutdown": return await buildShutdownControlPlaneResponse({
 			context: input.context,
+			lifecycle: input.lifecycle,
 			payload: request.payload,
 			requestMeta
 		});
@@ -20387,7 +21120,7 @@ async function buildShutdownControlPlaneResponse(input) {
 		mode: "graceful",
 		gracePeriodMs: 5e3
 	};
-	const payload = input.context.shutdownHandler ? await input.context.shutdownHandler(resolvedShutdownPayload) : {
+	const payload = input.context.shutdownHandler ? await input.context.shutdownHandler(resolvedShutdownPayload, input.lifecycle?.onShutdownAdmitted ? { onAdmitted: input.lifecycle.onShutdownAdmitted } : void 0) : {
 		accepted: false,
 		mode: resolvedShutdownPayload.mode,
 		gracePeriodMs: resolvedShutdownPayload.gracePeriodMs
@@ -20462,8 +21195,10 @@ const buildAuthenticatedControlPlaneResponse = async (input) => {
 		expectedToken: input.expectedToken,
 		providedToken: request.authToken
 	})) throw new Error("auth.unauthenticated");
+	input.lifecycle?.onAuthenticated?.();
 	return await buildControlPlaneResponse({
 		context: input.context,
+		lifecycle: input.lifecycle,
 		request
 	});
 };
@@ -29984,24 +30719,32 @@ async function writeAttempt(path, attempt) {
 const OPERATION_ID_ENV = "OPENMELD_INTERNAL_TOOLS_UPDATE_OPERATION_ID";
 const REQUESTED_AT_ENV = "OPENMELD_INTERNAL_TOOLS_UPDATE_REQUESTED_AT";
 const REQUEST_SOURCE_ENV = "OPENMELD_INTERNAL_TOOLS_UPDATE_REQUEST_SOURCE";
+const TARGET_CLI_VERSION_ENV = "OPENMELD_INTERNAL_TOOLS_UPDATE_TARGET_CLI_VERSION";
+const TARGET_SERVICE_VERSION_ENV = "OPENMELD_INTERNAL_TOOLS_UPDATE_TARGET_SERVICE_VERSION";
 function buildOpenMeldToolsUpdateContextEnv(context) {
 	return {
 		[OPERATION_ID_ENV]: context.operationId,
 		[REQUESTED_AT_ENV]: context.requestedAt,
-		[REQUEST_SOURCE_ENV]: context.requestSource
+		[REQUEST_SOURCE_ENV]: context.requestSource,
+		...context.targetCliVersion ? { [TARGET_CLI_VERSION_ENV]: context.targetCliVersion } : {},
+		...context.targetServiceVersion ? { [TARGET_SERVICE_VERSION_ENV]: context.targetServiceVersion } : {}
 	};
 }
 function readOpenMeldToolsUpdateContextFromEnv(env = process.env) {
 	const operationId = normalize$1(env[OPERATION_ID_ENV]);
 	const requestedAt = normalize$1(env[REQUESTED_AT_ENV]);
 	const requestSource = openMeldToolsUpdateRequestSourceSchema.safeParse(env[REQUEST_SOURCE_ENV]);
+	const targetCliVersion = normalize$1(env[TARGET_CLI_VERSION_ENV]);
+	const targetServiceVersion = normalize$1(env[TARGET_SERVICE_VERSION_ENV]);
 	if (!(operationId && requestedAt && requestSource.success)) return null;
 	const requestedAtMs = Date.parse(requestedAt);
 	if (!Number.isFinite(requestedAtMs)) return null;
 	return {
 		operationId,
 		requestedAt: new Date(requestedAtMs).toISOString(),
-		requestSource: requestSource.data
+		requestSource: requestSource.data,
+		...targetCliVersion ? { targetCliVersion } : {},
+		...targetServiceVersion ? { targetServiceVersion } : {}
 	};
 }
 function normalize$1(value) {
@@ -30151,7 +30894,7 @@ function createOpenMeldToolsUpdateCoordinator(overrides = {}, options = {}) {
 		}
 		const assessment = await deps.assessUpdate({ forceRefresh: true });
 		if (!(assessment.checked && assessment.latestVersion)) return { status: "unavailable" };
-		const serviceVersion = assessment.serviceVersion ?? assessment.currentVersion;
+		const serviceVersion = assessment.serviceVersion ?? assessment.latestVersion;
 		if (!(assessment.updateAvailable || await deps.serviceNeedsAlignment(serviceVersion))) return {
 			currentVersion: assessment.currentVersion,
 			status: "current"
@@ -30166,6 +30909,8 @@ function createOpenMeldToolsUpdateCoordinator(overrides = {}, options = {}) {
 				phase: "updating",
 				requestSource,
 				requestedAt: now,
+				targetCliVersion: assessment.latestVersion,
+				targetServiceVersion: serviceVersion,
 				targetVersion: assessment.updateAvailable ? assessment.latestVersion : serviceVersion,
 				updatedAt: now,
 				urgency: assessment.floorBreached ? "required" : await deps.resolveUrgency()
@@ -30203,7 +30948,9 @@ async function runAttempt(attempt, deps) {
 		const result = await deps.runUpgrade({
 			operationId: running.operation.operationId,
 			requestedAt: running.operation.requestedAt,
-			requestSource: running.operation.requestSource
+			requestSource: running.operation.requestSource,
+			targetCliVersion: running.operation.targetCliVersion,
+			targetServiceVersion: running.operation.targetServiceVersion
 		});
 		if (result.exitCode !== 0) {
 			const fallbackMessage = `OpenMeld update process exited with status ${String(result.exitCode)}.`;
@@ -30284,6 +31031,8 @@ function projectServiceJob(job) {
 		requestSource: job.requestSource,
 		requestedAt: job.requestedAt,
 		targetVersion: job.targetVersion,
+		...job.targetCliVersion ? { targetCliVersion: job.targetCliVersion } : {},
+		...job.targetServiceVersion ? { targetServiceVersion: job.targetServiceVersion } : {},
 		updatedAt: job.updatedAt,
 		urgency: job.urgency
 	};
@@ -30959,9 +31708,9 @@ function createModelCatalogReadSession(input) {
 async function readModelCatalogOnce(baseUrl) {
 	try {
 		const [apiClient, baseUrlModule, clientFoundationModule] = await Promise.all([
-			import("./dist--pb6JxqG.js"),
-			import("./base-url-BE3pFiOZ.js"),
-			import("./api-client-foundation-CrQN8_-N.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();
@@ -37617,6 +38366,8 @@ async function scheduleDaemonServiceUpdateLocked(input, deps) {
 		requestedAt: input.requestedAt ?? now,
 		phase: "waiting_for_work",
 		requestSource: input.requestSource ?? "cli",
+		...input.targetCliVersion ? { targetCliVersion: input.targetCliVersion } : {},
+		...input.targetServiceVersion ? { targetServiceVersion: input.targetServiceVersion } : {},
 		targetVersion: input.targetVersion,
 		updatedAt: now,
 		urgency: input.urgency
@@ -37641,19 +38392,7 @@ async function reschedulePendingDaemonServiceUpdate(input) {
 	const escalateUrgency = input.pending.phase !== "updated" && input.request.urgency === "required" && input.pending.urgency === "available";
 	const retained = replaceTarget || escalateUrgency ? {
 		...input.pending,
-		...replaceTarget ? {
-			attempts: 0,
-			errorMessage: null,
-			phase: "waiting_for_work",
-			preparedBundle: await input.dependencies.prepareBundle({
-				activate: false,
-				daemonVersion: input.request.targetVersion,
-				...input.request.binaryRelease ? { binaryRelease: input.request.binaryRelease } : {},
-				...input.request.cliScriptPath ? { cliScriptPath: input.request.cliScriptPath } : {}
-			}),
-			requestSource: input.request.requestSource ?? "cli",
-			targetVersion: input.request.targetVersion
-		} : {},
+		...replaceTarget ? await prepareReplacementJobFields(input) : {},
 		updatedAt: input.dependencies.now(),
 		urgency: escalateUrgency ? "required" : input.pending.urgency
 	} : input.pending;
@@ -37671,6 +38410,23 @@ async function reschedulePendingDaemonServiceUpdate(input) {
 		status: "already_scheduled"
 	};
 }
+async function prepareReplacementJobFields(input) {
+	return {
+		attempts: 0,
+		errorMessage: null,
+		phase: "waiting_for_work",
+		preparedBundle: await input.dependencies.prepareBundle({
+			activate: false,
+			daemonVersion: input.request.targetVersion,
+			...input.request.binaryRelease ? { binaryRelease: input.request.binaryRelease } : {},
+			...input.request.cliScriptPath ? { cliScriptPath: input.request.cliScriptPath } : {}
+		}),
+		requestSource: input.request.requestSource ?? "cli",
+		...input.request.targetCliVersion ? { targetCliVersion: input.request.targetCliVersion } : {},
+		...input.request.targetServiceVersion ? { targetServiceVersion: input.request.targetServiceVersion } : {},
+		targetVersion: input.request.targetVersion
+	};
+}
 async function pruneWorkerVersionsBestEffort(input) {
 	await input.dependencies.pruneWorkerVersions(input.job).catch((error) => {
 		console.warn("[openmeld.daemon_service.update_worker_prune_failed]", {
@@ -37883,6 +38639,6 @@ function isNewerTargetVersion(candidate, current) {
 	return compareSemver(candidate, current) > 0;
 }
 //#endregion
-export { buildDaemonServiceDependencyTitle as $, alignSelectedOpenMeldProfileStorage as $a, buildLocalAgentCatalogFromReadiness as $i, ProjectBindingStoreUpdateRequiredError as $n, settleInflightTask as $r, resolveCurrentDaemonExpectedVersion as $t, formatDeviceReplyReadinessLabel as A, MAX_RECONNECT_DELAY_MS as Aa, createLocalAdapterEntries as Ai, setAgentRegistrationEnabled as An, createInflightTaskControlRegistry as Ar, uninstallDaemonServiceUpdateWorker as At, resolveGatewayChainReadiness as B, isSelectedOpenMeldProfileRequiredError as Ba, forkCodexAppServerThread as Bi, resolveSkillsAgentRegistry as Bn, resolveDispatchContinuityObservation as Br, toStartBackgroundHelperExecutionCompatibility as Bt, formatDaemonServiceRefreshReliabilityMessage as C, CONTROLLED_SHUTDOWN_SOCKET_CLOSE_TIMEOUT_MS as Ca, resolveAgentExecutionStatus as Ci, listAgentTargetStates as Cn, buildDispatchReplyContextSummary as Cr, readLastOpenMeldToolsUpdateAttempt as Ct, writeDaemonStartFailureState as D, DAEMON_STREAM_KEEPALIVE_PONG_TIMEOUT_MS as Da, resolveSelectableCandidates as Di, reconcileNewRunnableBuiltinAgentsForSetup as Dn, createLocalTaskInterruptSender as Dr, writeOpenMeldToolsMaintenancePolicy as Dt, clearDaemonStartFailureState as E, DAEMON_STREAM_KEEPALIVE_INTERVAL_MS as Ea, resolveNativeAgentControllerPermissionModeForController as Ei, reconcileNewRunnableBuiltinAgentRegistrations as En, mergeOpenClawGatewayVisibility as Er, resolveOpenMeldToolsMaintenanceProjection as Et, formatSpaceMemberCommandRecoveryCopy as F, RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_RETRY_INTERVAL_MS as Fa, probeGrokBuildAcpInterface as Fi, parseAgentEnabledOption as Fn, applyIntervalJitterMs as Fr, readCurrentDaemonOwnerSnapshot as Ft, PREPARE_SESSION_RECONNECT_GRACE_MS as G, deleteOpenMeldProfile as Ga, resolveDispatchSpaceActionMcpServer as Gi, EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES as Gn, buildRuntimeWorkspaceFingerprint as Gr, isVersionDowngrade as Gt, resolveGatewayChainRetryGuidance as H, resolveOpenMeldProfileOrNull as Ha, resolveInstalledClaudeCodeLaunchCandidates as Hi, resolveRegistryOriginLaunchCommand as Hn, resolveCompatibleConversationExecutionState as Hr, readDaemonRuntimeContractRepairReport as Ht, resolveReplyReadinessAvailabilityReasonCopy as I, RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS as Ia, resolveInstalledGrokBuildLaunchCandidates as Ii, sortAgentRegistrations as In, pruneStaleLeases as Ir, resolveDaemonStopStrategy as It, getSetupFlowCopy as J, primeOpenMeldProfilesSessionCache as Ja, listAgentControllerSupervisedProcessIds as Ji, isHomebrewCommandPath as Jn, commitResolvedAgentContext as Jr, DAEMON_SERVICE_FULL_ALIGNMENT_ANOMALIES as Jt, buildDaemonRouteObservationPresentation as K, getOpenMeldProfileCapabilities as Ka, buildCliLaunchInvocation as Ki, resolveBuiltinAgentControllerDefinition as Kn, buildTaskResultEnvelope as Kr, resolveVersionChangeDirection as Kt, resolveReplyReadinessGuidanceSummaryCopy as L, parseCliViewMode as La, projectCodexUsageLimits as Li, repairBuiltinControllerInstall as Ln, resolveAdaptiveHeartbeatIntervalMs as Lr, resolveStoppedContractWriteBlockedReason as Lt, formatReplyReadinessSummary as M, PROVIDER_CONVERSATION_PROOF_SYNC_RETRY_INTERVAL_MS as Ma, forkOpenCodeServerSession as Mi, updateAgentRegistrations as Mn, MAX_HEARTBEAT_INTERVAL_MS as Mr, buildDaemonOwnerSnapshotFromObservedState as Mt, mapAgentReplyReadinessToLegacyAutoReply as N, REGISTER_RESPONSE_TIMEOUT_MS as Na, resolveInstalledOpenCodeLaunchCandidates as Ni, normalizeAgentId as Nn, MIN_HEARTBEAT_INTERVAL_MS as Nr, formatDaemonOwnerSummaryLabel as Nt, resolveCurrentReplyReadinessSnapshot as O, DEFAULT_RECONNECT_DELAY_MS as Oa, resolveCatalogSyncSkippedProfilesLogState as Oi, removeAgentCustomTarget as On, buildLocalServiceDiagnosticsPayload as Or, ensureDaemonServiceMaintenanceInstalled as Ot, REPLY_READINESS_COPY as P, RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_INTERVAL_MS as Pa, GrokBuildAcpTransportError as Pi, normalizeAgentIds as Pn, applyAcceptedLeases as Pr, hasActiveDaemonOwners as Pt, buildDaemonServiceDependencySummary as Q, readDaemonCatalogSyncSignal as Qa, describeServerRequiredVersionUnavailableReason as Qi, ProjectBindingOperationError as Qn, seedLegacyAgentContext as Qr, classifyDaemonServiceWakeability as Qt, resolveOpenClawDiagnosticsGuidance as R, resolveRuntimeContext as Ra, resolveCodexTimeoutMs as Ri, canManageRegistryAgentSkillTargets as Rn, resolveCatalogSyncIntervalMs as Rr, summarizeDaemonOwnerSnapshot as Rt, buildDaemonServiceUpdateRequiredNextStep as S, CONTROLLED_SHUTDOWN_RESULT_ACK_TIMEOUT_MS as Sa, resolveAgentControllerPermissionModeForController as Si, listAgentRegistrations as Sn, createSerialAgentInteractionCallback as Sr, readOpenMeldToolsUpdateContextFromEnv as St, resolveDaemonServiceFreshnessWarning as T, DAEMON_STREAM_CONNECT_TIMEOUT_MS as Ta, resolveEvidenceSyncHealth as Ti, readAgentRuntimeConfigHealth as Tn, createPendingAgentInteractionRegistry as Tr, readOpenMeldToolsMaintenancePolicy as Tt, resolveOpenClawLocalDiagnosticsValue as U, createOpenMeldAgentProfile as Ua, createUnavailableProviderUsageLimits as Ui, resolveRegistryRuntimeAdapterCapabilitySnapshot as Un, resolveLatestScopedConversationExecutionState as Ur, buildDaemonServiceTargetSpec as Ut, resolveGatewayChainRepairGuidance as V, requireOpenMeldProfile as Va, verifyCodexAppServerThread as Vi, listBuiltinAgentsRegistryEntries as Vn, resolveCompatibleAgentContextMatch as Vr, ensureDaemonRuntimeContractState as Vt, resolveLocalServiceDemand as W, createOpenMeldHumanProfile as Wa, createUnsupportedProviderUsageLimits as Wi, resolveRegistryRuntimeAdapterContractByAgentControllerRef as Wn, runRuntimeTask as Wr, resolveDaemonServiceAlignmentDecision as Wt, buildDaemonServiceDependencyMeaning as X, updateOpenMeldProfile as Xa, resolveServiceUpdateUrgency as Xi, isPnpmGlobalCommandPath as Xn, removeConversationExecutionState as Xr, DAEMON_SERVICE_WAKEABILITY_ADVISORY_ANOMALIES as Xt, buildDaemonServiceDependencyDetails as Y, resolveOpenMeldProfile as Ya, createProviderOriginalError as Yi, isNpmGlobalCommandPath as Yn, loadLedgerState as Yr, DAEMON_SERVICE_REPAIR_ANOMALIES as Yt, buildDaemonServiceDependencyNextStep as Z, assertAdditionalHumanProfileCreationEnabled as Za, assessServerRequiredVersion as Zi, notifyDaemonRouteCatalogChanged as Zn, resolveConversationExecutionStateByLookupKey as Zr, classifyDaemonServiceRunStartability as Zt, resolveServiceReadinessFromServiceStatus as _, buildDaemonSystemServiceCommandSpec as _a, parseAgentControllerRef as _i, validateCustomProfileWorkspacePath as _n, compareAgentControllerRefsForDisplay as _o, syncRuntimeEventToInflightTaskControlRegistry as _r, syncDeviceRuntimeStateProjection as _t, isDaemonInventoryRunningAndStartReady as a, asRecord as aa, DEFAULT_TASK_LIFECYCLE_HEARTBEAT_INTERVAL_MS as ai, readLocalEnabledControllers as an, buildAuthenticationStatusLabel as ao, removeAgentActivityBindingsWhileDeliveryLocked as ar, slugifyOpenClawNamePart as at, buildDaemonServiceRepairGuidance as b, CATALOG_SYNC_SIGNAL_POLL_INTERVAL_MS as ba, renderInformationProtectionPrompt as bi, createRegistrationFromCatalogTarget as bn, isDaemonReconcileInProgressError as br, resolveLocalRegistryAgentIdFromAgentControllerRef as bt, waitForSystemServiceStartup as c, normalizeHeartbeatIntervalMs as ca, buildInformationProtectionPromptPlan as ci, resolveProfileWorkspaceRuntime as cn, createAuthenticationError as co, resolveProjectBindingForPath as cr, createMutableRouteCatalogState as ct, captureDaemonServiceEvidenceBestEffort as d, normalizeText$11 as da, createAgentExecutionStatusDisplayRows as di, readProfileWorkspaceConfig as dn, resolveAuthenticationGuidanceFromError as do, unbindProject as dr, summarizeSkippedDaemonProfiles as dt, readCurrentLocalDeviceId as ea, upsertConversationExecutionState as ei, emitDriftDetectedEvidence as en, clearAllSelectedOpenMeldProfileIds as eo, bindProject as er, resolveDaemonServiceDependencyDiagnostics as et, formatDaemonFailureContextText as f, nowIsoString as fa, createAuthorityOpenMeldServiceRuntimeId as fi, readProfileWorkspaceConfigForAccount as fn, resolveAuthenticationGuidanceFromMessage as fo, canonicalizeLocalProjectPath as fr, syncDaemonRouteCatalogState as ft, resolveServiceReadiness as g, isCliUpdateCheckApplicable as ga, listAgentControllerPermissionModeOptions as gi, setOpenMeldManagedProfileWorkspace as gn, resolveCurrentOpenMeldAccountContext as go, normalizeDispatchThreadAction as gr, NO_LOCAL_AGENTS_NEED_OPENMELD_SERVICE_REASON as gt, resolveDaemonStatusAuthenticationAttention as h, assessCliUpdate as ha, isAgentExecutionReadyOrConnecting as hi, setCustomProfileWorkspace as hn, setProfileDefaultView as ho, withAgentActivityLocalStateLock as hr, resolveCurrentEffectiveProfileWorkingFolderRuntime as ht, runDaemonServiceLifecycle as i, resolvePreferredDaemonDeviceId as ia, buildAgentContextLookupKey as ii, buildRuntimeRouteTargets as in, buildAgentAuthenticationGuide as io, migrateProjectBindingStore as ir, normalizeOpenClawSpaceIdPrefix as it, formatHumanReplyReadinessReason as j, PROVIDER_CONVERSATION_PROOF_SYNC_INTERVAL_MS as ja, parseOpenCodeGoUsageResponse as ji, updateAgentCustomTarget as jn, ADAPTIVE_HEARTBEAT_JITTER_RATIO as jr, inspectDaemonServiceInventory as jt, formatAgentReplyReadinessLabel as k, HEARTBEAT_RESPONSE_TIMEOUT_MS as ka, createLocalAdapterContainer as ki, resolveAgentTargetState as kn, createLocalExecutionSlots as kr, prepareDaemonServiceUpdateWorkerCarrier as kt, startDaemonSystemServiceWithAutoRepair as l, normalizeNonNegativeInteger as la, buildWorkingLanguagePromptPlan as li, ensureOpenMeldManagedProfileWorkspace as ln, extractAuthenticationPromptAction as lo, runIfAgentActivityBindingGenerationIsCurrent as lr, createRouteCatalogFromMutableState as lt, resolveDaemonStatusAttention as m, warnDaemonEvent as ma, getAgentControllerPermissionModeFieldLabel as mi, resolveConfiguredProfileWorkspacePathForAccount as mn, getProfileDefaultView as mo, withAgentActivityDeliveryLock as mr, createModelCatalogReadSession as mt, scheduleDaemonServiceUpdate as n, ensureDaemonRuntimePaths as na, buildAuthenticatedControlPlaneResponse as ni, emitReconcileStartedEvidence as nn, getSelectedOpenMeldProfileId as no, listProjectBindings as nr, prepareProviderRuntime as nt, isSystemServiceStartupTimeoutError as o, dirnamePath as oa, areAgentControllerInterfaceAccountsSame as oi, resolveLocalController as on, buildCommandAuthenticationPromptMessage as oo, removeMissingProjectConnections as or, readDaemonRouteCatalogCache as ot, resolveDaemonStatusSnapshot as p, toErrorMessage$23 as pa, getAgentControllerPermissionModeDisplayMetadata as pi, resolveConfiguredProfileWorkspacePath as pn, resolveAuthenticationReasonFromState as po, resolveLocalProjectConnectionForPath as pr, syncProfileWorkspaceState as pt, buildOnboardingPlan as q, listOpenMeldProfiles as qa, materializeCliLaunchCommand as qi, isBunGlobalCommandPath as qn, appendLedgerHistoryEntry as qr, DAEMON_SERVICE_AUTO_HEAL_ANOMALIES as qt, DaemonServiceLifecycleDrainTimeoutError as r, resolveDaemonDeviceId as ra, assertLegacyAgentContextAssociation as ri, DaemonServiceRunError as rn, setSelectedOpenMeldProfileId as ro, listProjectConnectionsWithStatus as rr, buildOpenClawSpaceSessionKey as rt, resolveSystemServiceStartupWaitMs as s, emitRunLine as sa, buildAgentControllerRef as si, resolveLocalRuntimeControllerSupport as sn, buildHumanAuthenticationCard as so, removeProjectConnection as sr, writeDaemonRouteCatalogCache as st, runPendingDaemonServiceUpdate as t, buildLedgerPaths as ta, withLedgerStateTransaction as ti, emitReconcileCompletedEvidence as tn, clearSelectedOpenMeldProfileId as to, isProjectBound as tr, writeDaemonServiceContract as tt, captureDaemonServiceEvidence as u, normalizeOptionalText$51 as ua, createAgentControllerInterfaceDisplayRows as ui, normalizeCustomProfileWorkspacePath as un, resolveAuthenticationGuidance as uo, setDefaultProjectConnection as ur, loadDaemonRouteCatalog as ut, buildDaemonServiceRefreshNextStep as v, ensureDaemonSystemServiceCommandFiles as va, peopleComputerContainsDevice as vi, describeProfileWorkspacePathValidationFailure as vn, resolveBuiltinAgentControllerBrand as vo, SPACE_ACTION_CONTEXT_GUIDANCE_LINES as vr, createPrimaryBindingReadSession as vt, formatDaemonServiceUpdateRequiredMessage as w, DAEMON_RUNTIME_CONTRACT_EPOCH as wa, resolveAgentProfileEditCapabilities as wi, manageAgentRegistrationInstallation as wn, normalizeDispatchPostMessageAction as wr, readPendingOpenMeldToolsUpdateAttempt as wt, buildDaemonServiceStatusReadOnlyDetail as x, CONTROLLED_SHUTDOWN_REQUEST_TIMEOUT_MS as xa, renderWorkingLanguagePrompt as xi, listAgentCustomTargets as xn, resolveRouteRegistrationReconcileDecision as xr, createOpenMeldToolsUpdateCoordinator as xt, buildDaemonServiceRefreshPromptMessage as y, CATALOG_SYNC_RETRY_INTERVAL_MS as ya, projectPeopleComputersToLegacyLocalRuntimes as yi, addAgentCustomTarget as yn, SPACE_ACTION_TARGET_GUIDANCE_LINES as yr, resolveAgentProfilePrimaryAgentControllerReport as yt, classifyGatewayChainFailure as z, resolveViewProfileKey as za, resolveInstalledCodexLaunchCandidates as zi, detectInstalledSkillsAgents as zn, resolveDispatchQueueLogMeta as zr, resolveDaemonRuntimeContractCompatibility as zt };
+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-DcjOzGu1.js.map
+//# sourceMappingURL=daemon-service-update-coordinator--xLHNqDT.js.map