agent-transport-system 0.4.2 → 0.4.4

package/dist/ats.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import { $ as collectCanonicalMentionTextFragments, $n as writeCurrentDeviceBootstrapObservationResponseSchema, $t as patchSpaceContractBodySchema, A as SPACE_DISPATCH_TRACE_PROMPT_PREVIEW_MAX_CHARS, An as spaceConversationBindingImportResponseSchema, At as getPrepareReadinessQuerySchema, B as atsSpaceEgressActionSchema, Bn as startSessionResponseSchema, Bt as getSpaceWakeProgressResponseSchema, C as DISPATCH_ACTIVITY_DISPATCHING_PURPOSE, Cn as sanitizeSignalTextPreview, Ct as finalClaimRouteParamsSchema, D as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, Dn as signalEnvelopeSchema, Dt as gatewayErrorCodeSchema, E as LEGACY_RUNTIME_DISPATCH_POLICY, En as setOwnedDeviceDisplayNameBodySchema, Et as formatCanonicalMentionLiteral, F as SPACE_UPDATES_MAX_LIMIT, Fn as spaceMembersSnapshotSchema, Ft as getSpaceDispatchLookupResponseSchema, G as atsdTaskResultPayloadSchema, Gn as structuredGuidePayloadFromInputSchema, Gt as normalizeBuiltinControllerAgentId, H as atsdControlPlaneResponseSchema, Hn as startSessionSpaceChoiceResponseSchema, Ht as isExplicitBuiltinControllerRef, I as agentProfileBindingRouteParamsSchema, In as spaceMetaSchema, It as getSpaceDispatchResultResponseSchema, J as canonicalizeBuiltinControllerRef, Jn as submitRuntimeRegistrationBodySchema, Jt as normalizeMessageEnvelope, K as buildControllerRoutingKeyForKind, Kn as submitRuntimeCapabilityReportsBodySchema, Kt as normalizeBuiltinControllerProviderId, L as atsProfileIdSchema, Ln as startDeviceProjectionSchema, Lt as getSpaceMessageAddressingRelationSupportForTargetKind, M as SPACE_MEMBER_REMOVE_NOTICE_PURPOSE, Mn as spaceConversationBindingUpsertResponseSchema, Mt as getSpaceContractResponseSchema, N as SPACE_MENTION_REJECT_NOTICE_PURPOSE, Nn as spaceCreatorSchema, Nt as getSpaceConversationRemoteStatusResponseSchema, O as MAX_SIGNAL_REPLY_TO_PREVIEW_LENGTH, On as spaceConversationBindingConflictResponseSchema, Ot as gatewayErrorEnvelopeSchema, P as SPACE_PASSWORD_MIN_LENGTH, Pn as spaceDispatchTraceResponseSchema, Pt as getSpaceConversationStatusResponseSchema, Q as claimExecutionDiagnosticsResponseSchema, Qn as writeCurrentDeviceBootstrapObservationBodySchema, Qt as patchProfileSpaceHistoryStatusResponseSchema, R as atsRequestContextSchema, Rn as startProfileReadinessSummarySchema, Rt as getSpaceStatusResponseSchema, S as DAEMON_HUB_SCHEMA_VERSION, St as entryBriefSchema, T as DISPATCH_ACTIVITY_RETRYING_PURPOSE, Tn as setCurrentDeviceTargetBodySchema, Tt as forgetCurrentComputerResponseSchema, U as atsdTaskResultEnvelopeWriteSchema, Un as startSessionWithTokenResponseSchema, Ut as leaveSpaceResponseSchema, V as atsdControlPlaneRequestSchema, Vn as startSessionSpaceChoiceBodySchema, Vt as incomingServerMessageSchema, W as atsdTaskResultOpenClawGatewayVisibilityStatusSchema, Wn as startStateResponseSchema, Wt as listProfileSpaceHistoryResponseSchema, X as catchupResponseSchema, Xn as upsertProfileSpaceHistoryResponseSchema, Xt as ownedDevicesResponseSchema, Y as canonicalizeControllerRefForKind, Yn as submitRuntimeRegistrationResponseSchema, Yt as normalizeOptionalWorkingDirectory, Z as claimExecutionDiagnosticsQuerySchema, Zn as upsertSpaceDeletionTombstoneResponseSchema, Zt as parseOptionalClientMessageId, _ as AGENT_REPLY_PREVIEW_END_PURPOSE, _n as resolveSingleSpaceMentionLabels, _t as daemonServiceContractSchema, a as runWithHeldLock, an as postSpaceMembersResponseSchema, ar as writeStartObservedDeviceMetadataResponseSchema, at as currentDeviceTargetResponseSchema, b as ATSD_TASK_RESULT_SCHEMA_VERSION, bn as resolveStartHandoffResponseSchema, bt as ensureAgentProfilePrimaryBindingBodySchema, c as LEGACY_ATS_RUNTIME_SESSION_ENV_KEY, cn as profileWorkspaceModeSchema, cr as createDaemonRouteObservationSummary, ct as daemonHubDispatchPreviewEndRequestSchema, d as resolveRuntimeSession, dn as removeSpaceMembersResponseSchema, dt as daemonHubHeartbeatResponseSchema, en as patchSpaceContractResponseSchema, er as writeCurrentDeviceObservedMetadataBodySchema, et as continuitySchema, f as resolveRuntimeSessionId, fn as reserveFinalClaimBodySchema, ft as daemonHubRegisterSessionRequestSchema, g as AGENT_REPLYING_PURPOSE, gn as resolveMessageEnvelopeTargetField, gt as daemonRuntimeLeaseSchema, h as AGENT_REPLYING_END_PURPOSE, hn as resolveBuiltinUpstreamConversationRefKind, ht as daemonRouteObservationResponseSchema, i as releaseLock, in as postSpaceMembersBodySchema, ir as writeStartObservedDeviceMetadataBodySchema, it as createStartSessionBodySchema, j as SPACE_MEMBER_JOIN_NOTICE_PURPOSE, jn as spaceConversationBindingResponseSchema, jt as getPrepareReadinessResponseSchema, k as MESSAGE_MENTION_TYPE_VALUES, kn as spaceConversationBindingDeleteResponseSchema, kt as getAgentProfilePrimaryBindingResponseSchema, l as listRuntimeSessionStates, ln as providerDispatchRuntimeContextSchema, lt as daemonHubDispatchPreviewRequestSchema, m as resolveBuiltinAgentControllerBrand, mn as resolveBuiltinProviderConversationCapability, mt as daemonHubSubmitTaskResultRequestSchema, n as isAtsLockError, nn as postNormalMessageBodySchema, nr as writeStartObservationBodySchema, nt as createSpaceBodySchema, o as tryCleanupStaleLock, on as prepareSessionResponseSchema, or as writeStartSessionProgressBodySchema, ot as daemonHubDeliverDispatchRequestSchema, p as writeRuntimeSessionState, pn as reserveFinalClaimResponseSchema, pt as daemonHubRegisterSessionResponseSchema, q as buildUpstreamConversationRef, qn as submitRuntimeCapabilityReportsResponseSchema, qt as normalizeListSignalsReadQuerySemantics, r as readLockMeta, rn as postNormalMessageResponseSchema, rr as writeStartObservationResponseSchema, rt as createSpaceResponseSchema, s as ATS_RUNTIME_SESSION_ENV_KEY, sn as prepareSessionStreamServerFrameSchema, sr as writeStartSessionProgressResponseSchema, st as daemonHubDispatchLifecycleRequestSchema, t as acquireLock, tn as patchStartSessionBodySchema, tr as writeCurrentDeviceObservedMetadataResponseSchema, tt as conversationExecutionStateSchema, u as readRuntimeSessionState, un as querySpaceDeletionTombstonesResponseSchema, ut as daemonHubHeartbeatRequestSchema, v as AGENT_REPLY_PREVIEW_PURPOSE, vn as resolveSpaceMentionLabels, vt as daemonStreamFrameSchema, w as DISPATCH_ACTIVITY_FAILED_PURPOSE, wn as serverErrorFrameSchema, wt as forgetComputerResponseSchema, x as CONVERSATION_CONTINUITY_WARNING_PURPOSE, xt as ensureAgentProfilePrimaryBindingResponseSchema, y as ATSD_CONTROL_PLANE_SCHEMA_VERSION, yn as resolveStartHandoffBodySchema, yt as dispatchBriefSchema, z as atsRuntimeProfileIdSchema, zn as startSessionProgressSchema, zt as getSpaceUpdatesResponseSchema } from "./lock-CLqqzR_x.js";
+import { $ as catchupResponseSchema, $n as submitRuntimeCapabilityReportsResponseSchema, $t as normalizeListSignalsReadQuerySemantics, A as MAX_SIGNAL_REPLY_TO_PREVIEW_LENGTH, An as serverErrorFrameSchema, At as gatewayErrorCodeSchema, B as atsProfileIdSchema, Bn as spaceDispatchTraceResponseSchema, Bt as getSpaceConversationStatusResponseSchema, C as CONVERSATION_CONTINUITY_WARNING_PURPOSE, Cn as resolveSingleSpaceMentionLabels, Ct as ensureAgentProfilePrimaryBindingBodySchema, D as DISPATCH_ACTIVITY_RETRYING_PURPOSE, Dt as forgetComputerResponseSchema, E as DISPATCH_ACTIVITY_FAILED_PURPOSE, En as resolveStartHandoffResponseSchema, Et as finalClaimRouteParamsSchema, F as SPACE_MENTION_REJECT_NOTICE_PURPOSE, Fn as spaceConversationBindingDeleteResponseSchema, Ft as getAgentProfilePrimaryBindingResponseSchema, G as atsdControlPlaneResponseSchema, Gn as startSessionProgressSchema, Gt as getSpaceUpdatesResponseSchema, H as atsRuntimeProfileIdSchema, Hn as spaceMetaSchema, Ht as getSpaceDispatchResultResponseSchema, I as SPACE_PASSWORD_MIN_LENGTH, In as spaceConversationBindingImportResponseSchema, It as getPrepareReadinessQuerySchema, J as atsdTaskResultPayloadSchema, Jn as startSessionSpaceChoiceResponseSchema, Jt as isExplicitBuiltinControllerRef, K as atsdTaskResultEnvelopeWriteSchema, Kn as startSessionResponseSchema, Kt as getSpaceWakeProgressResponseSchema, L as SPACE_UPDATES_MAX_LIMIT, Ln as spaceConversationBindingResponseSchema, Lt as getPrepareReadinessResponseSchema, M as SPACE_DISPATCH_TRACE_PROMPT_PREVIEW_MAX_CHARS, Mn as setOwnedDeviceDisplayNameBodySchema, Mt as getAgentExecutionReadinessBatchBodySchema, N as SPACE_MEMBER_JOIN_NOTICE_PURPOSE, Nn as signalEnvelopeSchema, Nt as getAgentExecutionReadinessBatchResponseSchema, O as LEGACY_RUNTIME_DISPATCH_POLICY, Ot as forgetCurrentComputerResponseSchema, P as SPACE_MEMBER_REMOVE_NOTICE_PURPOSE, Pn as spaceConversationBindingConflictResponseSchema, Pt as getAgentExecutionReadinessResponseSchema, Q as canonicalizeControllerRefForKind, Qn as submitRuntimeCapabilityReportsBodySchema, Qt as normalizeBuiltinControllerProviderId, R as agentExecutionReadinessRouteParamsSchema, Rn as spaceConversationBindingUpsertResponseSchema, Rt as getSpaceContractResponseSchema, S as ATSD_TASK_RESULT_SCHEMA_VERSION, Sn as resolveMessageEnvelopeTargetField, St as dispatchBriefSchema, T as DISPATCH_ACTIVITY_DISPATCHING_PURPOSE, Tn as resolveStartHandoffBodySchema, Tt as entryBriefSchema, U as atsSpaceEgressActionSchema, Un as startDeviceProjectionSchema, Ut as getSpaceMessageAddressingRelationSupportForTargetKind, V as atsRequestContextSchema, Vn as spaceMembersSnapshotSchema, Vt as getSpaceDispatchLookupResponseSchema, W as atsdControlPlaneRequestSchema, Wn as startProfileReadinessSummarySchema, Wt as getSpaceStatusResponseSchema, X as buildUpstreamConversationRef, Xn as startStateResponseSchema, Xt as listProfileSpaceHistoryResponseSchema, Y as buildControllerRoutingKeyForKind, Yn as startSessionWithTokenResponseSchema, Yt as leaveSpaceResponseSchema, Z as canonicalizeBuiltinControllerRef, Zn as structuredGuidePayloadFromInputSchema, Zt as normalizeBuiltinControllerAgentId, _ as AGENT_REPLYING_END_PURPOSE, _n as removeSpaceMembersResponseSchema, _t as daemonHubSubmitTaskResultRequestSchema, a as runWithHeldLock, an as patchSpaceContractBodySchema, ar as writeCurrentDeviceBootstrapObservationResponseSchema, at as createSpaceBodySchema, b as AGENT_REPLY_PREVIEW_PURPOSE, bn as resolveBuiltinProviderConversationCapability, bt as daemonServiceContractSchema, c as LEGACY_ATS_RUNTIME_SESSION_ENV_KEY, cn as postNormalMessageBodySchema, cr as writeStartObservationBodySchema, ct as currentDeviceTargetResponseSchema, d as resolveRuntimeSession, dn as postSpaceMembersResponseSchema, dr as writeStartObservedDeviceMetadataResponseSchema, dt as daemonHubDispatchPreviewEndRequestSchema, en as normalizeMessageEnvelope, er as submitRuntimeRegistrationBodySchema, et as claimExecutionDiagnosticsQuerySchema, f as resolveRuntimeSessionId, fn as prepareSessionResponseSchema, fr as writeStartSessionProgressBodySchema, ft as daemonHubDispatchPreviewRequestSchema, g as resolveMappedPublicAgentFailureReason, gn as querySpaceDeletionTombstonesResponseSchema, gt as daemonHubRegisterSessionResponseSchema, h as resolveBuiltinAgentControllerBrand, hn as providerDispatchRuntimeContextSchema, ht as daemonHubRegisterSessionRequestSchema, i as releaseLock, in as patchProfileSpaceHistoryStatusResponseSchema, ir as writeCurrentDeviceBootstrapObservationBodySchema, it as conversationExecutionStateSchema, j as MESSAGE_MENTION_TYPE_VALUES, jn as setCurrentDeviceTargetBodySchema, jt as gatewayErrorEnvelopeSchema, k as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, kn as sanitizeSignalTextPreview, kt as formatCanonicalMentionLiteral, l as listRuntimeSessionStates, ln as postNormalMessageResponseSchema, lr as writeStartObservationResponseSchema, lt as daemonHubDeliverDispatchRequestSchema, m as CODEX_UPGRADE_REQUIRED_REASON, mn as profileWorkspaceModeSchema, mr as createDaemonRouteObservationSummary, mt as daemonHubHeartbeatResponseSchema, n as isAtsLockError, nn as ownedDevicesResponseSchema, nr as upsertProfileSpaceHistoryResponseSchema, nt as collectCanonicalMentionTextFragments, o as tryCleanupStaleLock, on as patchSpaceContractResponseSchema, or as writeCurrentDeviceObservedMetadataBodySchema, ot as createSpaceResponseSchema, p as writeRuntimeSessionState, pn as prepareSessionStreamServerFrameSchema, pr as writeStartSessionProgressResponseSchema, pt as daemonHubHeartbeatRequestSchema, q as atsdTaskResultOpenClawGatewayVisibilityStatusSchema, qn as startSessionSpaceChoiceBodySchema, qt as incomingServerMessageSchema, r as readLockMeta, rn as parseOptionalClientMessageId, rr as upsertSpaceDeletionTombstoneResponseSchema, rt as continuitySchema, s as ATS_RUNTIME_SESSION_ENV_KEY, sn as patchStartSessionBodySchema, sr as writeCurrentDeviceObservedMetadataResponseSchema, st as createStartSessionBodySchema, t as acquireLock, tn as normalizeOptionalWorkingDirectory, tr as submitRuntimeRegistrationResponseSchema, tt as claimExecutionDiagnosticsResponseSchema, u as readRuntimeSessionState, un as postSpaceMembersBodySchema, ur as writeStartObservedDeviceMetadataBodySchema, ut as daemonHubDispatchLifecycleRequestSchema, v as AGENT_REPLYING_PURPOSE, vn as reserveFinalClaimBodySchema, vt as daemonRouteObservationResponseSchema, w as DAEMON_HUB_SCHEMA_VERSION, wn as resolveSpaceMentionLabels, wt as ensureAgentProfilePrimaryBindingResponseSchema, x as ATSD_CONTROL_PLANE_SCHEMA_VERSION, xn as resolveBuiltinUpstreamConversationRefKind, xt as daemonStreamFrameSchema, y as AGENT_REPLY_PREVIEW_END_PURPOSE, yn as reserveFinalClaimResponseSchema, yt as daemonRuntimeLeaseSchema, z as agentProfileBindingRouteParamsSchema, zn as spaceCreatorSchema, zt as getSpaceConversationRemoteStatusResponseSchema } from "./lock-DNHgZaBJ.js";
 import { A as runtimeLogsDir, C as normalizeAtsProfileId, D as resolveAtsEnvPreset, E as resolveAtsCliEntryNameFromArgv, M as skillsDir, N as spacesDir, O as resolveAtsRootDir, P as systemDir, S as normalizeAccountKey, T as profileViewPath, a as accountProfileWorkspacePath, c as atsRootDir, d as deviceOpenClawProfileBootstrapPath, f as deviceOpenClawProfileDir, i as accountProfileViewPath, k as runtimeDir, n as accountProfileLocalMetaPath, o as accountsDir, p as deviceOpenClawProfileWorkspaceDir, r as accountProfileSpaceCacheDir, s as atsBackupsDir, t as ATS_HOME_ENV_KEY, w as profileDir, y as legacyAccountProfileSpacesDir } from "./paths-DyLxjg9Z.js";
