agent-transport-system 0.3.2 → 0.3.3

package/dist/ats.js

@@ -24,11 +24,11 @@ import wrapAnsi from "wrap-ansi";
 import { Box, Container, Editor, Key, ProcessTerminal, TUI, Text, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
 
 //#region package.json
-var version$1 = "0.3.2";
+var version$1 = "0.3.3";
 var package_default = {
 	name: "agent-transport-system",
 	version: version$1,
-	atsReleaseDate: "2026-04-16",
+	atsReleaseDate: "2026-04-17",
 	description: "Agent Transport System CLI - https://ats.sh",
 	license: "MIT",
 	type: "module",
@@ -28220,7 +28220,28 @@ function resolveBootstrapCommandUnavailableSummary(message) {
 
 //#endregion
 //#region src/system/reply-readiness.ts
-const REPLY_READINESS_REASON_PRIORITY = [...REPLY_READINESS_REASON_CODE_VALUES];
+const REPLY_READINESS_REASON_PRIORITY = [
+	"profile.inactive",
+	"profile.unbound",
+	"controller.binding.disabled",
+	"projection.missing",
+	"controller.registry.disabled",
+	"controller.launch.choice_required",
+	"controller.launch.needs_repair",
+	"workspace.missing",
+	"workspace.invalid",
+	"runtime.adapter.unsupported",
+	"controller.bootstrap.failed",
+	"controller.gateway.unhealthy",
+	"service.not_installed",
+	"service.drifted",
+	"service.not_running",
+	"dispatch.storage_not_ready",
+	"service.gateway_chain_unhealthy",
+	"local_agents.none_needed",
+	"route.offline",
+	"route.not_registered"
+];
 const MANUAL_SPACE_PARTICIPATION_REASON = "You can still join the space and send messages yourself";
 async function resolveDeviceReplyReadinessStatus(input = {}) {
 	const status = input.status ?? await getDaemonStatus();
@@ -47467,7 +47488,10 @@ async function runDaemon(input) {
 		return;
 	}
 	if (canUseInteractivePrompts(runtime)) {
-		await runInteractiveDaemonMenu({ view: runtime.resolvedView });
+		await runInteractiveDaemonMenu({
+			gatewayUrl: input.gatewayUrl,
+			view: runtime.resolvedView
+		});
 		return;
 	}
 	presenter.line({
@@ -48693,6 +48717,7 @@ async function runDaemonStatusFlow(input, options = {}) {
 	await runDaemonStatus(input);
 	if (!(options.offerStartPrompt && interactiveHuman)) return "completed";
 	return await maybeOfferDaemonStartAfterStatus({
+		gatewayUrl: input.gatewayUrl,
 		view: "human",
 		ownerUserId
 	});
@@ -49855,6 +49880,7 @@ async function runDaemonBackgroundStartForDecision(input) {
 	const previousExitCode = process.exitCode;
 	const result = await runDaemonRun({
 		agentOverviewHandled: true,
+		gatewayUrl: input.gatewayUrl,
 		mode: "background",
 		view: input.view
 	});
@@ -50937,7 +50963,10 @@ async function handleInteractiveDaemonMenuChoice(input, choice) {
 	}
 	if (choice === DAEMON_MENU_CHOICE.reinstall) {
 		const result = await runDaemonReinstall(input, { suppressInstallOutput: true });
-		if (isDaemonReinstallCompletedAndStopped(result)) return await maybeOfferDaemonStartAfterStatus({ view: input.view }) === "cancelled";
+		if (isDaemonReinstallCompletedAndStopped(result)) return await maybeOfferDaemonStartAfterStatus({
+			gatewayUrl: input.gatewayUrl,
+			view: input.view
+		}) === "cancelled";
 		return result.result === "cancelled";
 	}
 	return await runDaemonUninstall(input) === "cancelled";
@@ -50948,7 +50977,10 @@ async function maybeOfferDaemonStartAfterStatus(input) {
 		localDemand: input.localDemand
 	})).offerStartPrompt) return "completed";
 	const presenter = createPresenter(await resolveRuntimeContext({ view: input.view }));
-	const decision = await runDaemonStartDecisionPrompt({ startService: async () => await runDaemonBackgroundStartForDecision({ view: input.view }) });
+	const decision = await runDaemonStartDecisionPrompt({ startService: async () => await runDaemonBackgroundStartForDecision({
+		gatewayUrl: input.gatewayUrl,
+		view: input.view
+	}) });
 	if (decision === "cancelled") return "cancelled";
 	if (decision === "deferred_with_card") return "completed";
 	if (decision === "not_now") {
@@ -51363,12 +51395,18 @@ async function runDaemonServiceParticipationInstallStage(input) {
 	return { status: refreshedStatus };
 }
 async function runDaemonServiceParticipationActionStage(input) {
-	if (input.status.kind === "needs_repair") return mapDaemonBackgroundStartResult(await runDaemonBackgroundStartForDecision({ view: input.input.view }), {
+	if (input.status.kind === "needs_repair") return mapDaemonBackgroundStartResult(await runDaemonBackgroundStartForDecision({
+		gatewayUrl: input.input.gatewayUrl,
+		view: input.input.view
+	}), {
 		presenter: input.input.presenter,
 		codePrefix: input.codePrefix
 	});
 	if (input.status.kind !== "not_running") return { status: "aligned" };
-	return mapDaemonBackgroundStartResult(await runDaemonStartDecisionPrompt({ startService: async () => await runDaemonBackgroundStartForDecision({ view: input.input.view }) }), {
+	return mapDaemonBackgroundStartResult(await runDaemonStartDecisionPrompt({ startService: async () => await runDaemonBackgroundStartForDecision({
+		gatewayUrl: input.input.gatewayUrl,
+		view: input.input.view
+	}) }), {
 		presenter: input.input.presenter,
 		codePrefix: input.codePrefix
 	});
@@ -51495,7 +51533,10 @@ async function runServiceCheck(input) {
 		return { status: "cancelled" };
 	}
 	if (selected === CONTINUE_WITHOUT_SERVICE) return { status: "continue" };
-	if (!await fixServiceStatus(serviceStatus)) return { status: "continue" };
+	if (!await fixServiceStatus({
+		gatewayUrl: input.context.gatewayUrl,
+		serviceStatus
+	})) return { status: "continue" };
 	return { status: "continue" };
 }
 async function resolveServiceStatus(input) {
@@ -51549,16 +51590,16 @@ async function resolveServiceStatus(input) {
 		};
 	});
 }
-async function fixServiceStatus(serviceStatus) {
+async function fixServiceStatus(input) {
 	const expectedVersion = resolveCurrentDaemonExpectedVersion();
-	if (serviceStatus.kind === "missing") {
+	if (input.serviceStatus.kind === "missing") {
 		await ensureDaemonInstalledForCliStartup({
 			daemonVersion: expectedVersion,
 			mode: "always"
 		});
 		return true;
 	}
-	if (serviceStatus.kind === "outdated") {
+	if (input.serviceStatus.kind === "outdated") {
 		const daemonStatus = await getDaemonStatus();
 		await ensureDaemonVersionForCliStartup({
 			daemonVersion: expectedVersion,
@@ -51567,9 +51608,15 @@ async function fixServiceStatus(serviceStatus) {
 		});
 		return true;
 	}
-	if (serviceStatus.kind === "not_running") return await runDaemonBackgroundStartForDecision({ view: "human" }) === "started";
-	if (serviceStatus.kind === "needs_repair") return await runDaemonBackgroundStartForDecision({ view: "human" }) === "started";
-	if (serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") {
+	if (input.serviceStatus.kind === "not_running") return await runDaemonBackgroundStartForDecision({
+		gatewayUrl: input.gatewayUrl ?? void 0,
+		view: "human"
+	}) === "started";
+	if (input.serviceStatus.kind === "needs_repair") return await runDaemonBackgroundStartForDecision({
+		gatewayUrl: input.gatewayUrl ?? void 0,
+		view: "human"
+	}) === "started";
+	if (input.serviceStatus.kind === "repair_blocked" || input.serviceStatus.kind === "repair_failed") {
 		await runDaemonStatusSafely();
 		return false;
 	}
@@ -60988,7 +61035,9 @@ function buildReplyReadinessNextSteps(input) {
 			formatAtsCliCommand("ats service run")
 		];
 		case "profile.inactive": return [formatAtsCliCommand("ats profile list"), formatAtsCliCommand("ats profile set <agent-profile-id>")];
-		case "profile.unbound": return [formatAtsCliCommand(`ats profile update ${profileId} --controller-kind builtin --controller-ref ${controllerRef ?? "<controller-ref>"} --controller-enabled true`), formatAtsCliCommand(`ats space join <space-id> --profile ${profileId}`)];
+		case "profile.unbound":
+			if (controllerRef) return [formatAtsCliCommand(`ats profile update ${profileId} --controller-kind builtin --controller-ref ${controllerRef} --controller-enabled true`), formatAtsCliCommand(`ats space join <space-id> --profile ${profileId}`)];
+			return [formatAtsCliCommand("ats start"), formatAtsCliCommand("ats agents list")];
 		case "controller.binding.disabled": return [formatAtsCliCommand(`ats profile update ${profileId} --controller-enabled true`)];
 		case "projection.missing": return [formatAtsCliCommand("ats doctor --repair")];
 		case "controller.registry.disabled": return [formatAtsCliCommand(`ats agents enable --agent ${agentCommandId}`), formatAtsCliCommand("ats doctor --repair")];
@@ -64257,41 +64306,20 @@ async function runStartSkillsStep(input) {
 	}
 }
 async function runStartAgentsStep(input) {
-	const builtinCandidates = (await listStartLocalBuiltinAgentCandidates()).sort(compareStartAgentCandidates);
-	const selectableCandidates = builtinCandidates.filter((candidate) => candidate.selectable);
-	const payload = buildStartAgentsPayload({
-		builtinCandidates,
-		selectableCandidates
-	});
-	const onboardingState = await getConfiguredStartV1OnboardingState().catch(() => null);
-	const preconfiguredAgentSelection = resolvePreconfiguredStartAgentSelection({
-		builtinCandidates,
-		localAgentsSetupCompleted: typeof onboardingState?.localAgentsSetupCompletedAt === "string" && onboardingState.localAgentsSetupCompletedAt.length > 0,
-		selectableCandidates
-	});
+	const agentSelectionState = await resolveStartAgentSelectionState();
 	if (input.runtime.resolvedView === "agent") {
 		input.presenter.data({
 			code: "start.agents",
-			payload
+			payload: agentSelectionState.payload
+		});
+		return createStartAgentsStepResult(agentSelectionState.preconfiguredAgentSelection ?? {
+			mode: "unresolved",
+			selectedAgentIds: []
 		});
-		if (preconfiguredAgentSelection) return {
-			agentSelection: preconfiguredAgentSelection,
-			allowBackFromProfile: false
-		};
-		return {
-			agentSelection: {
-				mode: "unresolved",
-				selectedAgentIds: []
-			},
-			allowBackFromProfile: false
-		};
 	}
-	if (preconfiguredAgentSelection) return {
-		agentSelection: preconfiguredAgentSelection,
-		allowBackFromProfile: false
-	};
+	if (agentSelectionState.preconfiguredAgentSelection) return createStartAgentsStepResult(agentSelectionState.preconfiguredAgentSelection);
 	if (!input.interactive) {
-		if (selectableCandidates.length > 0) input.presenter.line({
+		if (agentSelectionState.selectableCandidates.length > 0) input.presenter.line({
 			code: "start.agents.non_interactive",
 			text: formatInlineAtsCliCommands("⚠️ Agent selection still needs a decision. Run `ats start` interactively or use `ats agents enable --all`, `ats agents enable --agent <id...>`, or `ats agents enable --agent <id> --install <install-id>` before continuing.")
 		});
@@ -64303,69 +64331,135 @@ async function runStartAgentsStep(input) {
 			allowBackFromProfile: false
 		};
 	}
+	return await runInteractiveStartAgentsSelectionLoop({
+		builtinCandidates: agentSelectionState.builtinCandidates,
+		profile: input.profile,
+		presenter: input.presenter,
+		view: input.view
+	});
+}
+async function resolveStartAgentSelectionState() {
+	const builtinCandidates = (await listStartLocalBuiltinAgentCandidates()).sort(compareStartAgentCandidates);
+	const selectableCandidates = builtinCandidates.filter((candidate) => candidate.selectable);
+	const onboardingState = await getConfiguredStartV1OnboardingState().catch(() => null);
+	const localAgentsSetupCompleted = typeof onboardingState?.localAgentsSetupCompletedAt === "string" && onboardingState.localAgentsSetupCompletedAt.length > 0;
+	return {
+		builtinCandidates,
+		selectableCandidates,
+		payload: buildStartAgentsPayload({
+			builtinCandidates,
+			selectableCandidates
+		}),
+		preconfiguredAgentSelection: resolvePreconfiguredStartAgentSelection({
+			builtinCandidates,
+			localAgentsSetupCompleted,
+			selectableCandidates
+		})
+	};
+}
+function createStartAgentsStepResult(agentSelection, allowBackFromProfile = false) {
+	return {
+		agentSelection,
+		allowBackFromProfile
+	};
+}
+async function runInteractiveStartAgentsSelectionLoop(input) {
 	for (;;) {
 		const localAgentDecision = await promptStartLocalAgentDecision();
 		if (localAgentDecision === "cancelled" || localAgentDecision === "exit") {
 			cancel("Cancelled.");
 			return "cancelled";
 		}
-		if (localAgentDecision === "no_agents") {
-			await syncStartLocalAgentSelection({
-				builtinCandidates,
-				selectedAgentIds: [],
-				profile: input.profile,
-				view: input.view
+		if (localAgentDecision === "no_agents") return await completeStartLocalAgentSelection({
+			builtinCandidates: input.builtinCandidates,
+			profile: input.profile,
+			presenter: input.presenter,
+			selectedAgentIds: [],
+			view: input.view
+		});
+		const repairedBuiltinCandidates = await maybeRepairStartLocalAgentsBeforeSelection({
+			builtinCandidates: input.builtinCandidates,
+			profile: input.profile,
+			view: input.view
+		});
+		if (repairedBuiltinCandidates === "cancelled") {
+			cancel("Cancelled.");
+			return "cancelled";
+		}
+		if (repairedBuiltinCandidates.filter((candidate) => candidate.selectable).length === 0) {
+			input.presenter.line({
+				code: "start.agents.none_ready_after_repair",
+				text: formatInlineAtsCliCommands("No local agents are ready to use on this device yet. Repair one with `ats agents repair --agent <id>` or keep local agents off for now.")
 			});
-			await persistStartLocalAgentsSetupCompleted();
-			emitStartLocalAgentsSetupSaved(input.presenter);
-			return {
-				agentSelection: {
-					mode: "no_agents",
-					selectedAgentIds: []
-				},
-				allowBackFromProfile: true
-			};
+			continue;
 		}
-		const selectedAgentIds = await promptStartAgentSelection(builtinCandidates);
+		const selectedAgentIds = await promptStartAgentSelection(repairedBuiltinCandidates);
 		if (selectedAgentIds === "cancelled") {
 			cancel("Cancelled.");
 			return "cancelled";
 		}
 		if (selectedAgentIds === "back") continue;
-		if (selectedAgentIds.length === 0) {
-			await syncStartLocalAgentSelection({
-				builtinCandidates,
-				selectedAgentIds,
-				profile: input.profile,
-				view: input.view
-			});
-			await persistStartLocalAgentsSetupCompleted();
-			emitStartLocalAgentsSetupSaved(input.presenter);
-			return {
-				agentSelection: {
-					mode: "no_agents",
-					selectedAgentIds: []
-				},
-				allowBackFromProfile: true
-			};
-		}
-		await syncStartLocalAgentSelection({
-			builtinCandidates,
-			selectedAgentIds,
+		if (selectedAgentIds.length === 0) return await completeStartLocalAgentSelection({
+			builtinCandidates: input.builtinCandidates,
 			profile: input.profile,
+			presenter: input.presenter,
+			selectedAgentIds: [],
+			view: input.view
+		});
+		return await completeStartLocalAgentSelection({
+			builtinCandidates: repairedBuiltinCandidates,
+			profile: input.profile,
+			presenter: input.presenter,
+			selectedAgentIds,
 			view: input.view
 		});
-		await persistStartLocalAgentsSetupCompleted();
-		emitStartLocalAgentsSetupSaved(input.presenter);
-		return {
-			agentSelection: {
-				mode: "selected_agents",
-				selectedAgentIds
-			},
-			allowBackFromProfile: true
-		};
 	}
 }
+async function completeStartLocalAgentSelection(input) {
+	await syncStartLocalAgentSelection({
+		builtinCandidates: input.builtinCandidates,
+		selectedAgentIds: input.selectedAgentIds,
+		profile: input.profile,
+		view: input.view
+	});
+	await persistStartLocalAgentsSetupCompleted();
+	emitStartLocalAgentsSetupSaved(input.presenter);
+	return createStartAgentsStepResult(input.selectedAgentIds.length === 0 ? {
+		mode: "no_agents",
+		selectedAgentIds: []
+	} : {
+		mode: "selected_agents",
+		selectedAgentIds: [...input.selectedAgentIds]
+	}, true);
+}
+async function maybeRepairStartLocalAgentsBeforeSelection(input) {
+	const repairableCandidates = input.builtinCandidates.filter((candidate) => candidate.detected && !candidate.selectable && candidate.selectableReason === "needs_repair");
+	if (repairableCandidates.length === 0) return input.builtinCandidates;
+	const repairDecision = await select({
+		message: buildStartLocalAgentRepairPromptMessage(repairableCandidates),
+		initialValue: "repair_now",
+		options: [{
+			value: "repair_now",
+			label: "Repair now"
+		}, {
+			value: "skip_for_now",
+			label: "Skip for now"
+		}]
+	});
+	if (isCancel(repairDecision)) return "cancelled";
+	if (repairDecision !== "repair_now") return input.builtinCandidates;
+	await runAgentsRepair({
+		agent: repairableCandidates.map((candidate) => candidate.agentId),
+		profile: input.profile,
+		view: input.view
+	});
+	return await listStartLocalBuiltinAgentCandidates();
+}
+function buildStartLocalAgentRepairPromptMessage(candidates) {
+	const displayNames = candidates.map((candidate) => candidate.displayName);
+	if (displayNames.length === 1) return `${displayNames[0]} needs repair on this device before ATS can use it. Repair it now?`;
+	return `${displayNames.join(", ")} need repair on this device before ATS can use them. Repair them now?`;
+}
 function buildStartAgentsPayload(input) {
 	return {
 		candidates: input.builtinCandidates.map((candidate) => ({
@@ -64397,11 +64491,17 @@ function resolveSavedStartAgentSelection(selectableCandidates) {
 	};
 }
 function resolvePreconfiguredStartAgentSelection(input) {
-	if (input.builtinCandidates.length === 0 || input.selectableCandidates.length === 0) return {
+	const hasRepairableCandidates = input.builtinCandidates.some((candidate) => candidate.detected && !candidate.selectable && candidate.selectableReason === "needs_repair");
+	if (input.builtinCandidates.length === 0) return {
 		mode: "no_agents",
 		selectedAgentIds: []
 	};
+	if (input.selectableCandidates.length === 0 && hasRepairableCandidates) return null;
 	if (!input.localAgentsSetupCompleted) return null;
+	if (input.selectableCandidates.length === 0) return {
+		mode: "no_agents",
+		selectedAgentIds: []
+	};
 	return resolveSavedStartAgentSelection([...input.selectableCandidates]);
 }
 async function persistStartLocalAgentsSetupCompleted() {
@@ -64733,6 +64833,7 @@ async function runStartServiceStep(input) {
 		presenter: input.presenter,
 		resolvedView: input.runtime.resolvedView,
 		allowPrompt: input.interactive,
+		gatewayUrl: input.gatewayUrl,
 		localDemand,
 		forcePrompt: selectedLocalAgentsRequireService || currentProfileIsExplicitLocalAgent,
 		view: input.view
@@ -64882,6 +64983,7 @@ async function runStartHandoff(input) {
 		const serviceStepResult = await runHandoffLocalStepWithFailedProgressSync({
 			run: async () => await runStartServiceStep({
 				foundation,
+				gatewayUrl,
 				runtime: input.runtime,
 				presenter: input.presenter,
 				interactive: true,
@@ -79622,6 +79724,26 @@ const LOCAL_SERVICE_ONLY_JOIN_BLOCK_REASON_CODES = new Set([
 	"service.not_installed",
 	"service.not_running"
 ]);
+const LOCAL_PARTICIPATION_ONLY_JOIN_BLOCK_REASON_CODES = new Set([
+	"service.not_installed",
+	"service.drifted",
+	"service.not_running",
+	"dispatch.storage_not_ready",
+	"service.gateway_chain_unhealthy",
+	"profile.unbound",
+	"controller.binding.disabled",
+	"projection.missing",
+	"controller.registry.disabled",
+	"controller.launch.choice_required",
+	"controller.launch.needs_repair",
+	"workspace.missing",
+	"workspace.invalid",
+	"runtime.adapter.unsupported",
+	"controller.bootstrap.failed",
+	"controller.gateway.unhealthy",
+	"route.offline",
+	"route.not_registered"
+]);
 async function prepareSpaceJoinEntryContext(input) {
 	const runtime = await resolveRuntimeContext({
 		profile: input.profile,
@@ -79724,19 +79846,18 @@ async function prepareSpaceJoinServiceState(input) {
 	};
 }
 async function assertSpaceJoinTargetPreflightReady(input) {
-	const serviceRequirement = input.resolvedView === "human" ? resolveCliServiceParticipationRequirement({
-		intent: input.serviceIntent ?? "space_join",
-		humanOnlyParticipation: !isExplicitLocalAgentProfile(input.atsProfile) && input.localDemand?.decision !== "keep_running",
-		explicitSelectedLocalAgents: isExplicitLocalAgentProfile(input.atsProfile),
-		selectedAgentProfilesHaveRunnableLocalSetup: hasRunnableLocalAgentSetup(input.atsProfile),
-		localDemand: input.localDemand ?? null
-	}) : "not_needed";
+	const { explicitLocalAgentProfile, serviceRequirement } = resolveSpaceJoinLocalParticipationState(input);
+	let emittedMembershipOnlyGuidance = false;
+	let emittedServiceGuidance = false;
 	if (serviceRequirement === "agent_setup_needed") {
 		input.presenter.line({
-			code: "space.join.agent_setup_needed",
-			text: `Finish local agent setup before you bring this profile into a space. Use \`ats profile ready --profile ${input.atsProfile.atsProfileId}\` or rerun \`ats start\`.`
+			code: "space.join.local_participation.pending",
+			text: buildSpaceJoinMembershipOnlyMessage({
+				atsProfile: input.atsProfile,
+				reasonCodes: ["profile.unbound"]
+			})
 		});
-		return "cancelled";
+		emittedMembershipOnlyGuidance = true;
 	}
 	const shouldManageServiceParticipation = serviceRequirement === "offer_service_gate";
 	const runPreflight = async () => await emitSpaceCommandPreflight({
@@ -79749,12 +79870,14 @@ async function assertSpaceJoinTargetPreflightReady(input) {
 	});
 	let preflight = await runPreflight();
 	if (shouldManageServiceParticipation) {
-		const gateResult = await runDaemonServiceParticipationGate({
-			intent: input.serviceIntent ?? "space_join",
+		const gateResult = await runSpaceJoinServiceParticipationGate({
+			allowPrompt: input.allowPrompt,
+			explicitLocalAgentProfile,
+			gatewayUrl: input.baseUrl,
+			localDemand: input.localDemand,
 			presenter: input.presenter,
 			resolvedView: input.resolvedView,
-			allowPrompt: input.allowPrompt ?? true,
-			localDemand: input.localDemand ?? null,
+			serviceIntent: input.serviceIntent,
 			view: input.view
 		});
 		if (gateResult.status === "cancelled") return "cancelled";
@@ -79767,24 +79890,90 @@ async function assertSpaceJoinTargetPreflightReady(input) {
 			humanServiceGuidanceMode: "suppress",
 			emitOutput: false
 		});
-		if (gateResult.status === "declined") input.presenter.line({
-			code: "space.join.service.declined",
-			text: "ATS will continue joining this space without wakeable local agent participation on this device. To enable background replies later, rerun `ats start` or use `ats service install` and `ats service run`."
+		if (gateResult.status === "declined") {
+			input.presenter.line({
+				code: "space.join.service.declined",
+				text: "ATS will continue joining this space without wakeable local agent participation on this device. To enable background replies later, rerun `ats start` or use `ats service install` and `ats service run`."
+			});
+			emittedServiceGuidance = true;
+		}
+	}
+	const blockedJoinResult = handleBlockedSpaceJoinLocalParticipation({
+		atsProfile: input.atsProfile,
+		explicitLocalAgentProfile,
+		preflight,
+		presenter: input.presenter,
+		serviceRequirement,
+		emittedMembershipOnlyGuidance,
+		emittedServiceGuidance
+	});
+	if (blockedJoinResult) return blockedJoinResult;
+	if (preflight.deviceReplyReadiness.replyReadiness === "blocked") throw new Error(preflight.deviceReplyReadiness.reasonText);
+	return "continue";
+}
+function resolveSpaceJoinLocalParticipationState(input) {
+	const explicitLocalAgentProfile = isExplicitLocalAgentProfile(input.atsProfile);
+	return {
+		explicitLocalAgentProfile,
+		serviceRequirement: resolveCliServiceParticipationRequirement({
+			intent: input.serviceIntent ?? "space_join",
+			humanOnlyParticipation: !explicitLocalAgentProfile && input.localDemand?.decision !== "keep_running",
+			explicitSelectedLocalAgents: explicitLocalAgentProfile,
+			selectedAgentProfilesHaveRunnableLocalSetup: hasRunnableLocalAgentSetup(input.atsProfile),
+			localDemand: input.localDemand ?? null
+		})
+	};
+}
+async function runSpaceJoinServiceParticipationGate(input) {
+	return await runDaemonServiceParticipationGate({
+		intent: input.serviceIntent ?? "space_join",
+		presenter: input.presenter,
+		resolvedView: input.resolvedView,
+		allowPrompt: input.allowPrompt ?? true,
+		gatewayUrl: input.gatewayUrl,
+		localDemand: input.localDemand ?? null,
+		forcePrompt: input.explicitLocalAgentProfile,
+		view: input.view
+	});
+}
+function handleBlockedSpaceJoinLocalParticipation(input) {
+	if (input.preflight.deviceReplyReadiness.replyReadiness !== "blocked" || !isBlockingLocalParticipationJoinAttention(input.preflight)) return null;
+	if (input.explicitLocalAgentProfile) {
+		if (!input.emittedMembershipOnlyGuidance) input.presenter.line({
+			code: "space.join.local_participation.pending",
+			text: buildSpaceJoinMembershipOnlyMessage({
+				atsProfile: input.atsProfile,
+				reasonCodes: input.preflight.deviceReplyReadiness.reasonCodes
+			})
 		});
+		return "continue";
 	}
-	if (preflight.deviceReplyReadiness.replyReadiness === "blocked" && (shouldManageServiceParticipation || serviceRequirement === "not_needed") && isBlockingLocalServiceJoinAttention(preflight)) {
-		if (serviceRequirement === "not_needed") input.presenter.line({
+	if (input.serviceRequirement === "not_needed") {
+		input.presenter.line({
 			code: "space.join.service.not_needed",
 			text: "ATS will keep joining this space without wakeable local agent participation on this device. If you decide to bring local agents later, rerun `ats start` or use `ats service install` and `ats service run`."
 		});
 		return "continue";
 	}
-	if (preflight.deviceReplyReadiness.replyReadiness === "blocked") throw new Error(preflight.deviceReplyReadiness.reasonText);
+	if (!input.emittedServiceGuidance) input.presenter.line({
+		code: "space.join.service.pending",
+		text: "ATS will keep joining this space without wakeable local agent participation on this device until ATS Service is ready. To enable background replies later, rerun `ats start` or use `ats service install` and `ats service run`."
+	});
 	return "continue";
 }
-function isBlockingLocalServiceJoinAttention(preflight) {
+function isBlockingLocalParticipationJoinAttention(preflight) {
 	const { deviceReplyReadiness } = preflight;
-	return deviceReplyReadiness.replyReadiness === "blocked" && deviceReplyReadiness.reasonCodes.length > 0 && deviceReplyReadiness.reasonCodes.every((reasonCode) => LOCAL_SERVICE_ONLY_JOIN_BLOCK_REASON_CODES.has(reasonCode));
+	return deviceReplyReadiness.replyReadiness === "blocked" && deviceReplyReadiness.reasonCodes.length > 0 && deviceReplyReadiness.reasonCodes.every((reasonCode) => LOCAL_PARTICIPATION_ONLY_JOIN_BLOCK_REASON_CODES.has(reasonCode));
+}
+function buildSpaceJoinMembershipOnlyMessage(input) {
+	const profileName = input.atsProfile.profileName;
+	const profileId = input.atsProfile.atsProfileId;
+	const reasonCodes = input.reasonCodes;
+	const setupCommand = `ats profile ready --profile ${profileId}`;
+	if (reasonCodes.includes("profile.unbound")) return `${profileName} will join this space, but it is not connected to a local agent on this device yet. It can appear here now, but it will not wake or reply from this device until you finish setup. Use \`${setupCommand}\` or rerun \`ats start\`.`;
+	if (reasonCodes.some((reasonCode) => LOCAL_SERVICE_ONLY_JOIN_BLOCK_REASON_CODES.has(reasonCode)) || reasonCodes.includes("dispatch.storage_not_ready") || reasonCodes.includes("service.gateway_chain_unhealthy") || reasonCodes.includes("route.offline") || reasonCodes.includes("route.not_registered")) return `${profileName} will join this space, but it will not wake or reply from this device until ATS Service is ready. Use \`ats service install\`, \`ats service run\`, or rerun \`ats start\`.`;
+	if (reasonCodes.includes("controller.launch.needs_repair") || reasonCodes.includes("controller.launch.choice_required") || reasonCodes.includes("workspace.missing") || reasonCodes.includes("workspace.invalid")) return `${profileName} will join this space, but it is not ready to wake or reply from this device yet. Use \`${setupCommand}\` or rerun \`ats start\`.`;
+	return `${profileName} will join this space, but local setup on this device is still incomplete. It can appear here now, but it will not wake or reply from this device until you finish setup. Use \`${setupCommand}\` or rerun \`ats start\`.`;
 }
 function buildJoinTargetMissingMessage(input) {
 	return formatMessage(input.resolvedView, "space.target.missing", { command: "join" });
@@ -80144,7 +80333,7 @@ function resolveSpaceJoinMembershipProfileKind(value) {
 	return value === "human" || value === "agent" ? value : null;
 }
 function normalizeOptionalString$2(value) {
-	return typeof value === "string" ? value : null;
+	return typeof value === "string" ? value : void 0;
 }
 function buildLocallyCreatedPendingSpaceJoinMembershipCandidate(profile) {
 	return {
@@ -80153,8 +80342,8 @@ function buildLocallyCreatedPendingSpaceJoinMembershipCandidate(profile) {
 		profileName: profile.profileName,
 		profileKind: profile.profileKind === "agent" ? "agent" : "human",
 		ownerUserId: profile.ownerUserId,
-		ownerName: typeof profile.ownerName === "string" ? profile.ownerName : null,
-		controllerRef: profile.controllerBinding?.controllerRef ?? null,
+		ownerName: typeof profile.ownerName === "string" ? profile.ownerName : void 0,
+		controllerRef: profile.controllerBinding?.controllerRef,
 		controllerEnabled: profile.controllerBinding?.controllerEnabled === true,
 		alreadyJoined: false,
 		needsActivation: false
@@ -80367,15 +80556,16 @@ async function applySelectedSpaceAddMembersBeforeJoin(input, dependencies) {
 		});
 	}
 	if (confirmedCandidates.candidates.length === 0) return "completed";
-	if (await dependencies.prepareSpaceMemberCandidatesLocalParticipation({
+	const servicePreparationResult = await dependencies.prepareSpaceMemberCandidatesLocalParticipation({
 		actorProfile: input.actorProfile,
 		candidates: confirmedCandidates.candidates,
 		presenter: input.presenter,
 		resolvedView: input.resolvedView
-	}) === "cancelled") return input.cancelResult;
+	});
+	if (servicePreparationResult.status === "cancelled") return input.cancelResult;
 	const result = await dependencies.applySpaceAddMembers({
 		actorProfile: input.actorProfile,
-		candidates: confirmedCandidates.candidates,
+		candidates: servicePreparationResult.candidates,
 		space: input.space,
 		baseUrl: input.baseUrl,
 		password: input.password
@@ -80391,7 +80581,7 @@ async function applySelectedSpaceAddMembersBeforeJoin(input, dependencies) {
 		presenter: input.presenter,
 		resolvedView: input.resolvedView,
 		space: input.space,
-		selectedCount: confirmedCandidates.candidates.length,
+		selectedCount: servicePreparationResult.candidates.length,
 		result,
 		joinNoticeSummary
 	});
@@ -82032,20 +82222,22 @@ async function runSpaceAddMembersForTarget(input) {
 		selectedProfileIds
 	});
 	if (selectedCandidates.length === 0) return { status: "completed" };
-	if (await ensureSpaceMemberCandidatesLocalParticipationReady({
+	const servicePreparationResult = await ensureSpaceMemberCandidatesLocalParticipationReady({
 		atsProfile: input.atsProfile,
 		candidates: selectedCandidates,
 		presenter: input.presenter,
 		resolvedView: input.runtime.resolvedView,
 		allowPrompt: input.allowPrompt,
 		view: input.view
-	}) === "cancelled") return input.allowBackToCaller ? {
+	});
+	if (servicePreparationResult.status === "cancelled") return input.allowBackToCaller ? {
 		status: "repeat_target",
 		authenticatedGatewayUrl
 	} : { status: "cancelled" };
+	const preparedCandidates = servicePreparationResult.candidates;
 	const result = await applySpaceAddMembers({
 		actorProfile: input.atsProfile,
-		candidates: selectedCandidates,
+		candidates: preparedCandidates,
 		space: input.target.space,
 		baseUrl: targetBaseUrl,
 		password: input.password
@@ -82061,7 +82253,7 @@ async function runSpaceAddMembersForTarget(input) {
 		presenter: input.presenter,
 		resolvedView: input.runtime.resolvedView,
 		space: input.target.space,
-		selectedCount: selectedCandidates.length,
+		selectedCount: preparedCandidates.length,
 		result,
 		joinNoticeSummary
 	});
@@ -82150,44 +82342,157 @@ function resolveSelectedSpaceMemberCandidates(input) {
 	return input.selectedProfileIds.map((profileId) => input.candidates.find((candidate) => candidate.profileId === profileId)).filter((candidate) => Boolean(candidate));
 }
 async function ensureSpaceMemberCandidatesLocalParticipationReady(input) {
-	const explicitSelectedLocalAgents = hasAnyExplicitLocalAgentCandidates(input.candidates);
-	const serviceRequirement = resolveCliServiceParticipationRequirement({
+	let preparedCandidates = await refreshSpaceMemberCandidatesLocalReadiness(input.candidates);
+	const repairableCandidates = preparedCandidates.filter(isSpaceMemberCandidateRepairableLocalParticipationCandidate);
+	if (repairableCandidates.length > 0 && input.resolvedView === "human" && input.allowPrompt) {
+		const repairNow = await confirm({
+			message: buildSpaceMemberRepairPromptMessage(repairableCandidates),
+			active: "Repair now",
+			inactive: "Not now",
+			initialValue: true
+		});
+		if (isCancel(repairNow)) {
+			cancel("Cancelled.");
+			return { status: "cancelled" };
+		}
+		if (repairNow) {
+			await repairSpaceMemberCandidatesLocalParticipation({
+				atsProfile: input.atsProfile,
+				candidates: repairableCandidates,
+				view: input.view
+			});
+			preparedCandidates = await refreshSpaceMemberCandidatesLocalReadiness(preparedCandidates);
+		}
+	}
+	const wakeableLocalCandidates = preparedCandidates.filter(isSpaceMemberCandidateRunnableLocalParticipationCandidate);
+	const explicitSelectedLocalAgents = hasAnyExplicitLocalAgentCandidates(wakeableLocalCandidates);
+	if (resolveCliServiceParticipationRequirement({
 		intent: "space_add_members",
 		humanOnlyParticipation: !explicitSelectedLocalAgents,
 		explicitSelectedLocalAgents,
-		selectedAgentProfilesHaveRunnableLocalSetup: haveAllExplicitLocalAgentCandidatesRunnable(input.candidates),
+		selectedAgentProfilesHaveRunnableLocalSetup: haveAllExplicitLocalAgentCandidatesRunnable(wakeableLocalCandidates),
 		localDemand: input.resolvedView === "human" ? await resolveDaemonLocalServiceDemand({ ownerUserId: input.atsProfile.ownerUserId }).catch(() => null) : null
-	});
-	if (serviceRequirement === "not_needed") return "continue";
-	if (serviceRequirement === "agent_setup_needed") {
-		input.presenter.line({
-			code: "space.add_members.agent_setup_needed",
-			text: "At least one selected agent profile is not set up on this device yet. Finish agent setup first, then retry. Use `ats start` or `ats profile ready --profile <agent-profile-id>`."
-		});
-		return "cancelled";
-	}
+	}) === "not_needed") return {
+		status: "continue",
+		candidates: preparedCandidates
+	};
 	if (!(input.resolvedView === "human" && input.allowPrompt)) {
 		input.presenter.line({
 			code: "space.add_members.service.deferred",
 			text: "ATS will continue without wakeable local agent participation on this device. To enable background replies later, rerun `ats start` or use `ats service install` and `ats service run`."
 		});
-		return "continue";
+		return {
+			status: "continue",
+			candidates: preparedCandidates
+		};
 	}
 	const gateResult = await runDaemonServiceParticipationGate({
 		intent: "space_add_members",
 		presenter: input.presenter,
 		resolvedView: input.resolvedView,
 		allowPrompt: input.allowPrompt,
+		gatewayUrl: input.gatewayUrl,
 		localDemand: await resolveDaemonLocalServiceDemand({ ownerUserId: input.atsProfile.ownerUserId }).catch(() => null),
 		forcePrompt: explicitSelectedLocalAgents,
 		view: input.view
 	});
-	if (gateResult.status === "cancelled") return "cancelled";
+	if (gateResult.status === "cancelled") return { status: "cancelled" };
 	if (gateResult.status !== "aligned") input.presenter.line({
 		code: "space.add_members.service.declined",
 		text: "ATS will continue adding these profiles without wakeable local agent participation on this device. To enable background replies later, rerun `ats start` or use `ats service install` and `ats service run`."
 	});
-	return "continue";
+	return {
+		status: "continue",
+		candidates: preparedCandidates
+	};
+}
+async function repairSpaceMemberCandidatesLocalParticipation(input) {
+	if (input.candidates.some((candidate) => candidate.localParticipationReasonCodes?.some((reasonCode) => reasonCode === "projection.missing" || reasonCode === "controller.launch.needs_repair"))) await syncDeviceRuntimeStateProjection({ mode: "repair" });
+	const repairableAgentIds = [...new Set(input.candidates.map((candidate) => candidate.localTargetLaunchStatus === "needs_repair" ? candidate.localTargetAgentId ?? null : null).filter((value) => Boolean(value)))];
+	if (repairableAgentIds.length > 0) await runAgentsRepair({
+		agent: repairableAgentIds,
+		profile: input.atsProfile.atsProfileId,
+		view: input.view
+	});
+	if (input.candidates.some((candidate) => candidate.localParticipationReasonCodes?.some((reasonCode) => reasonCode === "workspace.missing" || reasonCode === "workspace.invalid"))) await syncProfileWorkspaceState({ mode: "repair" });
+	if (input.candidates.some((candidate) => candidate.localParticipationReasonCodes?.some((reasonCode) => reasonCode === "dispatch.storage_not_ready" || reasonCode === "service.gateway_chain_unhealthy"))) await runDoctor({
+		profile: input.atsProfile.atsProfileId,
+		repair: true,
+		view: input.view,
+		agentOverviewHandled: true
+	});
+}
+async function refreshSpaceMemberCandidatesLocalReadiness(candidates) {
+	const localTargetStates = await listAgentTargetStates().catch(() => []);
+	if (localTargetStates.length === 0) return await Promise.all(candidates.map(async (candidate) => {
+		return await enrichSpaceMemberCandidateLocalParticipationReadiness({
+			...candidate,
+			localTargetDisplayName: candidate.localTargetDisplayName ?? null,
+			localTargetLaunchStatus: candidate.localTargetLaunchStatus ?? null,
+			localTargetSelectable: candidate.localTargetSelectable ?? false
+		});
+	}));
+	const localTargetStateById = new Map(localTargetStates.map((state) => [state.agentId, state]));
+	return await Promise.all(candidates.map(async (candidate) => {
+		const localTargetAgentId = resolveSpaceMemberCandidateLocalTargetAgentId({
+			profileKind: candidate.profileKind,
+			controllerRef: candidate.controllerRef,
+			controllerEnabled: candidate.controllerEnabled
+		});
+		const localTargetState = localTargetAgentId ? localTargetStateById.get(localTargetAgentId) ?? null : null;
+		return await enrichSpaceMemberCandidateLocalParticipationReadiness({
+			...candidate,
+			localTargetAgentId,
+			localTargetDisplayName: localTargetState?.displayName ?? null,
+			localTargetLaunchStatus: localTargetState?.launchStatus ?? null,
+			localTargetSelectable: localTargetState?.selectable ?? false
+		});
+	}));
+}
+async function enrichSpaceMemberCandidateLocalParticipationReadiness(candidate) {
+	if (candidate.profileKind !== "agent" || !candidate.atsProfile || candidate.controllerEnabled !== true || typeof candidate.controllerRef !== "string" || candidate.controllerRef.trim().length === 0) return {
+		...candidate,
+		localParticipationReadiness: null,
+		localParticipationReasonCodes: [],
+		localParticipationReasonText: null
+	};
+	let snapshot = null;
+	try {
+		snapshot = await resolveCurrentReplyReadinessSnapshot({
+			checkGatewayChain: false,
+			ownerUserId: candidate.atsProfile.ownerUserId,
+			profile: candidate.atsProfile
+		});
+	} catch {
+		snapshot = null;
+	}
+	if (!snapshot) return {
+		...candidate,
+		localParticipationReadiness: null,
+		localParticipationReasonCodes: [],
+		localParticipationReasonText: null
+	};
+	const readinessSummary = resolveServiceParticipationReadiness({
+		deviceReplyReadiness: snapshot.deviceReplyReadiness,
+		runtimeStatus: snapshot.displayRuntimeStatus ?? snapshot.runtimeStatus
+	});
+	return {
+		...candidate,
+		localParticipationReadiness: readinessSummary.serviceReadiness,
+		localParticipationReasonCodes: [...snapshot.deviceReplyReadiness.reasonCodes],
+		localParticipationReasonText: snapshot.deviceReplyReadiness.reasonText
+	};
+}
+function isSpaceMemberCandidateRunnableLocalParticipationCandidate(candidate) {
+	return candidate.profileKind === "agent" && candidate.controllerEnabled === true && typeof candidate.controllerRef === "string" && candidate.controllerRef.trim().length > 0 && candidate.localTargetSelectable === true && (candidate.localParticipationReadiness === "ready" || candidate.localParticipationReadiness === "not_running" || candidate.localParticipationReadiness === "not_installed");
+}
+function isSpaceMemberCandidateRepairableLocalParticipationCandidate(candidate) {
+	return candidate.profileKind === "agent" && candidate.controllerEnabled === true && typeof candidate.controllerRef === "string" && candidate.controllerRef.trim().length > 0 && (typeof candidate.localTargetAgentId === "string" && candidate.localTargetAgentId.trim().length > 0 && candidate.localTargetLaunchStatus === "needs_repair" || candidate.localParticipationReadiness === "needs_repair");
+}
+function buildSpaceMemberRepairPromptMessage(candidates) {
+	const displayNames = candidates.map((candidate) => candidate.localTargetDisplayName || candidate.localTargetAgentId || candidate.profileName);
+	if (displayNames.length === 1) return `${displayNames[0]} needs repair on this device before ATS can use it for background replies. Repair it now?`;
+	return `${displayNames.join(", ")} need repair on this device before ATS can use them for background replies. Repair them now?`;
 }
 async function runSpaceJoin(input) {
 	let failureRuntime = null;
@@ -82344,6 +82649,7 @@ async function runSpaceJoinTargetLoop(input) {
 			prepareSpaceMemberCandidatesLocalParticipation: async ({ actorProfile, candidates, presenter, resolvedView }) => await ensureSpaceMemberCandidatesLocalParticipationReady({
 				atsProfile: actorProfile,
 				candidates,
+				gatewayUrl: targetBaseUrl,
 				presenter,
 				resolvedView,
 				allowPrompt: input.canPromptPreJoinActions,
@@ -83360,6 +83666,8 @@ async function resolveSpaceRemoveMembersTarget(input) {
 }
 async function resolveSpaceMemberCandidatesForAdd(input) {
 	const profiles = await listAtsProfiles();
+	const localTargetStates = await listAgentTargetStates().catch(() => []);
+	const localTargetStateById = new Map(localTargetStates.map((state) => [state.agentId, state]));
 	const ownerProfileNameByOwnerUserId = buildOwnerProfileNameByOwnerUserId(profiles);
 	const candidateProfiles = profiles.filter((profile) => profile.status === "active" && isSpaceMembershipProfileKind(profile.profileKind) && profile.atsProfileId !== input.currentProfile.atsProfileId).filter((profile) => typeof input.currentOwnerUserId !== "string" || input.currentOwnerUserId.trim().length === 0 || profile.ownerUserId === input.currentOwnerUserId);
 	if (candidateProfiles.length === 0) return [];
@@ -83369,25 +83677,55 @@ async function resolveSpaceMemberCandidatesForAdd(input) {
 		...input.password === void 0 ? {} : { spacePassword: input.password }
 	});
 	const memberProfileIds = new Set([...membersSnapshot.humans, ...membersSnapshot.agents].map((member) => member.profileId));
-	return candidateProfiles.map((profile) => {
-		return {
-			profileId: profile.atsProfileId,
-			profileHandle: profile.profileHandle,
-			profileName: profile.profileName,
-			profileKind: profile.profileKind,
-			ownerProfileName: ownerProfileNameByOwnerUserId.get(profile.ownerUserId),
-			ownerUserId: profile.ownerUserId,
-			ownerName: profile.ownerName,
-			controllerRef: profile.controllerBinding?.controllerRef,
-			controllerEnabled: profile.controllerBinding?.controllerEnabled,
-			alreadyJoined: memberProfileIds.has(profile.atsProfileId),
-			needsActivation: false
-		};
-	}).sort((left, right) => {
+	return await refreshSpaceMemberCandidatesLocalReadiness(candidateProfiles.map((profile) => buildSpaceMemberCandidateFromProfile({
+		profile,
+		localTargetStateById,
+		ownerProfileName: ownerProfileNameByOwnerUserId.get(profile.ownerUserId) ?? void 0,
+		alreadyJoined: memberProfileIds.has(profile.atsProfileId)
+	})).sort((left, right) => {
 		const byName = left.profileName.localeCompare(right.profileName);
 		if (byName !== 0) return byName;
 		return left.profileId.localeCompare(right.profileId);
+	}));
+}
+function buildSpaceMemberCandidateFromProfile(input) {
+	const controllerRef = input.profile.controllerBinding?.controllerRef;
+	const controllerEnabled = input.profile.controllerBinding?.controllerEnabled;
+	const localTargetAgentId = resolveSpaceMemberCandidateLocalTargetAgentId({
+		profileKind: input.profile.profileKind,
+		controllerRef,
+		controllerEnabled
 	});
+	const localTargetState = localTargetAgentId ? input.localTargetStateById.get(localTargetAgentId) ?? null : null;
+	return {
+		atsProfile: input.profile,
+		profileId: input.profile.atsProfileId,
+		profileHandle: input.profile.profileHandle,
+		profileName: input.profile.profileName,
+		profileKind: input.profile.profileKind,
+		bindingState: input.profile.bindingState,
+		ownerProfileName: input.ownerProfileName,
+		ownerUserId: input.profile.ownerUserId,
+		ownerName: input.profile.ownerName,
+		controllerRef,
+		controllerEnabled,
+		localTargetAgentId,
+		localTargetDisplayName: localTargetState?.displayName ?? null,
+		localTargetLaunchStatus: localTargetState?.launchStatus ?? null,
+		localTargetSelectable: localTargetState?.selectable ?? false,
+		localParticipationReadiness: null,
+		localParticipationReasonCodes: [],
+		localParticipationReasonText: null,
+		alreadyJoined: input.alreadyJoined,
+		needsActivation: false
+	};
+}
+function resolveSpaceMemberCandidateLocalTargetAgentId(input) {
+	if (input.profileKind !== "agent" || input.controllerEnabled !== true || typeof input.controllerRef !== "string") return null;
+	const controllerRef = input.controllerRef.trim();
+	if (!controllerRef) return null;
+	if (controllerRef.startsWith("builtin:")) return normalizeBuiltinControllerAgentId(controllerRef) || null;
+	return controllerRef;
 }
 async function resolveSpaceMemberCandidatesForRemove(input) {
 	const membersSnapshot = await createCliSpaceApi(input.baseUrl).getMembersSnapshot({
@@ -83737,6 +84075,7 @@ async function applySpaceAddMembers(input) {
 	return result;
 }
 function emitSpaceAddMembersResult(input) {
+	const localParticipationFollowUps = input.result.added.map((candidate) => buildSpaceMemberJoinedFollowUp(candidate)).filter((followUp) => followUp !== null);
 	if (input.resolvedView === "agent") {
 		input.presenter.data({
 			code: "space.add_members",
@@ -83757,7 +84096,11 @@ function emitSpaceAddMembersResult(input) {
 					recordedCount: input.joinNoticeSummary.recordedCount,
 					failedCount: input.joinNoticeSummary.failedCount,
 					...input.joinNoticeSummary.firstFailure ? { firstFailure: input.joinNoticeSummary.firstFailure } : {}
-				}
+				},
+				localParticipationFollowUps: localParticipationFollowUps.map((followUp) => ({
+					profileId: followUp.profileId,
+					message: followUp.text
+				}))
 			}
 		});
 		return;
@@ -83775,6 +84118,10 @@ function emitSpaceAddMembersResult(input) {
 		sanitize: true,
 		minContentWidth: 56
 	});
+	for (const followUp of localParticipationFollowUps) input.presenter.line({
+		code: "space.add_members.local_participation_follow_up",
+		text: followUp.text
+	});
 	if (input.result.failed.length > 0) for (const failure of input.result.failed) input.presenter.line({
 		code: "space.add_members.failed",
 		text: `${failure.candidate.profileId}: ${toErrorMessage$2(failure.error)}`
@@ -83794,6 +84141,22 @@ function emitSpaceAddMembersResult(input) {
 		firstFailure: input.joinNoticeSummary.firstFailure
 	});
 }
+function buildSpaceMemberJoinedFollowUp(candidate) {
+	if (candidate.profileKind !== "agent") return null;
+	if (isSpaceMemberCandidateRepairableLocalParticipationCandidate(candidate)) {
+		const agentId = candidate.localTargetAgentId;
+		const repairCommand = agentId ? `ats agents repair --agent ${agentId}` : "ats start";
+		return {
+			profileId: candidate.profileId,
+			text: `${candidate.profileName} joined this space, but ${(candidate.localTargetDisplayName || candidate.localTargetAgentId || "this local agent").trim()} still needs repair on this device before it can wake or reply in the background. Use \`${repairCommand}\` or rerun \`ats start\`.`
+		};
+	}
+	if (!isSpaceMemberCandidateRunnableLocalParticipationCandidate(candidate)) return {
+		profileId: candidate.profileId,
+		text: `${candidate.profileName} joined this space, but it is not connected to a local agent on this device yet. It can appear here now, but it will not wake or reply from this device until you finish setup. Use \`ats profile ready --profile ${candidate.profileId}\` or rerun \`ats start\`.`
+	};
+	return null;
+}
 async function applySpaceRemoveMembers(input) {
 	const result = {
 		removed: [],
@@ -84134,7 +84497,7 @@ function formatSpaceMemberCandidateLabel(candidate) {
 function formatSpaceMemberCandidateHint(candidate) {
 	if (candidate.alreadyJoined) return "Already in this space";
 	if (candidate.needsActivation) return "Needs mention setup";
-	return "Selectable";
+	return resolveSpaceMemberCandidateStatusLabel(candidate) ?? "Selectable";
 }
 function buildHumanSpaceMemberCandidateSearchItem(candidate) {
 	return {
@@ -84146,10 +84509,12 @@ function buildHumanSpaceMemberCandidateSearchItem(candidate) {
 	};
 }
 function buildHumanSpaceMemberCandidateDetail(candidate) {
-	let status = null;
-	if (candidate.alreadyJoined === true) status = "already in this space";
-	else if (candidate.needsActivation) status = "needs mention setup";
-	return status ? `ID ${sanitizeSingleLinePromptText(candidate.profileId)} · ${sanitizeSingleLinePromptText(status)}` : `ID ${sanitizeSingleLinePromptText(candidate.profileId)}`;
+	const statuses = [];
+	if (candidate.alreadyJoined === true) statuses.push("already in this space");
+	else if (candidate.needsActivation) statuses.push("needs mention setup");
+	const agentStatuses = resolveSpaceMemberCandidateStatusBadges(candidate);
+	statuses.push(...agentStatuses.map((status) => status.toLowerCase()));
+	return statuses.length > 0 ? `ID ${sanitizeSingleLinePromptText(candidate.profileId)} · ${statuses.map((status) => sanitizeSingleLinePromptText(status)).join(" · ")}` : `ID ${sanitizeSingleLinePromptText(candidate.profileId)}`;
 }
 function buildHumanSpaceMemberCandidateSearchText(candidate) {
 	return [
@@ -84160,10 +84525,26 @@ function buildHumanSpaceMemberCandidateSearchText(candidate) {
 		sanitizeSingleLinePromptText(normalizeOptionalString$1(candidate.ownerName)),
 		sanitizeSingleLinePromptText(normalizeOptionalString$1(candidate.ownerUserId)),
 		sanitizeSingleLinePromptText(normalizeOptionalString$1(candidate.controllerRef)),
+		...resolveSpaceMemberCandidateStatusBadges(candidate),
 		candidate.alreadyJoined ? "already in this space" : null,
 		candidate.needsActivation ? "needs mention setup" : null
 	].filter((value) => typeof value === "string").join("\n");
 }
+function resolveSpaceMemberCandidateStatusLabel(candidate) {
+	const statuses = resolveSpaceMemberCandidateStatusBadges(candidate);
+	if (statuses.length === 0) return null;
+	return statuses.join(" · ");
+}
+function resolveSpaceMemberCandidateStatusBadges(candidate) {
+	if (candidate.profileKind !== "agent") return [];
+	if (isSpaceMemberCandidateBackgroundReplyReady(candidate)) return ["Ready for background replies"];
+	if (isSpaceMemberCandidateRepairableLocalParticipationCandidate(candidate)) return ["Needs repair"];
+	if (candidate.controllerEnabled === true && typeof candidate.controllerRef === "string" && candidate.controllerRef.trim().length > 0) return ["Can join only"];
+	return ["Not connected", "Can join only"];
+}
+function isSpaceMemberCandidateBackgroundReplyReady(candidate) {
+	return candidate.profileKind === "agent" && candidate.controllerEnabled === true && typeof candidate.controllerRef === "string" && candidate.controllerRef.trim().length > 0 && candidate.localTargetSelectable === true && candidate.localParticipationReadiness === "ready";
+}
 function normalizeRequestedMemberIds(value) {
 	if (!Array.isArray(value)) return [];
 	const ids = [];
@@ -87469,6 +87850,7 @@ async function runStart(input) {
 	});
 	const serviceStepResult = await runStartServiceStep({
 		foundation,
+		gatewayUrl,
 		runtime,
 		presenter,
 		interactive,