agent-transport-system 0.7.95 → 0.7.97

package/dist/ats.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { C as updateConfiguredSkillsConfig, S as updateConfiguredOnboardingConfig, _ as getRuntimeConfigReadHealth, a as resolveBaseUrl, b as setConfiguredSkillsConfig, c as resolveExplicitGatewayUrlOrThrow, d as createDefaultRuntimeAgentControllerSettings, f as getConfiguredDaemonDispatchLimits, g as getConfiguredViewCustomization, h as getConfiguredSkillsConfig, i as normalizeGatewayBaseUrlOrNull, l as DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE, m as getConfiguredOnboardingDisclaimerAcceptedAt, o as resolveBaseUrlOrNull, p as getConfiguredDeviceRuntimeState, r as normalizeGatewayBaseUrl, s as resolveDefaultGatewayBaseUrl, u as alignRuntimeConfigStorage, v as resolveRuntimeSkillsCustomTargetId, w as updateConfiguredStartV1OnboardingState, x as updateConfiguredDeviceRuntimeState, y as setConfiguredBaseUrl } from "./base-url-BLRaPMVx.js";
-import { $ as getSpaceThreadResponseSchema, $n as daemonStreamFrameSchema, $t as spaceMembersSnapshotSchema, A as dispatchBriefSchema, An as MAX_VISITED_PROFILE_IDS, Ar as runtimeTransportDispatchRuntimeEvidenceRequestSchema, At as prepareSessionResponseSchema, B as getAgentExecutionReadinessBatchResponseSchema, Bn as atsdControlPlaneRequestSchema, Br as runtimeTransportSubmitTaskResultRequestSchema, Bt as setCurrentLocalAgentEnabledResponseSchema, C as createSpaceThreadResponseSchema, Cn as DISPATCH_ACTIVITY_FAILED_PURPOSE, Ct as patchSpaceContractResponseSchema, D as daemonRouteObservationResponseSchema, Dn as MAX_PROFILE_ID_LENGTH, Dr as runtimeTransportDispatchLifecycleRequestSchema, Dt as postSpaceMembersResponseSchema, E as daemonRouteCatalogCacheSchema, En as LOCAL_COMPONENTS_SCHEMA_VERSION, Er as runtimeTransportDeliveryExecutionIdentitySchema, Et as postSpaceMembersBodySchema, F as forgetCurrentComputerResponseSchema, Fn as SPACE_MENTION_REJECT_NOTICE_PURPOSE, Fr as runtimeTransportLocalAgentControlRefreshCatalogFramePayloadSchema, Ft as refreshCurrentLocalAgentCatalogResponseSchema, G as getModelCatalogResponseSchema, Gn as buildAgentControllerConversationRef, Gt as signalEnvelopeSchema, H as getAgentProfilePrimaryBindingResponseSchema, Hn as atsdTaskResultEnvelopeWriteSchema, Ht as setSpaceAccessModeBodySchema, I as gatewayErrorCodeSchema, In as SPACE_PASSWORD_MIN_LENGTH, Ir as runtimeTransportLocalAgentControlSetEnabledFramePayloadSchema, It as removeSpaceMembersResponseSchema, J as getSpaceContractResponseSchema, Jn as canonicalizeBuiltinAgentControllerRef, Jt as spaceCreatorSchema, K as getPrepareReadinessQuerySchema, Kn as buildAgentControllerRoutingKey, Kt as spaceAccessModeStateSchema, L as gatewayErrorEnvelopeSchema, Ln as SPACE_UPDATES_MAX_LIMIT, Lr as runtimeTransportRegisterSessionRequestSchema, Lt as resolveSpaceDispatchTraceRootCause, M as ensureAgentProfilePrimaryBindingResponseSchema, Mn as RUNTIME_TRANSPORT_SCHEMA_VERSION, Mr as runtimeTransportHeartbeatResponseSchema, Mt as prepareSetupBootstrapWriteSchema, N as entryBriefSchema, Nn as SPACE_MEMBER_JOIN_NOTICE_PURPOSE, Nr as runtimeTransportLocalAgentControlCancelFramePayloadSchema, Nt as projectObservabilityWakeCorrelation, O as daemonRuntimeLeaseSchema, On as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, Or as runtimeTransportDispatchPreviewEndRequestSchema, Ot as postSpaceThreadSignalBodySchema, P as forgetComputerResponseSchema, Pn as SPACE_MEMBER_REMOVE_NOTICE_PURPOSE, Pr as runtimeTransportLocalAgentControlInterruptFramePayloadSchema, Pt as projectSpaceDispatchTraceFinalVisibleOutcome, Q as getSpaceStatusResponseSchema, Qn as daemonServiceLaneSchema, Qt as spaceMemberDirectorySchema, R as getActiveSpaceWakeProgressResponseSchema, Rn as atsRuntimeProfileIdSchema, Rr as runtimeTransportRegisterSessionResponseSchema, Rt as serverErrorFrameSchema, S as createSpaceThreadBodySchema, Sn as DISPATCH_ACTIVITY_DISPATCHING_PURPOSE, St as patchSpaceContractBodySchema, T as currentLocalRuntimeReplyReadinessResponseSchema, Tn as LEGACY_RUNTIME_DISPATCH_POLICY, Tr as runtimeTransportDeliverDispatchRequestSchema, Tt as postNormalMessageResponseSchema, U as getLocalRuntimeExpectedRoutesQuerySchema, Un as atsdTaskResultOpenClawGatewayVisibilityStatusSchema, Ut as setupPlanAgentViewEventSchema, V as getAgentExecutionReadinessResponseSchema, Vn as atsdControlPlaneResponseSchema, Vr as sanitizeSignalTextPreview, Vt as setLocalRuntimeDisplayNameBodySchema, W as getLocalRuntimeExpectedRoutesResponseSchema, Wn as atsdTaskResultPayloadSchema, Wt as setupPlanAgentViewPayloadSchema, X as getSpaceDispatchResultResponseSchema, Xn as conversationExecutionStateSchema, Xt as spaceIdentityDirectorySchema, Y as getSpaceDispatchLookupResponseSchema, Yn as collectCanonicalMentionTextFragments, Yt as spaceDispatchTraceResponseSchema, Z as getSpaceMessageDetailsResponseSchema, Zn as daemonServiceContractSchema, Zt as spaceMemberDirectoryEntrySchema, _ as continuitySchema, _n as AGENT_REPLY_PREVIEW_PURPOSE, _r as providerDispatchRuntimeContextSchema, _t as notifyAgentProfileRouteCatalogChangedBodySchema, a as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_VERSION, an as submitRuntimeProviderConversationProofsBodySchema, ar as getSpaceMessageAddressingRelationSupportForTargetKind, at as listProfileSpaceHistoryResponseSchema, b as createSpaceDiagnosticReportResponseSchema, bn as CONVERSATION_CONTINUITY_WARNING_PURPOSE, br as resolveSingleSpaceMentionLabels, bt as observabilityWakeTraceSelectorSchema, c as SETUP_PLAN_AGENT_VIEW_SCHEMA_VERSION, cn as submitRuntimeRegistrationResponseSchema, cr as normalizeKnownBuiltinAgentControllerId, ct as listSpaceThreadsResponseSchema, d as agentControllerPermissionModeSchema, dn as upsertProfileSpaceHistoryResponseSchema, dr as normalizeSpacePasswordText, dt as localRuntimeEnrollmentResponseSchema, en as spaceMetaSchema, er as formatCanonicalMentionLiteral, et as getSpaceUpdatesResponseSchema, f as agentExecutionReadinessRouteParamsSchema, fn as writeCurrentDeviceObservedMetadataBodySchema, fr as parseAgentControllerRef$1, ft as localRuntimesQuerySchema, g as cliJsonOutputEnvelopeSchema, gn as AGENT_REPLY_PREVIEW_END_PURPOSE, gr as profileWorkspaceModeSchema, gt as normalizeSpaceCursorPatch, h as catchupResponseSchema, hn as AGENT_REPLYING_PURPOSE, hr as postSpaceWakeStopResponseSchema, ht as normalizeListSignalsReadQuerySemantics, i as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME, in as submitRuntimeAgentControllerReportsResponseSchema, ir as formatLocalSetupActionLabel, it as leaveSpaceResponseSchema, j as ensureAgentProfilePrimaryBindingBodySchema, jn as MESSAGE_MENTION_TYPE_VALUES, jr as runtimeTransportHeartbeatRequestSchema, jt as prepareSessionStreamServerFrameSchema, k as deleteSpaceResponseSchema, kn as MAX_SIGNAL_REPLY_TO_PREVIEW_LENGTH, kr as runtimeTransportDispatchPreviewRequestSchema, kt as postSpaceThreadSignalResponseSchema, l as SPACE_DISPATCH_TRACE_PROMPT_PREVIEW_MAX_CHARS, ln as updateAgentProfilePrimaryBindingAgentControllerPermissionModeBodySchema, lr as normalizeMessageEnvelope, lt as localAgentCatalogSchema, m as atsRequestContextSchema, mn as AGENT_REPLYING_END_PURPOSE, mr as postSpaceWakeStopBodySchema, mt as modelCatalogSchema, n as resolveBuiltinAgentControllerBrand, nn as structuredGuidePayloadFromInputSchema, nr as formatLocalComponentsSummaryLabel, nt as getSpaceWakeTraceWaterfallResponseSchema, o as PREPARE_SESSION_STREAM_PROTOCOL_VERSION, on as submitRuntimeProviderConversationProofsResponseSchema, or as installedLocalComponentsSnapshotSchema, ot as listSpaceThreadEventsResponseSchema, p as agentProfileBindingRouteParamsSchema, pn as writeCurrentDeviceObservedMetadataResponseSchema, pr as parseOptionalClientMessageId, pt as localRuntimesResponseSchema, q as getPrepareReadinessResponseSchema, qn as canonicalizeAgentControllerRef, qt as spaceBootstrapResponseSchema, r as resolveMappedPublicAgentFailureReason, rn as submitRuntimeAgentControllerReportsBodySchema, rr as formatLocalSetupActionDescription, rt as incomingServerMessageSchema, s as SETUP_PLAN_AGENT_VIEW_CODE, sn as submitRuntimeRegistrationBodySchema, sr as normalizeBuiltinAgentControllerId, st as listSpaceThreadSignalsResponseSchema, t as CODEX_UPGRADE_REQUIRED_REASON, tn as spaceViewerMembershipResponseSchema, tr as formatLocalComponentsSummaryDescription, tt as getSpaceWakeProgressResponseSchema, u as accountSpaceIndexResponseSchema, un as updateAgentProfilePrimaryBindingModelSelectionBodySchema, ur as normalizeOptionalWorkingDirectory, ut as localRuntimeEnrollmentBodySchema, v as createSpaceBodySchema, vn as ATSD_CONTROL_PLANE_SCHEMA_VERSION, vr as resolveBuiltinAgentControllerConversationKind, vt as notifyAgentProfileRouteCatalogChangedResponseSchema, w as currentDeviceTargetResponseSchema, wn as DISPATCH_ACTIVITY_RETRYING_PURPOSE, wr as runtimeCoordinatorExecutionTokenEnvelopeSchema, wt as postNormalMessageBodySchema, x as createSpaceResponseSchema, xn as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, xr as resolveSpaceMentionLabels, xt as patchProfileSpaceHistoryStatusResponseSchema, y as createSpaceDiagnosticReportBodySchema, yn as ATSD_TASK_RESULT_SCHEMA_VERSION, yr as resolveMessageEnvelopeTargetField, yt as notifyAgentProfilesRouteCatalogChangedBodySchema, z as getAgentExecutionReadinessBatchBodySchema, zn as atsSpaceEgressActionSchema, zr as runtimeTransportRouteCatalogChangedFramePayloadSchema, zt as setCurrentLocalAgentEnabledBodySchema } from "./dist-CeaupHgY.js";
+import { C as updateConfiguredSkillsConfig, S as updateConfiguredOnboardingConfig, _ as getRuntimeConfigReadHealth, a as resolveBaseUrl, b as setConfiguredSkillsConfig, c as resolveExplicitGatewayUrlOrThrow, d as createDefaultRuntimeAgentControllerSettings, f as getConfiguredDaemonDispatchLimits, g as getConfiguredViewCustomization, h as getConfiguredSkillsConfig, i as normalizeGatewayBaseUrlOrNull, l as DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE, m as getConfiguredOnboardingDisclaimerAcceptedAt, o as resolveBaseUrlOrNull, p as getConfiguredDeviceRuntimeState, r as normalizeGatewayBaseUrl, s as resolveDefaultGatewayBaseUrl, u as alignRuntimeConfigStorage, v as resolveRuntimeSkillsCustomTargetId, w as updateConfiguredStartV1OnboardingState, x as updateConfiguredDeviceRuntimeState, y as setConfiguredBaseUrl } from "./base-url-SXaImoj4.js";
+import { $ as getSpaceStatusResponseSchema, $n as daemonServiceLaneSchema, $t as spaceMemberDirectorySchema, A as deleteSpaceResponseSchema, An as MAX_SIGNAL_REPLY_TO_PREVIEW_LENGTH, Ar as runtimeTransportDispatchPreviewRequestSchema, At as postSpaceThreadSignalResponseSchema, B as getAgentExecutionReadinessBatchBodySchema, Bn as atsSpaceEgressActionSchema, Br as runtimeTransportRouteCatalogChangedFramePayloadSchema, Bt as setCurrentLocalAgentEnabledBodySchema, C as createSpaceThreadBodySchema, Cn as DISPATCH_ACTIVITY_DISPATCHING_PURPOSE, Ct as patchSpaceContractBodySchema, D as daemonRouteCatalogCacheSchema, Dn as LOCAL_COMPONENTS_SCHEMA_VERSION, Dr as runtimeTransportDeliveryExecutionIdentitySchema, Dt as postSpaceMembersBodySchema, E as currentLocalRuntimeReplyReadinessResponseSchema, En as LEGACY_RUNTIME_DISPATCH_POLICY, Er as runtimeTransportDeliverDispatchRequestSchema, Et as postNormalMessageResponseSchema, F as forgetComputerResponseSchema, Fn as SPACE_MEMBER_REMOVE_NOTICE_PURPOSE, Fr as runtimeTransportLocalAgentControlInterruptFramePayloadSchema, Ft as projectSpaceDispatchTraceFinalVisibleOutcome, G as getLocalRuntimeExpectedRoutesResponseSchema, Gn as atsdTaskResultPayloadSchema, Gt as setupPlanAgentViewPayloadSchema, H as getAgentExecutionReadinessResponseSchema, Hn as atsdControlPlaneResponseSchema, Hr as sanitizeSignalTextPreview, Ht as setLocalRuntimeDisplayNameBodySchema, I as forgetCurrentComputerResponseSchema, In as SPACE_MENTION_REJECT_NOTICE_PURPOSE, Ir as runtimeTransportLocalAgentControlRefreshCatalogFramePayloadSchema, It as refreshCurrentLocalAgentCatalogResponseSchema, J as getPrepareReadinessResponseSchema, Jn as canonicalizeAgentControllerRef, Jt as spaceBootstrapResponseSchema, K as getModelCatalogResponseSchema, Kn as buildAgentControllerConversationRef, Kt as signalEnvelopeSchema, L as gatewayErrorCodeSchema, Ln as SPACE_PASSWORD_MIN_LENGTH, Lr as runtimeTransportLocalAgentControlSetEnabledFramePayloadSchema, Lt as removeSpaceMembersResponseSchema, M as ensureAgentProfilePrimaryBindingBodySchema, Mn as MESSAGE_MENTION_TYPE_VALUES, Mr as runtimeTransportHeartbeatRequestSchema, Mt as prepareSessionStreamServerFrameSchema, N as ensureAgentProfilePrimaryBindingResponseSchema, Nn as RUNTIME_TRANSPORT_SCHEMA_VERSION, Nr as runtimeTransportHeartbeatResponseSchema, Nt as prepareSetupBootstrapWriteSchema, O as daemonRouteObservationResponseSchema, On as MAX_PROFILE_ID_LENGTH, Or as runtimeTransportDispatchLifecycleRequestSchema, Ot as postSpaceMembersResponseSchema, P as entryBriefSchema, Pn as SPACE_MEMBER_JOIN_NOTICE_PURPOSE, Pr as runtimeTransportLocalAgentControlCancelFramePayloadSchema, Pt as projectObservabilityWakeCorrelation, Q as getSpaceMessageDetailsResponseSchema, Qn as daemonServiceContractSchema, Qt as spaceMemberDirectoryEntrySchema, R as gatewayErrorEnvelopeSchema, Rn as SPACE_UPDATES_MAX_LIMIT, Rr as runtimeTransportRegisterSessionRequestSchema, Rt as resolveSpaceDispatchTraceRootCause, S as createSpaceResponseSchema, Sn as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, Sr as resolveSpaceMentionLabels, St as patchProfileSpaceHistoryStatusResponseSchema, T as currentDeviceTargetResponseSchema, Tn as DISPATCH_ACTIVITY_RETRYING_PURPOSE, Tr as runtimeCoordinatorExecutionTokenEnvelopeSchema, Tt as postNormalMessageBodySchema, U as getAgentProfilePrimaryBindingResponseSchema, Un as atsdTaskResultEnvelopeWriteSchema, Ut as setSpaceAccessModeBodySchema, V as getAgentExecutionReadinessBatchResponseSchema, Vn as atsdControlPlaneRequestSchema, Vr as runtimeTransportSubmitTaskResultRequestSchema, Vt as setCurrentLocalAgentEnabledResponseSchema, W as getLocalRuntimeExpectedRoutesQuerySchema, Wn as atsdTaskResultOpenClawGatewayVisibilityStatusSchema, Wt as setupPlanAgentViewEventSchema, X as getSpaceDispatchLookupResponseSchema, Xn as collectCanonicalMentionTextFragments, Xt as spaceDispatchTraceResponseSchema, Y as getSpaceContractResponseSchema, Yn as canonicalizeBuiltinAgentControllerRef, Yt as spaceCreatorSchema, Z as getSpaceDispatchResultResponseSchema, Zn as conversationExecutionStateSchema, Zt as spaceIdentityDirectorySchema, _ as cliJsonOutputEnvelopeSchema, _n as AGENT_REPLY_PREVIEW_END_PURPOSE, _r as profileWorkspaceModeSchema, _t as normalizeSpaceCursorPatch, a as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_VERSION, an as submitRuntimeAgentControllerReportsResponseSchema, ar as formatLocalSetupActionLabel, at as leaveSpaceResponseSchema, b as createSpaceDiagnosticReportBodySchema, bn as ATSD_TASK_RESULT_SCHEMA_VERSION, br as resolveMessageEnvelopeTargetField, bt as notifyAgentProfilesRouteCatalogChangedBodySchema, c as SETUP_PLAN_AGENT_VIEW_CODE, cn as submitRuntimeRegistrationBodySchema, cr as normalizeBuiltinAgentControllerId, ct as listSpaceThreadSignalsResponseSchema, d as accountSpaceIndexResponseSchema, dn as updateAgentProfilePrimaryBindingModelSelectionBodySchema, dr as normalizeOptionalWorkingDirectory, dt as localRuntimeEnrollmentBodySchema, en as spaceMembersSnapshotSchema, er as daemonStreamFrameSchema, et as getSpaceThreadResponseSchema, f as agentControllerPermissionModeSchema, fn as upsertProfileSpaceHistoryResponseSchema, fr as normalizeSpacePasswordText, ft as localRuntimeEnrollmentResponseSchema, g as catchupResponseSchema, gn as AGENT_REPLYING_PURPOSE, gr as postSpaceWakeStopResponseSchema, gt as normalizeListSignalsReadQuerySemantics, h as atsRequestContextSchema, hn as AGENT_REPLYING_END_PURPOSE, hr as postSpaceWakeStopBodySchema, ht as modelCatalogSchema, i as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME, in as submitRuntimeAgentControllerReportsBodySchema, ir as formatLocalSetupActionDescription, it as incomingServerMessageSchema, j as dispatchBriefSchema, jn as MAX_VISITED_PROFILE_IDS, jr as runtimeTransportDispatchRuntimeEvidenceRequestSchema, jt as prepareSessionResponseSchema, k as daemonRuntimeLeaseSchema, kn as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, kr as runtimeTransportDispatchPreviewEndRequestSchema, kt as postSpaceThreadSignalBodySchema, l as SETUP_PLAN_AGENT_VIEW_SCHEMA_VERSION, ln as submitRuntimeRegistrationResponseSchema, lr as normalizeKnownBuiltinAgentControllerId, lt as listSpaceThreadsResponseSchema, m as agentProfileBindingRouteParamsSchema, mn as writeCurrentDeviceObservedMetadataResponseSchema, mr as parseOptionalClientMessageId, mt as localRuntimesResponseSchema, n as resolveBuiltinAgentControllerBrand, nn as spaceViewerMembershipResponseSchema, nr as formatLocalComponentsSummaryDescription, nt as getSpaceWakeProgressResponseSchema, o as PREPARE_SESSION_STREAM_PROTOCOL_VERSION, on as submitRuntimeProviderConversationProofsBodySchema, or as getSpaceMessageAddressingRelationSupportForTargetKind, ot as listProfileSpaceHistoryResponseSchema, p as agentExecutionReadinessRouteParamsSchema, pn as writeCurrentDeviceObservedMetadataBodySchema, pr as parseAgentControllerRef$1, pt as localRuntimesQuerySchema, q as getPrepareReadinessQuerySchema, qn as buildAgentControllerRoutingKey, qt as spaceAccessModeStateSchema, r as resolveMappedPublicAgentFailureReason, rn as structuredGuidePayloadFromInputSchema, rr as formatLocalComponentsSummaryLabel, rt as getSpaceWakeTraceWaterfallResponseSchema, s as PREPARE_STEP_DIAGNOSTICS_MAX_CHARS, sn as submitRuntimeProviderConversationProofsResponseSchema, sr as installedLocalComponentsSnapshotSchema, st as listSpaceThreadEventsResponseSchema, t as CODEX_UPGRADE_REQUIRED_REASON, tn as spaceMetaSchema, tr as formatCanonicalMentionLiteral, tt as getSpaceUpdatesResponseSchema, u as SPACE_DISPATCH_TRACE_PROMPT_PREVIEW_MAX_CHARS, un as updateAgentProfilePrimaryBindingAgentControllerPermissionModeBodySchema, ur as normalizeMessageEnvelope, ut as localAgentCatalogSchema, v as continuitySchema, vn as AGENT_REPLY_PREVIEW_PURPOSE, vr as providerDispatchRuntimeContextSchema, vt as notifyAgentProfileRouteCatalogChangedBodySchema, w as createSpaceThreadResponseSchema, wn as DISPATCH_ACTIVITY_FAILED_PURPOSE, wt as patchSpaceContractResponseSchema, x as createSpaceDiagnosticReportResponseSchema, xn as CONVERSATION_CONTINUITY_WARNING_PURPOSE, xr as resolveSingleSpaceMentionLabels, xt as observabilityWakeTraceSelectorSchema, y as createSpaceBodySchema, yn as ATSD_CONTROL_PLANE_SCHEMA_VERSION, yr as resolveBuiltinAgentControllerConversationKind, yt as notifyAgentProfileRouteCatalogChangedResponseSchema, z as getActiveSpaceWakeProgressResponseSchema, zn as atsRuntimeProfileIdSchema, zr as runtimeTransportRegisterSessionResponseSchema, zt as serverErrorFrameSchema } from "./dist-CyQTYZTj.js";
 import { A as runtimeDir, C as normalizeAtsProfileId, D as resolveAtsEnvPreset, E as resolveAtsCliEntryNameFromArgv, F as systemDir, N as skillsDir, O as resolveAtsRootDir, P as spacesDir, S as normalizeAccountKey, T as profileViewPath, a as accountProfileWorkspacePath, c as atsRootDir, d as deviceOpenClawProfileBootstrapPath, f as deviceOpenClawProfileDir, i as accountProfileViewPath, j as runtimeLogsDir, k as resolveDefaultAtsHomeDirname, 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-DP4LBid2.js";
 import { a as runWithHeldLock, c as LEGACY_ATS_CLI_CONTEXT_ENV_KEY, d as resolveCliContext, f as resolveCliContextId, i as releaseLock, l as listCliContextStates, n as isAtsLockError, o as tryCleanupStaleLock, p as writeCliContextState, r as readLockMeta, s as ATS_CLI_CONTEXT_ENV_KEY, t as acquireLock, u as readCliContextState } from "./lock-CBIWEyt0.js";
 import { _ as toSpaceWsUrl, a as toSpaceCursorUrl, c as toSpaceDispatchTraceUrl, d as toSpaceMetaUrl, f as toSpacePasswordUrl, g as toSpaceUpdatesUrl, h as toSpaceSignalsUrl, i as toSpaceCreateUrl, l as toSpaceLeaveUrl, m as toSpaceResultUrl, n as toDaemonRouteObservationUrl, o as toSpaceDeleteUrl, p as toSpaceRemoveMembersUrl, r as toSpaceContractUrl, s as toSpaceDispatchLookupUrl, t as normalizeBaseUrl, u as toSpaceMembersUrl } from "./urls-B8ZoQgpS.js";
@@ -12,7 +12,7 @@ import { cancel, confirm, intro, isCancel, multiselect, note, outro, password, s
 import crypto$1, { createHash, randomBytes, randomUUID } from "node:crypto";
 import { access, appendFile, chmod, copyFile, cp, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve } from "node:path";
-import { homedir, hostname, release, tmpdir, userInfo } from "node:os";
+import os, { homedir, hostname, release, tmpdir, userInfo } from "node:os";
 import pc from "picocolors";
 import { promisify, stripVTControlCharacters } from "node:util";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -29,14 +29,15 @@ import { createOpencodeClient } from "@opencode-ai/sdk/v2";
 import wrapAnsi from "wrap-ansi";
 import { Box, Container, Editor, Key, ProcessTerminal, TUI, Text, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
 import { ReadStream, WriteStream } from "node:tty";
+import { performance } from "node:perf_hooks";
 
 //#region package.json
-var version = "0.7.95";
+var version = "0.7.97";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
 	version,
-	atsReleaseDate: "2026-07-02",
+	atsReleaseDate: "2026-07-03",
 	description: "Agent Transport System CLI - https://ats.sh",
 	license: "MIT",
 	type: "module",
@@ -105,7 +106,7 @@ var package_default = {
 		"unplugin-lightningcss": "^0.4.0",
 		"vitest": "~3.2.0"
 	},
-	ats: { "minRequiredCliVersion": "0.7.91" }
+	ats: { "minRequiredCliVersion": "0.7.94" }
 };
 
 //#endregion
@@ -3985,7 +3986,7 @@ function resolveAtsAccountContext(input) {
 	};
 }
 async function resolveCurrentAtsAccountContext() {
-	const { getAuthSessionMetadata } = await import("./auth-session-D53RZPAF.js");
+	const { getAuthSessionMetadata } = await import("./auth-session-DBnyC4LY.js");
 	return resolveAtsAccountContext({ session: await getAuthSessionMetadata().catch(() => null) });
 }
 function resolveHostKey(baseUrl) {
@@ -4436,7 +4437,7 @@ async function setDaemonServiceRuntimeState(state, pathInput = {}) {
 	await writeDaemonServiceRuntimeState(state, pathInput);
 }
 async function clearDaemonServiceRuntimeState(pathInput = {}) {
-	const { clearDaemonRuntimeLease } = await import("./daemon-runtime-lease-fLtqNcO6.js");
+	const { clearDaemonRuntimeLease } = await import("./daemon-runtime-lease-DzRz8pH5.js");
 	await Promise.all([rm(daemonServiceRuntimeStatePath(pathInput), { force: true }), clearDaemonRuntimeLease(pathInput)]);
 }
 async function withDaemonServiceRunLock(callback, meta = {
@@ -7721,14 +7722,52 @@ async function buildAtsProfileIdentityRequestHeadersWithAuth(input) {
 		...input.spacePassword === void 0 ? {} : { spacePassword: input.spacePassword }
 	});
 }
+function resolveAuthTokenAttachment(input) {
+	const compatibility = resolveAuthRequestCompatibility({
+		session: input.session,
+		requestUrl: input.requestUrl
+	});
+	const token = normalizeAccessToken(input.session);
+	if (!token) return {
+		status: "dropped",
+		reason: "empty_token",
+		requestHost: compatibility.requestHost,
+		authHost: compatibility.authHost,
+		expectedGatewayHost: compatibility.expectedGatewayHost
+	};
+	if (!compatibility.compatible) return {
+		status: "dropped",
+		reason: compatibility.reason,
+		requestHost: compatibility.requestHost,
+		authHost: compatibility.authHost,
+		expectedGatewayHost: compatibility.expectedGatewayHost
+	};
+	return {
+		status: "attachable",
+		token,
+		tokenType: normalizeTokenType(input.session.tokenType)
+	};
+}
 async function attachAuthHeader(headers, input) {
 	const session = await resolveAuthSessionForHeaders(input);
 	if (session === null) return;
-	const token = normalizeAccessToken(session);
-	if (!token) return;
-	if (!canAttachAuthTokenToRequest(session, input.requestUrl)) return;
-	const tokenType = normalizeTokenType(session.tokenType);
-	if (token.length > 0) headers[AUTHORIZATION_HEADER] = `${tokenType} ${token}`;
+	const attachment = resolveAuthTokenAttachment({
+		session,
+		requestUrl: input.requestUrl
+	});
+	if (attachment.status === "dropped") {
+		warnDroppedAuthToken(attachment);
+		return;
+	}
+	headers[AUTHORIZATION_HEADER] = `${attachment.tokenType} ${attachment.token}`;
+}
+function warnDroppedAuthToken(attachment) {
+	console.warn("[ats.auth.request_token_dropped]", {
+		authHost: attachment.authHost,
+		expectedGatewayHost: attachment.expectedGatewayHost,
+		reason: attachment.reason,
+		requestHost: attachment.requestHost
+	});
 }
 async function resolveAuthSessionForHeaders(input) {
 	if (input.authSession !== void 0) return input.authSession;
@@ -26915,6 +26954,12 @@ async function runDaemonServiceManagerAction(input) {
 		});
 		return result;
 	} catch (error) {
+		let errorMetadata = null;
+		try {
+			errorMetadata = input.resolveErrorMetadata?.(error) ?? null;
+		} catch {
+			errorMetadata = null;
+		}
 		await emitDaemonLifecycleEvent({
 			type: "service_manager.action",
 			result: "failed",
@@ -26923,6 +26968,7 @@ async function runDaemonServiceManagerAction(input) {
 				controller: input.controller,
 				durationMs: Date.now() - startedAtMs,
 				errorMessage: toJournalErrorMessage$1(error),
+				...errorMetadata ?? {},
 				...input.metadata ?? {}
 			},
 			pathInput: input.pathInput,
@@ -26972,6 +27018,31 @@ async function readLatestDaemonLifecycleEvent(input) {
 	}
 	return null;
 }
+async function readRecentDaemonLifecycleEvents(input) {
+	if (input.maxEntries <= 0) return [];
+	const journalPath = daemonLifecycleJournalPath(input.pathInput);
+	let content;
+	try {
+		content = await readFile(journalPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const lines = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	const recent = [];
+	for (let index = lines.length - 1; index >= 0; index -= 1) {
+		const line = lines[index];
+		if (!line) continue;
+		try {
+			const parsed = JSON.parse(line);
+			if (isDaemonLifecycleEvent(parsed)) {
+				recent.push(parsed);
+				if (recent.length >= input.maxEntries) break;
+			}
+		} catch {}
+	}
+	return recent.reverse();
+}
 function formatDaemonLifecycleOriginSummary(event) {
 	const intent = formatDaemonLifecycleIntent(event.intent);
 	return `${event.result} ${intent} from ${event.command} at ${event.timestamp} (pid ${event.pid})`;
@@ -26981,9 +27052,43 @@ function formatDaemonLifecycleIntent(intent) {
 	return intent.replaceAll("_", " ");
 }
 
+//#endregion
+//#region src/local-service/inventory/agent-controller-interface-keeper.ts
+const LAST_GOOD_REUSE_TTL_MS = 15 * 6e4;
+const TRANSIENT_FAILURE_REPORT_THRESHOLD = 3;
+const keeperEntries = /* @__PURE__ */ new Map();
+function buildAgentControllerInterfaceKeeperKey(input) {
+	return `${input.agentId}\u0000${input.commandPath ?? ""}`;
+}
+function readReusableAgentControllerInterfaceSnapshot(input) {
+	const entry = keeperEntries.get(input.keeperKey);
+	if (!entry?.lastGoodSnapshot) return null;
+	if (input.nowMs - entry.lastSuccessAtMs >= LAST_GOOD_REUSE_TTL_MS) return null;
+	return entry.lastGoodSnapshot;
+}
+function recordAgentControllerInterfaceProbeSuccess(input) {
+	keeperEntries.set(input.keeperKey, {
+		failStreak: 0,
+		lastGoodSnapshot: input.snapshot,
+		lastSuccessAtMs: input.nowMs
+	});
+}
+function recordAgentControllerInterfaceProbeFailure(input) {
+	const entry = keeperEntries.get(input.keeperKey) ?? {
+		failStreak: 0,
+		lastGoodSnapshot: null,
+		lastSuccessAtMs: 0
+	};
+	entry.failStreak += 1;
+	keeperEntries.set(input.keeperKey, entry);
+	if (entry.lastGoodSnapshot && entry.failStreak < TRANSIENT_FAILURE_REPORT_THRESHOLD) return { heldSnapshot: entry.lastGoodSnapshot };
+	return { heldSnapshot: null };
+}
+
 //#endregion
 //#region src/local-service/inventory/opencode-readiness-probe.ts
 const DEFAULT_PROBE_TIMEOUT_MS = 8e3;
+const SDK_READ_TIMEOUT_MS = 4e3;
 const PROBE_OUTPUT_LIMIT$1 = 32e3;
 const OPENCODE_MODEL_ID_RE = /^[A-Za-z0-9_.-]+\/[^\s/]+$/u;
 const OPENCODE_PROBE_HOSTNAME = "127.0.0.1";
@@ -27002,13 +27107,15 @@ async function probeOpenCodeReadiness(input) {
 			directory: process.cwd(),
 			throwOnError: true
 		});
-		const [providerListResult] = await Promise.all([client.provider.list(), client.app.agents()]);
+		const [providerListResult] = await rejectAfterTimeout(Promise.all([client.provider.list(), client.app.agents()]), SDK_READ_TIMEOUT_MS, `Timed out while reading OpenCode provider status after ${SDK_READ_TIMEOUT_MS}ms.`);
 		return resolveOpenCodeReadinessFromProviderList(providerListResult.data);
 	} catch (error) {
+		const auth = resolveOpenCodeAuthSnapshotFromProbeError(error);
 		return {
-			auth: resolveOpenCodeAuthSnapshotFromProbeError(error),
+			auth,
 			message: `OpenCode is installed, but ATS could not confirm a connected OpenCode provider: ${toErrorMessage$29(error)}`,
 			models: [],
+			probeCompleted: auth.status === "unauthenticated",
 			status: "error"
 		};
 	} finally {
@@ -27108,6 +27215,20 @@ function killOpenCodeProbeProcess(child, signal) {
 		child.kill(signal);
 	} catch {}
 }
+function rejectAfterTimeout(promise, timeoutMs, timeoutMessage) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(new Error(timeoutMessage));
+		}, timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
 function findAvailableLocalPort() {
 	return new Promise((resolve, reject) => {
 		const server = createServer();
@@ -27144,6 +27265,7 @@ function resolveOpenCodeReadinessFromProviderList(providerList) {
 		auth: { status: "unknown" },
 		message: "OpenCode is installed, but its provider list was empty.",
 		models: [],
+		probeCompleted: true,
 		status: "error"
 	};
 	const connectedProviders = new Set(providerList.connected.map((providerId) => normalizeOptionalText$30(providerId)).filter((providerId) => Boolean(providerId)));
@@ -27151,6 +27273,7 @@ function resolveOpenCodeReadinessFromProviderList(providerList) {
 		auth: { status: "unknown" },
 		message: "OpenCode is installed, but no connected provider was reported. Open OpenCode and sign in to a provider before ATS can launch it.",
 		models: [],
+		probeCompleted: true,
 		status: "error"
 	};
 	const models = parseOpenCodeProviderModels({
@@ -27165,6 +27288,7 @@ function resolveOpenCodeReadinessFromProviderList(providerList) {
 		},
 		message: "OpenCode is installed and has a connected provider, but it did not report any models ATS can use.",
 		models: [],
+		probeCompleted: true,
 		status: "error"
 	};
 	return {
@@ -27175,6 +27299,7 @@ function resolveOpenCodeReadinessFromProviderList(providerList) {
 		},
 		message: null,
 		models,
+		probeCompleted: true,
 		status: "ready"
 	};
 }
@@ -27248,6 +27373,7 @@ function toErrorMessage$29(error) {
 //#endregion
 //#region src/local-service/inventory/agent-controller-interface.ts
 const PROBE_TIMEOUT_MS = 8e3;
+const CODEX_AUX_INVENTORY_GRACE_MS = 2500;
 const LATEST_VERSION_TIMEOUT_MS = 4e3;
 const LATEST_VERSION_CACHE_TTL_MS = 3600 * 1e3;
 const PROBE_OUTPUT_LIMIT = 32e3;
@@ -27284,11 +27410,34 @@ async function resolveAgentControllerInterfaceSnapshot(input) {
 	};
 	if (input.state.launchStatus !== "ready" || !input.state.launchContract) return baseSnapshot;
 	const snapshotResolver = CONTROLLER_INTERFACE_SNAPSHOT_RESOLVERS[input.state.agentId];
-	if (snapshotResolver) return await snapshotResolver({
+	if (!snapshotResolver) return baseSnapshot;
+	const probePolicy = input.probePolicy ?? "fresh";
+	const keeperKey = buildAgentControllerInterfaceKeeperKey({
+		agentId: input.state.agentId,
+		commandPath: resolveLaunchContractCommandPath(input.state.launchContract)
+	});
+	if (probePolicy === "background") {
+		const reusableSnapshot = readReusableAgentControllerInterfaceSnapshot({
+			keeperKey,
+			nowMs: Date.now()
+		});
+		if (reusableSnapshot) return reusableSnapshot;
+	}
+	const outcome = await snapshotResolver({
 		baseSnapshot,
 		launchContract: input.state.launchContract
 	});
-	return baseSnapshot;
+	if (outcome.probeCompleted) {
+		recordAgentControllerInterfaceProbeSuccess({
+			keeperKey,
+			nowMs: Date.now(),
+			snapshot: outcome.snapshot
+		});
+		return outcome.snapshot;
+	}
+	const { heldSnapshot } = recordAgentControllerInterfaceProbeFailure({ keeperKey });
+	if (probePolicy === "background" && heldSnapshot) return heldSnapshot;
+	return outcome.snapshot;
 }
 function resolveLaunchSnapshot(state) {
 	return {
@@ -27422,12 +27571,35 @@ async function resolveCodexInterfaceSnapshot(input) {
 	if (appServerProbe.ok) {
 		const version = appServerProbe.version ?? input.baseSnapshot.version;
 		return {
+			probeCompleted: true,
+			snapshot: {
+				...input.baseSnapshot,
+				auth: appServerProbe.auth,
+				message: appServerProbe.message,
+				models: appServerProbe.models,
+				skills: appServerProbe.skills,
+				status: appServerProbe.status,
+				version,
+				versionAdvisory: await resolveControllerVersionAdvisory({
+					checkedAt: input.baseSnapshot.checkedAt,
+					controllerId: input.baseSnapshot.controllerId,
+					currentVersion: version,
+					launchContract: input.launchContract
+				})
+			}
+		};
+	}
+	const versionProbe = await runLaunchContractCommand({
+		args: ["--version"],
+		launchContract: input.launchContract
+	});
+	const version = versionProbe.ok ? parseCliVersion(versionProbe.stdout) : null;
+	return {
+		probeCompleted: false,
+		snapshot: {
 			...input.baseSnapshot,
-			auth: appServerProbe.auth,
 			message: appServerProbe.message,
-			models: appServerProbe.models,
-			skills: appServerProbe.skills,
-			status: appServerProbe.status,
+			status: input.baseSnapshot.status === "ready" && appServerProbe.auth.status === "unknown" ? "warning" : input.baseSnapshot.status,
 			version,
 			versionAdvisory: await resolveControllerVersionAdvisory({
 				checkedAt: input.baseSnapshot.checkedAt,
@@ -27435,24 +27607,7 @@ async function resolveCodexInterfaceSnapshot(input) {
 				currentVersion: version,
 				launchContract: input.launchContract
 			})
-		};
-	}
-	const versionProbe = await runLaunchContractCommand({
-		args: ["--version"],
-		launchContract: input.launchContract
-	});
-	const version = versionProbe.ok ? parseCliVersion(versionProbe.stdout) : null;
-	return {
-		...input.baseSnapshot,
-		message: appServerProbe.message,
-		status: input.baseSnapshot.status === "ready" && appServerProbe.auth.status === "unknown" ? "warning" : input.baseSnapshot.status,
-		version,
-		versionAdvisory: await resolveControllerVersionAdvisory({
-			checkedAt: input.baseSnapshot.checkedAt,
-			controllerId: input.baseSnapshot.controllerId,
-			currentVersion: version,
-			launchContract: input.launchContract
-		})
+		}
 	};
 }
 async function resolveClaudeCodeInterfaceSnapshot(input) {
@@ -27467,17 +27622,20 @@ async function resolveClaudeCodeInterfaceSnapshot(input) {
 	const auth = resolveClaudeAuthSnapshot(authProbe);
 	const version = versionProbe.ok ? parseCliVersion(versionProbe.stdout) : null;
 	return {
-		...input.baseSnapshot,
-		auth,
-		message: auth.status === "unauthenticated" ? "Claude Code is installed, but this computer is not signed in to Claude Code." : input.baseSnapshot.message,
-		status: auth.status === "unauthenticated" ? "error" : input.baseSnapshot.status,
-		version,
-		versionAdvisory: await resolveControllerVersionAdvisory({
-			checkedAt: input.baseSnapshot.checkedAt,
-			controllerId: input.baseSnapshot.controllerId,
-			currentVersion: version,
-			launchContract: input.launchContract
-		})
+		probeCompleted: authProbe.ok,
+		snapshot: {
+			...input.baseSnapshot,
+			auth,
+			message: auth.status === "unauthenticated" ? "Claude Code is installed, but this computer is not signed in to Claude Code." : input.baseSnapshot.message,
+			status: auth.status === "unauthenticated" ? "error" : input.baseSnapshot.status,
+			version,
+			versionAdvisory: await resolveControllerVersionAdvisory({
+				checkedAt: input.baseSnapshot.checkedAt,
+				controllerId: input.baseSnapshot.controllerId,
+				currentVersion: version,
+				launchContract: input.launchContract
+			})
+		}
 	};
 }
 async function resolveOpenCodeInterfaceSnapshot(input) {
@@ -27490,12 +27648,15 @@ async function resolveOpenCodeInterfaceSnapshot(input) {
 	})]);
 	const version = versionProbe.ok ? parseCliVersion(versionProbe.stdout) : null;
 	return {
-		...input.baseSnapshot,
-		auth: readinessProbe.auth,
-		message: readinessProbe.message ?? input.baseSnapshot.message,
-		models: readinessProbe.models,
-		status: readinessProbe.status,
-		version
+		probeCompleted: readinessProbe.probeCompleted,
+		snapshot: {
+			...input.baseSnapshot,
+			auth: readinessProbe.auth,
+			message: readinessProbe.message ?? input.baseSnapshot.message,
+			models: readinessProbe.models,
+			status: readinessProbe.status,
+			version
+		}
 	};
 }
 function runLaunchContractCommand(input) {
@@ -27682,6 +27843,9 @@ function probeCodexAppServer(launchContract) {
 			});
 		});
 		runCodexAppServerProbeRequests({
+			clearProbeTimeout: () => {
+				clearTimeout(timeout);
+			},
 			finish,
 			notify,
 			request
@@ -27703,11 +27867,11 @@ async function runCodexAppServerProbeRequests(input) {
 		}
 	});
 	input.notify("initialized", {});
-	const [account, skills, models] = await Promise.all([
-		input.request("account/read", {}),
-		input.request("skills/list", { cwds: [process.cwd()] }).catch(() => null),
-		requestAllCodexModels(input.request).catch(() => [])
-	]);
+	const skillsPromise = input.request("skills/list", { cwds: [process.cwd()] }).catch(() => null);
+	const modelsPromise = requestAllCodexModels(input.request).catch(() => []);
+	const account = await input.request("account/read", {});
+	input.clearProbeTimeout();
+	const [skills, models] = await resolveWithinGrace(Promise.all([skillsPromise, modelsPromise]), CODEX_AUX_INVENTORY_GRACE_MS, [null, []]);
 	const auth = resolveCodexAuthSnapshot(account);
 	input.finish({
 		auth,
@@ -27719,6 +27883,20 @@ async function runCodexAppServerProbeRequests(input) {
 		version: parseCodexUserAgentVersion(initialized)
 	});
 }
+function resolveWithinGrace(promise, graceMs, fallback) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			resolve(fallback);
+		}, graceMs);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, () => {
+			clearTimeout(timer);
+			resolve(fallback);
+		});
+	});
+}
 function consumeJsonRpcMessagesFromChunk(input) {
 	let lineBuffer = `${input.lineBuffer}${String(input.chunk)}`;
 	while (true) {
@@ -27899,9 +28077,20 @@ const CONTROLLER_AUTH_UNAUTHENTICATED_REASON_CODES = ["provider_account.access_r
 const CONTROLLER_INTERFACE_ERROR_REASON_CODES = ["controller.interface.error"];
 async function collectLocalAgentControllerInventory(input = {}) {
 	const builtinStates = (await listAgentTargetStates()).filter((state) => state.targetKind === "builtin");
+	if (input.probePolicy === "background") {
+		const capabilities = [];
+		for (const state of builtinStates) capabilities.push(await resolveLocalAgentControllerInventoryItem({
+			includeControllerInterface: input.includeControllerInterface === true,
+			localAdapterContainer: input.localAdapterContainer,
+			probePolicy: input.probePolicy,
+			state
+		}));
+		return { capabilities };
+	}
 	return { capabilities: await Promise.all(builtinStates.map((state) => resolveLocalAgentControllerInventoryItem({
 		includeControllerInterface: input.includeControllerInterface === true,
 		localAdapterContainer: input.localAdapterContainer,
+		probePolicy: input.probePolicy,
 		state
 	}))) };
 }
@@ -27912,6 +28101,7 @@ async function resolveLocalAgentControllerInventoryItem(input) {
 		...item,
 		agentControllerInterface: await resolveAgentControllerInterfaceSnapshot({
 			agentControllerRef: item.agentControllerRef,
+			probePolicy: input.probePolicy,
 			state: input.state
 		})
 	};
@@ -30200,7 +30390,8 @@ function toErrorMessage$25(error) {
 async function syncLocalServiceRuntimeAgentControllerReports(input) {
 	const reports = (await collectLocalAgentControllerInventory({
 		includeControllerInterface: true,
-		localAdapterContainer: input.localAdapterContainer
+		localAdapterContainer: input.localAdapterContainer,
+		probePolicy: input.probePolicy
 	})).capabilities.filter((capability) => capability.registered).map((capability) => {
 		if (!capability.agentControllerRef) return null;
 		const reportDecision = resolveLocalAgentControllerReportDecision(capability, { requireEnabled: true });
@@ -30745,9 +30936,9 @@ function createModelCatalogReadSession(input) {
 async function readModelCatalogOnce(baseUrl) {
 	try {
 		const [apiClient, baseUrlModule, clientFoundationModule] = await Promise.all([
-			import("./dist-Cgdr3L3K.js"),
-			import("./base-url-BLRaPMVx.js").then((n) => n.n),
-			import("./api-client-foundation-hzrybspj.js")
+			import("./dist-zUuzNkK0.js"),
+			import("./base-url-SXaImoj4.js").then((n) => n.n),
+			import("./api-client-foundation-DFdzzDaR.js")
 		]);
 		if (typeof apiClient.createConfigApi !== "function") throw new Error("config api client is unavailable");
 		const resolvedBaseUrl = baseUrl ?? await baseUrlModule.resolveBaseUrl();
@@ -37256,6 +37447,14 @@ const LAUNCHD_SERVICE_NOT_FOUND_PATTERNS = [
 	/service could not be found/i,
 	/could not find domain/i
 ];
+const LAUNCHD_PRINT_RUNS_PATTERN = /^\s*runs\s*=\s*(\d+)\s*$/m;
+const LAUNCHD_PRINT_STATE_PATTERN = /^\s*state\s*=\s*(.+?)\s*$/m;
+const LAUNCHD_PRINT_LAST_EXIT_CODE_PATTERN = /^\s*last exit code\s*=\s*(.+?)\s*$/m;
+const LAUNCHD_PRINT_PENDED_NONDEMAND_SPAWN_PATTERN = /^\s*pended nondemand spawn\s*=\s*(.+?)\s*$/m;
+const LAUNCHD_PRINT_PROPERTIES_PATTERN = /^\s*properties\s*=\s*(.+?)\s*$/m;
+const LAUNCHD_PROPERTIES_KEEPALIVE_PATTERN = /\bkeepalive\b/i;
+const LAUNCHD_PROPERTIES_RUNATLOAD_PATTERN = /\brunatload\b/i;
+const INTEGER_TEXT_PATTERN = /^-?\d+$/;
 const SYSTEM_SERVICE_WAIT_MS = 15e3;
 const SYSTEM_SERVICE_POLL_MS = 200;
 const QUOTED_XML_REPLACEMENT = "&quot;";
@@ -37470,6 +37669,41 @@ function parseLaunchdEnabled(output) {
 	const value = parseRegexGroup(output, LAUNCHD_ENABLED_PATTERN);
 	return value !== null && value.toLowerCase() === "true";
 }
+function parseLaunchdServiceJobDiagnostics(printOutput) {
+	const runsText = parseRegexGroup(printOutput, LAUNCHD_PRINT_RUNS_PATTERN);
+	const lastExitCodeText = parseRegexGroup(printOutput, LAUNCHD_PRINT_LAST_EXIT_CODE_PATTERN);
+	const propertiesText = parseRegexGroup(printOutput, LAUNCHD_PRINT_PROPERTIES_PATTERN);
+	return {
+		controller: LAUNCHD_CONTROLLER,
+		loaded: true,
+		runs: runsText === null ? null : Number.parseInt(runsText, 10),
+		state: parseRegexGroup(printOutput, LAUNCHD_PRINT_STATE_PATTERN),
+		lastExitCodeText,
+		lastExitCode: lastExitCodeText !== null && INTEGER_TEXT_PATTERN.test(lastExitCodeText) ? Number.parseInt(lastExitCodeText, 10) : null,
+		pendedNondemandSpawn: parseRegexGroup(printOutput, LAUNCHD_PRINT_PENDED_NONDEMAND_SPAWN_PATTERN),
+		keepaliveRunAtLoad: propertiesText !== null && LAUNCHD_PROPERTIES_KEEPALIVE_PATTERN.test(propertiesText) && LAUNCHD_PROPERTIES_RUNATLOAD_PATTERN.test(propertiesText)
+	};
+}
+function isDaemonServiceJobNeverSpawned(diagnostics) {
+	return diagnostics.loaded && diagnostics.runs === 0 && diagnostics.keepaliveRunAtLoad;
+}
+function readDaemonServiceJobCrashExitCode(diagnostics) {
+	if (!diagnostics.loaded) return null;
+	if (diagnostics.runs === null || diagnostics.runs <= 0) return null;
+	if (diagnostics.lastExitCode === null || diagnostics.lastExitCode === 0) return null;
+	return diagnostics.lastExitCode;
+}
+function formatDaemonServiceJobDiagnosticsEvidence(diagnostics) {
+	if (!diagnostics.loaded) return `${diagnostics.controller} job: not loaded`;
+	const parts = [
+		`state=${diagnostics.state ?? "unknown"}`,
+		`runs=${diagnostics.runs ?? "unknown"}`,
+		`last exit code=${diagnostics.lastExitCodeText ?? "unknown"}`,
+		...diagnostics.pendedNondemandSpawn ? [`pended nondemand spawn=${diagnostics.pendedNondemandSpawn}`] : [],
+		...diagnostics.keepaliveRunAtLoad ? ["properties=keepalive|runatload"] : []
+	];
+	return `${diagnostics.controller} job: ${parts.join(", ")}`;
+}
 function parseLaunchdEnabledFromDisabledServices(output, label) {
 	const lines = output.split("\n");
 	for (const line of lines) {
@@ -37624,6 +37858,7 @@ function buildSystemdManager(pathInput = {}) {
 				commandSummary: installed ? await readSystemServiceCommandSummary(unitPath, "ExecStart=") : null
 			};
 		},
+		readJobDiagnostics: async () => null,
 		waitUntilAbsent: async () => {
 			await waitForCondition({
 				until: async () => {
@@ -37783,6 +38018,25 @@ function buildLaunchdManager(pathInput = {}) {
 				commandSummary: installed ? await readLaunchdProgramArguments(plistPath) : null
 			};
 		},
+		readJobDiagnostics: async () => {
+			const printResult = await runCommand$3({
+				command: "launchctl",
+				args: ["print", launchdServiceKey],
+				throwOnError: false
+			});
+			if (printResult.exitCode === 0) return parseLaunchdServiceJobDiagnostics(`${printResult.stdout}\n${printResult.stderr}`);
+			if (isLaunchdServiceMissing(printResult)) return {
+				controller: LAUNCHD_CONTROLLER,
+				loaded: false,
+				runs: null,
+				state: null,
+				lastExitCodeText: null,
+				lastExitCode: null,
+				pendedNondemandSpawn: null,
+				keepaliveRunAtLoad: false
+			};
+			return null;
+		},
 		waitUntilAbsent: async () => {
 			await waitForCondition({
 				until: async () => {
@@ -38006,6 +38260,7 @@ function buildWindowsManager(pathInput = {}) {
 				commandSummary: await readWindowsRunnerCommandSummary(scriptPath) ?? parseRegexGroup(qc.stdout, WINDOWS_BINARY_PATH_PATTERN) ?? null
 			};
 		},
+		readJobDiagnostics: async () => null,
 		waitUntilAbsent: async () => {
 			await waitForCondition({
 				until: async () => {
@@ -40647,12 +40902,17 @@ const OUTBOX_SCHEMA = "ats-daemon-dispatch-result-outbox-v1";
 const OUTBOX_RECORD_SCHEMA = "ats-daemon-dispatch-result-outbox-record-v1";
 const RESULT_OUTBOX_FILE_NAME = "dispatch-result-outbox.json";
 const RESULT_OUTBOX_TEMP_FILE_NAME = "dispatch-result-outbox.tmp";
-const BACKOFF_MS = [
+const SEND_FAILURE_BACKOFF_MS = [
 	1e3,
 	5e3,
 	15e3,
 	3e4
 ];
+const ACK_PENDING_BACKOFF_MS = [
+	15e3,
+	3e4,
+	6e4
+];
 function enqueueDispatchResultOutboxRecord(input) {
 	const nowMs = Date.now();
 	const record = {
@@ -40703,7 +40963,7 @@ function acknowledgeDispatchResultOutboxRecord(input) {
 				...record,
 				blockedReasonCode: null,
 				lastFailureReason: input.reasonCode ?? "daemon.dispatch.result_retry_later",
-				nextAttemptAtMs: record.nextAttemptAtMs > acknowledgedAtMs ? record.nextAttemptAtMs : acknowledgedAtMs + resolveOutboxBackoffMs(attemptCount),
+				nextAttemptAtMs: record.nextAttemptAtMs > acknowledgedAtMs ? record.nextAttemptAtMs : acknowledgedAtMs + resolveAckPendingBackoffMs(attemptCount),
 				updatedAtMs: acknowledgedAtMs
 			}];
 		}
@@ -40780,7 +41040,7 @@ function flushDispatchResultOutbox(input) {
 				connectionGeneration: activeConnectionGeneration,
 				lastFailureReason: null,
 				lastSendAtMs: nowMs,
-				nextAttemptAtMs: nowMs + resolveOutboxBackoffMs(record.attemptCount + 1),
+				nextAttemptAtMs: nowMs + resolveAckPendingBackoffMs(record.attemptCount + 1),
 				updatedAtMs: nowMs
 			};
 		} catch (error) {
@@ -40789,7 +41049,7 @@ function flushDispatchResultOutbox(input) {
 				...record,
 				attemptCount: record.attemptCount + 1,
 				lastFailureReason: toErrorMessage$30(error),
-				nextAttemptAtMs: nowMs + resolveOutboxBackoffMs(record.attemptCount + 1),
+				nextAttemptAtMs: nowMs + resolveSendFailureBackoffMs(record.attemptCount + 1),
 				updatedAtMs: nowMs
 			};
 		}
@@ -40800,8 +41060,12 @@ const sanitizeTaskResultPayload = (payload) => {
 	const { bootstrapTemplateFacts: _bootstrapTemplateFacts, promptTrace: _promptTrace, ...safePayload } = payload;
 	return safePayload;
 };
-const resolveOutboxBackoffMs = (attemptCount) => {
-	const backoffMs = BACKOFF_MS[Math.min(BACKOFF_MS.length - 1, Math.max(0, attemptCount - 1))];
+const resolveAckPendingBackoffMs = (attemptCount) => {
+	const backoffMs = ACK_PENDING_BACKOFF_MS[Math.min(ACK_PENDING_BACKOFF_MS.length - 1, Math.max(0, attemptCount - 1))];
+	return typeof backoffMs === "number" ? backoffMs : 6e4;
+};
+const resolveSendFailureBackoffMs = (attemptCount) => {
+	const backoffMs = SEND_FAILURE_BACKOFF_MS[Math.min(SEND_FAILURE_BACKOFF_MS.length - 1, Math.max(0, attemptCount - 1))];
 	return typeof backoffMs === "number" ? backoffMs : 3e4;
 };
 const upsertOutboxRecord = (ledgerPaths, record) => {
@@ -46584,6 +46848,7 @@ async function runDaemonSocketSession(input) {
 	let nextCatalogSyncAtMs = 0;
 	let nextProviderConversationProofSyncAtMs = 0;
 	let nextRuntimeAgentControllerReportSyncAtMs = 0;
+	let forceFreshAgentControllerProbes = false;
 	let providerConversationProofSyncInFlight = false;
 	let runtimeAgentControllerReportSyncInFlight = false;
 	let latestCatalogSyncStatus = null;
@@ -46769,6 +47034,7 @@ async function runDaemonSocketSession(input) {
 		nextCatalogSyncAtMs = 0;
 		nextProviderConversationProofSyncAtMs = 0;
 		nextRuntimeAgentControllerReportSyncAtMs = 0;
+		forceFreshAgentControllerProbes = true;
 		if (heartbeatInFlight || routeCatalogSyncInFlight) pendingLocalExecutionEvidenceRefreshReason = inputRequest.reason;
 		scheduleHeartbeat({
 			delayMs: 0,
@@ -46801,6 +47067,7 @@ async function runDaemonSocketSession(input) {
 		nextCatalogSyncAtMs = 0;
 		nextProviderConversationProofSyncAtMs = 0;
 		nextRuntimeAgentControllerReportSyncAtMs = 0;
+		forceFreshAgentControllerProbes = true;
 		scheduleHeartbeat({
 			delayMs: 0,
 			reason: "pending_local_execution_evidence_refresh"
@@ -47244,8 +47511,13 @@ async function runDaemonSocketSession(input) {
 	const syncRuntimeAgentControllerReportsIfDue = async () => {
 		if (runtimeAgentControllerReportSyncInFlight || Date.now() < nextRuntimeAgentControllerReportSyncAtMs) return;
 		runtimeAgentControllerReportSyncInFlight = true;
+		const probeFresh = forceFreshAgentControllerProbes;
+		forceFreshAgentControllerProbes = false;
 		try {
-			const result = await syncLocalServiceRuntimeAgentControllerReports({ localAdapterContainer: input.localAdapterContainer });
+			const result = await syncLocalServiceRuntimeAgentControllerReports({
+				localAdapterContainer: input.localAdapterContainer,
+				probePolicy: probeFresh ? "fresh" : "background"
+			});
 			const retryInMs = result.failedCount > 0 ? RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_RETRY_INTERVAL_MS : RUNTIME_AGENT_CONTROLLER_REPORT_SYNC_INTERVAL_MS;
 			nextRuntimeAgentControllerReportSyncAtMs = Date.now() + retryInMs;
 			let reportSyncLineText;
@@ -47373,7 +47645,10 @@ async function runDaemonSocketSession(input) {
 			const result = await setAgentRegistrationEnabled(controlInput);
 			let reportSyncStatus = "failed";
 			try {
-				reportSyncStatus = (await syncLocalServiceRuntimeAgentControllerReports({ localAdapterContainer: input.localAdapterContainer })).status;
+				reportSyncStatus = (await syncLocalServiceRuntimeAgentControllerReports({
+					localAdapterContainer: input.localAdapterContainer,
+					probePolicy: "fresh"
+				})).status;
 			} catch (error) {
 				emitRunLine({
 					presenter: input.presenter,
@@ -47749,9 +48024,11 @@ function resolveLocalAgentEnabledErrorCode$1(error) {
 //#region src/local-service/carrier/service-runner.ts
 var DaemonStreamAuthenticationRequiredError = class extends Error {
 	authState;
+	credentialFailure;
 	constructor(input) {
-		super(`authentication required before connecting daemon stream (session=${input.authState})`);
+		super(input.credentialFailure ? `authentication required before connecting daemon stream (session=${input.authState}, credentials=${input.credentialFailure.reason}, requestHost=${input.credentialFailure.requestHost ?? "unknown"}, authHost=${input.credentialFailure.authHost ?? "unknown"}, expectedGatewayHost=${input.credentialFailure.expectedGatewayHost ?? "unknown"})` : `authentication required before connecting daemon stream (session=${input.authState})`);
 		this.authState = input.authState;
+		this.credentialFailure = input.credentialFailure ?? null;
 		this.name = "DaemonStreamAuthenticationRequiredError";
 	}
 };
@@ -47791,6 +48068,15 @@ async function resolveDaemonStreamAuthContext(input) {
 		authState: resolveAuthenticationRequiredAuthState(authState),
 		status: "authentication_required"
 	};
+	const attachment = resolveAuthTokenAttachment({
+		session: authState.session,
+		requestUrl: input.requestUrl
+	});
+	if (attachment.status === "dropped") return {
+		authState: "invalid",
+		credentialFailure: attachment,
+		status: "authentication_required"
+	};
 	return {
 		authState: "valid",
 		headers: await buildDaemonStreamRequestHeaders({
@@ -48028,13 +48314,11 @@ const runDaemonServiceLoop = async (input) => {
 				requestUrl: wsUrl,
 				selectedAtsProfile
 			});
-			if (authContext.status === "authentication_required") {
-				noteAuthenticationRequiredState({
-					authState: authContext.authState,
-					connectionState
-				});
-				throw new DaemonStreamAuthenticationRequiredError({ authState: authContext.authState });
-			}
+			if (authContext.status === "authentication_required") throwDaemonStreamAuthenticationRequired({
+				authState: authContext.authState,
+				connectionState,
+				credentialFailure: authContext.credentialFailure ?? null
+			});
 			const ws = await connectWebSocket(wsUrl, {
 				headers: authContext.headers,
 				openTimeoutMs: DAEMON_STREAM_CONNECT_TIMEOUT_MS
@@ -48298,7 +48582,10 @@ async function handleLocalControlPlaneSetLocalAgentEnabled(input) {
 		});
 		let reportSyncStatus = "failed";
 		try {
-			reportSyncStatus = (await syncLocalServiceRuntimeAgentControllerReports({ localAdapterContainer: input.localAdapterContainer })).status;
+			reportSyncStatus = (await syncLocalServiceRuntimeAgentControllerReports({
+				localAdapterContainer: input.localAdapterContainer,
+				probePolicy: "fresh"
+			})).status;
 		} catch (error) {
 			emitRunLine({
 				presenter: input.presenter,
@@ -48472,10 +48759,28 @@ function noteReconnectFailureState(input) {
 		reason: input.failureReason
 	});
 }
+function throwDaemonStreamAuthenticationRequired(input) {
+	if (input.credentialFailure) console.warn("[ats.daemon.stream_credentials_not_attachable]", {
+		authHost: input.credentialFailure.authHost,
+		expectedGatewayHost: input.credentialFailure.expectedGatewayHost,
+		reason: input.credentialFailure.reason,
+		requestHost: input.credentialFailure.requestHost
+	});
+	noteAuthenticationRequiredState({
+		authState: input.authState,
+		connectionState: input.connectionState,
+		credentialFailure: input.credentialFailure
+	});
+	throw new DaemonStreamAuthenticationRequiredError({
+		authState: input.authState,
+		...input.credentialFailure ? { credentialFailure: input.credentialFailure } : {}
+	});
+}
 function noteAuthenticationRequiredState(input) {
+	const detail = input.credentialFailure ? `stored credentials are not attachable to the daemon stream (${input.credentialFailure.reason}: requestHost=${input.credentialFailure.requestHost ?? "unknown"}, authHost=${input.credentialFailure.authHost ?? "unknown"}, expectedGatewayHost=${input.credentialFailure.expectedGatewayHost ?? "unknown"})` : `connecting without credentials, session=${input.authState}`;
 	input.connectionState.set("authentication_required", {
 		authState: input.authState,
-		detail: `connecting without credentials, session=${input.authState}`,
+		detail,
 		reason: "auth_rejected"
 	});
 }
@@ -53072,6 +53377,12 @@ function sliceDaemonStartFailureLogBuffer(input) {
 	if (input.rawBuffer.length < input.cursor.size) return input.rawBuffer;
 	return input.rawBuffer.subarray(input.cursor.size);
 }
+async function readDaemonStartFailureLogTailLines(input) {
+	if (input.maxLines <= 0) return [];
+	const rawBuffer = await readFile(getDaemonSystemServiceLogPath()).catch(() => null);
+	if (!rawBuffer || rawBuffer.length === 0) return [];
+	return rawBuffer.toString("utf8").split(LOG_LINE_SPLIT_PATTERN).map((line) => normalizeLogLine(line)).filter((line) => line.length > 0).filter((line) => !LOG_STACK_TRACE_PATTERN.test(line)).filter((line) => !isLogNoise(line)).slice(-input.maxLines);
+}
 function selectRelevantDaemonStartFailureLogLine(rawLog) {
 	const lines = rawLog.split(LOG_LINE_SPLIT_PATTERN).map((line) => normalizeLogLine(line)).filter((line) => line.length > 0).filter((line) => !LOG_STACK_TRACE_PATTERN.test(line));
 	for (let index = lines.length - 1; index >= 0; index -= 1) {
@@ -55455,17 +55766,49 @@ var SystemServiceStartupTimeoutError = class extends Error {
 	inventory;
 	managerStatus;
 	runtimeStatus;
+	jobDiagnostics;
 	constructor(input) {
 		super(buildSystemServiceStartupTimeoutMessage(input));
 		this.name = "SystemServiceStartupTimeoutError";
 		this.inventory = input.inventory;
 		this.managerStatus = input.managerStatus;
 		this.runtimeStatus = input.runtimeStatus;
+		this.jobDiagnostics = input.jobDiagnostics ?? null;
 	}
 };
 function buildSystemServiceStartupFailureReport(input) {
 	const message = sanitizeSystemServiceErrorMessage(toErrorMessage$43(input.error));
 	const localLogPath = getDaemonSystemServiceLogPath();
+	const jobDiagnostics = isSystemServiceStartupTimeoutError(input.error) ? input.error.jobDiagnostics ?? null : null;
+	if (jobDiagnostics && isDaemonServiceJobNeverSpawned(jobDiagnostics)) {
+		const summary = "macOS is blocking the ATS Service background item, so ATS Service never launched.";
+		const card = buildDaemonStartNeedsAttentionCard({
+			summary,
+			nextStep: formatInlineAtsCliCommands("Open System Settings > General > Login Items & Extensions, enable the ATS background item, then run `ats service start` again. Power users can audit Background Task Management with `sfltool dumpbtm`."),
+			autoRepairAttempted: input.autoRepairAttempted,
+			detail: input.detail ?? formatDaemonServiceJobDiagnosticsEvidence(jobDiagnostics)
+		});
+		return {
+			title: card.title,
+			summary,
+			rows: card.rows
+		};
+	}
+	const crashExitCode = jobDiagnostics ? readDaemonServiceJobCrashExitCode(jobDiagnostics) : null;
+	if (jobDiagnostics && crashExitCode !== null) {
+		const summary = `ATS Service launched but keeps exiting (launchd reports ${jobDiagnostics.runs} runs, last exit code ${crashExitCode}).`;
+		const card = buildDaemonStartNeedsAttentionCard({
+			summary,
+			nextStep: formatInlineAtsCliCommands(`Run \`ats service start --mode foreground\` to see the live error. The latest local service log is at \`${localLogPath}\`. If it still fails, run \`ats service repair\`.`),
+			autoRepairAttempted: input.autoRepairAttempted,
+			detail: input.detail ?? formatDaemonServiceJobDiagnosticsEvidence(jobDiagnostics)
+		});
+		return {
+			title: card.title,
+			summary,
+			rows: card.rows
+		};
+	}
 	if (isLaunchdBootstrapIosError(message)) {
 		const card = buildDaemonStartNeedsAttentionCard({
 			summary: "ATS could not finish starting ATS Service on this Mac.",
@@ -55515,6 +55858,7 @@ function buildSystemServiceStartupFailureDiagnostics(input) {
 		anomalies: timeoutError?.inventory?.anomalies ?? [],
 		autoRepairAttempted: input.autoRepairAttempted === true,
 		controller: input.controller ?? null,
+		jobDiagnostics: timeoutError?.jobDiagnostics ?? null,
 		launchdLabel: (input.controller ?? null) === "launchd" ? getDaemonServiceLaunchdLabel() : null,
 		lifecycleJournalPath: daemonLifecycleJournalPath(),
 		managerStatus: timeoutError?.managerStatus ?? null,
@@ -55525,7 +55869,9 @@ function buildSystemServiceStartupFailureDiagnostics(input) {
 	};
 }
 function buildSystemServiceStartupTimeoutMessage(input) {
-	return `ATS Service failed to reach a running local service state in time. runtime=${input.runtimeStatus?.status ?? "unknown"}, reason=${input.runtimeStatus?.reason || "unknown"}, managerRunning=${String(input.managerStatus?.running ?? false)}, anomalies=${input.inventory?.anomalies.map((anomaly) => anomaly.code).join(",") || "unknown"}`;
+	const base = `ATS Service failed to reach a running local service state in time. runtime=${input.runtimeStatus?.status ?? "unknown"}, reason=${input.runtimeStatus?.reason || "unknown"}, managerRunning=${String(input.managerStatus?.running ?? false)}, anomalies=${input.inventory?.anomalies.map((anomaly) => anomaly.code).join(",") || "unknown"}`;
+	if (!input.jobDiagnostics) return base;
+	return `${base}; ${formatDaemonServiceJobDiagnosticsEvidence(input.jobDiagnostics)}`;
 }
 function isSystemServiceStartupTimeoutError(error) {
 	return error instanceof SystemServiceStartupTimeoutError || typeof error === "object" && error !== null && "code" in error && error.code === "ats.service.startup_timeout";
@@ -55579,7 +55925,8 @@ async function waitForSystemServiceStartup(input) {
 	throw new SystemServiceStartupTimeoutError({
 		inventory: finalInventory,
 		managerStatus: await input.manager.status().catch(() => null),
-		runtimeStatus: finalRuntimeStatus
+		runtimeStatus: finalRuntimeStatus,
+		jobDiagnostics: await input.manager.readJobDiagnostics?.().catch(() => null) ?? null
 	});
 }
 
@@ -58574,6 +58921,7 @@ async function runSystemServiceManager(input) {
 			command: "ats service run",
 			controller: input.systemManager.controller,
 			intent: "run_background",
+			resolveErrorMetadata: (error) => isSystemServiceStartupTimeoutError(error) && error.jobDiagnostics ? { jobDiagnostics: error.jobDiagnostics } : null,
 			run: async () => await waitForSystemServiceStartup({
 				expectedVersion: input.daemonVersion,
 				manager: input.systemManager,
@@ -82581,6 +82929,16 @@ function toErrorMessage$7(error) {
 //#endregion
 //#region src/space/web-url.ts
 function buildSpaceWebUrl(baseUrl, spaceId, options) {
+	const url = new URL(resolveGatewayWebOrigin(baseUrl));
+	const surface = options?.surface ?? "public";
+	url.pathname = surface === "app" ? `/app/spaces/${encodeURIComponent(spaceId)}` : `/spaces/${encodeURIComponent(spaceId)}`;
+	url.search = "";
+	const profileId = normalizeOptionalText$5(options?.profileId);
+	if (surface === "app" && profileId) url.searchParams.set("profileId", profileId);
+	url.hash = "";
+	return url.toString();
+}
+function resolveGatewayWebOrigin(baseUrl) {
 	const url = new URL(baseUrl);
 	if (isLoopbackHostname$2(url.hostname) && url.port === "8080") url.port = "3000";
 	if (url.hostname === "gateway.ats.sh") {
@@ -82588,13 +82946,10 @@ function buildSpaceWebUrl(baseUrl, spaceId, options) {
 		url.port = "";
 		url.protocol = "https:";
 	}
-	const surface = options?.surface ?? "public";
-	url.pathname = surface === "app" ? `/app/spaces/${encodeURIComponent(spaceId)}` : `/spaces/${encodeURIComponent(spaceId)}`;
+	url.pathname = "";
 	url.search = "";
-	const profileId = normalizeOptionalText$5(options?.profileId);
-	if (surface === "app" && profileId) url.searchParams.set("profileId", profileId);
 	url.hash = "";
-	return url.toString();
+	return url.origin;
 }
 function isLoopbackHostname$2(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
@@ -97785,6 +98140,69 @@ function requireValidSetupBootstrapWrite(input) {
 	return parsed.data;
 }
 
+//#endregion
+//#region src/guides/local-agents-guide-url.ts
+const LOCAL_AGENTS_GUIDE_PATH = "/guides/local-agents";
+const LOCAL_AGENTS_GUIDE_AGENT_NAMES = "Codex, Claude Code, or OpenCode";
+function buildLocalAgentsGuideUrl(baseUrl) {
+	const url = new URL(resolveGatewayWebOrigin(baseUrl));
+	url.pathname = LOCAL_AGENTS_GUIDE_PATH;
+	url.search = "";
+	url.hash = "";
+	return url.toString();
+}
+function buildNoLocalAgentsNoticeLines(input) {
+	return [
+		`ATS did not find ${LOCAL_AGENTS_GUIDE_AGENT_NAMES} on this computer.`,
+		"Install and sign in to one of them if you want this computer to run local agents from ATS.",
+		`Guide: ${input.guideUrl}`
+	];
+}
+function appendLocalAgentsGuideUrl(input) {
+	return `${input.message} Install guide: ${input.guideUrl}`;
+}
+async function confirmContinueWithoutLocalAgents(input) {
+	return await runInteractivePrompt({
+		initialState: { guideUrl: input.guideUrl },
+		fallbackResult: "continue",
+		renderLines: renderLocalAgentsGuidePromptLines,
+		handleKeypress: handleLocalAgentsGuidePromptKeypress
+	}, input.streams);
+}
+function renderLocalAgentsGuidePromptLines(state, status) {
+	if (status === "submitted") return ["Continuing setup without local agents."];
+	if (status === "cancelled") return ["Setup cancelled."];
+	return [...buildNoLocalAgentsNoticeLines({ guideUrl: state.guideUrl }), "Continue setting up the ATS service without any local agents? [Y/n]"];
+}
+function handleLocalAgentsGuidePromptKeypress(input) {
+	if (input.key.name === "return" || input.key.name === "enter") return {
+		type: "result",
+		status: "submitted",
+		result: "continue",
+		state: input.state
+	};
+	const value = String(input.str ?? "").trim().toLowerCase();
+	if (value === "y") return {
+		type: "result",
+		status: "submitted",
+		result: "continue",
+		state: input.state
+	};
+	if (value === "n" || input.key.name === "escape") return {
+		type: "result",
+		status: "cancelled",
+		result: "cancelled",
+		state: input.state
+	};
+	if (input.key.ctrl && input.key.name === "c") return {
+		type: "result",
+		status: "cancelled",
+		result: "cancelled",
+		state: input.state
+	};
+	return { type: "ignore" };
+}
+
 //#endregion
 //#region src/local-service/reporting/selected-agent-controller-reporting.ts
 function resolveSelectedAgentControllerReadiness(input) {
@@ -97895,6 +98313,64 @@ function normalizeId(value) {
 	return value.trim();
 }
 
+//#endregion
+//#region src/ui/controlling-terminal.ts
+const CONTROLLING_TERMINAL_PATH = "/dev/tty";
+function hasUsableProcessTerminal() {
+	return process$1.stdin.isTTY === true && process$1.stdout.isTTY === true && typeof process$1.stdin.setRawMode === "function";
+}
+function closeFdSafely(fd) {
+	if (fd === null) return;
+	try {
+		closeSync(fd);
+	} catch {}
+}
+function resolveControllingTerminalSession() {
+	if (hasUsableProcessTerminal()) return {
+		streams: {
+			input: process$1.stdin,
+			output: process$1.stdout
+		},
+		close: () => void 0
+	};
+	if (process$1.platform === "win32") return null;
+	let readFd = null;
+	let writeFd = null;
+	let input = null;
+	let output = null;
+	try {
+		readFd = openSync(CONTROLLING_TERMINAL_PATH, "r");
+		input = new ReadStream(readFd);
+		readFd = null;
+		writeFd = openSync(CONTROLLING_TERMINAL_PATH, "w");
+		output = new WriteStream(writeFd);
+		writeFd = null;
+		if (input.isTTY !== true || output.isTTY !== true || typeof input.setRawMode !== "function") {
+			input.destroy();
+			output.destroy();
+			return null;
+		}
+		const ttyInput = input;
+		const ttyOutput = output;
+		return {
+			streams: {
+				input: ttyInput,
+				output: ttyOutput
+			},
+			close: () => {
+				ttyInput.destroy();
+				ttyOutput.destroy();
+			}
+		};
+	} catch {
+		if (input) input.destroy();
+		else closeFdSafely(readFd);
+		if (output) output.destroy();
+		else closeFdSafely(writeFd);
+		return null;
+	}
+}
+
 //#endregion
 //#region src/ui/setup-progress.ts
 function createSetupProgressReporter(input) {
@@ -98526,62 +99002,129 @@ async function writeConnectedComputerEnrollmentToServiceContract(input) {
 }
 
 //#endregion
-//#region src/ui/controlling-terminal.ts
-const CONTROLLING_TERMINAL_PATH = "/dev/tty";
-function hasUsableProcessTerminal() {
-	return process$1.stdin.isTTY === true && process$1.stdout.isTTY === true && typeof process$1.stdin.setRawMode === "function";
+//#region src/commands/prepare-step-diagnostics.ts
+const PREPARE_STEP_DIAGNOSTICS_PAYLOAD_MAX_CHARS = Math.min(16e3, PREPARE_STEP_DIAGNOSTICS_MAX_CHARS);
+const ATS_NO_DIAGNOSTICS_ENV = "ATS_NO_DIAGNOSTICS";
+const LIFECYCLE_JOURNAL_TAIL_MAX_ENTRIES = 10;
+const SERVICE_LOG_TAIL_MAX_LINES = 30;
+const SERVICE_LOG_LINE_MAX_CHARS = 320;
+const JOURNAL_ENTRY_MAX_CHARS = 700;
+const SOURCE_TIMEOUT_MS = 2e3;
+function isPrepareStepDiagnosticsOptedOut(env = process$1.env) {
+	return String(env[ATS_NO_DIAGNOSTICS_ENV] ?? "").trim() === "1";
 }
-function closeFdSafely(fd) {
-	if (fd === null) return;
+async function collectPrepareStepDiagnostics(input) {
 	try {
-		closeSync(fd);
-	} catch {}
+		if (isPrepareStepDiagnosticsOptedOut(input.env)) return null;
+		const sources = input.sources ?? {};
+		const collectionErrors = [];
+		const [lifecycleJournalTail, serviceLogTail, inventoryAnomalies, serviceJob] = await Promise.all([
+			collectDiagnosticsSource({
+				collectionErrors,
+				sourceName: "lifecycle_journal",
+				read: sources.readLifecycleJournalTail ?? (() => readRecentDaemonLifecycleEvents({ maxEntries: LIFECYCLE_JOURNAL_TAIL_MAX_ENTRIES }))
+			}),
+			collectDiagnosticsSource({
+				collectionErrors,
+				sourceName: "service_log",
+				read: sources.readServiceLogTail ?? (() => readDaemonStartFailureLogTailLines({ maxLines: SERVICE_LOG_TAIL_MAX_LINES }))
+			}),
+			collectDiagnosticsSource({
+				collectionErrors,
+				sourceName: "inventory_anomalies",
+				read: sources.readInventoryAnomalyCodes ?? readInventoryAnomalyCodes
+			}),
+			collectDiagnosticsSource({
+				collectionErrors,
+				sourceName: "service_job",
+				read: sources.readServiceJobDiagnostics ?? readServiceJobDiagnostics
+			})
+		]);
+		const cliVersion = getCliVersionInfo().version;
+		return serializeBoundedPrepareStepDiagnostics({
+			bundleVersion: 1,
+			collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			supportCode: input.supportCode,
+			stepId: input.stepId,
+			cliVersion,
+			os: {
+				platform: process$1.platform,
+				release: os.release()
+			},
+			inventoryAnomalies,
+			serviceJob,
+			lifecycleJournalTail: lifecycleJournalTail === null ? null : lifecycleJournalTail.map(boundLifecycleJournalEntry),
+			serviceLogTail: serviceLogTail === null ? null : serviceLogTail.map(boundServiceLogLine),
+			collectionErrors,
+			truncated: false
+		});
+	} catch {
+		return null;
+	}
 }
-function resolveControllingTerminalSession() {
-	if (hasUsableProcessTerminal()) return {
-		streams: {
-			input: process$1.stdin,
-			output: process$1.stdout
-		},
-		close: () => void 0
+function serializeBoundedPrepareStepDiagnostics(bundle) {
+	let candidate = bundle;
+	let serialized = JSON.stringify(candidate);
+	if (serialized.length <= PREPARE_STEP_DIAGNOSTICS_PAYLOAD_MAX_CHARS) return serialized;
+	candidate = {
+		...candidate,
+		truncated: true
 	};
-	if (process$1.platform === "win32") return null;
-	let readFd = null;
-	let writeFd = null;
-	let input = null;
-	let output = null;
-	try {
-		readFd = openSync(CONTROLLING_TERMINAL_PATH, "r");
-		input = new ReadStream(readFd);
-		readFd = null;
-		writeFd = openSync(CONTROLLING_TERMINAL_PATH, "w");
-		output = new WriteStream(writeFd);
-		writeFd = null;
-		if (input.isTTY !== true || output.isTTY !== true || typeof input.setRawMode !== "function") {
-			input.destroy();
-			output.destroy();
-			return null;
-		}
-		const ttyInput = input;
-		const ttyOutput = output;
-		return {
-			streams: {
-				input: ttyInput,
-				output: ttyOutput
-			},
-			close: () => {
-				ttyInput.destroy();
-				ttyOutput.destroy();
-			}
+	serialized = JSON.stringify(candidate);
+	while (serialized.length > PREPARE_STEP_DIAGNOSTICS_PAYLOAD_MAX_CHARS) {
+		const serviceLogTail = candidate.serviceLogTail;
+		const lifecycleJournalTail = candidate.lifecycleJournalTail;
+		if (serviceLogTail && serviceLogTail.length > 0) candidate = {
+			...candidate,
+			serviceLogTail: serviceLogTail.slice(1)
 		};
+		else if (lifecycleJournalTail && lifecycleJournalTail.length > 0) candidate = {
+			...candidate,
+			lifecycleJournalTail: lifecycleJournalTail.slice(1)
+		};
+		else {
+			candidate = {
+				...candidate,
+				lifecycleJournalTail: null,
+				serviceLogTail: null
+			};
+			serialized = JSON.stringify(candidate);
+			break;
+		}
+		serialized = JSON.stringify(candidate);
+	}
+	return serialized;
+}
+async function collectDiagnosticsSource(input) {
+	let timer = null;
+	try {
+		return await Promise.race([input.read(), new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("diagnostics source timed out")), SOURCE_TIMEOUT_MS);
+		})]);
 	} catch {
-		if (input) input.destroy();
-		else closeFdSafely(readFd);
-		if (output) output.destroy();
-		else closeFdSafely(writeFd);
+		input.collectionErrors.push(input.sourceName);
 		return null;
+	} finally {
+		if (timer !== null) clearTimeout(timer);
 	}
 }
+async function readInventoryAnomalyCodes() {
+	return (await inspectDaemonServiceInventory({ expectedVersion: resolveCurrentDaemonExpectedVersion() })).anomalies.map((anomaly) => anomaly.code);
+}
+async function readServiceJobDiagnostics() {
+	return await (await resolveDaemonServiceManager())?.readJobDiagnostics?.() ?? null;
+}
+function boundLifecycleJournalEntry(entry) {
+	if (JSON.stringify(entry).length <= JOURNAL_ENTRY_MAX_CHARS) return entry;
+	return {
+		...entry,
+		metadata: { truncated: true }
+	};
+}
+function boundServiceLogLine(line) {
+	if (line.length <= SERVICE_LOG_LINE_MAX_CHARS) return line;
+	return `${line.slice(0, SERVICE_LOG_LINE_MAX_CHARS - 1).trimEnd()}…`;
+}
 
 //#endregion
 //#region src/commands/prepare-session-executor.ts
@@ -98720,12 +99263,15 @@ async function runPrepareSessionExecutorOnce(input) {
 }
 async function resolveAgentSelection(input) {
 	if (input.input.localAgentSelection) {
+		const guideUrl = buildLocalAgentsGuideUrl(input.input.gatewayUrl);
 		const localAgentIds = resolveTerminalSelectedLocalAgentIds({
+			guideUrl,
 			selection: input.input.localAgentSelection,
 			snapshot: input.snapshot
 		});
 		if (hasAgentSelectionBeenSaved(input.snapshot) && haveSameLocalAgentIds(input.snapshot.selectedLocalAgentIds, localAgentIds)) return input.snapshot;
 		return await writeTerminalAgentSelection({
+			...localAgentIds.length === 0 && input.input.localAgentSelection.mode !== "none" ? { emptySelectionGuideUrl: guideUrl } : {},
 			input: input.input,
 			localAgentIds,
 			stream: input.stream,
@@ -98748,10 +99294,7 @@ const PROMPT_LOCAL_AGENT_SELECTION_MESSAGE = "Choose the local agents to connect
 async function resolveTerminalInteractiveLocalAgentSelection(input) {
 	const selectableEntries = resolveSelectableLocalAgentCatalogEntries(input.snapshot);
 	if (selectableEntries.length === 0) {
-		emitPrepareProgressLine(input.input, {
-			state: "success",
-			text: "No supported local agents found. Setup will continue without local agents."
-		});
+		await confirmZeroLocalAgentPrepareSessionIfNeeded({ input: input.input });
 		return [];
 	}
 	const allSelectableIds = selectableEntries.map((entry) => entry.agentId);
@@ -98783,6 +99326,35 @@ async function resolveTerminalInteractiveLocalAgentSelection(input) {
 		terminal.close();
 	}
 }
+async function confirmZeroLocalAgentPrepareSessionIfNeeded(input) {
+	const guideUrl = buildLocalAgentsGuideUrl(input.input.gatewayUrl);
+	const terminal = input.input.runtime.resolvedView === "human" ? resolveControllingTerminalSession() : null;
+	if (!terminal) {
+		emitPrepareNoLocalAgentsNotice({
+			guideUrl,
+			input: input.input
+		});
+		return;
+	}
+	try {
+		if (await confirmContinueWithoutLocalAgents({
+			guideUrl,
+			streams: terminal.streams
+		}) === "continue") return;
+		emitHumanStatus(input.input, "Setup cancelled", ["Install an agent CLI, then re-run the setup command from ATS Web.", `Guide: ${guideUrl}`]);
+		throw new Error("ATS setup was cancelled before choosing local agents.");
+	} finally {
+		terminal.close();
+	}
+}
+function emitPrepareNoLocalAgentsNotice(input) {
+	const [summary, ...details] = buildNoLocalAgentsNoticeLines({ guideUrl: input.guideUrl });
+	emitPrepareProgressLine(input.input, {
+		state: "success",
+		text: summary ? `${summary} Setup will continue without local agents.` : "Setup will continue without local agents."
+	});
+	for (const detail of details) emitPrepareProgressDetail(input.input, detail);
+}
 function resolveSelectableLocalAgentCatalogEntries(snapshot) {
 	return (snapshot.localAgentCatalog?.entries ?? []).filter((entry) => entry.selectable);
 }
@@ -98796,10 +99368,17 @@ function resolveTerminalSelectedLocalAgentIds(input) {
 	const missingIds = selectedIds.filter((agentId) => !selectableById.has(agentId));
 	if (missingIds.length > 0) {
 		const selectableIds = [...selectableById.keys()];
-		throw new Error([`ATS cannot select local agent ${missingIds.join(", ")} for setup.`, selectableIds.length > 0 ? `Selectable local agents: ${selectableIds.join(", ")}.` : "No selectable local agents were found on this computer."].join(" "));
+		throw new Error([`ATS cannot select local agent ${missingIds.join(", ")} for setup.`, selectableIds.length > 0 ? `Selectable local agents: ${selectableIds.join(", ")}.` : formatNoSelectableLocalAgentsFound(input.guideUrl)].join(" "));
 	}
 	return selectedIds;
 }
+function formatNoSelectableLocalAgentsFound(guideUrl) {
+	const message = "No selectable local agents were found on this computer.";
+	return guideUrl ? appendLocalAgentsGuideUrl({
+		guideUrl,
+		message
+	}) : message;
+}
 function assertCompletedPrepareSessionMatchesTerminalSelection(input) {
 	const localAgentIds = resolveTerminalSelectedLocalAgentIds(input);
 	if (haveSameLocalAgentIds(input.snapshot.selectedLocalAgentIds, localAgentIds)) return;
@@ -98819,13 +99398,20 @@ async function writeTerminalAgentSelection(input) {
 	});
 	emitPrepareProgressLine(input.input, {
 		state: "success",
-		text: input.localAgentIds.length === 0 ? "Selected: no local agents" : `Selected: ${formatSelectedLocalAgentNames({
+		text: input.localAgentIds.length === 0 ? formatSelectedNoLocalAgents(input.emptySelectionGuideUrl) : `Selected: ${formatSelectedLocalAgentNames({
 			localAgentIds: input.localAgentIds,
 			snapshot: selectedSnapshot
 		})}`
 	});
 	return selectedSnapshot;
 }
+function formatSelectedNoLocalAgents(guideUrl) {
+	const message = "Selected: no local agents";
+	return guideUrl ? appendLocalAgentsGuideUrl({
+		guideUrl,
+		message
+	}) : message;
+}
 async function reportLocalAgentCatalogForSelection(input) {
 	const connectionEpoch = requireConnectionEpoch(input.snapshot);
 	emitHumanSection(input.input, "Local agents");
@@ -98988,19 +99574,33 @@ async function runTerminalStep(input) {
 			stepId: input.stepId,
 			rawMessage
 		});
+		const reasonCode = resolveTerminalStepFailureReasonCode({
+			rawMessage,
+			stepId: input.stepId
+		});
+		const diagnostics = await (input.collectDiagnostics ?? collectPrepareStepDiagnostics)({
+			stepId: input.stepId,
+			supportCode: reasonCode
+		});
 		input.stream.writeTerminalStep({
 			connectionEpoch: input.connectionEpoch,
 			expectedRevision: startedSnapshot.sessionRevision,
 			stepId: input.stepId,
 			status: "failed",
-			reasonCode: resolveTerminalStepFailureReasonCode({
-				rawMessage,
-				stepId: input.stepId
-			}),
-			message
+			reasonCode,
+			message,
+			...diagnostics === null ? {} : { diagnostics }
+		});
+		if (diagnostics !== null) await waitForTerminalStepWriteToSettle({
+			revisionFloor: startedSnapshot.sessionRevision,
+			stream: input.stream
 		});
 		progress.fail(message);
-		emitHumanStatus(input.input, "Setup blocked", [message, "After fixing this step, copy a fresh setup command from ATS Web and run setup again."]);
+		emitHumanStatus(input.input, "Setup blocked", [
+			message,
+			"After fixing this step, copy a fresh setup command from ATS Web and run setup again.",
+			...diagnostics === null ? [] : [`A diagnostic summary was shared with ATS to help fix this (support code: ${reasonCode}).`]
+		]);
 		const userFacingError = new Error(message);
 		userFacingError.cause = error;
 		throw userFacingError;
@@ -99490,6 +100090,20 @@ function buildPrepareSessionClientHelloFrame(input) {
 function isLegacyPrepareSessionClientHelloRejection(input) {
 	return input.code === "schema.invalid" && input.message === "Invalid prepare session frame.";
 }
+function isPrepareSessionFrameSchemaRejection(input) {
+	return input.code === "prepare.session.protocol_mismatch" || input.code === "schema.invalid";
+}
+const TERMINAL_STEP_FAILURE_SETTLE_TIMEOUT_MS = 2e3;
+async function waitForTerminalStepWriteToSettle(input) {
+	let timer = null;
+	try {
+		await Promise.race([input.stream.waitForSnapshot((snapshot) => snapshot.sessionRevision > input.revisionFloor), new Promise((resolve) => {
+			timer = setTimeout(resolve, TERMINAL_STEP_FAILURE_SETTLE_TIMEOUT_MS);
+		})]);
+	} catch {} finally {
+		if (timer !== null) clearTimeout(timer);
+	}
+}
 async function waitForSnapshotWithProgress(input) {
 	let progress = input.progress ?? null;
 	let progressStartedByWait = false;
@@ -99523,6 +100137,7 @@ async function connectPrepareSessionStream(input) {
 	};
 	let closedError = null;
 	let stateWriteSent = false;
+	let pendingStepWriteFallbackFrame = null;
 	const assertStreamOpen = () => {
 		if (closedError) throw closedError;
 	};
@@ -99535,6 +100150,18 @@ async function connectPrepareSessionStream(input) {
 			throw closedError;
 		}
 	};
+	const handleServerErrorFrame = (payload) => {
+		if (!stateWriteSent && isLegacyPrepareSessionClientHelloRejection(payload)) return;
+		if (pendingStepWriteFallbackFrame !== null && isPrepareSessionFrameSchemaRejection(payload)) {
+			const fallbackFrame = pendingStepWriteFallbackFrame;
+			pendingStepWriteFallbackFrame = null;
+			try {
+				sendFrame(fallbackFrame);
+			} catch {}
+			return;
+		}
+		rejectWaiters(errorFromPrepareSessionServerError(payload));
+	};
 	ws.onMessage((raw) => {
 		const frame = parseServerFrame(raw);
 		if (!frame) return;
@@ -99544,11 +100171,11 @@ async function connectPrepareSessionStream(input) {
 			return;
 		}
 		if (frame.type === "server.error") {
-			if (!stateWriteSent && isLegacyPrepareSessionClientHelloRejection(frame.payload)) return;
-			rejectWaiters(errorFromPrepareSessionServerError(frame.payload));
+			handleServerErrorFrame(frame.payload);
 			return;
 		}
 		if (frame.type !== "snapshot" && frame.type !== "snapshot_changed") return;
+		pendingStepWriteFallbackFrame = null;
 		const snapshot = frame.payload.snapshot;
 		latestSnapshot = snapshot;
 		for (const waiter of [...waiters]) {
@@ -99584,20 +100211,36 @@ async function connectPrepareSessionStream(input) {
 		writeTerminalStep: (step) => {
 			if (!latestSnapshot) throw new Error("Setup session snapshot is not available yet.");
 			stateWriteSent = true;
+			const basePayload = {
+				prepareSessionId: latestSnapshot.prepareSessionId,
+				connectionEpoch: step.connectionEpoch,
+				expectedRevision: step.expectedRevision,
+				...step.deviceId === void 0 ? {} : { deviceId: step.deviceId },
+				...step.runtimeLane === void 0 ? {} : { runtimeLane: step.runtimeLane },
+				stepAttemptId: crypto.randomUUID(),
+				stepId: step.stepId,
+				status: step.status,
+				...step.reasonCode === void 0 ? {} : { reasonCode: step.reasonCode },
+				...step.localReadinessSnapshot === void 0 ? {} : { localReadinessSnapshot: step.localReadinessSnapshot },
+				...step.message === void 0 ? {} : { message: step.message }
+			};
+			if (step.diagnostics === void 0) {
+				pendingStepWriteFallbackFrame = null;
+				sendFrame({
+					type: "terminal.step.write",
+					payload: basePayload
+				});
+				return;
+			}
+			pendingStepWriteFallbackFrame = {
+				type: "terminal.step.write",
+				payload: basePayload
+			};
 			sendFrame({
 				type: "terminal.step.write",
 				payload: {
-					prepareSessionId: latestSnapshot.prepareSessionId,
-					connectionEpoch: step.connectionEpoch,
-					expectedRevision: step.expectedRevision,
-					...step.deviceId === void 0 ? {} : { deviceId: step.deviceId },
-					...step.runtimeLane === void 0 ? {} : { runtimeLane: step.runtimeLane },
-					stepAttemptId: crypto.randomUUID(),
-					stepId: step.stepId,
-					status: step.status,
-					...step.reasonCode === void 0 ? {} : { reasonCode: step.reasonCode },
-					...step.localReadinessSnapshot === void 0 ? {} : { localReadinessSnapshot: step.localReadinessSnapshot },
-					...step.message === void 0 ? {} : { message: step.message }
+					...basePayload,
+					diagnostics: step.diagnostics
 				}
 			});
 		},
@@ -100502,11 +101145,21 @@ async function runSetupUnlocked(input) {
 		readiness: initialReadiness,
 		view: runtime.resolvedView
 	});
+	const localAgentsGuideUrl = buildLocalAgentsGuideUrl(gatewayUrl);
 	const selectedLocalAgentIds = resolveSetupLocalAgentIds({
+		guideUrl: localAgentsGuideUrl,
 		localAgent: input.localAgent,
 		localAgents: input.localAgents,
 		readiness: initialReadiness
 	});
+	await confirmZeroLocalAgentSetupIfNeeded({
+		explicitSelection: hasExplicitLocalAgentSelection(input),
+		guideUrl: localAgentsGuideUrl,
+		localAgentsMode: input.localAgents,
+		presenter,
+		runtime,
+		selectedLocalAgentIds
+	});
 	if (selectedLocalAgentIds.length > 0) assertStartLocalAgentsEnableCompleted(await runWithSetupSpinner({
 		code: "setup.progress.local_agents.enabling",
 		message: setupCopy.cliProgressConnectingLocalAgents,
@@ -100648,12 +101301,79 @@ function resolveSetupLocalAgentIds(input) {
 		const missingIds = localAgentIds.filter((agentId) => !selectableById.has(agentId));
 		if (missingIds.length > 0) {
 			const selectableIds = [...selectableById.keys()];
-			throw new Error([`ATS cannot set up local agent ${missingIds.join(", ")} on this computer.`, selectableIds.length > 0 ? `Available local agents: ${selectableIds.join(", ")}.` : "No available local agents were found on this computer."].join(" "));
+			throw new Error([`ATS cannot set up local agent ${missingIds.join(", ")} on this computer.`, selectableIds.length > 0 ? `Available local agents: ${selectableIds.join(", ")}.` : formatNoAvailableLocalAgentsFound(input.guideUrl)].join(" "));
 		}
 		return localAgentIds;
 	}
 	return [...selectableById.keys()].sort((left, right) => left.localeCompare(right));
 }
+async function confirmZeroLocalAgentSetupIfNeeded(input) {
+	if (input.selectedLocalAgentIds.length > 0 || normalizeOptionalString$1(input.localAgentsMode) === "none") return;
+	if (input.explicitSelection) {
+		emitSetupNoLocalAgentsWarning(input);
+		return;
+	}
+	const terminal = input.runtime.resolvedView === "human" ? resolveControllingTerminalSession() : null;
+	if (!terminal) {
+		emitSetupNoLocalAgentsWarning(input);
+		return;
+	}
+	try {
+		if (await confirmContinueWithoutLocalAgents({
+			guideUrl: input.guideUrl,
+			streams: terminal.streams
+		}) === "continue") return;
+		emitSetupNoLocalAgentsCancelled(input);
+		throw new Error("ATS setup was cancelled before choosing local agents.");
+	} finally {
+		terminal.close();
+	}
+}
+function emitSetupNoLocalAgentsWarning(input) {
+	const lines = buildNoLocalAgentsNoticeLines({ guideUrl: input.guideUrl });
+	if (input.runtime.resolvedView === "human") {
+		renderInfoCard({
+			presenter: input.presenter,
+			title: "No Local Agents Found",
+			codePrefix: "setup.local_agents.none",
+			rows: lines.map((line) => ({
+				label: "",
+				value: line
+			})),
+			sanitize: true,
+			minContentWidth: 56
+		});
+		return;
+	}
+	for (const [index, line] of lines.entries()) input.presenter.line({
+		code: `setup.local_agents.none.${index + 1}`,
+		text: line
+	});
+}
+function emitSetupNoLocalAgentsCancelled(input) {
+	if (input.runtime.resolvedView !== "human") return;
+	renderInfoCard({
+		presenter: input.presenter,
+		title: "Setup Cancelled",
+		codePrefix: "setup.local_agents.cancelled",
+		rows: [{
+			label: "",
+			value: "Install an agent CLI, then re-run the setup command from ATS Web."
+		}, {
+			label: "",
+			value: `Guide: ${input.guideUrl}`
+		}],
+		sanitize: true,
+		minContentWidth: 56
+	});
+}
+function formatNoAvailableLocalAgentsFound(guideUrl) {
+	const message = "No available local agents were found on this computer.";
+	return guideUrl ? appendLocalAgentsGuideUrl({
+		guideUrl,
+		message
+	}) : message;
+}
 function assertStartLocalAgentsEnableCompleted(result) {
 	if (result.status !== "completed") throw new Error("ATS setup cannot continue until selected local agents are available on this computer.");
 	const blockingError = result.summary.errors[0] ?? null;
@@ -100736,6 +101456,7 @@ async function resolveDelegatedSetupCompletionFacts(input) {
 		selectedLocalAgentIds: []
 	};
 	const selectedLocalAgentIds = sessionSelectedLocalAgentIds ? [...sessionSelectedLocalAgentIds] : resolveSetupLocalAgentIds({
+		guideUrl: buildLocalAgentsGuideUrl(input.gatewayUrl),
 		localAgent: input.setupInput.localAgent,
 		localAgents: input.setupInput.localAgents,
 		readiness: await collectStartLocalReadiness({ auth: {
@@ -100822,6 +101543,7 @@ function emitSetupComplete(input) {
 	if (input.view === "human") {
 		const setupCopy = getSetupFlowCopy("setup");
 		const serviceGuidance = buildSetupServiceGuidance({ cliCommandPrefix });
+		const localAgentsGuideUrl = buildLocalAgentsGuideUrl(input.gatewayUrl);
 		renderInfoCard({
 			presenter: input.presenter,
 			title: setupCopy.cliCompletionTitle,
@@ -100829,13 +101551,30 @@ function emitSetupComplete(input) {
 			compact: true,
 			minContentWidth: 44,
 			sanitize: true,
-			rows: [{
-				label: "Agents",
-				value: formatSetupCompleteLocalAgents(input.selectedLocalAgentIds)
-			}, ...input.bootstrap.status === "completed" ? [] : [{
-				label: "Space",
-				value: formatSetupBootstrapHumanSummary(input.bootstrap)
-			}]]
+			rows: [
+				{
+					label: "Agents",
+					value: formatSetupCompleteLocalAgents({
+						guideUrl: localAgentsGuideUrl,
+						selectedLocalAgentIds: input.selectedLocalAgentIds
+					})
+				},
+				...input.selectedLocalAgentIds.length === 0 ? [{
+					label: "Install guide",
+					value: localAgentsGuideUrl
+				}] : [],
+				...input.bootstrap.status === "completed" ? [] : [{
+					label: "Space",
+					value: formatSetupBootstrapHumanSummary(input.bootstrap)
+				}]
+			]
+		});
+		if (input.selectedLocalAgentIds.length === 0) input.presenter.line({
+			code: "setup.complete.local_agents.guide",
+			text: `Open guide: ${formatTerminalHyperlink({
+				label: "Local agent install guide",
+				url: localAgentsGuideUrl
+			})} (${localAgentsGuideUrl})`
 		});
 		renderSetupServiceGuidanceCard({
 			atsServiceRuntimeIdentity: input.atsServiceRuntimeIdentity,
@@ -100992,9 +101731,9 @@ async function finalizeLocalComponentsSetupSnapshot() {
 	await writeInstalledLocalComponentsSnapshot({ source: "setup" });
 	return await resolveLocalComponentsStatus();
 }
-function formatSetupCompleteLocalAgents(selectedLocalAgentIds) {
-	if (selectedLocalAgentIds.length === 0) return "No local agents selected";
-	return `${selectedLocalAgentIds.length} detected: ${selectedLocalAgentIds.join(", ")}`;
+function formatSetupCompleteLocalAgents(input) {
+	if (input.selectedLocalAgentIds.length === 0) return `No local agents connected. Install one from the guide: ${input.guideUrl}`;
+	return `${input.selectedLocalAgentIds.length} detected: ${input.selectedLocalAgentIds.join(", ")}`;
 }
 function formatSetupCompleteSpaceSetupHint(input) {
 	if (input.bootstrap.status === "completed") return `${input.bootstrap.welcomingSpace.outcome === "reused" ? "Reused" : "Created"} ${input.bootstrap.welcomingSpace.name}`;
@@ -102764,8 +103503,17 @@ const LEADING_AT_PATTERN = /^@/u;
 const TRAILING_RELATION_PATTERN = /\((wake|reference|cc)\)$/iu;
 const WHITESPACE_PATTERN = /\s+/g;
 const DISPATCH_ACTION_CLI_PLACEHOLDER = "<DISPATCH_ACTION_CLI>";
+const SPACE_ACTION_REPLY_TIMING_EVENT = "ats.space_action.reply_timing";
 function runSpaceActionReply(input) {
+	const timing = createSpaceActionReplyTiming();
+	timing.emit("command_start", void 0, {
+		ccTargetCount: input.ccTargets?.length ?? 0,
+		messagePartCount: input.messageParts.length,
+		referenceTargetCount: input.referenceTargets?.length ?? 0,
+		wakeTargetCount: input.wakeTargets?.length ?? 0
+	});
 	const context = readDispatchSpaceActionContextFromEnv();
+	timing.emit("context_ready", context);
 	assertAllowedAction(context, "post_message");
 	const text = normalizeRequiredJoinedText(input.messageParts, "Reply message is required.");
 	const targetIds = resolveMessageEnvelopeTargetIds({
@@ -102774,7 +103522,13 @@ function runSpaceActionReply(input) {
 		referenceTargets: input.referenceTargets ?? [],
 		ccTargets: input.ccTargets ?? []
 	});
-	recordAction({
+	timing.emit("targets_resolved", context, {
+		activationTargetCount: targetIds.activationTargets.length,
+		ccTargetCount: targetIds.ccTargets.length,
+		messageLength: text.length,
+		referenceTargetCount: targetIds.referenceTargets.length
+	});
+	const record = recordAction({
 		action: {
 			type: "post_message",
 			messageEnvelope: {
@@ -102788,6 +103542,8 @@ function runSpaceActionReply(input) {
 		command: "reply",
 		context
 	});
+	timing.emit("record_written", context, { actionType: record.action.type });
+	timing.emit("done", context, { actionType: record.action.type });
 }
 function runSpaceActionWake(input) {
 	const context = readDispatchSpaceActionContextFromEnv();
@@ -102886,7 +103642,33 @@ function formatSpaceActionHelpCommand(action, context) {
 	return formatAtsCliCommand(`ats space action ${action}`);
 }
 function recordAction(input) {
-	outLine(`Posted to Space: ATS accepted this final action (${writeDispatchSpaceActionRecord(input).action.type}) for the current Wake.`);
+	const record = writeDispatchSpaceActionRecord(input);
+	outLine(`Posted to Space: ATS accepted this final action (${record.action.type}) for the current Wake.`);
+	return record;
+}
+function createSpaceActionReplyTiming() {
+	const startedAt = performance.now();
+	let previousAt = startedAt;
+	const commandStartProcessUptimeMs = Math.round(startedAt);
+	return { emit: (phase, context, fields = {}) => {
+		const now = performance.now();
+		const elapsedMs = Math.max(0, Math.round(now - startedAt));
+		const durationMs = Math.max(0, Math.round(now - previousAt));
+		previousAt = now;
+		process.stderr.write(`[${SPACE_ACTION_REPLY_TIMING_EVENT}] ${JSON.stringify({
+			event: SPACE_ACTION_REPLY_TIMING_EVENT,
+			phase,
+			elapsedMs,
+			durationMs,
+			commandStartProcessUptimeMs,
+			attemptId: context?.attemptId ?? null,
+			dispatchId: context?.dispatchId ?? null,
+			spaceId: context?.spaceId ?? null,
+			targetProfileId: context?.targetProfileId ?? null,
+			taskId: context?.taskId ?? null,
+			...fields
+		})}\n`);
+	} };
 }
 function resolveMessageEnvelopeTargetIds(input) {
 	const targets = {
@@ -103453,7 +104235,7 @@ function normalizeOptionalString(value) {
 	return normalized.length > 0 ? normalized : null;
 }
 async function runDefaultSpaceAddMeMembership(input) {
-	const { runSpaceAddMeMembership } = await import("./add-me-membership-Cf5nxrwV.js");
+	const { runSpaceAddMeMembership } = await import("./add-me-membership-CT_vAgoU.js");
 	return await runSpaceAddMeMembership(input);
 }