-import { A as toSpaceCursorUrl, B as toSpaceSignalsUrl, C as resolveDefaultGatewayBaseUrl, D as toDaemonRouteObservationUrl, E as toClaimExecutionDiagnosticsUrl, F as toSpaceMembersUrl, H as toSpaceWsUrl, I as toSpaceMetaUrl, L as toSpacePasswordUrl, M as toSpaceDispatchLookupUrl, N as toSpaceDispatchTraceUrl, O as toSpaceContractUrl, P as toSpaceLeaveUrl, R as toSpaceRemoveMembersUrl, S as resolveBaseUrlOrNull, T as normalizeBaseUrl, V as toSpaceUpdatesUrl, _ as updateConfiguredStartV1OnboardingState, a as getConfiguredDeviceRuntimeState, b as normalizeGatewayBaseUrlOrNull, c as getConfiguredStartV1OnboardingState, d as resolveRuntimeSkillsCustomTargetId, f as setConfiguredBaseUrl, g as updateConfiguredSkillsConfig, h as updateConfiguredOnboardingConfig, i as getConfiguredDaemonDispatchLimits, j as toSpaceDeleteUrl, k as toSpaceCreateUrl, l as getConfiguredViewCustomization, m as updateConfiguredDeviceRuntimeState, n as alignRuntimeConfigStorage, o as getConfiguredOnboardingDisclaimerAcceptedAt, p as setConfiguredSkillsConfig, r as createDefaultRuntimeAgentControllerSettings, s as getConfiguredSkillsConfig, t as DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE, u as getRuntimeConfigReadHealth, w as resolveExplicitGatewayUrlOrThrow, x as resolveBaseUrl, y as normalizeGatewayBaseUrl, z as toSpaceResultUrl } from "./runtime-config-CPtfyCpL.js";
+import { A as toSpaceCursorUrl, B as toSpaceSignalsUrl, C as resolveDefaultGatewayBaseUrl, D as toDaemonRouteObservationUrl, E as toClaimExecutionDiagnosticsUrl, F as toSpaceMembersUrl, H as toSpaceWsUrl, I as toSpaceMetaUrl, L as toSpacePasswordUrl, M as toSpaceDispatchLookupUrl, N as toSpaceDispatchTraceUrl, O as toSpaceContractUrl, P as toSpaceLeaveUrl, R as toSpaceRemoveMembersUrl, S as resolveBaseUrlOrNull, T as normalizeBaseUrl, V as toSpaceUpdatesUrl, _ as updateConfiguredStartV1OnboardingState, a as getConfiguredDeviceRuntimeState, b as normalizeGatewayBaseUrlOrNull, c as getConfiguredStartV1OnboardingState, d as resolveRuntimeSkillsCustomTargetId, f as setConfiguredBaseUrl, g as updateConfiguredSkillsConfig, h as updateConfiguredOnboardingConfig, i as getConfiguredDaemonDispatchLimits, j as toSpaceDeleteUrl, k as toSpaceCreateUrl, l as getConfiguredViewCustomization, m as updateConfiguredDeviceRuntimeState, n as alignRuntimeConfigStorage, o as getConfiguredOnboardingDisclaimerAcceptedAt, p as setConfiguredSkillsConfig, r as createDefaultRuntimeAgentControllerSettings, s as getConfiguredSkillsConfig, t as DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE, u as getRuntimeConfigReadHealth, w as resolveExplicitGatewayUrlOrThrow, x as resolveBaseUrl, y as normalizeGatewayBaseUrl, z as toSpaceResultUrl } from "./runtime-config-JF1fXrHX.js";
 import { createRequire } from "node:module";
 import { Command, Option } from "commander";
 import { accessSync, appendFileSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
@@ -27,12 +27,12 @@ import wrapAnsi from "wrap-ansi";
 import { Box, Container, Editor, Key, ProcessTerminal, TUI, Text, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
 
 //#region package.json
-var version = "0.4.2";
+var version = "0.4.4";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
 	version,
-	atsReleaseDate: "2026-05-09",
+	atsReleaseDate: "2026-05-11",
 	description: "Agent Transport System CLI - https://ats.sh",
 	license: "MIT",
 	type: "module",
@@ -4013,7 +4013,7 @@ async function setDaemonServiceRuntimeState(state, pathInput = {}) {
 	await writeDaemonServiceRuntimeState(state, pathInput);
 }
 async function clearDaemonServiceRuntimeState(pathInput = {}) {
-	const { clearDaemonRuntimeLease } = await import("./daemon-runtime-lease-Bs_rD8WX.js");
+	const { clearDaemonRuntimeLease } = await import("./daemon-runtime-lease-BCpF6ncF.js");
 	await Promise.all([rm(daemonServiceRuntimeStatePath(pathInput), { force: true }), clearDaemonRuntimeLease(pathInput)]);
 }
 async function withDaemonServiceRunLock(callback, meta = {
@@ -24246,6 +24246,17 @@ function resolveWakeAvailability(input) {
 		reasonText: null
 	};
 	if (!input.agentMember) throw new Error("Agent Space Message Addressing target is missing.");
+	const readiness = input.agentMember.agentExecutionReadiness ?? null;
+	if (readiness) {
+		const ready = readiness.displayState === "ready";
+		return {
+			daemonRouteObservation: input.agentMember.daemonRouteObservation,
+			status: ready ? "ready" : "blocked",
+			wakeState: ready ? "wakeable" : "offline",
+			reasonCodes: [...readiness.reasonCodes],
+			reasonText: formatAgentExecutionReadinessReason(readiness)
+		};
+	}
 	return {
 		daemonRouteObservation: input.agentMember.daemonRouteObservation,
 		status: input.agentMember.wakeability.status,
@@ -24254,6 +24265,14 @@ function resolveWakeAvailability(input) {
 		reasonText: normalizeOptionalText$5$1(input.agentMember.wakeability.reasonText)
 	};
 }
+function formatAgentExecutionReadinessReason(readiness) {
+	if (readiness.displayState === "ready") return "This agent can reply in this space.";
+	if (readiness.facts.claim.executionBlocked) return "ATS cannot safely send work to this agent yet.";
+	if (!readiness.facts.binding.routable) return "This agent is not connected to a local agent yet.";
+	if (!readiness.facts.runtime.ready) return "ATS needs current local agent readiness from this computer.";
+	if (!readiness.facts.route.online) return "ATS cannot see this agent's local connection right now.";
+	return "This agent is not ready to reply yet.";
+}
 function buildActiveSpaceMemberInputs(snapshot) {
 	return [...snapshot.agents.map((member) => ({
 		expectedProfileKind: "agent",
@@ -24369,6 +24388,52 @@ function normalizeOptionalText$5$1(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
+function formatBlockedWakeAvailabilityLabel(wakeAvailability) {
+	const reason = resolveBlockedWakeAvailabilityReason(wakeAvailability);
+	return reason ? `Unavailable now: ${reason}` : "Unavailable now";
+}
+function formatBlockedWakeSubmissionMessage(input) {
+	const reason = resolveBlockedWakeAvailabilityReason(input.wakeAvailability, { preferReasonText: true });
+	if (!reason) return `"${input.profileName}" cannot reply yet. Review this computer from Members or Agents, then try again.`;
+	return `"${input.profileName}" cannot reply yet: ${formatSentence(reason)}`;
+}
+function resolveBlockedWakeAvailabilityReason(wakeAvailability, options = {}) {
+	if (wakeAvailability.status !== "blocked") return null;
+	const reasonText = normalizeReasonText(wakeAvailability.reasonText);
+	if (options.preferReasonText && reasonText) return reasonText;
+	switch (wakeAvailability.reasonCodes[0]) {
+		case "profile.unbound": return "Not connected to a local agent on this device yet";
+		case "agent_profile_binding.missing":
+		case "claim_eligibility.binding_missing": return "This agent is not connected to a local agent yet";
+		case "claim_eligibility.binding_runtime_mismatch":
+		case "claim_eligibility.runtime_id_mismatch": return "This agent is connected to an older computer setup";
+		case "claim_eligibility.binding_capability_mismatch": return "This agent is connected to a different local agent setup";
+		case "claim_eligibility.binding_owner_mismatch":
+		case "claim_eligibility.owner_mismatch": return "This agent is connected to a different ATS account";
+		case "controller.binding.disabled": return "Turned off on this device";
+		case "controller.registry.disabled": return "Turned off in ATS on this device";
+		case "controller.launch.choice_required": return "Needs an install choice on this device";
+		case "controller.launch.needs_repair": return "Needs repair on this device";
+		case "workspace.missing": return "Missing its local workspace on this device";
+		case "workspace.invalid": return "Local workspace is broken on this device";
+		case "service.not_installed": return "ATS Service is not installed on this device";
+		case "service.not_running": return "ATS Service is not running on this device";
+		case "projection.missing": return "ATS is still setting up this device";
+		case "route.offline": return "Offline from this device right now";
+		case "route.not_registered": return "Still setting up replies on this device";
+		default: return reasonText;
+	}
+}
+function formatSentence(value) {
+	const normalized = normalizeReasonText(value);
+	if (!normalized) return "Review this computer from Members or Agents, then try again.";
+	return `${normalized}.`;
+}
+function normalizeReasonText(value) {
+	const normalized = String(value ?? "").trim();
+	if (!normalized) return null;
+	return normalized.endsWith(".") ? normalized.slice(0, Math.max(0, normalized.length - 1)) : normalized;
+}
 const CANONICAL_MENTION_TYPES = new Set(MESSAGE_MENTION_TYPE_VALUES);
 const DUPLICATE_TARGET_ISSUE_PATTERN = /^(activationTargets|referenceTargets|ccTargets) must not contain duplicate profileId$/u;
 const DISTINCT_TARGET_ISSUE_PATTERN = /^(activationTargets|referenceTargets|ccTargets) must not reuse profileId from (activationTargets|referenceTargets|ccTargets)$/u;
@@ -24420,7 +24485,10 @@ function prepareSpaceComposerSubmission(input) {
 			mentionText: fragment.text,
 			relation: parsedLiteral.type
 		}));
-		if (parsedLiteral.type === "wake" && target.wakeAvailability.status === "blocked") throw createSubmissionError("addressing.wake_blocked", buildBlockedWakeCanonicalMentionMessage({ profileName: target.profileName }));
+		if (parsedLiteral.type === "wake" && target.wakeAvailability.status === "blocked") throw createSubmissionError("addressing.wake_blocked", formatBlockedWakeSubmissionMessage({
+			profileName: target.profileName,
+			wakeAvailability: target.wakeAvailability
+		}));
 		envelopeInput[resolveMessageEnvelopeTargetField(parsedLiteral.type)].push(target.profileId);
 		profileIdsInTextOrder.push(target.profileId);
 		canonicalMentionsInTextOrder.push({
@@ -24541,9 +24609,6 @@ function describeRelationSupport(relation) {
 	if (relation === "wake") return "agent targets";
 	return "active targets";
 }
-function buildBlockedWakeCanonicalMentionMessage(input) {
-	return `"${input.profileName}" is not ready for Wake yet. Finish local agent setup first.`;
-}
 function formatCanonicalMentionEnvelopeError(error) {
 	const issues = extractEnvelopeIssueMessages(error);
 	for (const issueMessage of issues) {
@@ -24730,10 +24795,6 @@ function listSpaceMentionRelationChoices(input) {
 	}
 	return choices;
 }
-function formatBlockedWakeAvailabilityLabel(wakeAvailability) {
-	const reason = resolveBlockedWakeAvailabilityReason(wakeAvailability);
-	return reason ? `Unavailable now: ${reason}` : "Unavailable now";
-}
 function normalizeRecentMentionProfileIds(input) {
 	const maxRecentProfileIds = resolveMaxRecentProfileIds(input.maxRecentProfileIds);
 	const allowedProfileIds = toAllowedProfileIdSet(input.allowedProfileIds);
@@ -24852,29 +24913,6 @@ function normalizeSearchTerm(value) {
 function areCaseInsensitiveMatches$1(left, right) {
 	return left.localeCompare(right, "en", { sensitivity: "accent" }) === 0;
 }
-function resolveBlockedWakeAvailabilityReason(wakeAvailability) {
-	if (wakeAvailability.status !== "blocked") return null;
-	switch (wakeAvailability.reasonCodes[0]) {
-		case "profile.unbound": return "Not connected to a local agent on this device yet";
-		case "controller.binding.disabled": return "Turned off on this device";
-		case "controller.registry.disabled": return "Turned off in ATS on this device";
-		case "controller.launch.choice_required": return "Needs an install choice on this device";
-		case "controller.launch.needs_repair": return "Needs repair on this device";
-		case "workspace.missing": return "Missing its local workspace on this device";
-		case "workspace.invalid": return "Local workspace is broken on this device";
-		case "service.not_installed": return "ATS Service is not installed on this device";
-		case "service.not_running": return "ATS Service is not running on this device";
-		case "projection.missing": return "ATS is still setting up this device";
-		case "route.offline": return "Offline from this device right now";
-		case "route.not_registered": return "Still setting up replies on this device";
-		default: return normalizeReasonText(wakeAvailability.reasonText);
-	}
-}
-function normalizeReasonText(value) {
-	const normalized = String(value ?? "").trim();
-	if (!normalized) return null;
-	return normalized.endsWith(".") ? normalized.slice(0, Math.max(0, normalized.length - 1)) : normalized;
-}
 function resolveRecentMentionProfileIdsFromCanonicalMentions(canonicalMentionsInTextOrder) {
 	if (!(canonicalMentionsInTextOrder && canonicalMentionsInTextOrder.length > 0)) return [];
 	return canonicalMentionsInTextOrder.toReversed().map((mention) => mention.profileId);
@@ -24902,6 +24940,28 @@ function spaceTextHasOneShotMentionAttempts(text) {
 	return spaceTextHasCanonicalMentionAttempts(text);
 }
 function buildSpaceMemberAgentPresencePresentation(member) {
+	const readiness = member.agentExecutionReadiness ?? null;
+	if (readiness) {
+		if (readiness.displayState === "ready") return member.liveNow ? {
+			detailLabel: "Live agent",
+			shortLabel: "live now",
+			status: "live"
+		} : {
+			detailLabel: "Wakeable agent",
+			shortLabel: "wakeable",
+			status: "wakeable"
+		};
+		if (hasUnavailableRoute(readiness.facts.route.reasonCodes)) return {
+			detailLabel: "Daemon route unavailable",
+			shortLabel: "daemon route unavailable",
+			status: "unavailable"
+		};
+		return {
+			detailLabel: "Offline agent",
+			shortLabel: "offline",
+			status: "offline"
+		};
+	}
 	if (member.liveNow) return {
 		detailLabel: "Live agent",
 		shortLabel: "live now",
@@ -24923,6 +24983,9 @@ function buildSpaceMemberAgentPresencePresentation(member) {
 		status: "offline"
 	};
 }
+function hasUnavailableRoute(reasonCodes) {
+	return reasonCodes.some((reasonCode) => reasonCode === "route.unavailable" || reasonCode === "agent_execution.route_unavailable");
+}
 function createSpaceMemberIdentityIndex(input) {
 	const byProfileId = /* @__PURE__ */ new Map();
 	for (const signal of input.signals ?? []) registerSignalIdentity(byProfileId, signal);
@@ -26817,24 +26880,36 @@ function resolveAgentExecutionStatus(input) {
 	});
 	const runtime = resolveRuntimeFact(input.runtimeReadiness);
 	const claim = resolveClaimFact(input.claimDiagnostics);
+	const route = resolveRouteFact(input.route);
 	const reasonCodes = uniqueReasonCodes$2([
 		...binding.reasonCodes,
 		...runtime.reasonCodes,
-		...claim.reasonCodes
+		...claim.reasonCodes,
+		...route.reasonCodes
 	]);
+	const displayState = resolveDisplayState({
+		bindingBlocked: binding.source === "blocked",
+		bindingRoutable: binding.routable,
+		claimBlocked: claim.executionBlocked,
+		routeOnline: route.online,
+		runtimeReady: runtime.ready
+	});
 	return {
 		agentProfileId: input.agentProfileId,
-		displayState: resolveDisplayState({
-			bindingBlocked: binding.source === "blocked",
-			bindingRoutable: binding.routable,
-			claimBlocked: claim.executionBlocked,
-			runtimeReady: runtime.ready
-		}),
+		displayState,
 		facts: {
 			binding,
 			claim,
+			route,
 			runtime
 		},
+		primaryAction: resolvePrimaryAction({
+			binding,
+			claim,
+			displayState,
+			route,
+			runtime
+		}),
 		reasonCodes
 	};
 }
@@ -26901,11 +26976,42 @@ function resolveClaimFact(claimDiagnostics) {
 		source: "claim_diagnostics"
 	};
 }
+function resolveRouteFact(route) {
+	if (!route) return {
+		deviceId: null,
+		observedAt: null,
+		online: false,
+		reasonCodes: ["agent_execution.route_missing"],
+		source: "missing"
+	};
+	if (route.status === "online") return {
+		deviceId: route.deviceId?.trim() || null,
+		observedAt: route.observedAt?.trim() || null,
+		online: true,
+		reasonCodes: route.reasonCodes ?? [],
+		source: "daemon_route"
+	};
+	return {
+		deviceId: route.deviceId?.trim() || null,
+		observedAt: route.observedAt?.trim() || null,
+		online: false,
+		reasonCodes: route.reasonCodes,
+		source: "daemon_route"
+	};
+}
 function resolveDisplayState(input) {
 	if (input.claimBlocked || input.bindingBlocked) return "blocked";
-	if (input.bindingRoutable && input.runtimeReady) return "ready";
+	if (input.bindingRoutable && input.runtimeReady && input.routeOnline) return "ready";
 	return "not_ready";
 }
+function resolvePrimaryAction(input) {
+	if (input.displayState === "ready") return "none";
+	if (input.claim.executionBlocked) return "check_status";
+	if (!input.binding.routable) return input.binding.source === "unavailable" ? "check_status" : "reconnect_binding";
+	if (!input.runtime.ready) return "run_prepare";
+	if (!input.route.online) return "check_status";
+	return "check_status";
+}
 function uniqueReasonCodes$2(reasonCodes) {
 	return [...new Set(reasonCodes.filter((reasonCode) => reasonCode.trim()))];
 }
@@ -26923,6 +27029,10 @@ function createAgentExecutionStatusDisplayRows(projection) {
 			label: "Runtime Evidence",
 			value: formatRuntimeEvidence(projection)
 		},
+		{
+			label: "Route Evidence",
+			value: formatRouteEvidence(projection)
+		},
 		{
 			label: "Claim Evidence",
 			value: formatClaimEvidence(projection)
@@ -26931,7 +27041,7 @@ function createAgentExecutionStatusDisplayRows(projection) {
 }
 function formatAgentExecutionStatus(projection) {
 	switch (projection.displayState) {
-		case "ready": return "Ready · Binding truth and Runtime readiness are ready.";
+		case "ready": return "Ready · Binding truth, Runtime readiness, and route are ready.";
 		case "blocked": return `Blocked · ${formatBlockingReason(projection)}`;
 		case "not_ready": return `Not ready · ${formatNotReadyReason(projection)}`;
 		case "unknown": return "Unknown";
@@ -26956,6 +27066,11 @@ function formatRuntimeEvidence(projection) {
 	if (projection.facts.runtime.reasonCodes.includes("prepare_readiness.read_failed")) return `Prepare readiness · unavailable · ${formatPrimaryReason(projection.facts.runtime.reasonCodes)}`;
 	return `Prepare readiness · not ready · ${formatPrimaryReason(projection.facts.runtime.reasonCodes)}`;
 }
+function formatRouteEvidence(projection) {
+	if (projection.facts.route.online) return "Daemon route · online";
+	if (projection.facts.route.source === "missing") return "Missing";
+	return `Daemon route · not online · ${formatPrimaryReason(projection.facts.route.reasonCodes)}`;
+}
 function formatClaimEvidence(projection) {
 	if (projection.facts.claim.source === "not_checked") return "Not checked";
 	if (projection.facts.claim.executionBlocked) return `Blocked · ${formatPrimaryReason(projection.facts.claim.reasonCodes)}`;
@@ -26969,10 +27084,14 @@ function formatPrimaryReason(reasonCodes) {
 function formatNotReadyReason(projection) {
 	if (!projection.facts.binding.routable) return formatPrimaryReason(projection.facts.binding.reasonCodes);
 	if (!projection.facts.runtime.ready) return formatPrimaryReason(projection.facts.runtime.reasonCodes);
+	if (!projection.facts.route.online) return formatPrimaryReason(projection.facts.route.reasonCodes);
 	return formatPrimaryReason(projection.reasonCodes);
 }
 const REASON_TEXT = {
 	"agent_execution.binding_agent_profile_mismatch": "Binding belongs to a different agent profile.",
+	"agent_execution.route_missing": "Daemon route is missing.",
+	"agent_execution.route_offline": "Daemon route is offline.",
+	"agent_execution.route_unavailable": "Daemon route is unavailable.",
 	"agent_profile_binding.missing": "Binding is missing.",
 	"agent_profile_binding.read_unavailable": "Binding evidence is unavailable.",
 	"claim_execution_diagnostics.lease_missing": "claim lease evidence is missing.",
@@ -27180,6 +27299,14 @@ function buildLegacyDefaultMentionAliasSeed(input) {
 function buildAgentProfilePrimaryBindingRoute(agentProfileId) {
 	return `/v1/agent-profiles/${encodeURIComponent(agentProfileId)}/primary-binding`;
 }
+function buildAgentExecutionReadinessRoute(agentProfileId) {
+	return `/v1/agent-profiles/${encodeURIComponent(agentProfileId)}/execution-readiness`;
+}
+function buildAgentExecutionReadinessBatchRoute() {
+	return "/v1/agent-profiles/execution-readiness/batch";
+}
+const getAgentExecutionReadinessInputSchema = agentExecutionReadinessRouteParamsSchema.extend({ requestContext: atsRequestContextSchema.optional() });
+const getAgentExecutionReadinessBatchInputSchema = getAgentExecutionReadinessBatchBodySchema.extend({ requestContext: atsRequestContextSchema.optional() });
 const ensureAgentProfilePrimaryBindingInputSchema = agentProfileBindingRouteParamsSchema.merge(ensureAgentProfilePrimaryBindingBodySchema).extend({ requestContext: atsRequestContextSchema.optional() });
 function requireValidBindingCommandBody(input) {
 	const parsed = ensureAgentProfilePrimaryBindingInputSchema.safeParse(input);
@@ -27187,8 +27314,42 @@ function requireValidBindingCommandBody(input) {
 	const { agentProfileId: _agentProfileId, requestContext: _requestContext, ...body } = parsed.data;
 	return body;
 }
+function requireValidExecutionReadinessInput(input) {
+	const parsed = getAgentExecutionReadinessInputSchema.safeParse(input);
+	if (!parsed.success) throw new Error(parsed.error.issues[0]?.message ?? "Invalid Agent Execution Readiness request.");
+	return parsed.data;
+}
+function requireValidExecutionReadinessBatchInput(input) {
+	const parsed = getAgentExecutionReadinessBatchInputSchema.safeParse(input);
+	if (!parsed.success) throw new Error(parsed.error.issues[0]?.message ?? "Invalid Agent Execution Readiness batch request.");
+	return parsed.data;
+}
 const createAgentProfileBindingApi = (client) => {
 	return {
+		getExecutionReadiness: async (input) => {
+			const request = requireValidExecutionReadinessInput(input);
+			return await client.requestJson({
+				invalidMessage: "Invalid Agent Execution Readiness response.",
+				method: "GET",
+				operation: "agent_execution_readiness.read",
+				requestContext: request.requestContext,
+				schema: getAgentExecutionReadinessResponseSchema,
+				url: buildAgentExecutionReadinessRoute(request.agentProfileId)
+			});
+		},
+		getExecutionReadinessBatch: async (input) => {
+			const request = requireValidExecutionReadinessBatchInput(input);
+			return await client.requestJson({
+				body: JSON.stringify({ agentProfileIds: request.agentProfileIds }),
+				headers: { "content-type": "application/json" },
+				invalidMessage: "Invalid Agent Execution Readiness batch response.",
+				method: "POST",
+				operation: "agent_execution_readiness.batch_read",
+				requestContext: request.requestContext,
+				schema: getAgentExecutionReadinessBatchResponseSchema,
+				url: buildAgentExecutionReadinessBatchRoute()
+			});
+		},
 		getPrimaryBinding: async (input) => await client.requestJson({
 			invalidMessage: "Invalid Agent Profile Binding response.",
 			method: "GET",
@@ -32365,24 +32526,12 @@ const LIVE_RESUME_PROBE_PROMPT = "ATS resume probe. Reply with one short confirm
 
 //#endregion
 //#region ../../packages/space-mesh/dist/index.js
-const CODEX_UPGRADE_REQUIRED_REASON = "Codex on this device is too old for the current model. Upgrade Codex on this device, then try again.";
 function resolvePublicAgentFailureReason(input) {
 	const errorCode = normalizeOptionalText$2$1(input.errorCode)?.toLowerCase();
 	const detailedReason = resolveDetailedPublicAgentFailureReason(input.errorMessage);
 	if (detailedReason) return detailedReason;
 	if (!errorCode) return normalizeOptionalText$2$1(input.defaultReason);
-	if (errorCode.includes("claim_eligibility.binding_missing") || errorCode.includes("dispatch.claim_eligibility.binding.missing")) return "This agent needs setup before it can reply.";
-	if (errorCode.includes("controller.launch.choice_required") || errorCode.includes("launch choice")) return "ATS found more than one working install for this agent on this device. Choose which one ATS should use here, then try again.";
-	if (errorCode.includes("profile.workspace.missing")) return "This agent is missing its local workspace on this device. Run `ats doctor --repair`, then `ats agents prepare --profile <agent-profile-id>`, and try again.";
-	if (errorCode.includes("profile.workspace.invalid")) return "This agent's local workspace is broken on this device. Run `ats doctor --repair`, then `ats agents prepare --profile <agent-profile-id>`, and try again.";
-	if (errorCode.includes("auth") || errorCode.includes("credential") || errorCode.includes("login")) return "Authentication failed.";
-	if (errorCode.includes("model.unsupported") || errorCode.includes("unsupported_model")) return "The current model is not available for this agent's account.";
-	if (errorCode.includes("controller.client.upgrade_required")) return CODEX_UPGRADE_REQUIRED_REASON;
-	if (errorCode.includes("rate") || errorCode.includes("quota")) return "The agent hit a rate limit.";
-	if (errorCode.includes("permission") || errorCode.includes("forbidden") || errorCode.includes("unauthorized")) return "The agent does not have permission to reply here.";
-	if (errorCode.includes("controller.launch.needs_repair")) return "ATS could not start this agent on this device. Repair it on this device, then try again.";
-	if (errorCode.includes("timeout") || errorCode.includes("network") || errorCode.includes("unavailable") || errorCode.includes("provider") || errorCode.includes("upstream")) return "The agent could not complete this reply right now.";
-	return normalizeOptionalText$2$1(input.defaultReason);
+	return resolveMappedPublicAgentFailureReason(input.errorCode) ?? normalizeOptionalText$2$1(input.defaultReason);
 }
 function resolveDetailedPublicAgentFailureReason(errorMessage) {
 	const normalizedMessage = normalizeProviderFailureMessage(errorMessage);
@@ -54812,9 +54961,9 @@ function stripAnsi(value) {
 
 //#endregion
 //#region src/system/selected-local-runtime-reporting.ts
-async function submitSelectedLocalRuntimeReports(input) {
+function resolveSelectedLocalRuntimeReadiness(input) {
 	const uniqueAgentIds = [...new Set(input.localAgentIds.map(normalizeId))].filter(Boolean).sort();
-	const results = [];
+	const decisions = [];
 	for (const agentId of uniqueAgentIds) {
 		const capabilityRef = resolveCapabilityRefFromControllerBinding({
 			controllerKind: "builtin",
@@ -54825,18 +54974,26 @@ async function submitSelectedLocalRuntimeReports(input) {
 			candidate: input.readiness.agents.candidates.find((currentCandidate) => currentCandidate.agentId === agentId) ?? null,
 			readiness: input.readiness
 		});
-		results.push({
+		decisions.push({
 			agentId,
 			capabilityRef,
 			localParticipationState: readinessDecision.localParticipationState,
-			reasonCodes: readinessDecision.reasonCodes,
-			runtimeReportSubmission: await submitPrepareRuntimeCapabilityReport({
-				capabilityRef,
-				localParticipationState: readinessDecision.localParticipationState,
-				reasonCodes: readinessDecision.reasonCodes
-			})
+			reasonCodes: readinessDecision.reasonCodes
 		});
 	}
+	return decisions;
+}
+async function submitSelectedLocalRuntimeReports(input) {
+	const decisions = resolveSelectedLocalRuntimeReadiness(input);
+	const results = [];
+	for (const decision of decisions) results.push({
+		...decision,
+		runtimeReportSubmission: await submitPrepareRuntimeCapabilityReport({
+			capabilityRef: decision.capabilityRef,
+			localParticipationState: decision.localParticipationState,
+			reasonCodes: decision.reasonCodes
+		})
+	});
 	return results;
 }
 function assertSelectedLocalRuntimeReportsAccepted(results) {
@@ -54845,6 +55002,11 @@ function assertSelectedLocalRuntimeReportsAccepted(results) {
 	const reasonCode = failed.reasonCodes[0] ?? failed.runtimeReportSubmission.reasonCodes[0] ?? failed.runtimeReportSubmission.reason ?? "runtime.reporting.unavailable";
 	throw new Error(formatSelectedRuntimeReportFailure(failed.agentId, reasonCode));
 }
+function assertSelectedLocalRuntimeReadinessReady(decisions) {
+	const failed = decisions.find((decision) => decision.localParticipationState !== "ready");
+	if (!failed) return;
+	throw new Error(formatSelectedRuntimeReportFailure(failed.agentId, failed.reasonCodes[0] ?? "runtime.reporting.unavailable"));
+}
 function formatSelectedRuntimeReportFailure(agentId, reasonCode) {
 	if (reasonCode === "service.not_running") return `ATS could not connect selected agents to ATS for ${agentId} because ATS Service is not running. Run \`${formatAtsCliCommand("ats service status")}\` to inspect it, then \`${formatAtsCliCommand("ats service run")}\` to start it and retry this Web setup command.`;
 	if (reasonCode === "service.not_installed") return `ATS could not connect selected agents to ATS for ${agentId} because ATS Service is not installed. Run \`${formatAtsCliCommand("ats service install")}\`, then \`${formatAtsCliCommand("ats service run")}\`, and retry this Web setup command.`;
@@ -54975,6 +55137,8 @@ async function syncLocalSetupCurrentDeviceTargetFromServiceContract(input) {
 const PREPARE_TOKEN_HEADER = "x-ats-prepare-token";
 const PREPARE_SESSION_MAX_RECONNECT_ATTEMPTS = 3;
 const PREPARE_SESSION_RECONNECT_DELAY_MS = 1e3;
+const ROUTE_CATALOG_SYNC_MAX_ATTEMPTS = 8;
+const ROUTE_CATALOG_SYNC_RETRY_DELAY_MS = 750;
 const TERMINAL_PREPARE_STEP_ORDER = [
 	"prepare_selected_agents",
 	"refresh_service",
@@ -55233,7 +55397,7 @@ function buildTerminalStep(input) {
 		case "verify_setup": return {
 			message: "Checking that selected local agents are ready.",
 			run: async () => {
-				return await connectSelectedLocalAgentsToAts({
+				return await verifySelectedLocalAgentsConnectedToAts({
 					gatewayUrl: input.input.gatewayUrl,
 					localAgentIds: input.localAgentIds
 				});
@@ -55299,12 +55463,71 @@ async function connectSelectedLocalAgentsToAts(input) {
 		readiness,
 		localAgentIds: input.localAgentIds
 	}));
-	if (input.syncRouteCatalog) await notifyDaemonRouteCatalogChanged({ reason: "prepare_selected_agents_connected" });
+	if (input.syncRouteCatalog) await waitForConfirmedRouteCatalogSync({ reason: "prepare_selected_agents_connected" });
+	return {
+		...runtimeIdentity,
+		localReadinessSnapshot: buildPrepareLocalReadinessSnapshot(readiness)
+	};
+}
+async function verifySelectedLocalAgentsConnectedToAts(input) {
+	const runtimeIdentity = await readTerminalRuntimeIdentityFromServiceContract();
+	const readiness = await collectStartLocalReadiness({ auth: {
+		status: "valid",
+		email: null,
+		authBaseUrl: null,
+		gatewayUrl: input.gatewayUrl
+	} });
+	const selectedReadiness = resolveSelectedLocalRuntimeReadiness({
+		readiness,
+		localAgentIds: input.localAgentIds
+	});
+	assertSelectedLocalRuntimeReadinessReady(selectedReadiness);
+	await assertSelectedRuntimeReadinessIsReadableByAts({
+		gatewayUrl: input.gatewayUrl,
+		runtimeIdentity,
+		selectedReadiness
+	});
 	return {
 		...runtimeIdentity,
 		localReadinessSnapshot: buildPrepareLocalReadinessSnapshot(readiness)
 	};
 }
+async function readTerminalRuntimeIdentityFromServiceContract() {
+	const serviceContract = await readDaemonServiceContract();
+	const deviceId = serviceContract?.deviceId;
+	const runtimeLane = serviceContract?.lane;
+	if (!(deviceId && runtimeLane)) throw new Error("ATS could not verify selected agents because ATS Service did not provide this computer's device identity yet. Keep ATS Service running, then run the same setup command again.");
+	return {
+		deviceId,
+		runtimeLane
+	};
+}
+async function waitForConfirmedRouteCatalogSync(input) {
+	let latestDelivery = null;
+	for (let attempt = 1; attempt <= ROUTE_CATALOG_SYNC_MAX_ATTEMPTS; attempt++) {
+		latestDelivery = await notifyDaemonRouteCatalogChanged({ reason: input.reason });
+		if (latestDelivery.delivery === "control_plane") return latestDelivery;
+		if (attempt < ROUTE_CATALOG_SYNC_MAX_ATTEMPTS) await sleep$1(ROUTE_CATALOG_SYNC_RETRY_DELAY_MS);
+	}
+	throw new Error(formatRouteCatalogSyncFailure(latestDelivery));
+}
+async function assertSelectedRuntimeReadinessIsReadableByAts(input) {
+	const capabilityRefs = input.selectedReadiness.map((decision) => decision.capabilityRef);
+	if (capabilityRefs.length === 0) return;
+	const response = await createPrepareReadinessApi(createCliApiClientFoundation(input.gatewayUrl)).getReadiness({
+		capabilityRefs,
+		deviceId: input.runtimeIdentity.deviceId,
+		lane: input.runtimeIdentity.runtimeLane
+	});
+	const runnableCapabilityRefs = new Set(response.runnableCapabilities.map((capability) => capability.capabilityRef));
+	const missingCapabilityRef = capabilityRefs.find((capabilityRef) => !runnableCapabilityRefs.has(capabilityRef));
+	if (response.status === "ready" && response.runtimeId && !missingCapabilityRef) return;
+	const reasonCode = response.summary.reasonCodes[0] ?? response.reason ?? (missingCapabilityRef ? "prepare_readiness.capability_not_ready" : "prepare_readiness.not_ready");
+	throw new Error(`ATS could not verify that selected agents are connected to ATS yet. Keep ATS Service running, then run the same setup command again. Support code: ${reasonCode}.`);
+}
+function formatRouteCatalogSyncFailure(latestDelivery) {
+	return `ATS Service started, but ATS could not confirm that selected agents are available for Wake yet. Keep ATS Service running, then run the same setup command again. Support code: ${latestDelivery?.delivery === "signal" ? `route_catalog_sync.${latestDelivery.fallbackReason}` : "route_catalog_sync.unavailable"}.`;
+}
 function buildPrepareLocalReadinessSnapshot(readiness) {
 	return {
 		observedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -55493,9 +55716,13 @@ function startHumanWaitingIndicator(input, message) {
 	}
 	let tick = 0;
 	const render = () => {
-		const dots = ".".repeat(tick % 3 + 1);
+		const line = formatHumanWaitingIndicatorLine({
+			message: normalizedMessage,
+			terminalColumns: process$1.stdout.columns,
+			tick
+		});
 		tick += 1;
-		process$1.stdout.write(`\r${normalizedMessage}${dots}   `);
+		process$1.stdout.write(`\r\x1b[2K${line}`);
 	};
 	render();
 	const timer = setInterval(render, 500);
@@ -55504,6 +55731,23 @@ function startHumanWaitingIndicator(input, message) {
 		process$1.stdout.write("\r\x1B[2K");
 	} };
 }
+function formatHumanWaitingIndicatorLine(input) {
+	const label = shortHumanWaitingIndicatorLabel(input.message);
+	const dots = ".".repeat(input.tick % 3 + 1);
+	const maxLength = typeof input.terminalColumns === "number" && input.terminalColumns > 12 ? input.terminalColumns - 1 : 79;
+	return `${truncateTerminalLine(label, Math.max(8, maxLength - dots.length))}${dots}`;
+}
+function shortHumanWaitingIndicatorLabel(message) {
+	const normalizedMessage = message.toLowerCase();
+	if (normalizedMessage.includes("choice in ats web")) return "Waiting for ATS Web";
+	if (normalizedMessage.includes("connecting")) return "Connecting to ATS Web";
+	return message;
+}
+function truncateTerminalLine(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	if (maxLength <= 1) return value.slice(0, maxLength);
+	return `${value.slice(0, maxLength - 1)}.`;
+}
 function toStatusCodeSlug(title) {
 	const slug = title.toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "");
 	return slug.length > 0 ? slug : "status";
@@ -61395,6 +61639,7 @@ function buildServiceTraceAgentExecutionStatus(input) {
 		agentProfileId: input.agentProfileId,
 		binding: normalizeBindingProjection(input.binding),
 		claimDiagnostics: normalizeClaimDiagnostics(input.claimDiagnostics),
+		route: input.route ?? null,
 		runtimeReadiness: normalizePrepareReadiness(input.prepareReadiness)
 	});
 }