agent-transport-system 0.3.49 → 0.4.0

package/dist/{lock-BDqdJx3V.js → lock-pvOz4vGl.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { C as normalizeAtsProfileId, j as sessionsDir, x as locksDir } from "./paths-DTn3aLSP.js";
+import { C as normalizeAtsProfileId, j as sessionsDir, x as locksDir } from "./paths-DyLxjg9Z.js";
 import { join } from "node:path";
 import process$1 from "node:process";
 import { mkdir, open, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
@@ -4146,7 +4146,7 @@ const daemonRouteObservationSummarySchema = strictObject({
 });
 
 //#endregion
-//#region ../../packages/schemas/dist/entry-brief-C9fPiNkJ.js
+//#region ../../packages/schemas/dist/entry-brief-eseGyF4R.js
 const providerConversationExternalImportCapabilitySchema = _enum(["unsupported", "by_ref_id"]);
 const providerConversationResumeCapabilitySchema = _enum(["unsupported", "by_ref_id"]);
 const providerConversationDiscoverCapabilitySchema = literal("unsupported");
@@ -4456,6 +4456,7 @@ const spaceMemberAgentSnapshotSchema = baseSpaceMemberSnapshotSchema.extend({
 	ownerName: nullableTrimmedStringSchema$5,
 	controllerKind: nullableControllerKindSchema,
 	controllerRef: nullableTrimmedStringSchema$5,
+	runtimeDeviceDisplayName: nullableTrimmedStringSchema$5.optional(),
 	agentContextId: nullableTrimmedStringSchema$5,
 	upstreamConversation: nullableUpstreamConversationRefSchema.optional(),
 	workingDirectory: profileWorkingDirectorySchema.nullable().optional(),
@@ -5334,23 +5335,32 @@ const spacePasswordStateSchema = strictObject({ passwordProtected: boolean() });
 const MULTI_SPACE_PATTERN$1 = /\s+/g;
 const CANONICAL_MENTION_LITERAL_PATTERN = /^@(?<name>.+)\((?<type>wake|reference|cc)\)$/u;
 const CANONICAL_MENTION_TEXT_FRAGMENT_PATTERN = /(^|[^\w\\])(?<mention>@[^\n@]*\([^\n@)]*\)?)/gu;
-const MESSAGE_MENTION_TYPE_VALUES = [
+const SPACE_MESSAGE_ADDRESSING_RELATION_VALUES = [
 	"wake",
 	"reference",
 	"cc"
 ];
+const MESSAGE_MENTION_TYPE_VALUES = SPACE_MESSAGE_ADDRESSING_RELATION_VALUES;
 const MESSAGE_ENVELOPE_TARGET_FIELD_VALUES = [
 	"activationTargets",
 	"referenceTargets",
 	"ccTargets"
 ];
-const messageMentionTypeSchema = _enum(MESSAGE_MENTION_TYPE_VALUES);
+const SPACE_MESSAGE_ADDRESSING_TARGET_KIND_VALUES = ["human_profile", "agent_profile"];
+const spaceMessageAddressingRelationSchema = _enum(SPACE_MESSAGE_ADDRESSING_RELATION_VALUES);
+const messageMentionTypeSchema = spaceMessageAddressingRelationSchema;
 const messageEnvelopeTargetFieldSchema = _enum(MESSAGE_ENVELOPE_TARGET_FIELD_VALUES);
+const spaceMessageAddressingTargetKindSchema = _enum(SPACE_MESSAGE_ADDRESSING_TARGET_KIND_VALUES);
 const MESSAGE_ENVELOPE_TARGET_FIELD_BY_MENTION_TYPE = {
 	wake: "activationTargets",
 	reference: "referenceTargets",
 	cc: "ccTargets"
 };
+const SPACE_MESSAGE_ADDRESSING_TARGET_KIND_SUPPORT_BY_RELATION = {
+	wake: ["agent_profile"],
+	reference: ["human_profile", "agent_profile"],
+	cc: ["human_profile", "agent_profile"]
+};
 const normalizeCanonicalMentionName = (value) => {
 	const normalized = trimmedStringFromUnknown(value).replace(MULTI_SPACE_PATTERN$1, " ").trim();
 	if (normalized.length === 0) return;
@@ -5480,6 +5490,31 @@ const resolveMessageEnvelopeTargetField = (value) => {
 	if (!parsed.success) throw parsed.error;
 	return MESSAGE_ENVELOPE_TARGET_FIELD_BY_MENTION_TYPE[parsed.data];
 };
+const isSpaceMessageAddressingRelationSupportedForTargetKind = (input) => {
+	const relation = spaceMessageAddressingRelationSchema.safeParse(input.relation);
+	if (!relation.success) throw relation.error;
+	const targetKind = spaceMessageAddressingTargetKindSchema.safeParse(input.targetKind);
+	if (!targetKind.success) throw targetKind.error;
+	return SPACE_MESSAGE_ADDRESSING_TARGET_KIND_SUPPORT_BY_RELATION[relation.data].includes(targetKind.data);
+};
+const getSpaceMessageAddressingRelationSupportForTargetKind = (value) => {
+	const targetKind = spaceMessageAddressingTargetKindSchema.safeParse(value);
+	if (!targetKind.success) throw targetKind.error;
+	return {
+		wake: isSpaceMessageAddressingRelationSupportedForTargetKind({
+			relation: "wake",
+			targetKind: targetKind.data
+		}),
+		reference: isSpaceMessageAddressingRelationSupportedForTargetKind({
+			relation: "reference",
+			targetKind: targetKind.data
+		}),
+		cc: isSpaceMessageAddressingRelationSupportedForTargetKind({
+			relation: "cc",
+			targetKind: targetKind.data
+		})
+	};
+};
 const spaceAuthorityOrderSchema = literal("default");
 const spaceDispatchPolicyModeSchema = _enum(["mention_only", "listen_all"]);
 const spaceDispatchPolicySchema = strictObject({ mode: spaceDispatchPolicyModeSchema });
@@ -5618,16 +5653,20 @@ const sanitizeSignalTextPreview = (text) => {
 };
 const signalTextReplyToSchema = signalReplyToSchema;
 const signalTextContentSchema = preprocess(trimmedStringFromUnknown, string().min(1).max(MAX_TEXT_LENGTH));
+const runtimeDeviceDisplayNameSchema = preprocess(trimmedStringFromUnknown, string().min(1).max(80));
 const signalTextMetaSchema = object({
 	transient: literal(true).optional(),
 	clientMessageId: clientMessageIdSchema.optional(),
 	sourceEventId: preprocess(trimmedStringFromUnknown, string().max(200)).optional(),
+	sourceClientMessageId: clientMessageIdSchema.optional(),
 	purpose: preprocess(trimmedStringFromUnknown, string().min(1).max(80)).optional(),
+	errorCode: preprocess(trimmedStringFromUnknown, string().min(1).max(120)).optional(),
 	dispatchId: preprocess(trimmedStringFromUnknown, string().max(200)).optional(),
 	targetProfileId: atsRuntimeProfileIdSchema.optional(),
 	targetProfileKind: _enum(["human", "agent"]).optional(),
 	targetProfileName: preprocess(trimmedStringFromUnknown, string().min(1).max(MAX_PROFILE_NAME_LENGTH)).optional(),
 	targetMentionLabel: spaceMentionLabelSchema.optional(),
+	runtimeDeviceDisplayName: runtimeDeviceDisplayNameSchema.optional(),
 	addedByProfileId: atsRuntimeProfileIdSchema.optional(),
 	addedByDisplayName: preprocess(trimmedStringFromUnknown, string().min(1).max(MAX_PROFILE_NAME_LENGTH)).optional(),
 	removedByProfileId: atsRuntimeProfileIdSchema.optional(),
@@ -5780,6 +5819,10 @@ const atsdDispatchContinuitySnapshotSchema = strictObject({
 	messagesSinceThen: number().int().finite().min(0),
 	higherAuthorityUpdates: boolean()
 });
+const atsdDispatchOwnerSchema = strictObject({
+	kind: literal("owner_account"),
+	id: string().min(1)
+});
 const atsdDispatchQueueLegacyMessageSchemaV1 = strictObject({
 	v: literal(1),
 	dispatchId: string().min(1),
@@ -5795,6 +5838,7 @@ const atsdDispatchQueueMessageSchema = strictObject({
 	spaceId: string().min(1),
 	sourceEventId: string().min(1),
 	sourceClientMessageId: string().min(1).max(200).nullable().optional(),
+	dispatchOwner: atsdDispatchOwnerSchema.optional(),
 	targetProfileId: string().min(1),
 	targetProfileMentionLabel: spaceMentionLabelSchema.optional(),
 	dispatchChainId: string().min(1),
@@ -5994,6 +6038,11 @@ const atsdTaskResultPromptTraceSchema = strictObject({
 	length: int().nonnegative(),
 	preview: union([string().min(1), _null()])
 });
+const atsdTaskResultClaimLeaseSchema = strictObject({
+	claimLeaseId: string().min(1),
+	outcome: _enum(["existing_lease", "new_lease"]),
+	status: literal("accepted")
+});
 const atsdTaskResultTelemetrySchema = strictObject({
 	completedAtMs: number().int().nonnegative(),
 	contextHealed: boolean().optional(),
@@ -6027,6 +6076,7 @@ const atsdTaskResultCommonSchema = atsdTaskResultCommonSchemaV1.extend({
 	effectiveRuntimeWorkingDirectory: profileWorkingDirectorySchema.optional(),
 	runtimeWorkspaceFingerprint: string().min(1).optional(),
 	promptTrace: atsdTaskResultPromptTraceSchema.optional(),
+	claimLease: atsdTaskResultClaimLeaseSchema.optional(),
 	bootstrapTemplateFacts: bootstrapTemplateFactsSchema.optional(),
 	dispatchExecution: dispatchExecutionSchema.optional(),
 	openClawGatewayVisibility: atsdTaskResultOpenClawGatewayVisibilitySchema.optional(),
@@ -6228,6 +6278,7 @@ const daemonHubDeliverDispatchPayloadSchema = strictObject({
 	taskId: string().min(1),
 	spaceId: string().min(1),
 	sourceEventId: string().min(1),
+	sourceClientMessageId: string().min(1).max(200).nullable().optional(),
 	sourceSignal: daemonHubDispatchSourceSignalSchema,
 	targetProfileId: string().min(1),
 	dispatchContractVersion: number().int().positive(),
@@ -6399,6 +6450,7 @@ const resolvedAtsProfileSchema = strictObject({
 });
 const atsActorContextSchema = strictObject({
 	requestId: nonEmptyTextSchema,
+	callerPrincipalId: nonEmptyTextSchema.optional(),
 	atsProfileId: atsActorProfileIdSchema,
 	profileKind: profileKindSchema,
 	profileHandle: profileHandleSchema.optional(),
@@ -6439,6 +6491,9 @@ const REPLY_READINESS_REASON_CODE_VALUES = [
 	"service.not_installed",
 	"service.drifted",
 	"service.not_running",
+	"service.account_mismatch",
+	"service.auth_missing",
+	"service.auth_stale",
 	"dispatch.storage_not_ready",
 	"service.gateway_chain_unhealthy",
 	"profile.inactive",
@@ -6626,6 +6681,268 @@ const dbInspectionSummarySchema = strictObject({
 	}),
 	notes: array(trimmedNonEmptyStringSchema$5)
 });
+const boundedIdentifierSchema$4 = string().trim().min(1).max(256);
+const reasonCodeSchema$3 = string().trim().min(1).max(256);
+const agentProfileBindingRouteParamsSchema = strictObject({ agentProfileId: boundedIdentifierSchema$4 });
+const agentProfileBindingRuntimeIdSchema = strictObject({
+	source: literal("runtime_registry_authority"),
+	value: string().trim().min(1).max(512)
+});
+const ensureAgentProfilePrimaryBindingBodySchema = strictObject({
+	capabilityRef: boundedIdentifierSchema$4,
+	deviceId: boundedIdentifierSchema$4,
+	lane: boundedIdentifierSchema$4,
+	runtimeId: agentProfileBindingRuntimeIdSchema
+});
+const agentProfileBindingStateSchema = _enum([
+	"missing",
+	"enabled_primary",
+	"disabled_historical",
+	"conflict",
+	"owner_mismatch"
+]);
+const agentProfileBindingResolutionSourceSchema = _enum([
+	"binding_truth",
+	"missing_projection",
+	"conflict_evidence"
+]);
+const agentProfileBindingAuthoritySourceSchema = _enum([
+	"binding_truth",
+	"none",
+	"blocked"
+]);
+const agentProfileBindingRuntimeCapabilitySchema = strictObject({
+	capabilityRef: boundedIdentifierSchema$4,
+	runtimeId: agentProfileBindingRuntimeIdSchema
+});
+const agentProfileBindingDispatchEligibilitySchema = strictObject({
+	reasonCodes: array(reasonCodeSchema$3),
+	routable: boolean(),
+	status: _enum(["routable", "not_routable"])
+});
+const agentProfileBindingProjectionSchema = strictObject({
+	agentProfileId: boundedIdentifierSchema$4,
+	authoritySource: agentProfileBindingAuthoritySourceSchema,
+	bindingId: boundedIdentifierSchema$4.optional(),
+	bindingState: agentProfileBindingStateSchema,
+	dispatchEligibility: agentProfileBindingDispatchEligibilitySchema,
+	grantsClaimSuccess: literal(false),
+	reasonCodes: array(reasonCodeSchema$3),
+	resolutionSource: agentProfileBindingResolutionSourceSchema,
+	routable: boolean(),
+	runtimeCapability: agentProfileBindingRuntimeCapabilitySchema.nullable()
+}).superRefine(validateAgentProfileBindingProjection);
+const getAgentProfilePrimaryBindingResponseSchema = strictObject({
+	binding: agentProfileBindingProjectionSchema,
+	grantsClaimSuccess: literal(false),
+	status: _enum(["found", "missing"])
+}).superRefine((value, context) => {
+	const expectedStatus = value.binding.bindingState === "missing" ? "missing" : "found";
+	if (value.status !== expectedStatus) context.addIssue({
+		code: "custom",
+		message: "Binding read status must match Binding projection",
+		path: ["status"]
+	});
+});
+const ensureAgentProfilePrimaryBindingResponseSchema = strictObject({
+	binding: agentProfileBindingProjectionSchema.optional(),
+	grantsClaimSuccess: literal(false),
+	outcome: _enum(["created", "reused"]).optional(),
+	reasonCodes: array(reasonCodeSchema$3),
+	routable: boolean(),
+	status: _enum(["accepted", "rejected"])
+}).superRefine((value, context) => {
+	if (value.status === "accepted") {
+		if (!value.binding) context.addIssue({
+			code: "custom",
+			message: "accepted Binding command response requires Binding truth",
+			path: ["binding"]
+		});
+		if (!value.outcome) context.addIssue({
+			code: "custom",
+			message: "accepted Binding command response requires an outcome",
+			path: ["outcome"]
+		});
+		if (!value.routable) context.addIssue({
+			code: "custom",
+			message: "accepted Binding command response must be routable",
+			path: ["routable"]
+		});
+		if (value.binding) requireAcceptedBindingCommandProjection(value.binding, context);
+		return;
+	}
+	if (value.outcome) context.addIssue({
+		code: "custom",
+		message: "rejected Binding command response cannot include outcome",
+		path: ["outcome"]
+	});
+	if (value.routable) context.addIssue({
+		code: "custom",
+		message: "rejected Binding command response cannot be routable",
+		path: ["routable"]
+	});
+});
+function validateAgentProfileBindingProjection(value, context) {
+	validateBindingDispatchEligibility(value, context);
+	bindingProjectionValidators[value.bindingState](value, context);
+}
+const bindingProjectionValidators = {
+	conflict: validateConflictProjection,
+	disabled_historical: validateDisabledHistoricalProjection,
+	enabled_primary: validateEnabledPrimaryProjection,
+	missing: validateMissingProjection,
+	owner_mismatch: validateOwnerMismatchProjection
+};
+function validateBindingDispatchEligibility(value, context) {
+	if (value.dispatchEligibility.routable !== value.routable) context.addIssue({
+		code: "custom",
+		message: "Binding routable fields must agree",
+		path: ["dispatchEligibility", "routable"]
+	});
+	if (value.dispatchEligibility.status !== (value.routable ? "routable" : "not_routable")) context.addIssue({
+		code: "custom",
+		message: "Binding dispatch status must match routable state",
+		path: ["dispatchEligibility", "status"]
+	});
+}
+function validateEnabledPrimaryProjection(value, context) {
+	requireBindingTruthProjection(value, context);
+	if (!value.routable) context.addIssue({
+		code: "custom",
+		message: "enabled primary Binding must be routable",
+		path: ["routable"]
+	});
+}
+function validateDisabledHistoricalProjection(value, context) {
+	requireBindingTruthProjection(value, context);
+	if (value.routable) context.addIssue({
+		code: "custom",
+		message: "disabled historical Binding cannot be routable",
+		path: ["routable"]
+	});
+}
+function validateMissingProjection(value, context) {
+	if (value.authoritySource !== "none") context.addIssue({
+		code: "custom",
+		message: "missing Binding projection cannot have authority source",
+		path: ["authoritySource"]
+	});
+	if (value.resolutionSource !== "missing_projection") context.addIssue({
+		code: "custom",
+		message: "missing Binding projection requires missing source",
+		path: ["resolutionSource"]
+	});
+	rejectMissingProjectionEvidence(value, context);
+}
+function rejectMissingProjectionEvidence(value, context) {
+	if (value.bindingId) context.addIssue({
+		code: "custom",
+		message: "missing Binding projection cannot include bindingId",
+		path: ["bindingId"]
+	});
+	if (value.runtimeCapability) context.addIssue({
+		code: "custom",
+		message: "missing Binding projection cannot include Runtime capability",
+		path: ["runtimeCapability"]
+	});
+	if (value.routable) context.addIssue({
+		code: "custom",
+		message: "missing Binding projection cannot be routable",
+		path: ["routable"]
+	});
+}
+function validateConflictProjection(value, context) {
+	if (value.authoritySource !== "blocked") context.addIssue({
+		code: "custom",
+		message: "conflict Binding projection must be blocked",
+		path: ["authoritySource"]
+	});
+	if (value.resolutionSource !== "conflict_evidence") context.addIssue({
+		code: "custom",
+		message: "conflict Binding projection requires conflict evidence",
+		path: ["resolutionSource"]
+	});
+	if (value.routable) context.addIssue({
+		code: "custom",
+		message: "conflict Binding projection cannot be routable",
+		path: ["routable"]
+	});
+}
+function validateOwnerMismatchProjection(value, context) {
+	if (value.authoritySource !== "blocked") context.addIssue({
+		code: "custom",
+		message: "owner mismatch Binding projection must be blocked",
+		path: ["authoritySource"]
+	});
+	if (value.routable) context.addIssue({
+		code: "custom",
+		message: "owner mismatch Binding projection cannot be routable",
+		path: ["routable"]
+	});
+}
+function requireBindingTruthProjection(value, context) {
+	if (value.authoritySource !== "binding_truth") context.addIssue({
+		code: "custom",
+		message: "Binding truth projection requires binding authority",
+		path: ["authoritySource"]
+	});
+	if (value.resolutionSource !== "binding_truth") context.addIssue({
+		code: "custom",
+		message: "Binding truth projection requires binding resolution source",
+		path: ["resolutionSource"]
+	});
+	if (!value.bindingId) context.addIssue({
+		code: "custom",
+		message: "Binding truth projection requires bindingId",
+		path: ["bindingId"]
+	});
+	if (!value.runtimeCapability) context.addIssue({
+		code: "custom",
+		message: "Binding truth projection requires Runtime capability",
+		path: ["runtimeCapability"]
+	});
+}
+function requireAcceptedBindingCommandProjection(binding, context) {
+	if (binding.bindingState !== "enabled_primary") context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires enabled primary truth",
+		path: ["binding", "bindingState"]
+	});
+	if (binding.authoritySource !== "binding_truth") context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires Binding authority",
+		path: ["binding", "authoritySource"]
+	});
+	if (binding.resolutionSource !== "binding_truth") context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires Binding truth source",
+		path: ["binding", "resolutionSource"]
+	});
+	if (!binding.bindingId) context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires bindingId",
+		path: ["binding", "bindingId"]
+	});
+	if (!binding.runtimeCapability) context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires Runtime capability",
+		path: ["binding", "runtimeCapability"]
+	});
+	if (!(binding.routable && binding.dispatchEligibility.routable)) context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires routable Binding truth",
+		path: ["binding", "routable"]
+	});
+	if (binding.dispatchEligibility.status !== "routable") context.addIssue({
+		code: "custom",
+		message: "accepted Binding command response requires routable status",
+		path: [
+			"binding",
+			"dispatchEligibility",
+			"status"
+		]
+	});
+}
 const setAuthPasswordBodySchema = strictObject({ newPassword: string() });
 const setAuthPasswordResponseSchema = strictObject({ status: boolean() });
 /**
@@ -6642,6 +6959,62 @@ const catchupResponseSchema = strictObject({
 		nextCursor
 	};
 });
+const boundedIdentifierSchema$3 = string().trim().min(1).max(512);
+const boundedStatusSchema = string().trim().min(1).max(256);
+const nullableBoundedIdentifierSchema = boundedIdentifierSchema$3.nullable();
+const claimExecutionDiagnosticsQuerySchema = strictObject({
+	claimLeaseId: boundedIdentifierSchema$3.optional(),
+	dispatchId: boundedIdentifierSchema$3.optional(),
+	sourceClientMessageId: boundedIdentifierSchema$3.optional(),
+	spaceId: boundedIdentifierSchema$3.optional(),
+	targetProfileId: boundedIdentifierSchema$3.optional()
+}).superRefine((value, context) => {
+	const hasDispatchAnchor = Boolean(value.dispatchId);
+	const hasClaimLeaseAnchor = Boolean(value.claimLeaseId);
+	const hasBoundedSourceAnchor = Boolean(value.sourceClientMessageId && value.spaceId && value.targetProfileId);
+	if (hasDispatchAnchor || hasClaimLeaseAnchor || hasBoundedSourceAnchor) return;
+	context.addIssue({
+		code: "custom",
+		message: value.sourceClientMessageId === void 0 ? "claim execution diagnostics lookup requires dispatchId, claimLeaseId, or sourceClientMessageId with spaceId and targetProfileId" : "sourceClientMessageId diagnostics lookup requires spaceId and targetProfileId unless paired with dispatchId or claimLeaseId",
+		path: ["sourceClientMessageId"]
+	});
+});
+const claimExecutionDispatchOwnerSchema = strictObject({
+	id: boundedIdentifierSchema$3,
+	kind: boundedIdentifierSchema$3
+});
+const claimExecutionDiagnosticsDispatchSchema = strictObject({
+	dispatchId: boundedIdentifierSchema$3,
+	owner: claimExecutionDispatchOwnerSchema.nullable(),
+	sourceClientMessageId: nullableBoundedIdentifierSchema,
+	sourceEventId: boundedIdentifierSchema$3,
+	status: boundedStatusSchema,
+	targetProfileId: boundedIdentifierSchema$3
+});
+const claimExecutionDiagnosticsClaimLeaseSchema = strictObject({
+	claimLeaseId: boundedIdentifierSchema$3,
+	dispatchId: boundedIdentifierSchema$3,
+	leaseState: boundedStatusSchema,
+	sourceClientMessageId: nullableBoundedIdentifierSchema,
+	status: literal("found")
+});
+const claimExecutionDiagnosticsResultSchema = strictObject({
+	dispatchId: boundedIdentifierSchema$3,
+	publicOutcome: boundedStatusSchema,
+	publishedSignalId: nullableBoundedIdentifierSchema,
+	resultRef: boundedIdentifierSchema$3,
+	statusType: nullableBoundedIdentifierSchema
+});
+const claimExecutionDiagnosticsResponseSchema = strictObject({
+	claimLease: claimExecutionDiagnosticsClaimLeaseSchema.nullable(),
+	dispatch: claimExecutionDiagnosticsDispatchSchema.nullable(),
+	result: claimExecutionDiagnosticsResultSchema.nullable(),
+	status: _enum([
+		"found",
+		"mismatch",
+		"missing"
+	])
+});
 const START_ISO_DATE_TIME_SCHEMA = datetime({ offset: true });
 const START_TRIMMED_NON_EMPTY_STRING_SCHEMA = string().trim().min(1);
 const START_BOUNDED_ID_SCHEMA = START_TRIMMED_NON_EMPTY_STRING_SCHEMA.max(256);
@@ -6655,6 +7028,95 @@ const startReplyReadinessSummarySchema = strictObject({
 function toStartTimestampMs(value) {
 	return Date.parse(value);
 }
+const boundedIdentifierSchema$2 = string().trim().min(1).max(256);
+const reasonCodeSchema$2 = string().trim().min(1).max(256);
+const prepareReadinessRouteParamsSchema = strictObject({ deviceId: boundedIdentifierSchema$2 });
+const getPrepareReadinessQuerySchema = strictObject({
+	capabilityRefs: array(string().trim().min(1).max(256)).optional(),
+	lane: boundedIdentifierSchema$2,
+	runtimeId: string().trim().min(1).max(512).optional()
+});
+const prepareReadinessRuntimeIdSchema = strictObject({
+	source: literal("runtime_registry_authority"),
+	value: string().trim().min(1).max(512)
+});
+const prepareReadinessDisplayStateSchema = _enum([
+	"ready",
+	"pending",
+	"unavailable",
+	"needs_prepare",
+	"needs_repair",
+	"stale",
+	"unknown"
+]);
+const prepareReadinessRunnableCapabilitySchema = strictObject({
+	capabilityRef: string().trim().min(1).max(256),
+	expiresAtMs: int().nonnegative(),
+	observedAtMs: int().nonnegative(),
+	reasonCodes: array(reasonCodeSchema$2),
+	status: literal("ready")
+});
+const prepareReadinessNonRunnableCapabilitySchema = strictObject({
+	capabilityRef: string().trim().min(1).max(256),
+	expiresAtMs: int().nonnegative().optional(),
+	observedAtMs: int().nonnegative().optional(),
+	reasonCodes: array(reasonCodeSchema$2),
+	status: _enum([
+		"disabled",
+		"invalid",
+		"missing",
+		"stale",
+		"unavailable",
+		"unknown"
+	])
+});
+const prepareReadinessProjectionSchema = strictObject({
+	allRunnableCapabilitiesPrepared: strictObject({ status: _enum([
+		"prepared",
+		"not_prepared",
+		"partial",
+		"unknown"
+	]) }).optional(),
+	projectionStatus: prepareReadinessDisplayStateSchema,
+	reasonCodes: array(reasonCodeSchema$2),
+	serviceReadiness: strictObject({ status: _enum([
+		"running",
+		"starting",
+		"not_running",
+		"not_installed",
+		"needs_repair",
+		"unavailable",
+		"unknown"
+	]) }).optional()
+});
+const prepareReadinessSummarySchema = strictObject({
+	displayState: prepareReadinessDisplayStateSchema,
+	ready: boolean(),
+	reasonCodes: array(reasonCodeSchema$2)
+});
+const getPrepareReadinessResponseSchema = strictObject({
+	capabilityReportsRead: boolean(),
+	nonRunnableCapabilities: array(prepareReadinessNonRunnableCapabilitySchema),
+	projection: prepareReadinessProjectionSchema,
+	reason: _enum([
+		"runtime_identity_invalid",
+		"runtime_id_invalid",
+		"runtime_id_mismatch",
+		"runtime_lookup_conflict",
+		"runtime_missing",
+		"runtime_not_ready"
+	]).optional(),
+	runnableCapabilities: array(prepareReadinessRunnableCapabilitySchema),
+	runtimeId: prepareReadinessRuntimeIdSchema.optional(),
+	status: _enum(["not_ready", "ready"]),
+	summary: prepareReadinessSummarySchema
+}).superRefine((value, context) => {
+	if (value.status === "ready" && !value.runtimeId) context.addIssue({
+		code: "custom",
+		message: "ready prepare readiness response requires authority runtimeId evidence",
+		path: ["runtimeId"]
+	});
+});
 const ownedDeviceDisplayNameSourceSchema = _enum([
 	"user",
 	"observed",
@@ -6672,6 +7134,39 @@ const ownedDeviceTypeSchema = _enum([
 	"server",
 	"unknown"
 ]);
+const reasonCodeSchema$1 = string().trim().min(1).max(256);
+const ownedDeviceExecutionTargetCapabilitySchema = strictObject({
+	capabilityRef: string().trim().min(1).max(256),
+	reasonCodes: array(reasonCodeSchema$1),
+	status: _enum([
+		"ready",
+		"not_ready",
+		"stale",
+		"unknown"
+	])
+});
+const ownedDeviceExecutionTargetStatusSchema = _enum([
+	"ready",
+	"partial",
+	"not_ready",
+	"stale",
+	"unknown"
+]);
+const ownedDeviceExecutionTargetSchema = strictObject({
+	deviceId: START_BOUNDED_ID_SCHEMA,
+	runtimeLane: daemonServiceLaneSchema,
+	userFacingCommand: _enum([
+		"ats",
+		"ats-dev",
+		"ats-canary"
+	]),
+	runtimeId: prepareReadinessRuntimeIdSchema.nullable(),
+	status: ownedDeviceExecutionTargetStatusSchema,
+	capabilities: array(ownedDeviceExecutionTargetCapabilitySchema),
+	reasonCodes: array(reasonCodeSchema$1),
+	lastObservedAtMs: number().int().nonnegative().nullable(),
+	isCurrent: boolean()
+});
 const ownedDeviceOptionSchema = strictObject({
 	deviceId: START_BOUNDED_ID_SCHEMA,
 	deviceDisplayName: string().min(1),
@@ -6681,23 +7176,31 @@ const ownedDeviceOptionSchema = strictObject({
 	deviceType: ownedDeviceTypeSchema,
 	firstSeenAtMs: number().int().nonnegative(),
 	lastObservedAtMs: number().int().nonnegative().nullable(),
-	isCurrent: boolean()
+	isCurrent: boolean(),
+	executionTargets: array(ownedDeviceExecutionTargetSchema)
 });
 const ownedDevicesResponseSchema = strictObject({
 	currentDeviceId: START_BOUNDED_ID_SCHEMA.nullable(),
+	currentRuntimeLane: daemonServiceLaneSchema.nullable(),
 	devices: array(ownedDeviceOptionSchema)
 });
 const setOwnedDeviceDisplayNameBodySchema = strictObject({ displayName: string().trim().min(1).max(80).nullable() });
+const currentDeviceTargetDeviceIdSchema = START_BOUNDED_ID_SCHEMA;
 const currentDeviceTargetResolvedSchema = strictObject({
 	availability: literal("resolved"),
-	deviceId: START_BOUNDED_ID_SCHEMA
+	deviceId: currentDeviceTargetDeviceIdSchema,
+	runtimeLane: daemonServiceLaneSchema
+});
+const currentDeviceTargetMissingSchema = strictObject({
+	availability: literal("missing"),
+	reasonCodes: array(string().trim().min(1).max(256)).optional()
 });
-const currentDeviceTargetMissingSchema = strictObject({ availability: literal("missing") });
 const currentDeviceTargetResponseSchema = discriminatedUnion("availability", [currentDeviceTargetResolvedSchema, currentDeviceTargetMissingSchema]);
 const currentDeviceTargetWriteModeSchema = _enum(["replace", "if_missing"]);
 const currentDeviceTargetActivationSourceSchema = _enum(["local_setup"]);
 const setCurrentDeviceTargetBodySchema = strictObject({
-	deviceId: START_BOUNDED_ID_SCHEMA,
+	deviceId: currentDeviceTargetDeviceIdSchema,
+	runtimeLane: daemonServiceLaneSchema,
 	activationSource: currentDeviceTargetActivationSourceSchema.optional(),
 	writeMode: currentDeviceTargetWriteModeSchema.optional()
 });
@@ -6708,90 +7211,18 @@ const forgetCurrentComputerResponseSchema = strictObject({
 	currentDeviceTarget: currentDeviceTargetMissingSchema,
 	ownedDevices: ownedDevicesResponseSchema
 });
+const forgetComputerRouteParamsSchema = strictObject({ deviceId: currentDeviceTargetDeviceIdSchema });
+const forgetComputerResponseSchema = strictObject({
+	status: forgetCurrentComputerStatusSchema,
+	forgottenDeviceId: START_BOUNDED_ID_SCHEMA.nullable(),
+	currentDeviceTarget: currentDeviceTargetResponseSchema,
+	ownedDevices: ownedDevicesResponseSchema
+});
 const daemonRouteObservationResponseSchema = strictObject({
 	observedAt: string().trim().min(1),
 	profileId: string().trim().min(1),
 	route: daemonHubLookupRouteResponseSchema
 });
-const deviceAgentRuntimeModeSchema = _enum(["selected_agents", "no_agents"]);
-const selectedAgentIdsSchema$1 = array(START_BOUNDED_ID_SCHEMA).superRefine((value, ctx) => {
-	const seen = /* @__PURE__ */ new Set();
-	for (const [index, agentId] of value.entries()) {
-		if (seen.has(agentId)) {
-			ctx.addIssue({
-				code: "custom",
-				message: "selectedAgentIds must not contain duplicate local agent ids",
-				path: [index]
-			});
-			continue;
-		}
-		seen.add(agentId);
-	}
-});
-const deviceAgentRuntimePreferenceSchema = strictObject({
-	deviceId: START_BOUNDED_ID_SCHEMA,
-	mode: deviceAgentRuntimeModeSchema,
-	selectedAgentIds: selectedAgentIdsSchema$1,
-	updatedAt: START_ISO_DATE_TIME_SCHEMA
-}).superRefine((value, ctx) => {
-	if (value.mode === "selected_agents" && value.selectedAgentIds.length === 0) ctx.addIssue({
-		code: "custom",
-		message: "selectedAgentIds must contain at least one agent when mode is selected_agents",
-		path: ["selectedAgentIds"]
-	});
-	if (value.mode === "no_agents" && value.selectedAgentIds.length !== 0) ctx.addIssue({
-		code: "custom",
-		message: "selectedAgentIds must be empty when mode is no_agents",
-		path: ["selectedAgentIds"]
-	});
-});
-const savedDeviceAgentRuntimeSchema = discriminatedUnion("availability", [strictObject({ availability: literal("missing") }), strictObject({
-	availability: literal("saved"),
-	mode: deviceAgentRuntimeModeSchema,
-	selectedAgentIds: selectedAgentIdsSchema$1,
-	updatedAt: START_ISO_DATE_TIME_SCHEMA
-}).superRefine((value, ctx) => {
-	if (value.mode === "selected_agents" && value.selectedAgentIds.length === 0) ctx.addIssue({
-		code: "custom",
-		message: "selectedAgentIds must contain at least one agent when mode is selected_agents",
-		path: ["selectedAgentIds"]
-	});
-	if (value.mode === "no_agents" && value.selectedAgentIds.length !== 0) ctx.addIssue({
-		code: "custom",
-		message: "selectedAgentIds must be empty when mode is no_agents",
-		path: ["selectedAgentIds"]
-	});
-})]);
-const selectedAgentIdsSchema = array(START_BOUNDED_ID_SCHEMA).superRefine((value, ctx) => {
-	const seen = /* @__PURE__ */ new Set();
-	for (const [index, agentId] of value.entries()) {
-		if (seen.has(agentId)) {
-			ctx.addIssue({
-				code: "custom",
-				message: "selectedAgentIds must not contain duplicate local agent ids",
-				path: [index]
-			});
-			continue;
-		}
-		seen.add(agentId);
-	}
-});
-const deviceAgentRuntimeRouteParamsSchema = strictObject({ deviceId: START_BOUNDED_ID_SCHEMA });
-const writeDeviceAgentRuntimeBodySchema = strictObject({
-	mode: deviceAgentRuntimeModeSchema,
-	selectedAgentIds: selectedAgentIdsSchema
-}).superRefine((value, ctx) => {
-	if (value.mode === "selected_agents" && value.selectedAgentIds.length === 0) ctx.addIssue({
-		code: "custom",
-		message: "selectedAgentIds must contain at least one agent when mode is selected_agents",
-		path: ["selectedAgentIds"]
-	});
-	if (value.mode === "no_agents" && value.selectedAgentIds.length !== 0) ctx.addIssue({
-		code: "custom",
-		message: "selectedAgentIds must be empty when mode is no_agents",
-		path: ["selectedAgentIds"]
-	});
-});
 const startSessionLifecycleStatusSchema = _enum([
 	"active",
 	"superseded",
@@ -6812,10 +7243,10 @@ const startSpaceChoiceModeSchema = _enum([
 	"create_new",
 	"join_existing"
 ]);
-const startAgentSelectionModeSchema = _enum([
+const startLocalAgentPreparationModeSchema = _enum([
 	"unresolved",
-	"selected_agents",
-	"no_agents"
+	"prepare_local_agents",
+	"skip_local_agents"
 ]);
 const startSpaceMemberSelectionModeSchema = _enum([
 	"unresolved",
@@ -6873,26 +7304,26 @@ function validateStartTargetSpaceId(input) {
 		path: ["targetSpaceId"]
 	});
 }
-const startSelectedAgentIdsSchema = array(START_BOUNDED_ID_SCHEMA).superRefine((value, ctx) => {
+const startLocalAgentIdsSchema = array(START_BOUNDED_ID_SCHEMA).superRefine((value, ctx) => {
 	if (new Set(value).size !== value.length) ctx.addIssue({
 		code: "custom",
-		message: "selectedAgentIds must not contain duplicates"
+		message: "localAgentIds must not contain duplicates"
 	});
 });
-const startAgentSelectionSchema = strictObject({
-	mode: startAgentSelectionModeSchema,
-	selectedAgentIds: startSelectedAgentIdsSchema
+const startLocalAgentPreparationSchema = strictObject({
+	mode: startLocalAgentPreparationModeSchema,
+	localAgentIds: startLocalAgentIdsSchema
 }).superRefine((value, ctx) => {
-	const hasSelectedAgentIds = value.selectedAgentIds.length > 0;
-	if (value.mode === "selected_agents" && !hasSelectedAgentIds) ctx.addIssue({
+	const hasLocalAgentIds = value.localAgentIds.length > 0;
+	if (value.mode === "prepare_local_agents" && !hasLocalAgentIds) ctx.addIssue({
 		code: "custom",
-		message: "selected_agents agent selection must provide at least one selectedAgentId",
-		path: ["selectedAgentIds"]
+		message: "prepare_local_agents local agent preparation must provide at least one localAgentId",
+		path: ["localAgentIds"]
 	});
-	if (value.mode !== "selected_agents" && hasSelectedAgentIds) ctx.addIssue({
+	if (value.mode !== "prepare_local_agents" && hasLocalAgentIds) ctx.addIssue({
 		code: "custom",
-		message: "unresolved and no_agents agent selection must use an empty selectedAgentIds list",
-		path: ["selectedAgentIds"]
+		message: "unresolved and skip_local_agents local agent preparation must use an empty localAgentIds list",
+		path: ["localAgentIds"]
 	});
 });
 const startSelectedSpaceMemberProfileIdsSchema = array(atsProfileIdSchema).superRefine((value, ctx) => {
@@ -6924,7 +7355,7 @@ const startSessionSchema = strictObject({
 	initiator: startSessionInitiatorSchema,
 	lifecycleStatus: startSessionLifecycleStatusSchema,
 	profileChoice: startProfileChoiceSchema,
-	agentSelection: startAgentSelectionSchema,
+	localAgentPreparation: startLocalAgentPreparationSchema,
 	spaceMemberSelection: startSpaceMemberSelectionSchema.default({
 		mode: "unresolved",
 		selectedProfileIds: []
@@ -6986,6 +7417,58 @@ const writeStartObservedDeviceMetadataBodySchema = strictObject({
 	metadata: observedDeviceMetadataSchema
 });
 const writeStartObservedDeviceMetadataResponseSchema = writeCurrentDeviceObservedMetadataResponseSchema;
+const boundedIdentifierSchema$1 = string().trim().min(1).max(512);
+const boundedReasonCodeSchema = string().trim().min(1).max(256);
+const timestampMsSchema = int().nonnegative();
+const finalClaimRouteParamsSchema = strictObject({
+	dispatchId: boundedIdentifierSchema$1,
+	spaceId: boundedIdentifierSchema$1
+});
+const finalClaimRuntimeIdSchema = strictObject({
+	source: literal("runtime_registry_authority"),
+	value: boundedIdentifierSchema$1
+});
+const reserveFinalClaimBodySchema = strictObject({
+	capabilityRef: boundedIdentifierSchema$1,
+	claimIdempotencyKey: boundedIdentifierSchema$1,
+	deviceId: boundedIdentifierSchema$1,
+	lane: boundedIdentifierSchema$1,
+	runtimeId: finalClaimRuntimeIdSchema,
+	sourceClientMessageId: boundedIdentifierSchema$1.nullable().optional(),
+	sourceSignalId: boundedIdentifierSchema$1,
+	targetProfileId: boundedIdentifierSchema$1
+});
+const finalClaimDiagnosticPointerSchema = strictObject({
+	dispatchId: boundedIdentifierSchema$1.optional(),
+	requestId: boundedIdentifierSchema$1.optional(),
+	spaceId: boundedIdentifierSchema$1.optional(),
+	targetProfileId: boundedIdentifierSchema$1.optional()
+});
+const finalClaimAcceptedLeaseSchema = strictObject({
+	bindingId: boundedIdentifierSchema$1,
+	capabilityRef: boundedIdentifierSchema$1,
+	dispatchId: boundedIdentifierSchema$1,
+	expiresAtMs: timestampMsSchema,
+	leaseId: boundedIdentifierSchema$1,
+	runtimeId: finalClaimRuntimeIdSchema,
+	targetProfileId: boundedIdentifierSchema$1
+});
+const reserveFinalClaimAcceptedResponseSchema = strictObject({
+	claimLeaseReserved: literal(true),
+	lease: finalClaimAcceptedLeaseSchema,
+	outcome: _enum(["new_lease", "existing_lease"]),
+	runtimeExecutionStarted: literal(false),
+	status: literal("accepted")
+});
+const reserveFinalClaimRejectedResponseSchema = strictObject({
+	claimLeaseReserved: literal(false),
+	diagnosticPointer: finalClaimDiagnosticPointerSchema.optional(),
+	reason: boundedIdentifierSchema$1,
+	reasonCode: boundedReasonCodeSchema,
+	runtimeExecutionStarted: literal(false),
+	status: literal("rejected")
+});
+const reserveFinalClaimResponseSchema = discriminatedUnion("status", [reserveFinalClaimAcceptedResponseSchema, reserveFinalClaimRejectedResponseSchema]);
 const trimmedNonEmptyStringSchema$4 = string().trim().min(1);
 const gatewayErrorCodeSchema = _enum([
 	"bad_request",
@@ -7444,6 +7927,113 @@ const updateProfileResponseSchema = strictObject({
 	ok: literal(true),
 	profile: authProfileViewSchema
 });
+const boundedIdentifierSchema = string().trim().min(1).max(256);
+const reasonCodeSchema = string().trim().min(1).max(256);
+const runtimeReportingRouteParamsSchema = strictObject({ deviceId: boundedIdentifierSchema });
+const runtimeReportingRuntimeIdSchema = strictObject({
+	source: literal("runtime_registry_authority"),
+	value: string().trim().min(1).max(512)
+});
+const submitRuntimeRegistrationBodySchema = strictObject({ lane: boundedIdentifierSchema });
+const runtimeRegistrationRejectedReasonSchema = _enum([
+	"device_forgotten",
+	"owner_authorization_denied",
+	"owner_authorization_unknown",
+	"owner_authorization_unavailable",
+	"owner_kind_unsupported",
+	"runtime_id_collision",
+	"runtime_id_invalid",
+	"runtime_id_not_opaque",
+	"runtime_record_missing_after_conflict",
+	"unknown"
+]);
+const submitRuntimeRegistrationResponseSchema = strictObject({
+	reason: runtimeRegistrationRejectedReasonSchema.optional(),
+	runtimeId: runtimeReportingRuntimeIdSchema.optional(),
+	status: _enum([
+		"created",
+		"reused",
+		"rejected"
+	])
+}).superRefine((value, context) => {
+	if (value.status !== "rejected" && !value.runtimeId) context.addIssue({
+		code: "custom",
+		message: "registered Runtime response requires authority runtimeId",
+		path: ["runtimeId"]
+	});
+	if (value.status === "rejected" && !value.reason) context.addIssue({
+		code: "custom",
+		message: "rejected Runtime registration requires a reason",
+		path: ["reason"]
+	});
+});
+const runtimeCapabilityReportStatusSchema = _enum([
+	"ready",
+	"disabled",
+	"unavailable",
+	"unknown"
+]);
+const submitRuntimeCapabilityReportItemSchema = strictObject({
+	capabilityRef: boundedIdentifierSchema,
+	expiresAtMs: int().positive(),
+	observedAtMs: int().positive(),
+	reasonCodes: array(reasonCodeSchema).optional(),
+	status: runtimeCapabilityReportStatusSchema
+});
+const submitRuntimeCapabilityReportsBodySchema = strictObject({
+	lane: boundedIdentifierSchema,
+	reports: array(submitRuntimeCapabilityReportItemSchema).min(1).max(64),
+	runtimeId: runtimeReportingRuntimeIdSchema
+});
+const runtimeCapabilityReportRejectedReasonSchema = _enum([
+	"capability_ref_invalid",
+	"conflict",
+	"out_of_order",
+	"report_status_invalid",
+	"report_time_invalid",
+	"runtime_id_invalid",
+	"runtime_id_mismatch",
+	"runtime_identity_invalid",
+	"runtime_lookup_conflict",
+	"runtime_missing",
+	"stale"
+]);
+const submitRuntimeCapabilityReportResultSchema = strictObject({
+	capabilityRef: boundedIdentifierSchema,
+	outcome: _enum([
+		"created",
+		"updated",
+		"reused"
+	]).optional(),
+	reason: runtimeCapabilityReportRejectedReasonSchema.optional(),
+	status: _enum(["accepted", "rejected"])
+}).superRefine((value, context) => {
+	if (value.status === "accepted" && !value.outcome) context.addIssue({
+		code: "custom",
+		message: "accepted Runtime Capability Report requires an outcome",
+		path: ["outcome"]
+	});
+	if (value.status === "rejected" && !value.reason) context.addIssue({
+		code: "custom",
+		message: "rejected Runtime Capability Report requires a reason",
+		path: ["reason"]
+	});
+});
+const submitRuntimeCapabilityReportsResponseSchema = strictObject({
+	reports: array(submitRuntimeCapabilityReportResultSchema),
+	runtimeId: runtimeReportingRuntimeIdSchema.optional(),
+	status: _enum([
+		"accepted",
+		"partial",
+		"rejected"
+	])
+}).superRefine((value, context) => {
+	if (value.status !== "rejected" && !value.runtimeId) context.addIssue({
+		code: "custom",
+		message: "accepted Runtime Capability Report response requires authority runtimeId",
+		path: ["runtimeId"]
+	});
+});
 const patchSpaceContractBodySchema = spaceContractFieldsSchema.pick({
 	dispatchPolicy: true,
 	publicationMode: true,
@@ -7850,7 +8440,7 @@ const spaceDispatchTraceResponseSchema = strictObject({
 	query: spaceDispatchTraceQuerySchema,
 	trace: union([spaceDispatchTraceSnapshotSchema, _null()])
 });
-const optionalSelectorSchema$1 = preprocess((value) => {
+const optionalSelectorSchema$2 = preprocess((value) => {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : void 0;
 }, string().min(1).optional());
@@ -7860,9 +8450,9 @@ const optionalClientMessageIdSchema = preprocess((value) => {
 }, clientMessageIdSchema.optional());
 const getSpaceDispatchLookupInputSchema = strictObject({
 	spaceId: nonEmptyTrimmedStringFromUnknown,
-	sourceSignalId: optionalSelectorSchema$1,
+	sourceSignalId: optionalSelectorSchema$2,
 	clientMessageId: optionalClientMessageIdSchema,
-	targetProfileId: optionalSelectorSchema$1
+	targetProfileId: optionalSelectorSchema$2
 }).superRefine((value, context) => {
 	if (Number(value.sourceSignalId !== void 0) + Number(value.clientMessageId !== void 0) === 1) return;
 	context.addIssue({
@@ -7891,6 +8481,8 @@ const getSpaceDispatchLookupResponseSchema = strictObject({
 	}),
 	matches: array(spaceDispatchLookupMatchSchema)
 });
+const MAX_SPACE_NAME_LENGTH = 80;
+const spaceNameSchema = string().trim().min(1).max(MAX_SPACE_NAME_LENGTH);
 const isoDateTimeSchema$1 = datetime({ offset: true });
 const nullableTrimmedStringSchema = union([string().trim().min(1), _null()]);
 const dispatchResultKindSchema = _enum(["text", "status"]);
@@ -7951,14 +8543,14 @@ const dispatchResultSchema = strictObject({
 		path: ["messageEnvelope", "replyToSignalId"]
 	});
 });
-const optionalSelectorSchema = preprocess((value) => {
+const optionalSelectorSchema$1 = preprocess((value) => {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : void 0;
 }, string().min(1).optional());
 const getSpaceDispatchResultInputSchema = strictObject({
 	spaceId: nonEmptyTrimmedStringFromUnknown,
-	dispatchId: optionalSelectorSchema,
-	resultRef: optionalSelectorSchema
+	dispatchId: optionalSelectorSchema$1,
+	resultRef: optionalSelectorSchema$1
 }).superRefine((value, ctx) => {
 	if (Number(typeof value.dispatchId === "string") + Number(typeof value.resultRef === "string") !== 1) ctx.addIssue({
 		code: "custom",
@@ -8086,6 +8678,45 @@ const getSpaceUpdatesInputSchema = strictObject({
 	limit: updatesLimitSchema
 });
 const getSpaceUpdatesResponseSchema = strictObject({ signals: array(signalEnvelopeSchema) });
+const optionalSelectorSchema = preprocess((value) => {
+	const normalized = String(value ?? "").trim();
+	return normalized.length > 0 ? normalized : void 0;
+}, string().min(1).optional());
+const wakeProgressPhaseSchema = _enum([
+	"sending",
+	"request_sent",
+	"queued",
+	"connecting",
+	"running",
+	"writing",
+	"retrying",
+	"failed",
+	"replied"
+]);
+const wakeProgressItemSchema = strictObject({
+	clientMessageId: clientMessageIdSchema.nullable(),
+	sourceSignalId: string().trim().min(1).nullable(),
+	dispatchId: string().trim().min(1).nullable(),
+	targetProfileId: string().trim().min(1),
+	targetLabel: string().trim().min(1),
+	phase: wakeProgressPhaseSchema,
+	message: string().trim().min(1),
+	updatedAtMs: int().min(0),
+	terminal: boolean()
+});
+const getSpaceWakeProgressInputSchema = strictObject({
+	spaceId: nonEmptyTrimmedStringFromUnknown,
+	clientMessageId: clientMessageIdSchema,
+	targetProfileId: optionalSelectorSchema
+});
+const getSpaceWakeProgressResponseSchema = strictObject({
+	query: strictObject({
+		spaceId: string().trim().min(1),
+		clientMessageId: clientMessageIdSchema,
+		targetProfileId: string().trim().min(1).nullable()
+	}),
+	items: array(wakeProgressItemSchema)
+});
 const startBackgroundHelperInstallStatusSchema = _enum([
 	"not_installed",
 	"installed_current",
@@ -8255,10 +8886,10 @@ const startDeviceAgentCatalogSchema = strictObject({
 });
 const startDeviceProjectionSchema = strictObject({
 	deviceId: START_BOUNDED_ID_SCHEMA,
+	runtimeLane: daemonServiceLaneSchema,
 	observedAt: START_ISO_DATE_TIME_SCHEMA,
 	backgroundHelper: startBackgroundHelperProjectionSchema,
 	skillsReadiness: startSkillsReadinessProjectionSchema,
-	savedAgentRuntime: savedDeviceAgentRuntimeSchema,
 	deviceAgentCatalog: startDeviceAgentCatalogSchema,
 	deviceReplyReadiness: startReplyReadinessSummarySchema
 });
@@ -8287,7 +8918,7 @@ const startNextActionIdSchema = _enum([
 	"sign_in",
 	"identity",
 	"device_check",
-	"agent_selection",
+	"local_agent_preparation",
 	"space_choice",
 	"space_entry"
 ]);
@@ -8298,7 +8929,7 @@ const startPlannerReasonCodeSchema = _enum([
 	"sign_in.required",
 	"identity.required",
 	"device_check.pending",
-	"agent_selection.pending",
+	"local_agent_preparation.pending",
 	"space_choice.pending",
 	"space_entry.pending",
 	"device_projection.missing",
@@ -8312,11 +8943,14 @@ const startPlannerReasonCodeSchema = _enum([
 	"background_helper.not_running",
 	"background_helper.stale",
 	"background_helper.unknown",
+	"device_reply_readiness.blocked",
+	"device_reply_readiness.degraded",
+	"device_reply_readiness.unknown",
 	"skills_readiness.action_required",
 	"skills_readiness.unknown",
-	"selected_agents.not_found",
-	"selected_agents.not_enabled",
-	"selected_agents.not_selectable",
+	"local_agent_preparation.not_found",
+	"local_agent_preparation.not_enabled",
+	"local_agent_preparation.not_selectable",
 	"profile_readiness.route_offline",
 	"profile_readiness.route_unavailable",
 	"profile_readiness.reply_blocked",
@@ -8371,10 +9005,33 @@ const startSessionStepIdSchema = _enum([
 	"sign_in",
 	"identity",
 	"device_check",
-	"agent_selection",
+	"local_agent_preparation",
 	"space_choice",
 	"space_entry"
 ]);
+const startSessionHandoffFailureGateSchema = _enum([
+	"auth",
+	"device",
+	"service",
+	"local_agent",
+	"runtime_report",
+	"binding",
+	"route"
+]);
+const startSessionHandoffFailureRetryActionSchema = _enum([
+	"rerun_prepare",
+	"copy_fresh_command",
+	"change_selection",
+	"start_over"
+]);
+const startSessionHandoffFailureSchema = strictObject({
+	gate: startSessionHandoffFailureGateSchema,
+	reasonCode: START_TRIMMED_NON_EMPTY_STRING_SCHEMA.max(256),
+	localAgentId: union([START_BOUNDED_ID_SCHEMA, _null()]).optional(),
+	profileId: union([START_BOUNDED_ID_SCHEMA, _null()]).optional(),
+	occurredAt: START_ISO_DATE_TIME_SCHEMA,
+	retryAction: startSessionHandoffFailureRetryActionSchema
+});
 const startSessionProgressSchema = strictObject({
 	sessionId: START_BOUNDED_ID_SCHEMA,
 	userId: START_BOUNDED_ID_SCHEMA,
@@ -8383,13 +9040,14 @@ const startSessionProgressSchema = strictObject({
 	currentStepId: startSessionStepIdSchema,
 	completedStepIds: array(startSessionStepIdSchema),
 	profileChoice: startProfileChoiceSchema,
-	agentSelection: startAgentSelectionSchema,
+	localAgentPreparation: startLocalAgentPreparationSchema,
 	spaceMemberSelection: startSpaceMemberSelectionSchema.default({
 		mode: "unresolved",
 		selectedProfileIds: []
 	}),
 	spaceChoice: startSpaceChoiceSchema,
 	targetSpaceId: startTargetSpaceIdSchema,
+	lastFailure: union([startSessionHandoffFailureSchema, _null()]).optional(),
 	startedAt: START_ISO_DATE_TIME_SCHEMA,
 	updatedAt: START_ISO_DATE_TIME_SCHEMA,
 	completedAt: START_NULLABLE_COMPLETION_TIME_SCHEMA
@@ -8537,19 +9195,19 @@ const startSessionRouteParamsSchema = strictObject({ deviceId: START_BOUNDED_ID_
 const createStartSessionBodySchema = strictObject({
 	initiator: startSessionInitiatorSchema,
 	profileChoice: startProfileChoiceSchema,
-	agentSelection: startAgentSelectionSchema,
+	localAgentPreparation: startLocalAgentPreparationSchema,
 	spaceMemberSelection: startSpaceMemberSelectionSchema.optional(),
 	spaceChoice: startSpaceChoiceSchema,
 	writeMode: _enum(["replace", "if_missing"]).optional()
 });
 const patchStartSessionBodySchema = strictObject({
 	profileChoice: startProfileChoiceSchema.optional(),
-	agentSelection: startAgentSelectionSchema.optional(),
+	localAgentPreparation: startLocalAgentPreparationSchema.optional(),
 	spaceMemberSelection: startSpaceMemberSelectionSchema.optional(),
 	spaceChoice: startSpaceChoiceSchema.optional(),
 	targetSpaceId: startTargetSpaceIdSchema.optional()
 }).refine((value) => {
-	return value.profileChoice !== void 0 || value.agentSelection !== void 0 || value.spaceMemberSelection !== void 0 || value.spaceChoice !== void 0 || value.targetSpaceId !== void 0;
+	return value.profileChoice !== void 0 || value.localAgentPreparation !== void 0 || value.spaceMemberSelection !== void 0 || value.spaceChoice !== void 0 || value.targetSpaceId !== void 0;
 }, "at least one start session field must be provided");
 const startSessionResponseSchema = strictObject({ session: startSessionSchema });
 const startSessionWithTokenResponseSchema = strictObject({
@@ -8558,7 +9216,7 @@ const startSessionWithTokenResponseSchema = strictObject({
 });
 const startSessionSpaceChoiceCreateNewBodySchema = strictObject({
 	mode: literal("create_new"),
-	name: string().trim().min(1).max(32),
+	name: spaceNameSchema,
 	password: spacePasswordSchema.optional()
 });
 const startSessionSpaceChoiceJoinExistingBodySchema = strictObject({
@@ -9037,5 +9695,5 @@ function toErrorMessage(error) {
 }
 
 //#endregion
-export { currentDeviceTargetResponseSchema as $, resolveSpaceMentionLabels as $t, SPACE_MEMBER_REMOVE_NOTICE_PURPOSE as A, writeCurrentDeviceBootstrapObservationResponseSchema as An, normalizeBuiltinControllerAgentId as At, atsdTaskResultOpenClawGatewayVisibilityStatusSchema as B, patchStartSessionBodySchema as Bt, DISPATCH_ACTIVITY_DISPATCHING_PURPOSE as C, startSessionSpaceChoiceResponseSchema as Cn, getSpaceDispatchResultResponseSchema as Ct, MAX_PROFILE_WORKING_DIRECTORY_LENGTH as D, upsertProfileSpaceHistoryResponseSchema as Dn, isExplicitBuiltinControllerRef as Dt, LEGACY_RUNTIME_DISPATCH_POLICY as E, structuredGuidePayloadFromInputSchema as En, incomingServerMessageSchema as Et, atsRuntimeProfileIdSchema as F, writeStartObservedDeviceMetadataBodySchema as Fn, ownedDevicesResponseSchema as Ft, canonicalizeControllerRefForKind as G, profileWorkspaceModeSchema as Gt, buildControllerRoutingKeyForKind as H, postNormalMessageResponseSchema as Ht, atsSpaceEgressActionSchema as I, writeStartObservedDeviceMetadataResponseSchema as In, parseOptionalClientMessageId as It, continuitySchema as J, removeSpaceMembersResponseSchema as Jt, catchupResponseSchema as K, providerDispatchRuntimeContextSchema as Kt, atsdControlPlaneRequestSchema as L, writeStartSessionProgressBodySchema as Ln, patchProfileSpaceHistoryStatusResponseSchema as Lt, SPACE_PASSWORD_MIN_LENGTH as M, writeCurrentDeviceObservedMetadataResponseSchema as Mn, normalizeListSignalsReadQuerySemantics as Mt, SPACE_UPDATES_MAX_LIMIT as N, writeStartObservationBodySchema as Nn, normalizeMessageEnvelope as Nt, SPACE_DISPATCH_TRACE_PROMPT_PREVIEW_MAX_CHARS as O, upsertSpaceDeletionTombstoneResponseSchema as On, leaveSpaceResponseSchema as Ot, atsProfileIdSchema as P, writeStartObservationResponseSchema as Pn, normalizeOptionalWorkingDirectory as Pt, createStartSessionBodySchema as Q, resolveSingleSpaceMentionLabels as Qt, atsdControlPlaneResponseSchema as R, writeStartSessionProgressResponseSchema as Rn, patchSpaceContractBodySchema as Rt, DAEMON_HUB_SCHEMA_VERSION as S, startSessionSpaceChoiceBodySchema as Sn, getSpaceDispatchLookupResponseSchema as St, DISPATCH_ACTIVITY_RETRYING_PURPOSE as T, startStateResponseSchema as Tn, getSpaceUpdatesResponseSchema as Tt, buildUpstreamConversationRef as U, postSpaceMembersBodySchema as Ut, atsdTaskResultPayloadSchema as V, postNormalMessageBodySchema as Vt, canonicalizeBuiltinControllerRef as W, postSpaceMembersResponseSchema as Wt, createSpaceBodySchema as X, resolveBuiltinUpstreamConversationRefKind as Xt, conversationExecutionStateSchema as Y, resolveBuiltinProviderConversationCapability as Yt, createSpaceResponseSchema as Z, resolveMessageEnvelopeTargetField as Zt, AGENT_REPLY_PREVIEW_END_PURPOSE as _, spaceMetaSchema as _n, gatewayErrorCodeSchema as _t, runWithHeldLock as a, serverErrorFrameSchema as an, daemonHubHeartbeatResponseSchema as at, ATSD_TASK_RESULT_SCHEMA_VERSION as b, startSessionProgressSchema as bn, getSpaceConversationRemoteStatusResponseSchema as bt, LEGACY_ATS_RUNTIME_SESSION_ENV_KEY as c, signalEnvelopeSchema as cn, daemonHubSubmitTaskResultRequestSchema as ct, resolveRuntimeSession as d, spaceConversationBindingImportResponseSchema as dn, daemonServiceContractSchema as dt, resolveStartHandoffBodySchema as en, daemonHubDeliverDispatchRequestSchema as et, resolveRuntimeSessionId as f, spaceConversationBindingResponseSchema as fn, daemonStreamFrameSchema as ft, AGENT_REPLYING_PURPOSE as g, spaceMembersSnapshotSchema as gn, formatCanonicalMentionLiteral as gt, AGENT_REPLYING_END_PURPOSE as h, spaceDispatchTraceResponseSchema as hn, forgetCurrentComputerResponseSchema as ht, releaseLock as i, sanitizeSignalTextPreview as in, daemonHubHeartbeatRequestSchema as it, SPACE_MENTION_REJECT_NOTICE_PURPOSE as j, writeCurrentDeviceObservedMetadataBodySchema as jn, normalizeBuiltinControllerProviderId as jt, SPACE_MEMBER_JOIN_NOTICE_PURPOSE as k, writeCurrentDeviceBootstrapObservationBodySchema as kn, listProfileSpaceHistoryResponseSchema as kt, listRuntimeSessionStates as l, spaceConversationBindingConflictResponseSchema as ln, daemonRouteObservationResponseSchema as lt, resolveBuiltinAgentControllerBrand as m, spaceCreatorSchema as mn, entryBriefSchema as mt, isAtsLockError as n, runtimeAgentControllerLaunchContractSchema as nn, daemonHubDispatchPreviewEndRequestSchema as nt, tryCleanupStaleLock as o, setCurrentDeviceTargetBodySchema as on, daemonHubRegisterSessionRequestSchema as ot, writeRuntimeSessionState as p, spaceConversationBindingUpsertResponseSchema as pn, dispatchBriefSchema as pt, collectCanonicalMentionTextFragments as q, querySpaceDeletionTombstonesResponseSchema as qt, readLockMeta as r, runtimeAgentControllerSettingsSchema as rn, daemonHubDispatchPreviewRequestSchema as rt, ATS_RUNTIME_SESSION_ENV_KEY as s, setOwnedDeviceDisplayNameBodySchema as sn, daemonHubRegisterSessionResponseSchema as st, acquireLock as t, resolveStartHandoffResponseSchema as tn, daemonHubDispatchLifecycleRequestSchema as tt, readRuntimeSessionState as u, spaceConversationBindingDeleteResponseSchema as un, daemonRuntimeLeaseSchema as ut, AGENT_REPLY_PREVIEW_PURPOSE as v, startDeviceProjectionSchema as vn, gatewayErrorEnvelopeSchema as vt, DISPATCH_ACTIVITY_FAILED_PURPOSE as w, startSessionWithTokenResponseSchema as wn, getSpaceStatusResponseSchema as wt, CONVERSATION_CONTINUITY_WARNING_PURPOSE as x, startSessionResponseSchema as xn, getSpaceConversationStatusResponseSchema as xt, ATSD_CONTROL_PLANE_SCHEMA_VERSION as y, startProfileReadinessSummarySchema as yn, getSpaceContractResponseSchema as yt, atsdTaskResultEnvelopeWriteSchema as z, createDaemonRouteObservationSummary as zn, patchSpaceContractResponseSchema as zt };
-//# sourceMappingURL=lock-BDqdJx3V.js.map
+export { continuitySchema as $, writeStartObservationBodySchema as $n, patchSpaceContractResponseSchema as $t, SPACE_MEMBER_JOIN_NOTICE_PURPOSE as A, spaceCreatorSchema as An, getPrepareReadinessResponseSchema as At, atsdControlPlaneRequestSchema as B, startSessionWithTokenResponseSchema as Bn, incomingServerMessageSchema as Bt, DISPATCH_ACTIVITY_DISPATCHING_PURPOSE as C, setOwnedDeviceDisplayNameBodySchema as Cn, forgetComputerResponseSchema as Ct, MAX_PROFILE_WORKING_DIRECTORY_LENGTH as D, spaceConversationBindingImportResponseSchema as Dn, gatewayErrorEnvelopeSchema as Dt, LEGACY_RUNTIME_DISPATCH_POLICY as E, spaceConversationBindingDeleteResponseSchema as En, gatewayErrorCodeSchema as Et, agentProfileBindingRouteParamsSchema as F, startProfileReadinessSummarySchema as Fn, getSpaceDispatchResultResponseSchema as Ft, buildControllerRoutingKeyForKind as G, submitRuntimeRegistrationBodySchema as Gn, normalizeBuiltinControllerProviderId as Gt, atsdTaskResultEnvelopeWriteSchema as H, structuredGuidePayloadFromInputSchema as Hn, leaveSpaceResponseSchema as Ht, atsProfileIdSchema as I, startSessionProgressSchema as In, getSpaceMessageAddressingRelationSupportForTargetKind as It, canonicalizeControllerRefForKind as J, upsertSpaceDeletionTombstoneResponseSchema as Jn, normalizeOptionalWorkingDirectory as Jt, buildUpstreamConversationRef as K, submitRuntimeRegistrationResponseSchema as Kn, normalizeListSignalsReadQuerySemantics as Kt, atsRequestContextSchema as L, startSessionResponseSchema as Ln, getSpaceStatusResponseSchema as Lt, SPACE_MENTION_REJECT_NOTICE_PURPOSE as M, spaceMembersSnapshotSchema as Mn, getSpaceConversationRemoteStatusResponseSchema as Mt, SPACE_PASSWORD_MIN_LENGTH as N, spaceMetaSchema as Nn, getSpaceConversationStatusResponseSchema as Nt, MESSAGE_MENTION_TYPE_VALUES as O, spaceConversationBindingResponseSchema as On, getAgentProfilePrimaryBindingResponseSchema as Ot, SPACE_UPDATES_MAX_LIMIT as P, startDeviceProjectionSchema as Pn, getSpaceDispatchLookupResponseSchema as Pt, collectCanonicalMentionTextFragments as Q, writeCurrentDeviceObservedMetadataResponseSchema as Qn, patchSpaceContractBodySchema as Qt, atsRuntimeProfileIdSchema as R, startSessionSpaceChoiceBodySchema as Rn, getSpaceUpdatesResponseSchema as Rt, DAEMON_HUB_SCHEMA_VERSION as S, setCurrentDeviceTargetBodySchema as Sn, finalClaimRouteParamsSchema as St, DISPATCH_ACTIVITY_RETRYING_PURPOSE as T, spaceConversationBindingConflictResponseSchema as Tn, formatCanonicalMentionLiteral as Tt, atsdTaskResultOpenClawGatewayVisibilityStatusSchema as U, submitRuntimeCapabilityReportsBodySchema as Un, listProfileSpaceHistoryResponseSchema as Ut, atsdControlPlaneResponseSchema as V, startStateResponseSchema as Vn, isExplicitBuiltinControllerRef as Vt, atsdTaskResultPayloadSchema as W, submitRuntimeCapabilityReportsResponseSchema as Wn, normalizeBuiltinControllerAgentId as Wt, claimExecutionDiagnosticsQuerySchema as X, writeCurrentDeviceBootstrapObservationResponseSchema as Xn, parseOptionalClientMessageId as Xt, catchupResponseSchema as Y, writeCurrentDeviceBootstrapObservationBodySchema as Yn, ownedDevicesResponseSchema as Yt, claimExecutionDiagnosticsResponseSchema as Z, writeCurrentDeviceObservedMetadataBodySchema as Zn, patchProfileSpaceHistoryStatusResponseSchema as Zt, AGENT_REPLY_PREVIEW_END_PURPOSE as _, resolveStartHandoffResponseSchema as _n, daemonStreamFrameSchema as _t, runWithHeldLock as a, profileWorkspaceModeSchema as an, createDaemonRouteObservationSummary as ar, daemonHubDeliverDispatchRequestSchema as at, ATSD_TASK_RESULT_SCHEMA_VERSION as b, sanitizeSignalTextPreview as bn, ensureAgentProfilePrimaryBindingResponseSchema as bt, LEGACY_ATS_RUNTIME_SESSION_ENV_KEY as c, removeSpaceMembersResponseSchema as cn, daemonHubDispatchPreviewRequestSchema as ct, resolveRuntimeSession as d, resolveBuiltinProviderConversationCapability as dn, daemonHubRegisterSessionRequestSchema as dt, patchStartSessionBodySchema as en, writeStartObservationResponseSchema as er, conversationExecutionStateSchema as et, resolveRuntimeSessionId as f, resolveBuiltinUpstreamConversationRefKind as fn, daemonHubRegisterSessionResponseSchema as ft, AGENT_REPLYING_PURPOSE as g, resolveStartHandoffBodySchema as gn, daemonServiceContractSchema as gt, AGENT_REPLYING_END_PURPOSE as h, resolveSpaceMentionLabels as hn, daemonRuntimeLeaseSchema as ht, releaseLock as i, postSpaceMembersResponseSchema as in, writeStartSessionProgressResponseSchema as ir, currentDeviceTargetResponseSchema as it, SPACE_MEMBER_REMOVE_NOTICE_PURPOSE as j, spaceDispatchTraceResponseSchema as jn, getSpaceContractResponseSchema as jt, SPACE_DISPATCH_TRACE_PROMPT_PREVIEW_MAX_CHARS as k, spaceConversationBindingUpsertResponseSchema as kn, getPrepareReadinessQuerySchema as kt, listRuntimeSessionStates as l, reserveFinalClaimBodySchema as ln, daemonHubHeartbeatRequestSchema as lt, resolveBuiltinAgentControllerBrand as m, resolveSingleSpaceMentionLabels as mn, daemonRouteObservationResponseSchema as mt, isAtsLockError as n, postNormalMessageResponseSchema as nn, writeStartObservedDeviceMetadataResponseSchema as nr, createSpaceResponseSchema as nt, tryCleanupStaleLock as o, providerDispatchRuntimeContextSchema as on, daemonHubDispatchLifecycleRequestSchema as ot, writeRuntimeSessionState as p, resolveMessageEnvelopeTargetField as pn, daemonHubSubmitTaskResultRequestSchema as pt, canonicalizeBuiltinControllerRef as q, upsertProfileSpaceHistoryResponseSchema as qn, normalizeMessageEnvelope as qt, readLockMeta as r, postSpaceMembersBodySchema as rn, writeStartSessionProgressBodySchema as rr, createStartSessionBodySchema as rt, ATS_RUNTIME_SESSION_ENV_KEY as s, querySpaceDeletionTombstonesResponseSchema as sn, daemonHubDispatchPreviewEndRequestSchema as st, acquireLock as t, postNormalMessageBodySchema as tn, writeStartObservedDeviceMetadataBodySchema as tr, createSpaceBodySchema as tt, readRuntimeSessionState as u, reserveFinalClaimResponseSchema as un, daemonHubHeartbeatResponseSchema as ut, AGENT_REPLY_PREVIEW_PURPOSE as v, runtimeAgentControllerLaunchContractSchema as vn, dispatchBriefSchema as vt, DISPATCH_ACTIVITY_FAILED_PURPOSE as w, signalEnvelopeSchema as wn, forgetCurrentComputerResponseSchema as wt, CONVERSATION_CONTINUITY_WARNING_PURPOSE as x, serverErrorFrameSchema as xn, entryBriefSchema as xt, ATSD_CONTROL_PLANE_SCHEMA_VERSION as y, runtimeAgentControllerSettingsSchema as yn, ensureAgentProfilePrimaryBindingBodySchema as yt, atsSpaceEgressActionSchema as z, startSessionSpaceChoiceResponseSchema as zn, getSpaceWakeProgressResponseSchema as zt };
+//# sourceMappingURL=lock-pvOz4vGl.js.map