agent-transport-system 0.3.0 → 0.3.2

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.0";
+var version$1 = "0.3.2";
 var package_default = {
 	name: "agent-transport-system",
 	version: version$1,
-	atsReleaseDate: "2026-03-12",
+	atsReleaseDate: "2026-04-16",
 	description: "Agent Transport System CLI - https://ats.sh",
 	license: "MIT",
 	type: "module",
@@ -4319,7 +4319,7 @@ const daemonRouteObservationSummarySchema = strictObject({
 });
 
 //#endregion
-//#region ../../packages/schemas/dist/entry-brief-LY-buFs9.js
+//#region ../../packages/schemas/dist/entry-brief-B2jV7t7E.js
 const providerConversationExternalImportCapabilitySchema = _enum(["unsupported", "by_ref_id"]);
 const providerConversationResumeCapabilitySchema = _enum(["unsupported", "by_ref_id"]);
 const providerConversationDiscoverCapabilitySchema = literal("unsupported");
@@ -6576,6 +6576,7 @@ const REPLY_READINESS_REASON_CODE_VALUES = [
 	"runtime.adapter.unsupported",
 	"controller.bootstrap.failed",
 	"controller.gateway.unhealthy",
+	"local_agents.none_needed",
 	"route.offline",
 	"route.not_registered"
 ];
@@ -11423,6 +11424,10 @@ function buildSkillsSharedNotes(context) {
 //#endregion
 //#region src/command-entry-checks/command-check-requirements.ts
 const SKIP_ALL_CHECKS = {
+	disclaimer: {
+		mode: "skip",
+		stage: "before-entry"
+	},
 	cliUpdate: {
 		mode: "skip",
 		stage: "before-entry"
@@ -11452,6 +11457,10 @@ const OPTIONAL_CLI_UPDATE = { cliUpdate: {
 	mode: "optional",
 	stage: "before-entry"
 } };
+const REQUIRED_DISCLAIMER = { disclaimer: {
+	mode: "required",
+	stage: "before-entry"
+} };
 const AUTO_FIX_LOCAL_RUNTIME = { localRuntimeState: {
 	mode: "auto-fix",
 	stage: "before-entry"
@@ -11480,10 +11489,6 @@ const STATUS_ONLY_SELECTED_PROFILE = { selectedProfile: {
 	mode: "status-only",
 	stage: "status-only"
 } };
-const OPTIONAL_SERVICE_AFTER_PROFILE = { service: {
-	mode: "optional",
-	stage: "after-profile"
-} };
 const STATUS_ONLY_SERVICE = { service: {
 	mode: "status-only",
 	stage: "status-only"
@@ -11494,77 +11499,77 @@ function buildCommandChecks(...parts) {
 const COMMAND_CHECK_REQUIREMENTS = Object.freeze({
 	root: buildCommandChecks(OPTIONAL_CLI_UPDATE),
 	view: buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	start: buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"repair.local-state": buildCommandChecks(),
-	uninstall: buildCommandChecks(),
-	reset: buildCommandChecks(),
-	upgrade: buildCommandChecks(),
-	"auth.menu": buildCommandChecks(),
-	"auth.status": buildCommandChecks(),
-	"auth.login": buildCommandChecks(),
-	"auth.logout": buildCommandChecks(),
-	"skills.menu": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"skills.install": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"skills.uninstall": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"skills.list": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"skills.check": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"skills.update": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"agents.menu": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.detect": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.list": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.manage": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.enable": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.repair": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.disable": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.show": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.custom.list": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.custom.add": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.custom.update": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.custom.remove": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"agents.config": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"service.menu": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"service.run": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
-	"service.status": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"service.snapshot": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"service.interrupt": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"service.cancel": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
-	"service.trace": buildCommandChecks(OPTIONAL_CLI_UPDATE, REQUIRED_SIGN_IN, REQUIRED_SELECTED_PROFILE),
-	"service.install": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"service.uninstall": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"service.reinstall": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"service.stop": buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"space.menu": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.create": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE, OPTIONAL_SERVICE_AFTER_PROFILE),
-	"space.delete": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.conversation.bind": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.conversation.clear": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.conversation.status": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.join": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE, OPTIONAL_SERVICE_AFTER_PROFILE),
-	"space.add-members": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.remove-members": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.watch": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE, OPTIONAL_SERVICE_AFTER_PROFILE),
-	"space.send": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.history": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.contract": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.contract.set": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.status": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.updates": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.result": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.list": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.password": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.guide": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.guide.set": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	"space.guide.clear": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
-	doctor: buildCommandChecks(OPTIONAL_CLI_UPDATE, OPTIONAL_SIGN_IN, STATUS_ONLY_SERVICE),
-	whoami: buildCommandChecks(OPTIONAL_CLI_UPDATE),
-	"profile.menu": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
-	"profile.create": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
-	"profile.list": buildCommandChecks(OPTIONAL_CLI_UPDATE, REQUIRED_SIGN_IN),
-	"profile.ready": buildCommandChecks(OPTIONAL_CLI_UPDATE, STATUS_ONLY_SIGN_IN, STATUS_ONLY_SELECTED_PROFILE),
-	"profile.set": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
-	"profile.show": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
-	"profile.update": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
-	"profile.delete": buildCommandChecks(OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN)
+	start: buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"repair.local-state": buildCommandChecks(REQUIRED_DISCLAIMER),
+	uninstall: buildCommandChecks(REQUIRED_DISCLAIMER),
+	reset: buildCommandChecks(REQUIRED_DISCLAIMER),
+	upgrade: buildCommandChecks(REQUIRED_DISCLAIMER),
+	"auth.menu": buildCommandChecks(REQUIRED_DISCLAIMER),
+	"auth.status": buildCommandChecks(REQUIRED_DISCLAIMER),
+	"auth.login": buildCommandChecks(REQUIRED_DISCLAIMER),
+	"auth.logout": buildCommandChecks(REQUIRED_DISCLAIMER),
+	"skills.menu": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"skills.install": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"skills.uninstall": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"skills.list": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"skills.check": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"skills.update": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"agents.menu": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.detect": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.list": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.manage": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.enable": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.repair": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.disable": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.show": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.custom.list": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.custom.add": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.custom.update": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.custom.remove": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"agents.config": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"service.menu": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"service.run": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
+	"service.status": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"service.snapshot": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"service.interrupt": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"service.cancel": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME),
+	"service.trace": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, REQUIRED_SIGN_IN, REQUIRED_SELECTED_PROFILE),
+	"service.install": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"service.uninstall": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"service.reinstall": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"service.stop": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"space.menu": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.create": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.delete": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.conversation.bind": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.conversation.clear": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.conversation.status": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.join": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.add-members": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.remove-members": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.watch": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.send": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.history": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.contract": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.contract.set": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.status": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.updates": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.result": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.list": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.password": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.guide": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.guide.set": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	"space.guide.clear": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN, CONFIRM_SELECTED_PROFILE),
+	doctor: buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, OPTIONAL_SIGN_IN, STATUS_ONLY_SERVICE),
+	whoami: buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE),
+	"profile.menu": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
+	"profile.create": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
+	"profile.list": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, REQUIRED_SIGN_IN),
+	"profile.ready": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, STATUS_ONLY_SIGN_IN, STATUS_ONLY_SELECTED_PROFILE),
+	"profile.set": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
+	"profile.show": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
+	"profile.update": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN),
+	"profile.delete": buildCommandChecks(REQUIRED_DISCLAIMER, OPTIONAL_CLI_UPDATE, AUTO_FIX_LOCAL_RUNTIME, REQUIRED_SIGN_IN)
 });
 function getCommandCheckRequirements(entryName) {
 	return COMMAND_CHECK_REQUIREMENTS[entryName];
@@ -13127,6 +13132,13 @@ function daemonServiceStableLauncherPath(pathInput = {}) {
 function daemonTokenPath(pathInput = {}) {
 	return join(systemDir(pathInput), "daemon-token.json");
 }
+async function restoreDaemonInstallStateSnapshot(snapshot, pathInput = {}) {
+	if (!snapshot) {
+		await rm(daemonStatePath(pathInput), { force: true });
+		return;
+	}
+	await writeDaemonInstallState(snapshot, pathInput);
+}
 function resolveDaemonControlPlaneEndpoint(pathInput = {}) {
 	const runtimeRoot = daemonRuntimeRootPath(pathInput);
 	const suffix = createHash("sha256").update(runtimeRoot).digest("hex").slice(0, 24);
@@ -13306,9 +13318,9 @@ function parseDaemonInstallState(raw) {
 function isDaemonInstallSource(value) {
 	return value === "cli.auto_check" || value === "daemon.command.install";
 }
-async function writeDaemonInstallState(state) {
-	const path = daemonStatePath();
-	await mkdir(systemDir(), { recursive: true });
+async function writeDaemonInstallState(state, pathInput = {}) {
+	const path = daemonStatePath(pathInput);
+	await mkdir(systemDir(pathInput), { recursive: true });
 	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
 	let shouldCleanupTemp = true;
 	try {
@@ -14663,6 +14675,9 @@ async function getConfiguredDaemonDispatchLimits() {
 async function getConfiguredOnboardingConfig() {
 	return (await readRuntimeConfig())?.onboarding ?? null;
 }
+async function getConfiguredOnboardingDisclaimerAcceptedAt() {
+	return (await getConfiguredOnboardingConfig())?.disclaimerAcceptedAt ?? null;
+}
 async function getConfiguredStartV1OnboardingState() {
 	return (await getConfiguredOnboardingConfig())?.startV1 ?? null;
 }
@@ -14727,10 +14742,23 @@ async function updateConfiguredDeviceRuntimeState(updater) {
 async function updateConfiguredStartV1OnboardingState(updater) {
 	await withRuntimeConfigLock(async () => {
 		const previous = await readRuntimeConfig();
-		const previousStartV1 = previous?.onboarding?.startV1 ?? null;
+		const previousOnboarding = previous?.onboarding ?? null;
+		const previousStartV1 = previousOnboarding?.startV1 ?? null;
 		const nextStartV1 = updater(previousStartV1);
 		if (JSON.stringify(previousStartV1) === JSON.stringify(nextStartV1)) return;
-		await writeRuntimeConfig(buildNextConfig(previous, { onboarding: nextStartV1 ? { startV1: nextStartV1 } : null }));
+		await writeRuntimeConfig(buildNextConfig(previous, { onboarding: nextStartV1 || previousOnboarding?.disclaimerAcceptedAt ? {
+			...previousOnboarding?.disclaimerAcceptedAt ? { disclaimerAcceptedAt: previousOnboarding.disclaimerAcceptedAt } : {},
+			...nextStartV1 ? { startV1: nextStartV1 } : {}
+		} : null }));
+	});
+}
+async function updateConfiguredOnboardingConfig(updater) {
+	await withRuntimeConfigLock(async () => {
+		const previous = await readRuntimeConfig();
+		const previousOnboarding = previous?.onboarding ?? null;
+		const nextOnboarding = updater(previousOnboarding);
+		if (JSON.stringify(previousOnboarding) === JSON.stringify(nextOnboarding)) return;
+		await writeRuntimeConfig(buildNextConfig(previous, { onboarding: nextOnboarding }));
 	});
 }
 function buildNextConfig(previous, overrides) {
@@ -14860,9 +14888,14 @@ function parseRuntimeDeviceRuntimeStateObject(value) {
 }
 function parseRuntimeOnboardingConfig(value) {
 	if (!value || typeof value !== "object") return;
-	const startV1 = parseRuntimeStartV1OnboardingState(value.startV1);
-	if (!startV1) return;
-	return { startV1 };
+	const obj = value;
+	const disclaimerAcceptedAt = toTrimmedStringOrUndefined(obj.disclaimerAcceptedAt);
+	const startV1 = parseRuntimeStartV1OnboardingState(obj.startV1);
+	if (!(disclaimerAcceptedAt || startV1)) return;
+	return {
+		...disclaimerAcceptedAt ? { disclaimerAcceptedAt } : {},
+		...startV1 ? { startV1 } : {}
+	};
 }
 function parseRuntimeStartV1OnboardingState(value) {
 	if (!value || typeof value !== "object") return;
@@ -16604,8 +16637,77 @@ function createPresenter(context) {
 
 //#endregion
 //#region src/system/daemon-install-attention.ts
+const DAEMON_INSTALL_DECISION_CHOICE = {
+	install: "install",
+	notNow: "not_now"
+};
 const DAEMON_INSTALL_COMMAND = "ats service install";
 const DAEMON_UPGRADE_COMMAND = "ats upgrade";
+const DAEMON_DECISION_RECOMMENDED_HINT = "Recommended";
+const DAEMON_INSTALL_DECISION_COPY = {
+	missing: {
+		question: "ATS Service is missing. Install it now?",
+		explanation: "Without it, local agents on this device can't reply from Space.",
+		primaryLabel: "Yes, install it for me",
+		deferred: "ATS Service is still missing. Local agents on this device can't reply from Space until you install it later with `ats service install`.",
+		failed: "ATS Service could not be installed. Local agents on this device still can't reply from Space. Run `ats service install`."
+	},
+	outdated: {
+		question: "ATS Service needs an update. Fix it now?",
+		explanation: "Until ATS fixes it, local agents on this device may not be able to reply from Space.",
+		primaryLabel: "Yes, fix it for me",
+		deferred: "ATS Service still needs an update. Local agents on this device may not be able to reply from Space until ATS fixes it. Run `ats service install` later.",
+		failed: "ATS Service was not updated. Local agents on this device may not be able to reply from Space. Run `ats service install`."
+	}
+};
+function buildDaemonInstallDecisionPromptConfig(input) {
+	const copy = DAEMON_INSTALL_DECISION_COPY[input.kind];
+	const detailLine = input.kind === "outdated" && typeof input.installedVersion === "string" && typeof input.expectedVersion === "string" ? `Installed v${input.installedVersion}, expected v${input.expectedVersion}.` : null;
+	return {
+		message: [
+			copy.question,
+			copy.explanation,
+			detailLine
+		].filter((line) => typeof line === "string" && line.length > 0).join("\n"),
+		initialValue: DAEMON_INSTALL_DECISION_CHOICE.install,
+		options: [{
+			value: DAEMON_INSTALL_DECISION_CHOICE.install,
+			label: copy.primaryLabel,
+			hint: DAEMON_DECISION_RECOMMENDED_HINT
+		}, {
+			value: DAEMON_INSTALL_DECISION_CHOICE.notNow,
+			label: "Not now"
+		}]
+	};
+}
+async function promptForDaemonInstallDecision(input) {
+	const choice = await select(buildDaemonInstallDecisionPromptConfig(input));
+	if (isCancel(choice)) return "cancelled";
+	return choice === DAEMON_INSTALL_DECISION_CHOICE.install ? DAEMON_INSTALL_DECISION_CHOICE.install : DAEMON_INSTALL_DECISION_CHOICE.notNow;
+}
+async function runDaemonInstallDecisionPrompt(input) {
+	const decision = await promptForDaemonInstallDecision({
+		kind: input.kind,
+		installedVersion: input.installedVersion,
+		expectedVersion: input.expectedVersion
+	});
+	if (decision === DAEMON_INSTALL_DECISION_CHOICE.install) try {
+		await input.installService();
+		return "install";
+	} catch {
+		await input.emitLine(formatDaemonInstallFailedMessage(input.kind));
+		return "failed";
+	}
+	if (decision === "cancelled") return "cancelled";
+	await input.emitLine(formatDaemonInstallDeferredMessage(input.kind));
+	return decision;
+}
+function formatDaemonInstallDeferredMessage(kind) {
+	return formatInlineAtsCliCommands(DAEMON_INSTALL_DECISION_COPY[kind].deferred);
+}
+function formatDaemonInstallFailedMessage(kind) {
+	return formatInlineAtsCliCommands(DAEMON_INSTALL_DECISION_COPY[kind].failed);
+}
 function formatDaemonServiceMissingRecommendation() {
 	return "ATS Service is not installed yet. Local agents on this device can't reply from Space until it is installed.";
 }
@@ -17432,6 +17534,17 @@ async function writeDaemonServiceLauncher() {
 		mode: 448
 	});
 }
+async function restoreDaemonActiveBundleStateSnapshot(snapshot, pathInput = {}) {
+	if (!snapshot) {
+		await rm(daemonServiceActiveBundlePath(pathInput), { force: true });
+		return;
+	}
+	await mkdir(daemonRuntimeStateRootPath(pathInput), { recursive: true });
+	await writeFile(daemonServiceActiveBundlePath(pathInput), `${JSON.stringify(snapshot, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
 async function cleanupInactiveDaemonServiceBundles(input = {}) {
 	const [active, serviceContract, runtimeLease] = await Promise.all([
 		readDaemonActiveBundleState(),
@@ -19694,6 +19807,12 @@ function getStepOrderIndex$1(stepId) {
 	if (index === -1) throw new Error(`unknown start session step "${stepId}"`);
 	return index;
 }
+function resolveServiceParticipationRequirement(input) {
+	if (input.humanOnlyParticipation) return "not_needed";
+	if (input.explicitSelectedLocalAgents) return input.selectedAgentProfilesHaveRunnableLocalSetup ? "offer_service_gate" : "agent_setup_needed";
+	if (input.deviceLocalDemand === "keep_running") return "offer_service_gate";
+	return "not_needed";
+}
 function buildDaemonRouteObservationPresentation$1(observation) {
 	if (observation.status === "online") return {
 		detail: "ATS server can see an active daemon route for this profile.",
@@ -19756,6 +19875,7 @@ function formatStartReplyReadinessReason(reasonCode) {
 		case "runtime.adapter.unsupported": return "This agent setup can't reply from this device";
 		case "controller.bootstrap.failed": return "ATS couldn't finish setting up OpenClaw on this device";
 		case "controller.gateway.unhealthy": return "OpenClaw is not ready on this device yet";
+		case "local_agents.none_needed": return "This device does not need ATS Service until you choose local agents to bring into a space";
 		case "route.offline": return "ATS server can't currently see an active daemon route for this profile";
 		case "route.not_registered": return "ATS is still setting up replies for this profile on this device";
 		default: return reasonCode ? "ATS can't confirm reply status yet" : null;
@@ -26893,6 +27013,7 @@ function emitStructuredReconcileEvidence(eventName, payload) {
 
 //#endregion
 //#region src/system/device-runtime-state-sync.ts
+const NO_LOCAL_AGENTS_NEED_ATS_SERVICE_REASON = "No local agents on this device need ATS Service right now";
 async function syncDeviceRuntimeStateProjection(input) {
 	const mode = input?.mode ?? "check";
 	const currentControllers = await readCurrentControllers();
@@ -26932,7 +27053,7 @@ async function syncDeviceRuntimeStateProjection(input) {
 		disabledControllerIds: [],
 		repairRequiredControllerIds: [],
 		repairedControllerIds: [],
-		reason: "no bound agent controller requires local projection"
+		reason: NO_LOCAL_AGENTS_NEED_ATS_SERVICE_REASON
 	});
 	const gap = resolveProjectionGap({
 		currentControllers,
@@ -28021,7 +28142,7 @@ function normalizeOptionalString$14(value) {
 }
 function resolveZeroLocalValueReason(projection) {
 	if (!projection) return "no wakeable local agent routes are available";
-	if (projection.status === "ok" && projection.projectedControllerIds.length === 0) return "no bound agent controller currently needs local projection";
+	if (projection.status === "ok" && projection.projectedControllerIds.length === 0) return NO_LOCAL_AGENTS_NEED_ATS_SERVICE_REASON;
 	if (projection.status === "degraded") return "projected local controllers are not currently wakeable";
 	return "no wakeable local agent routes are available";
 }
@@ -28454,13 +28575,17 @@ function resolveDeviceReplyReadinessFromRuntimeProjection(runtimeProjection) {
 	return null;
 }
 function createRouteNotRegisteredReplyReadinessStatus(input) {
+	const projectionWithoutLocalDemand = input.localDemand?.projection ?? input.runtimeProjection;
 	return createDeviceReplyReadinessStatus({
-		reasonCode: "route.not_registered",
-		reasonText: normalizeReplyReadinessReason(input.localDemand?.reason ?? input.runtimeProjection?.reason) ?? "ATS is still setting up replies on this device",
-		replyReadiness: input.runtimeProjection?.status === "skipped" ? "unknown" : "blocked",
+		reasonCode: input.runtimeProjection?.status === "skipped" || hasNoProjectedLocalControllers(projectionWithoutLocalDemand) ? "local_agents.none_needed" : "route.not_registered",
+		reasonText: normalizeOptionalText$17(input.localDemand?.reason ?? input.runtimeProjection?.reason) ?? "ATS is still setting up replies on this device",
+		replyReadiness: input.runtimeProjection?.status === "skipped" || hasNoProjectedLocalControllers(projectionWithoutLocalDemand) ? "unknown" : "blocked",
 		wakeableRouteCount: 0
 	});
 }
+function hasNoProjectedLocalControllers(projection) {
+	return projection?.status === "ok" && projection.projectedControllerIds.length === 0;
+}
 function createDeviceReplyReadinessStatus(input) {
 	return {
 		reasonCodes: sortReplyReadinessReasonCodes(input.reasonCode ? [input.reasonCode] : []),
@@ -28513,6 +28638,7 @@ function describeReplyReadinessReason(reasonCode) {
 		case "runtime.adapter.unsupported": return "the local agent controller setup is not supported";
 		case "controller.bootstrap.failed": return "ATS couldn't finish setting up the local OpenClaw agent for this profile";
 		case "controller.gateway.unhealthy": return "the local OpenClaw Gateway is not healthy on this device";
+		case "local_agents.none_needed": return "no local agents on this device need ATS Service right now";
 		case "route.offline": return "ATS server can't currently see an active daemon route for this profile";
 		case "route.not_registered": return "ATS is still setting up replies for this profile on this device";
 		default: return "ATS can't confirm local reply readiness yet";
@@ -29611,6 +29737,7 @@ async function runDaemonServiceFullAlignmentLocked(input) {
 	});
 	const inventoryBefore = input.state.inventoryBefore;
 	if (!inventoryBefore) throw new Error("ATS could not resolve local service inventory for alignment.");
+	const desiredState = resolveAlignmentDesiredState(inventoryBefore);
 	const shouldRestoreBackground = resolveShouldRestoreBackground(inventoryBefore);
 	const commandOptions = await resolveAlignmentCommandOptions({
 		inventory: inventoryBefore,
@@ -29621,9 +29748,16 @@ async function runDaemonServiceFullAlignmentLocked(input) {
 	});
 	const serviceManager = await resolveAlignmentServiceManager(inventoryBefore) ?? null;
 	if (!serviceManager) throw new Error("ATS could not resolve a system service manager for background service alignment.");
+	const restorePoint = {
+		desiredState,
+		previousActiveBundle: inventoryBefore.activeBundle ?? null,
+		previousContract: inventoryBefore.serviceContract ?? null,
+		previousInstallState: inventoryBefore.installStatus.installed ? inventoryBefore.installStatus.state : null
+	};
 	const alignmentContext = {
 		commandOptions,
 		currentContract: inventoryBefore.serviceContract ?? null,
+		desiredState,
 		serviceManager,
 		shouldRestoreBackground
 	};
@@ -29646,8 +29780,7 @@ async function runDaemonServiceFullAlignmentLocked(input) {
 	} catch (error) {
 		try {
 			await restoreDaemonServiceAfterFailedAlignment({
-				commandOptions: alignmentContext.commandOptions,
-				currentContract: alignmentContext.currentContract,
+				restorePoint,
 				serviceManager: alignmentContext.serviceManager,
 				shouldRestoreBackground: alignmentContext.shouldRestoreBackground
 			});
@@ -29689,7 +29822,7 @@ async function executeDaemonServiceFullAlignment(input) {
 		commandOptions: input.alignmentContext.commandOptions,
 		currentContract: input.alignmentContext.currentContract,
 		daemonVersion: input.expectedVersion,
-		desiredState: input.alignmentContext.shouldRestoreBackground ? "background" : "stopped",
+		desiredState: input.alignmentContext.desiredState,
 		preparedBundle,
 		serviceController: input.alignmentContext.serviceManager.controller
 	});
@@ -29722,6 +29855,7 @@ async function executeDaemonServiceFullAlignment(input) {
 		...input.alignmentContext.shouldRestoreBackground ? { intendedMode: "background" } : {}
 	});
 	const verificationError = verifyAlignedInventory({
+		desiredState: input.alignmentContext.desiredState,
 		inventory: inventoryAfter,
 		shouldRestoreBackground: input.alignmentContext.shouldRestoreBackground,
 		target: input.target
@@ -29795,9 +29929,15 @@ async function resolveAlignmentCommandOptions(input) {
 		...typeof heartbeatMs === "number" ? { heartbeatMs } : {}
 	};
 }
+function resolveAlignmentDesiredState(inventory) {
+	if (inventory.serviceContract?.desiredState === "background") return "background";
+	if (inventory.serviceContract?.desiredState === "stopped") return "stopped";
+	if (inventory.serviceManagerStatus?.running) return "background";
+	if (inventory.runtimeStatus.mode !== "background") return "stopped";
+	return inventory.runtimeStatus.status === "running" || inventory.runtimeStatus.status === "stale" || inventory.runtimeStatus.managedBySystemService || inventory.runtimeStatus.autoStart ? "background" : "stopped";
+}
 function resolveShouldRestoreBackground(inventory) {
-	if (inventory.serviceContract?.desiredState === "background") return true;
-	if (inventory.serviceContract?.desiredState === "stopped") return false;
+	if (resolveAlignmentDesiredState(inventory) !== "background") return false;
 	if (inventory.serviceManagerStatus?.running) return true;
 	if (inventory.runtimeStatus.mode !== "background") return false;
 	return inventory.runtimeStatus.status === "running" || inventory.runtimeStatus.status === "stale" || inventory.runtimeStatus.managedBySystemService || inventory.runtimeStatus.autoStart;
@@ -29912,8 +30052,7 @@ function verifyAlignedInventoryContractState(input) {
 	if (!contract) return "Alignment verification failed because the service contract is missing.";
 	if (contract.daemonVersion !== input.target.daemonVersion) return `Alignment verification failed because service contract version is ${contract.daemonVersion} instead of ${input.target.daemonVersion}.`;
 	if (input.inventory.activeBundle && contract.bundleId !== input.inventory.activeBundle.bundleId) return `Alignment verification failed because service contract bundle is ${contract.bundleId} instead of ${input.inventory.activeBundle.bundleId}.`;
-	const expectedDesiredState = input.shouldRestoreBackground ? "background" : "stopped";
-	if (contract.desiredState !== expectedDesiredState) return `Alignment verification failed because service contract desiredState is ${contract.desiredState} instead of ${expectedDesiredState}.`;
+	if (contract.desiredState !== input.desiredState) return `Alignment verification failed because service contract desiredState is ${contract.desiredState} instead of ${input.desiredState}.`;
 	return null;
 }
 function verifyAlignedInventoryBundleState(input) {
@@ -29946,16 +30085,28 @@ async function ensureAlignmentServiceContract(input) {
 		...input.currentContract?.lane ? { lane: input.currentContract.lane } : {}
 	});
 }
-async function restoreDaemonServiceAfterFailedAlignment(input) {
-	const activeBundle = await readDaemonActiveBundleState().catch(() => null);
-	if (activeBundle) await ensureAlignmentServiceContract({
-		commandOptions: input.commandOptions,
-		currentContract: input.currentContract,
-		daemonVersion: activeBundle.daemonVersion ?? input.currentContract?.daemonVersion ?? "unknown",
-		desiredState: input.shouldRestoreBackground ? "background" : "stopped",
-		preparedBundle: activeBundle,
-		serviceController: input.serviceManager.controller
+async function restoreAlignmentServiceContractSnapshot(snapshot) {
+	if (!snapshot) {
+		await clearDaemonServiceContract();
+		return;
+	}
+	await upsertDaemonServiceContract({
+		daemonVersion: snapshot.daemonVersion,
+		bundleId: snapshot.bundleId,
+		desiredState: snapshot.desiredState,
+		serviceController: snapshot.serviceController,
+		autoStart: snapshot.autoStart,
+		gatewayUrl: snapshot.gatewayUrl,
+		profileId: snapshot.profileId,
+		deviceId: snapshot.deviceId,
+		heartbeatMs: snapshot.heartbeatMs,
+		lane: snapshot.lane
 	});
+}
+async function restoreDaemonServiceAfterFailedAlignment(input) {
+	await restoreDaemonInstallStateSnapshot(input.restorePoint.previousInstallState);
+	await restoreDaemonActiveBundleStateSnapshot(input.restorePoint.previousActiveBundle);
+	await restoreAlignmentServiceContractSnapshot(input.restorePoint.previousContract);
 	await installSystemServiceRegistrationForAlignment({ serviceManager: input.serviceManager });
 	if (input.shouldRestoreBackground) {
 		await startDaemonSystemServiceWithAutoRepair({
@@ -30846,7 +30997,7 @@ const COMMAND_ENTRY_COPY_BY_NAME = Object.freeze({
 		signInAction: "creating a space",
 		profileAction: "creating a space",
 		cliUpdateAction: "creating a space",
-		serviceAction: "creating a space"
+		serviceAction: null
 	},
 	"space.delete": {
 		signInAction: "deleting a space",
@@ -30876,7 +31027,7 @@ const COMMAND_ENTRY_COPY_BY_NAME = Object.freeze({
 		signInAction: "joining a space",
 		profileAction: "joining a space",
 		cliUpdateAction: "joining a space",
-		serviceAction: "joining a space"
+		serviceAction: null
 	},
 	"space.add-members": {
 		signInAction: "adding members to a space",
@@ -30894,7 +31045,7 @@ const COMMAND_ENTRY_COPY_BY_NAME = Object.freeze({
 		signInAction: "watching a space",
 		profileAction: "watching a space",
 		cliUpdateAction: "watching a space",
-		serviceAction: "watching a space"
+		serviceAction: null
 	},
 	"space.send": {
 		signInAction: "sending a message",
@@ -31303,6 +31454,82 @@ async function runCliUpdateCheck(input) {
 	};
 }
 
+//#endregion
+//#region src/onboarding/disclaimer.ts
+const ATS_ACCEPT_DISCLAIMER_ENV = "ATS_ACCEPT_DISCLAIMER";
+const ATS_ONBOARDING_DISCLAIMER_ACCEPT = "__onboarding_disclaimer_accept__";
+const ATS_ONBOARDING_DISCLAIMER_DECLINE = "__onboarding_disclaimer_decline__";
+const ATS_ONBOARDING_DISCLAIMER_TEXT = "ATSD is experimental and changes rapidly. Breaking changes may occur. You are fully responsible for data security and sensitive information handling. Use ATSD only in trusted environments.";
+async function runOnboardingDisclaimerGate(input) {
+	if (await getConfiguredOnboardingDisclaimerAcceptedAt().catch(() => null)) return true;
+	if (shouldBypassDisclaimerWithEnv()) {
+		await persistOnboardingDisclaimerAccepted();
+		return true;
+	}
+	if (input.runtime.resolvedView === "agent") {
+		input.presenter.data({
+			code: input.codePrefix,
+			payload: {
+				acceptedAt: null,
+				text: ATS_ONBOARDING_DISCLAIMER_TEXT,
+				mode: "agent_notice",
+				requiresConfirmation: false
+			}
+		});
+		await persistOnboardingDisclaimerAccepted();
+		return true;
+	}
+	note(`⚠️ ${ATS_ONBOARDING_DISCLAIMER_TEXT}`, "Disclaimer");
+	if (!input.interactive) {
+		input.presenter.line({
+			code: `${input.codePrefix}.auto_continue`,
+			text: "Non-interactive session: disclaimer displayed and ATS continues."
+		});
+		await persistOnboardingDisclaimerAccepted();
+		return true;
+	}
+	const decision = await select({
+		message: "Do you accept and continue?",
+		options: [{
+			value: ATS_ONBOARDING_DISCLAIMER_ACCEPT,
+			label: "Yes, continue"
+		}, {
+			value: ATS_ONBOARDING_DISCLAIMER_DECLINE,
+			label: "No, exit"
+		}],
+		initialValue: ATS_ONBOARDING_DISCLAIMER_ACCEPT
+	});
+	if (isCancel(decision) || decision === ATS_ONBOARDING_DISCLAIMER_DECLINE) {
+		cancel("Cancelled.");
+		return false;
+	}
+	await persistOnboardingDisclaimerAccepted();
+	return true;
+}
+function shouldBypassDisclaimerWithEnv() {
+	return String(process.env[ATS_ACCEPT_DISCLAIMER_ENV] ?? "").trim() === "1";
+}
+async function persistOnboardingDisclaimerAccepted() {
+	const acceptedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await updateConfiguredOnboardingConfig((current) => ({
+		...current ?? {},
+		disclaimerAcceptedAt: acceptedAt
+	}));
+}
+
+//#endregion
+//#region src/command-entry-checks/check-disclaimer.ts
+async function runDisclaimerCheck(input) {
+	if (input.requirement.mode === "skip") return { status: "continue" };
+	if (await runOnboardingDisclaimerGate({
+		runtime: input.context.runtime,
+		presenter: input.context.presenter,
+		interactive: input.context.allowPrompt,
+		codePrefix: "command.entry.disclaimer"
+	})) return { status: "continue" };
+	return { status: "cancelled" };
+}
+
 //#endregion
 //#region src/config/storage-version.ts
 const STORAGE_VERSION_SCHEMA = "ats-local-state-v1";
@@ -37417,9 +37644,11 @@ const loadLedgerState = async (input) => {
 };
 const handleInvalidLedgerState = async (input) => {
 	if (input.invalidStateStrategy !== "backup_and_reset") throw new Error(input.errorCode);
-	const emptyState = createEmptyLedgerState();
+	const resetAtMs = Date.now();
+	const emptyState = createEmptyLedgerState(resetAtMs);
 	await persistLedgerStateAtomic({
 		io: input.io,
+		nowMs: resetAtMs,
 		paths: input.paths,
 		state: emptyState
 	});
@@ -37428,7 +37657,7 @@ const handleInvalidLedgerState = async (input) => {
 const buildScopedStateTempFilePath = (input) => `${input.stateTempFilePath}.${Date.now()}.${Math.random().toString(36).slice(2, 10)}`;
 const persistLedgerStateAtomic = async (input) => {
 	const normalizedState = compactLedgerState({
-		nowMs: Date.now(),
+		nowMs: input.nowMs ?? Date.now(),
 		state: cloneLedgerState$1(input.state)
 	});
 	await input.io.mkdir(input.paths.rootDirPath, { recursive: true });
@@ -46738,7 +46967,7 @@ function resolveServiceParticipationReadiness(input) {
 		};
 	}
 	if (reasonCodes.includes("service.not_installed")) {
-		const nextSteps = formatAtsCliCommands(["ats service install", "ats service run --mode foreground"]);
+		const nextSteps = formatAtsCliCommands(["ats service install", "ats service run"]);
 		return {
 			serviceReadiness: "not_installed",
 			summaryText: "Not installed",
@@ -46749,7 +46978,7 @@ function resolveServiceParticipationReadiness(input) {
 		};
 	}
 	if (reasonCodes.includes("service.not_running")) {
-		const nextSteps = [formatAtsCliCommand("ats service run --mode foreground")];
+		const nextSteps = [formatAtsCliCommand("ats service run")];
 		return {
 			serviceReadiness: "not_running",
 			summaryText: "Not running",
@@ -46767,6 +46996,21 @@ function resolveServiceParticipationReadiness(input) {
 		nextSteps: [],
 		runtimeHeadline
 	};
+	if (reasonCodes.includes("local_agents.none_needed")) {
+		const nextSteps = formatAtsCliCommands([
+			"ats start",
+			"ats service install",
+			"ats service run"
+		]);
+		return {
+			serviceReadiness: "unknown",
+			summaryText: "Not needed yet",
+			detailText: input.deviceReplyReadiness.reasonText,
+			nextStepSummary: "If you later choose local agents to bring into a space, rerun `ats start` or enable ATS Service directly.",
+			nextSteps,
+			runtimeHeadline
+		};
+	}
 	const nextSteps = [formatAtsCliCommand("ats service status")];
 	return {
 		serviceReadiness: "unknown",
@@ -50806,7 +51050,7 @@ function mapLocalControllerStatusReason(reason) {
 	const projectedControllersDisabledReason = "one or more projected controllers are disabled locally";
 	if (reason.includes("already exists")) return "setup is already prepared";
 	if (reason.includes("authentication is not valid")) return "sign in required";
-	if (reason.includes("no bound agent controller requires local projection")) return "no local agent is configured for this device";
+	if (reason.includes(NO_LOCAL_AGENTS_NEED_ATS_SERVICE_REASON)) return "no local agent is configured for this device";
 	if (reason.includes(missingOrDisabledReason)) return "some local agents are missing or turned off";
 	if (reason.includes("is missing for one or more bound controllers")) return "some local agents are missing";
 	if (reason.includes(projectedControllersDisabledReason)) return "some local agent entries are disabled";
@@ -51012,6 +51256,177 @@ async function ensureDaemonVersionForCliStartup(input) {
 	};
 }
 
+//#endregion
+//#region src/system/daemon-service-participation-gate.ts
+function shouldRequireDaemonServiceParticipation(localDemand) {
+	return localDemand?.decision === "keep_running";
+}
+async function resolveDaemonServiceParticipationStatus(input) {
+	const expectedVersion = input?.expectedVersion ?? resolveCurrentDaemonExpectedVersion();
+	const inventory = await inspectDaemonServiceInventory({ expectedVersion });
+	if (!(inventory.installStatus.installed && inventory.installStatus.state)) return {
+		kind: "missing",
+		expectedVersion
+	};
+	const installedVersion = inventory.installStatus.state.daemonVersion;
+	if (installedVersion !== expectedVersion) return {
+		kind: "outdated",
+		expectedVersion,
+		installedVersion
+	};
+	const repairAnomalies = inventory.anomalies.filter((anomaly) => DAEMON_SERVICE_REPAIR_ANOMALIES.has(anomaly.code));
+	if (repairAnomalies.length > 0) return {
+		kind: "needs_repair",
+		expectedVersion,
+		installedVersion,
+		runtimeStatus: inventory.runtimeStatus.status,
+		detail: repairAnomalies[0]?.message ?? "ATS found conflicting local service state on this device.",
+		anomalyCodes: repairAnomalies.map((anomaly) => anomaly.code)
+	};
+	if (inventory.runtimeStatus.status !== "running") return {
+		kind: "not_running",
+		expectedVersion,
+		installedVersion,
+		runtimeStatus: inventory.runtimeStatus.status
+	};
+	return {
+		kind: "ready",
+		expectedVersion,
+		installedVersion,
+		runtimeStatus: inventory.runtimeStatus.status
+	};
+}
+async function runDaemonServiceParticipationGate(input) {
+	if (!shouldRunDaemonServiceParticipationGate(input)) return { status: "aligned" };
+	const initialStatus = await resolveDaemonServiceParticipationStatus();
+	if (initialStatus.kind === "ready") return { status: "aligned" };
+	const codePrefix = resolveDaemonServiceParticipationCodePrefix(input.intent);
+	const installStageResult = await runDaemonServiceParticipationInstallStage({
+		input,
+		codePrefix,
+		status: initialStatus
+	});
+	if (installStageResult.result) return installStageResult.result;
+	return await runDaemonServiceParticipationActionStage({
+		input,
+		codePrefix,
+		status: installStageResult.status
+	});
+}
+function shouldRunDaemonServiceParticipationGate(input) {
+	return input.resolvedView === "human" && input.allowPrompt && (input.forcePrompt === true || shouldRequireDaemonServiceParticipation(input.localDemand));
+}
+async function runDaemonServiceParticipationInstallStage(input) {
+	if (input.status.kind !== "missing" && input.status.kind !== "outdated") return { status: input.status };
+	const installResult = await runDaemonInstallDecisionPrompt({
+		kind: input.status.kind,
+		...input.status.kind === "outdated" ? { installedVersion: input.status.installedVersion } : {},
+		expectedVersion: input.status.expectedVersion,
+		emitLine: (text) => {
+			input.input.presenter.line({
+				code: `${input.codePrefix}.install`,
+				text
+			});
+		},
+		installService: async () => {
+			await runDaemonInstall({ view: input.input.view }, { suppressHumanOutput: shouldSuppressHumanInstallOutput(input.input.intent) });
+		}
+	});
+	if (installResult === "cancelled") return {
+		status: input.status,
+		result: { status: "cancelled" }
+	};
+	if (installResult === "failed") return {
+		status: input.status,
+		result: { status: "needs_attention" }
+	};
+	if (installResult === "not_now" || !shouldStartAfterDaemonInstall(input.input.intent)) return {
+		status: input.status,
+		result: { status: "declined" }
+	};
+	const refreshedStatus = await resolveDaemonServiceParticipationStatus();
+	if (refreshedStatus.kind === "ready") return {
+		status: refreshedStatus,
+		result: { status: "aligned" }
+	};
+	if (refreshedStatus.kind === "missing" || refreshedStatus.kind === "outdated") {
+		renderDaemonStartNeedsAttention({
+			presenter: input.input.presenter,
+			codePrefix: input.codePrefix,
+			summary: refreshedStatus.kind === "missing" ? formatDaemonInstallFailedMessage("missing") : formatDaemonInstallFailedMessage("outdated")
+		});
+		return {
+			status: refreshedStatus,
+			result: { status: "needs_attention" }
+		};
+	}
+	return { status: refreshedStatus };
+}
+async function runDaemonServiceParticipationActionStage(input) {
+	if (input.status.kind === "needs_repair") return mapDaemonBackgroundStartResult(await runDaemonBackgroundStartForDecision({ 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 }) }), {
+		presenter: input.input.presenter,
+		codePrefix: input.codePrefix
+	});
+}
+function resolveDaemonServiceParticipationCodePrefix(intent) {
+	switch (intent) {
+		case "start": return "start.service";
+		case "space_create_join": return "space.create_join.service";
+		case "space_join": return "space.join.service";
+		case "space_add_members": return "space.add_members.service";
+		default: throw new Error(`Unknown daemon service participation intent: ${intent}`);
+	}
+}
+function shouldStartAfterDaemonInstall(_intent) {
+	return true;
+}
+function shouldSuppressHumanInstallOutput(intent) {
+	return intent !== "start";
+}
+function mapDaemonBackgroundStartResult(result, input) {
+	if (result === "started" || result === "deferred_with_card") return { status: "aligned" };
+	if (result === "cancelled") return { status: "cancelled" };
+	if (result === "not_now") {
+		renderDaemonStartDeferred({
+			presenter: input.presenter,
+			codePrefix: input.codePrefix
+		});
+		return { status: "declined" };
+	}
+	if (result === "failed") {
+		renderDaemonStartNeedsAttention({
+			presenter: input.presenter,
+			codePrefix: input.codePrefix,
+			summary: "ATS could not finish starting ATS Service."
+		});
+		return { status: "needs_attention" };
+	}
+	return { status: "needs_attention" };
+}
+function renderDaemonStartDeferred(input) {
+	const card = buildDaemonStartDeferredCard();
+	renderInfoCard({
+		presenter: input.presenter,
+		title: card.title,
+		codePrefix: `${input.codePrefix}.deferred`,
+		rows: card.rows
+	});
+}
+function renderDaemonStartNeedsAttention(input) {
+	const card = buildDaemonStartNeedsAttentionCard({ summary: input.summary });
+	renderInfoCard({
+		presenter: input.presenter,
+		title: card.title,
+		codePrefix: `${input.codePrefix}.failed`,
+		rows: card.rows
+	});
+}
+
 //#endregion
 //#region src/command-entry-checks/check-service.ts
 const FIX_SERVICE = "__command_entry_fix_service__";
@@ -51024,10 +51439,9 @@ async function runServiceCheck(input) {
 		shouldAutoRepair: input.requirement.mode !== "status-only",
 		view: input.context.runtime.resolvedView
 	});
-	const shouldSuppressStandaloneHumanServiceCard = shouldDeferHumanServiceCardToJoinQuickCheck(input.context);
 	if (serviceStatus.kind === "ready") return { status: "continue" };
 	if (input.requirement.mode === "status-only") {
-		if (!shouldSuppressStandaloneHumanServiceCard) emitServiceStatus({
+		emitServiceStatus({
 			context: input.context,
 			serviceStatus,
 			blocking: false
@@ -51035,22 +51449,21 @@ async function runServiceCheck(input) {
 		return { status: "continue" };
 	}
 	if (input.context.runtime.resolvedView !== "human" || !input.context.allowPrompt) {
-		if (!shouldSuppressStandaloneHumanServiceCard) emitServiceStatus({
+		emitServiceStatus({
 			context: input.context,
 			serviceStatus,
 			blocking: false
 		});
 		return { status: "continue" };
 	}
-	if (serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") {
-		if (!shouldSuppressStandaloneHumanServiceCard) emitServiceStatus({
+	if (serviceStatus.kind === "needs_repair" || serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") {
+		emitServiceStatus({
 			context: input.context,
 			serviceStatus,
 			blocking: false
 		});
 		return { status: "continue" };
 	}
-	if (shouldSuppressStandaloneHumanServiceCard) return { status: "continue" };
 	const copy = getCommandEntryCopy(input.context.entryName);
 	showHumanCheckCard({
 		presenter: input.context.presenter,
@@ -51085,12 +51498,21 @@ async function runServiceCheck(input) {
 	if (!await fixServiceStatus(serviceStatus)) return { status: "continue" };
 	return { status: "continue" };
 }
-function shouldDeferHumanServiceCardToJoinQuickCheck(context) {
-	return context.entryName === "space.join" && context.runtime.resolvedView === "human";
-}
 async function resolveServiceStatus(input) {
 	const expectedVersion = resolveCurrentDaemonExpectedVersion();
-	const currentStatus = await readCurrentServiceStatus(expectedVersion);
+	const currentStatus = await resolveDaemonServiceParticipationStatus({ expectedVersion }).catch((error) => {
+		warnServiceCheckIssue("resolveDaemonServiceParticipationStatus failed", {
+			error,
+			expectedVersion,
+			view: input.view
+		});
+		return {
+			kind: "not_running",
+			expectedVersion,
+			installedVersion: null,
+			runtimeStatus: null
+		};
+	});
 	if (currentStatus.kind === "ready") return currentStatus;
 	if (input.shouldAutoRepair) {
 		const preflight = await runDaemonStartupPreflight({
@@ -51113,27 +51535,19 @@ async function resolveServiceStatus(input) {
 			detail: buildStartupPreflightAttentionDetail(preflight)
 		};
 	}
-	return await readCurrentServiceStatus(expectedVersion);
-}
-async function readCurrentServiceStatus(expectedVersion) {
-	const daemonStatus = await getDaemonStatus();
-	if (!(daemonStatus.installed && daemonStatus.state)) return { kind: "missing" };
-	if (daemonStatus.state.daemonVersion !== expectedVersion) return {
-		kind: "outdated",
-		installedVersion: daemonStatus.state.daemonVersion
-	};
-	const runtime = await readCurrentDaemonRuntimeContext({ status: daemonStatus }).catch((error) => {
-		warnServiceCheckIssue("readCurrentDaemonRuntimeContext failed", {
-			daemonStatus,
-			error
+	return await resolveDaemonServiceParticipationStatus({ expectedVersion }).catch((error) => {
+		warnServiceCheckIssue("resolveDaemonServiceParticipationStatus failed", {
+			error,
+			expectedVersion,
+			view: input.view
 		});
-		return null;
+		return {
+			kind: "not_running",
+			expectedVersion,
+			installedVersion: null,
+			runtimeStatus: null
+		};
 	});
-	if (!runtime || runtime.effectiveRuntimeStatus !== "running") return {
-		kind: "not_running",
-		runtimeStatus: runtime?.runtimeStatus ?? null
-	};
-	return { kind: "ready" };
 }
 async function fixServiceStatus(serviceStatus) {
 	const expectedVersion = resolveCurrentDaemonExpectedVersion();
@@ -51154,6 +51568,7 @@ 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") {
 		await runDaemonStatusSafely();
 		return false;
@@ -51203,6 +51618,7 @@ function emitServiceStatus(input) {
 function buildServiceStatusText(serviceStatus) {
 	if (serviceStatus.kind === "missing") return "ATS Service is not installed on this device.";
 	if (serviceStatus.kind === "outdated") return `ATS Service is on ${serviceStatus.installedVersion}. ${resolveCurrentDaemonExpectedVersion()} is needed.`;
+	if (serviceStatus.kind === "needs_repair") return "ATS Service needs cleanup before local agents on this device can reply from Space.";
 	if (serviceStatus.kind === "repair_blocked") return "ATS Service needs manual repair before ATS can align it automatically.";
 	if (serviceStatus.kind === "repair_failed") return "ATS tried to repair ATS Service automatically, but the service still needs attention.";
 	return "ATS Service is installed but not running.";
@@ -51210,17 +51626,19 @@ function buildServiceStatusText(serviceStatus) {
 function buildServiceNextText(serviceStatus, action) {
 	if (serviceStatus.kind === "missing") return action ? `Install ATS Service now, or continue ${action} without it.` : "Install ATS Service now, or continue without it.";
 	if (serviceStatus.kind === "outdated") return "Update ATS Service now to match the current ATS CLI.";
+	if (serviceStatus.kind === "needs_repair") return "Repair ATS Service now so local agents on this device can reply from Space again.";
 	if (serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") return "Run `ats service status` first. If ATS still says the service needs repair, run `ats service reinstall`.";
 	return action ? `Start ATS Service now, or continue ${action} without it.` : "Start ATS Service now, or continue without it.";
 }
 function buildServiceFixLabel(serviceStatus) {
 	if (serviceStatus.kind === "missing") return "Install ATS Service now (Recommended)";
 	if (serviceStatus.kind === "outdated") return "Update ATS Service now (Recommended)";
+	if (serviceStatus.kind === "needs_repair") return "Repair ATS Service now (Recommended)";
 	if (serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") return "Open ATS Service diagnostics (Recommended)";
 	return "Start ATS Service now (Recommended)";
 }
 function buildServiceAgentNextSteps(serviceStatus) {
-	if (serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") return formatAtsCliCommands(["ats service status", "ats service reinstall"]);
+	if (serviceStatus.kind === "needs_repair" || serviceStatus.kind === "repair_blocked" || serviceStatus.kind === "repair_failed") return formatAtsCliCommands(["ats service status", "ats service reinstall"]);
 	return formatAtsCliCommands(["ats service install", "ats service run"]);
 }
 function buildStartupPreflightAttentionDetail(preflight) {
@@ -54638,6 +55056,7 @@ async function runSkillsCheck(input) {
 //#endregion
 //#region src/command-entry-checks/run-command-entry-flow.ts
 const CHECK_RUNNERS = {
+	disclaimer: runDisclaimerCheck,
 	cliUpdate: runCliUpdateCheck,
 	signIn: runSignInCheck,
 	selectedProfile: runSelectedProfileCheck,
@@ -54652,6 +55071,7 @@ const CHECK_STAGES = [
 	"status-only"
 ];
 const CHECK_ORDER = [
+	"disclaimer",
 	"cliUpdate",
 	"localRuntimeState",
 	"signIn",
@@ -60533,6 +60953,7 @@ function buildServiceReplyReadinessGuidance(input) {
 }
 function buildReplyReadinessGuidanceSummary(reasonCode) {
 	switch (reasonCode) {
+		case "local_agents.none_needed": return "This device does not need ATS Service until you choose local agents to bring into a space.";
 		case "profile.inactive": return "Choose an active agent profile first.";
 		case "profile.unbound": return "This profile is not connected to an agent yet.";
 		case "controller.binding.disabled": return "This profile's agent is turned off.";
@@ -60561,6 +60982,11 @@ function buildReplyReadinessNextSteps(input) {
 		controllerRef
 	}) ?? controllerRef ?? "<agent-id>";
 	switch (input.reasonCode) {
+		case "local_agents.none_needed": return [
+			formatAtsCliCommand("ats start"),
+			formatAtsCliCommand("ats service install"),
+			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 "controller.binding.disabled": return [formatAtsCliCommand(`ats profile update ${profileId} --controller-enabled true`)];
@@ -62583,19 +63009,6 @@ function normalizeOptionalString$5(value) {
 
 //#endregion
 //#region src/start-foundation/selectors.ts
-const BACKGROUND_HELPER_REASON_CODES = new Set([
-	"background_helper.not_installed",
-	"background_helper.installed_outdated",
-	"background_helper.not_running",
-	"background_helper.stale",
-	"background_helper.unknown"
-]);
-function isCliStartBackgroundHelperReasonCode(reasonCode) {
-	return BACKGROUND_HELPER_REASON_CODES.has(reasonCode);
-}
-function isCliStartBackgroundHelperSignal(signal) {
-	return signal.actionId === "device_check" && isCliStartBackgroundHelperReasonCode(signal.reasonCode);
-}
 function findCliStartSelectedProfileReadinessEntry(input) {
 	return input.foundation.foundationState.readModel.profileReadiness.find((entry) => entry.profileId === input.profileId) ?? null;
 }
@@ -62605,8 +63018,13 @@ function readCliStartDeviceProjection(foundation) {
 function isCliStartNextActionBlocked(foundation) {
 	return foundation.foundationState.decision.status === "blocking";
 }
-function hasCliStartBackgroundHelperBlockingOrAttentionSignal(foundation) {
-	return [...foundation.foundationState.decision.blocking, ...foundation.foundationState.decision.attention].some(isCliStartBackgroundHelperSignal);
+function hasCliStartSelectedLocalAgents(foundation) {
+	return foundation.foundationState.readModel.session.value?.agentSelection.mode === "selected_agents";
+}
+function readCliStartSelectedLocalAgentIds(foundation) {
+	const agentSelection = foundation.foundationState.readModel.session.value?.agentSelection;
+	if (!agentSelection || agentSelection.mode !== "selected_agents") return [];
+	return agentSelection.selectedAgentIds;
 }
 
 //#endregion
@@ -62900,12 +63318,6 @@ function collectStartLocalBackgroundHelperReadiness() {
 async function resolveStartLocalBackgroundHelperDemand(input) {
 	return await resolveDaemonLocalServiceDemand(input);
 }
-async function runStartLocalBackgroundHelperInstall(input) {
-	await runDaemonInstall({ view: input.view });
-}
-async function runStartLocalBackgroundHelperBackgroundStart(input) {
-	return await runDaemonBackgroundStartForDecision({ view: input.view });
-}
 
 //#endregion
 //#region src/start-local/skills-local.ts
@@ -62948,49 +63360,13 @@ async function collectStartLocalReadiness(input) {
 
 //#endregion
 //#region src/commands/start-auth-and-readiness.ts
-const START_DISCLAIMER_ACCEPT = "__start_disclaimer_accept__";
-const START_DISCLAIMER_DECLINE = "__start_disclaimer_decline__";
-const START_V1_DISCLAIMER_VERSION = "start-v1-2026-03-02";
-const START_V1_DISCLAIMER_TEXT = "ATSD is experimental and changes rapidly. Breaking changes may occur. You are fully responsible for data security and sensitive information handling. Use ATSD only in trusted environments.";
 async function runStartDisclaimerStep(input) {
-	if ((await getConfiguredStartV1OnboardingState().catch(() => null))?.disclaimerAcceptedVersion === START_V1_DISCLAIMER_VERSION) return true;
-	if (input.runtime.resolvedView === "agent") {
-		input.presenter.data({
-			code: "start.disclaimer",
-			payload: {
-				version: START_V1_DISCLAIMER_VERSION,
-				text: START_V1_DISCLAIMER_TEXT,
-				mode: "agent_notice",
-				requiresConfirmation: false
-			}
-		});
-		return true;
-	}
-	note(`⚠️ ${START_V1_DISCLAIMER_TEXT}`, "Disclaimer");
-	if (!input.interactive) {
-		input.presenter.line({
-			code: "start.disclaimer.auto_continue",
-			text: "Non-interactive session: disclaimer displayed and onboarding continues."
-		});
-		return true;
-	}
-	const decision = await select({
-		message: "Do you accept and continue?",
-		options: [{
-			value: START_DISCLAIMER_ACCEPT,
-			label: "Yes, continue"
-		}, {
-			value: START_DISCLAIMER_DECLINE,
-			label: "No, exit"
-		}],
-		initialValue: START_DISCLAIMER_ACCEPT
+	return await runOnboardingDisclaimerGate({
+		runtime: input.runtime,
+		presenter: input.presenter,
+		interactive: input.interactive,
+		codePrefix: "start.disclaimer"
 	});
-	if (isCancel(decision) || decision === START_DISCLAIMER_DECLINE) {
-		cancel("Cancelled.");
-		return false;
-	}
-	await persistStartDisclaimerAccepted();
-	return true;
 }
 async function markStartV1Completed() {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -63077,12 +63453,6 @@ function formatReadinessLine(input) {
 	if (!input.detail) return line;
 	return `${line} ${pc.dim(input.detail)}`;
 }
-async function persistStartDisclaimerAccepted() {
-	await updateConfiguredStartV1OnboardingState((current) => ({
-		...current ?? {},
-		disclaimerAcceptedVersion: START_V1_DISCLAIMER_VERSION
-	}));
-}
 function evaluateStartAuthentication(input) {
 	return evaluateCommandAuthentication({ gatewayUrl: input.gatewayUrl });
 }
@@ -64247,10 +64617,14 @@ function resolveStartBackgroundHelperShellState(input) {
 		runtimeStatus: input.readiness.service.runtime?.status ?? "unknown"
 	};
 }
-function resolveStartServiceRecommendation(input) {
-	if (input.backgroundHelper.status === "installed_outdated") return "recommended";
-	if (input.backgroundHelper.status === "installed_current") return input.localDemand?.decision === "keep_running" ? "recommended" : "optional";
-	return hasCliStartBackgroundHelperBlockingOrAttentionSignal(input.foundation) ? "recommended" : "optional";
+function haveRunnableSelectedLocalAgentSetup(input) {
+	const selectedAgentIds = readCliStartSelectedLocalAgentIds(input.foundation);
+	if (selectedAgentIds.length === 0) return false;
+	const candidateById = new Map(input.readiness.agents.candidates.map((candidate) => [candidate.agentId, candidate]));
+	return selectedAgentIds.every((selectedAgentId) => {
+		const candidate = candidateById.get(selectedAgentId);
+		return candidate?.enabled === true && candidate.selectable === true;
+	});
 }
 function emitStartServiceNonInteractiveLine(input) {
 	const text = input.backgroundHelper.status === "installed_current" ? formatInlineAtsCliCommands("⚠️ ATS Service: Installed and up to date, but not currently running. Start it manually with `ats service run`.") : formatInlineAtsCliCommands(input.backgroundHelper.status === "not_installed" ? `⚠️ ATS Service: ${formatDaemonServiceMissingStatus()} ${formatDaemonServiceMissingAction()}` : `⚠️ ATS Service: ${formatDaemonServiceOutdatedStatus({
@@ -64262,78 +64636,47 @@ function emitStartServiceNonInteractiveLine(input) {
 		text
 	});
 }
-function emitStartServiceSkippedLine(input) {
-	const text = resolveStartServiceSkippedText(input);
-	input.presenter.line({
-		code: "start.service.skipped",
-		text: formatInlineAtsCliCommands(text)
+
+//#endregion
+//#region src/system/service-participation-policy.ts
+function resolveCliServiceParticipationRequirement(input) {
+	return resolveServiceParticipationRequirement({
+		intent: input.intent,
+		humanOnlyParticipation: input.humanOnlyParticipation,
+		explicitSelectedLocalAgents: input.explicitSelectedLocalAgents,
+		selectedAgentProfilesHaveRunnableLocalSetup: input.selectedAgentProfilesHaveRunnableLocalSetup,
+		deviceLocalDemand: mapDaemonLocalServiceDemandToSharedValue(input.localDemand)
 	});
 }
-function renderStartServiceDeferredCard(input) {
-	const card = buildDaemonStartDeferredCard();
-	renderInfoCard({
-		presenter: input.presenter,
-		title: card.title,
-		codePrefix: "start.service.deferred",
-		rows: card.rows
-	});
+function isExplicitLocalAgentProfile(profile) {
+	return profile.profileKind === "agent";
 }
-function renderStartServiceFailureCard(input) {
-	const card = buildDaemonStartNeedsAttentionCard({ summary: "ATS could not finish starting ATS Service." });
-	renderInfoCard({
-		presenter: input.presenter,
-		title: card.title,
-		codePrefix: "start.service.failed",
-		rows: card.rows
+function hasRunnableLocalAgentSetup(profile) {
+	return hasRunnableLocalAgentParticipationCandidate({
+		profileKind: profile.profileKind === "agent" ? "agent" : "human",
+		controllerRef: profile.controllerBinding?.controllerRef,
+		controllerEnabled: profile.controllerBinding?.controllerEnabled
 	});
 }
-async function promptForStartServiceInstallDecision(input) {
-	const actionLabel = input.kind === "outdated" ? "Update ATS Service now" : "Install ATS Service now";
-	const statusLine = input.kind === "outdated" ? formatDaemonServiceOutdatedStatus({
-		installedVersion: input.installedVersion,
-		expectedVersion: input.expectedVersion
-	}) : formatDaemonServiceMissingStatus();
-	const explanation = input.recommendation === "recommended" ? "ATS Service lets local agents on this device reply from Space, so we recommend it for this setup." : "You can keep going without ATS Service, but local agents on this device won't be able to reply from Space.";
-	const detailLine = input.kind === "outdated" && input.installedVersion ? `Installed v${input.installedVersion}, expected v${input.expectedVersion}.` : null;
-	const decision = await select({
-		message: [
-			input.kind === "outdated" ? "ATS Service needs an update. Fix it now?" : "ATS Service is missing. Install it now?",
-			explanation,
-			`Current status: ${statusLine}`,
-			detailLine
-		].filter((line) => typeof line === "string" && line.length > 0).join("\n"),
-		initialValue: "fix_now",
-		options: [{
-			value: "fix_now",
-			label: actionLabel,
-			hint: input.recommendation === "recommended" ? "Recommended" : "Optional"
-		}, {
-			value: "not_now",
-			label: "Not now"
-		}]
-	});
-	if (isCancel(decision)) return "cancelled";
-	return decision === "fix_now" ? "fix_now" : "not_now";
+function hasAnyExplicitLocalAgentCandidates(candidates) {
+	return candidates.some((candidate) => candidate.profileKind === "agent");
 }
-function resolveStartServiceSkippedText(input) {
-	if (input.outcome === "failed_install") return input.backgroundHelper.status === "installed_outdated" ? "ATS Service was not updated. Local agents on this device may not be able to reply from Space. Run `ats service install`." : "ATS Service could not be installed. Local agents on this device still can't reply from Space. Run `ats service install`.";
-	return input.backgroundHelper.status === "installed_outdated" ? "ATS Service still needs an update. Local agents on this device may not be able to reply from Space until ATS fixes it. Run `ats service install` later." : "ATS Service is still missing. Local agents on this device can't reply from Space until you install it later with `ats service install`.";
+function haveAllExplicitLocalAgentCandidatesRunnable(candidates) {
+	const agentCandidates = candidates.filter((candidate) => candidate.profileKind === "agent");
+	if (agentCandidates.length === 0) return false;
+	return agentCandidates.every((candidate) => hasRunnableLocalAgentParticipationCandidate(candidate));
 }
-async function promptForStartServiceStartDecision(input) {
-	const decision = await select({
-		message: ["ATS Service is not running. Start it now?", input.recommendation === "recommended" ? "ATS Service lets local agents on this device reply from Space, so we recommend it for this setup." : "You can keep going without ATS Service, but local agents on this device won't be able to reply from Space."].join("\n"),
-		initialValue: "fix_now",
-		options: [{
-			value: "fix_now",
-			label: "Start ATS Service now",
-			hint: input.recommendation === "recommended" ? "Recommended" : "Optional"
-		}, {
-			value: "not_now",
-			label: "Not now"
-		}]
-	});
-	if (isCancel(decision)) return "cancelled";
-	return decision === "fix_now" ? "fix_now" : "not_now";
+function hasRunnableLocalAgentParticipationCandidate(candidate) {
+	if (candidate.profileKind !== "agent") return false;
+	return candidate.controllerEnabled === true && typeof candidate.controllerRef === "string" && candidate.controllerRef.trim().length > 0;
+}
+function mapDaemonLocalServiceDemandToSharedValue(localDemand) {
+	switch (localDemand?.decision) {
+		case "keep_running":
+		case "allow_auto_stop":
+		case "indeterminate": return localDemand.decision;
+		default: return "indeterminate";
+	}
 }
 
 //#endregion
@@ -64343,6 +64686,7 @@ async function runStartServiceStep(input) {
 		foundation: input.foundation,
 		readiness: input.readiness
 	});
+	const selectedLocalAgentsRequireService = hasCliStartSelectedLocalAgents(input.foundation);
 	const payload = buildStartServicePayload({
 		readiness: input.readiness,
 		backgroundHelper
@@ -64354,15 +64698,7 @@ async function runStartServiceStep(input) {
 		});
 		return "continue";
 	}
-	if (backgroundHelper.status === "installed_current") return await runInstalledCurrentStartServiceStep({
-		...input,
-		backgroundHelper
-	});
-	const recommendation = resolveStartServiceRecommendation({
-		backgroundHelper,
-		foundation: input.foundation,
-		localDemand: null
-	});
+	if (backgroundHelper.status === "installed_current" && backgroundHelper.runtimeStatus === "running") return "continue";
 	if (!input.interactive) {
 		emitStartServiceNonInteractiveLine({
 			presenter: input.presenter,
@@ -64370,78 +64706,46 @@ async function runStartServiceStep(input) {
 		});
 		return "continue";
 	}
-	const decision = await promptForStartServiceInstallDecision({
-		kind: backgroundHelper.status === "installed_outdated" ? "outdated" : "missing",
-		installedVersion: backgroundHelper.installedVersion ?? void 0,
-		expectedVersion: backgroundHelper.expectedVersion,
-		recommendation
+	const localDemand = await resolveStartLocalBackgroundHelperDemand({ ownerUserId: input.ownerUserId }).catch(() => null);
+	const currentProfileIsExplicitLocalAgent = isExplicitLocalAgentProfile(input.profile);
+	const selectedLocalAgentsHaveRunnableLocalSetup = !selectedLocalAgentsRequireService || haveRunnableSelectedLocalAgentSetup({
+		foundation: input.foundation,
+		readiness: input.readiness
 	});
-	if (decision === "cancelled") {
-		cancel("Cancelled.");
-		return "cancelled";
-	}
-	if (decision === "fix_now") {
-		try {
-			await runStartLocalBackgroundHelperInstall({ view: input.view });
-		} catch {
-			emitStartServiceSkippedLine({
-				presenter: input.presenter,
-				backgroundHelper,
-				outcome: "failed_install"
-			});
-			return "needs_attention";
-		}
-		return "continue";
-	}
-	emitStartServiceSkippedLine({
-		presenter: input.presenter,
-		backgroundHelper,
-		outcome: "not_fixed"
+	const currentProfileHasRunnableLocalSetup = !currentProfileIsExplicitLocalAgent || hasRunnableLocalAgentSetup(input.profile);
+	const serviceRequirement = resolveCliServiceParticipationRequirement({
+		intent: "start",
+		humanOnlyParticipation: !(selectedLocalAgentsRequireService || currentProfileIsExplicitLocalAgent) && localDemand?.decision !== "keep_running",
+		explicitSelectedLocalAgents: selectedLocalAgentsRequireService || currentProfileIsExplicitLocalAgent,
+		selectedAgentProfilesHaveRunnableLocalSetup: selectedLocalAgentsHaveRunnableLocalSetup && currentProfileHasRunnableLocalSetup,
+		localDemand
 	});
-	return "continue";
-}
-async function runInstalledCurrentStartServiceStep(input) {
-	const localDemand = input.runtime.resolvedView === "human" && input.interactive ? await resolveStartLocalBackgroundHelperDemand({ ownerUserId: input.ownerUserId }).catch(() => null) : null;
-	if (input.backgroundHelper.runtimeStatus === "running") return "continue";
-	if (localDemand && localDemand.decision !== "keep_running") return "continue";
-	if (!input.interactive) {
-		emitStartServiceNonInteractiveLine({
-			presenter: input.presenter,
-			backgroundHelper: input.backgroundHelper
+	if (serviceRequirement === "not_needed") return "continue";
+	if (serviceRequirement === "agent_setup_needed") {
+		input.presenter.line({
+			code: "start.service.agent_setup_needed",
+			text: `Finish local agent setup before you bring this profile into a space. Use \`ats profile ready --profile ${input.profile.atsProfileId}\` or rerun \`ats start\`.`
 		});
 		return "continue";
 	}
-	return await handleInstalledCurrentStartServiceDecision({
+	const gateResult = await runDaemonServiceParticipationGate({
+		intent: "start",
 		presenter: input.presenter,
-		recommendation: resolveStartServiceRecommendation({
-			backgroundHelper: input.backgroundHelper,
-			foundation: input.foundation,
-			localDemand
-		}),
+		resolvedView: input.runtime.resolvedView,
+		allowPrompt: input.interactive,
+		localDemand,
+		forcePrompt: selectedLocalAgentsRequireService || currentProfileIsExplicitLocalAgent,
 		view: input.view
 	});
-}
-async function handleInstalledCurrentStartServiceDecision(input) {
-	const decision = await promptForStartServiceStartDecision({ recommendation: input.recommendation });
-	if (decision === "cancelled") {
-		cancel("Cancelled.");
-		return "cancelled";
-	}
-	if (decision === "not_now") {
-		renderStartServiceDeferredCard({ presenter: input.presenter });
-		return "continue";
-	}
-	const startResult = await runStartLocalBackgroundHelperBackgroundStart({ view: input.view }).catch(() => "failed");
-	if (startResult === "cancelled") {
+	if (gateResult.status === "cancelled") {
 		cancel("Cancelled.");
 		return "cancelled";
 	}
-	if (startResult === "deferred_with_card") return "continue";
-	if (startResult === "failed") {
-		renderStartServiceFailureCard({ presenter: input.presenter });
-		return "needs_attention";
-	}
-	if (startResult === "failed_with_card") return "needs_attention";
+	if (gateResult.status === "needs_attention") return "needs_attention";
+	if (gateResult.status === "declined") input.presenter.line({
+		code: "start.service.declined",
+		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";
 }
 
@@ -71915,6 +72219,11 @@ async function emitSpaceCommandPreflight(input) {
 		},
 		serviceRepairGuidance: resolveSpacePreflightRepairGuidance({ serviceParticipationReadiness })
 	};
+	if (!shouldEmitSpaceCommandPreflightOutput(input.emitOutput)) return {
+		deviceReplyReadiness: replyReadinessSnapshot.deviceReplyReadiness,
+		payload,
+		serviceParticipationReadiness
+	};
 	if (input.resolvedView === "human") {
 		const authLabel = buildHumanPreflightAuthLabel(payload.auth);
 		const agentReplyReadinessLabel = payload.agentReplyReadiness && input.profile.profileKind === "agent" && shouldSurfaceSenderReplyReadinessInPreflightHeadline(input.command) ? formatReplyReadinessSummary(payload.agentReplyReadiness) : null;
@@ -71926,7 +72235,8 @@ async function emitSpaceCommandPreflight(input) {
 			profileName: payload.profile.profileName,
 			agentReplyReadinessLabel,
 			guidance: payload.serviceRepairGuidance,
-			serviceParticipationReadiness
+			serviceParticipationReadiness,
+			humanServiceGuidanceMode: input.humanServiceGuidanceMode ?? "show"
 		});
 		return {
 			deviceReplyReadiness: replyReadinessSnapshot.deviceReplyReadiness,
@@ -71984,7 +72294,8 @@ function emitHumanSpaceCommandPreflight(input) {
 		emitSpacePreflightRepairGuidance({
 			presenter: input.presenter,
 			command: input.command,
-			guidance: input.guidance
+			guidance: input.guidance,
+			mode: input.humanServiceGuidanceMode
 		});
 		return;
 	}
@@ -71995,7 +72306,8 @@ function emitHumanSpaceCommandPreflight(input) {
 	emitSpacePreflightRepairGuidance({
 		presenter: input.presenter,
 		command: input.command,
-		guidance: input.guidance
+		guidance: input.guidance,
+		mode: input.humanServiceGuidanceMode
 	});
 }
 function shouldSurfaceSenderReplyReadinessInPreflightHeadline(command) {
@@ -72063,7 +72375,7 @@ function toSpacePreflightAgentReplyReadiness(input) {
 	};
 }
 function emitSpacePreflightRepairGuidance(input) {
-	if (!input.guidance) return;
+	if (!input.guidance || input.mode === "suppress") return;
 	input.presenter.line({
 		code: `space.${input.command}.preflight.next_step`,
 		text: `Next step: ${input.guidance.summary}`,
@@ -72073,6 +72385,9 @@ function emitSpacePreflightRepairGuidance(input) {
 		}
 	});
 }
+function shouldEmitSpaceCommandPreflightOutput(emitOutput) {
+	return emitOutput !== false;
+}
 function emitSpaceFailureNextStep(input) {
 	const guidance = resolveSpaceFailureGuidance(input.error);
 	if (!guidance) return;
@@ -79302,10 +79617,6 @@ function emitSpaceJoinLockBlocked(input) {
 
 //#endregion
 //#region src/space/join-entry.ts
-const NOT_INSTALLED_DAEMON_STATUS = {
-	installed: false,
-	state: null
-};
 const LOCAL_SERVICE_ONLY_JOIN_BLOCK_REASON_CODES = new Set([
 	"service.drifted",
 	"service.not_installed",
@@ -79413,99 +79724,67 @@ 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";
+	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\`.`
+		});
+		return "cancelled";
+	}
+	const shouldManageServiceParticipation = serviceRequirement === "offer_service_gate";
 	const runPreflight = async () => await emitSpaceCommandPreflight({
 		presenter: input.presenter,
 		command: "join",
 		profile: input.atsProfile,
 		baseUrl: input.baseUrl,
-		resolvedView: input.resolvedView
-	});
-	let preflight = await runPreflight();
-	const blockingLocalServiceOutcome = await maybeHandleBlockingLocalServiceAttentionBeforeSpaceJoin({
-		localDemand: input.localDemand ?? null,
-		preflight,
-		presenter: input.presenter,
 		resolvedView: input.resolvedView,
-		view: input.view
+		humanServiceGuidanceMode: shouldManageServiceParticipation || serviceRequirement === "not_needed" ? "suppress" : "show"
 	});
-	if (blockingLocalServiceOutcome === "recovered") preflight = await runPreflight();
-	if (preflight.deviceReplyReadiness.replyReadiness === "blocked") {
-		if (blockingLocalServiceOutcome === "continue_without_service" || blockingLocalServiceOutcome === "recovered" && isBlockingLocalServiceJoinAttention(preflight)) return;
-		if (await maybeOfferDaemonStartBeforeSpaceJoin({
-			localDemand: input.localDemand ?? null,
+	let preflight = await runPreflight();
+	if (shouldManageServiceParticipation) {
+		const gateResult = await runDaemonServiceParticipationGate({
+			intent: input.serviceIntent ?? "space_join",
 			presenter: input.presenter,
+			resolvedView: input.resolvedView,
+			allowPrompt: input.allowPrompt ?? true,
+			localDemand: input.localDemand ?? null,
 			view: input.view
-		})) preflight = await runPreflight();
-		if (preflight.deviceReplyReadiness.replyReadiness === "blocked") throw new Error(preflight.deviceReplyReadiness.reasonText);
-		return;
-	}
-	if (blockingLocalServiceOutcome !== "not_applicable") return;
-	await maybeOfferDaemonStartBeforeSpaceJoin({
-		localDemand: input.localDemand ?? null,
-		presenter: input.presenter,
-		view: input.view
-	});
-}
-async function maybeHandleBlockingLocalServiceAttentionBeforeSpaceJoin(input) {
-	if (input.resolvedView !== "human" || !isBlockingLocalServiceJoinAttention(input.preflight)) return "not_applicable";
-	if (input.preflight.deviceReplyReadiness.reasonCodes.includes("service.drifted")) return await maybeOfferDaemonRepairBeforeSpaceJoin({
-		localDemand: input.localDemand ?? null,
-		view: input.view
-	}) ? "recovered" : "continue_without_service";
-	return await maybeOfferDaemonStartBeforeSpaceJoin({
-		localDemand: input.localDemand ?? null,
-		presenter: input.presenter,
-		view: input.view
-	}) ? "recovered" : "continue_without_service";
-}
-function isBlockingLocalServiceJoinAttention(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));
-}
-async function maybeOfferDaemonRepairBeforeSpaceJoin(input) {
-	if (!isHumanInteractiveJoinRuntime(await resolveRuntimeContext({ view: input.view }))) return false;
-	if (input.localDemand?.decision !== "keep_running") return false;
-	return await runDaemonBackgroundStartForDecision({ view: input.view }) === "started";
-}
-async function maybeOfferDaemonStartBeforeSpaceJoin(input) {
-	const runtime = await resolveRuntimeContext({ view: input.view });
-	if (runtime.resolvedView !== "human" || !canUseInteractivePrompts(runtime)) return false;
-	if (input.localDemand?.decision !== "keep_running") return false;
-	const daemonStatus = await getDaemonStatus().catch(() => NOT_INSTALLED_DAEMON_STATUS);
-	if (!daemonStatus.installed) return false;
-	const runtimeState = await resolveDaemonRuntimeState(daemonStatus);
-	if (!runtimeState) return false;
-	const { serviceManagerStatus } = await resolveDaemonServiceManagerForRuntimeState({
-		runtimeState,
-		status: daemonStatus
-	});
-	if (!shouldOfferDaemonStartDecision(getEffectiveDaemonRuntimeStatus({
-		runtimeState,
-		serviceManagerStatus
-	}))) return false;
-	const decision = await runDaemonStartDecisionPrompt({ startService: async () => await runDaemonBackgroundStartForDecision({ view: input.view }) });
-	if (decision === "not_now") {
-		const card = buildDaemonStartDeferredCard();
-		renderInfoCard({
+		});
+		if (gateResult.status === "cancelled") return "cancelled";
+		preflight = await emitSpaceCommandPreflight({
 			presenter: input.presenter,
-			title: card.title,
-			codePrefix: "space.join.service.deferred",
-			rows: card.rows
+			command: "join",
+			profile: input.atsProfile,
+			baseUrl: input.baseUrl,
+			resolvedView: input.resolvedView,
+			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`."
 		});
-		return false;
 	}
-	if (decision === "cancelled" || decision === "deferred_with_card") return false;
-	if (decision === "failed") {
-		const card = buildDaemonStartNeedsAttentionCard({ summary: "ATS could not finish starting ATS Service." });
-		renderInfoCard({
-			presenter: input.presenter,
-			title: card.title,
-			codePrefix: "space.join.service.failed",
-			rows: card.rows
+	if (preflight.deviceReplyReadiness.replyReadiness === "blocked" && (shouldManageServiceParticipation || serviceRequirement === "not_needed") && isBlockingLocalServiceJoinAttention(preflight)) {
+		if (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 false;
+		return "continue";
 	}
-	return decision === "started";
+	if (preflight.deviceReplyReadiness.replyReadiness === "blocked") throw new Error(preflight.deviceReplyReadiness.reasonText);
+	return "continue";
+}
+function isBlockingLocalServiceJoinAttention(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));
 }
 function buildJoinTargetMissingMessage(input) {
 	return formatMessage(input.resolvedView, "space.target.missing", { command: "join" });
@@ -79857,7 +80136,8 @@ function normalizeSpaceJoinMembershipCandidate(value) {
 		ownerProfileName: normalizeOptionalString$2(candidate.ownerProfileName),
 		ownerUserId: normalizeOptionalString$2(candidate.ownerUserId),
 		ownerName: normalizeOptionalString$2(candidate.ownerName),
-		controllerRef: normalizeOptionalString$2(candidate.controllerRef)
+		controllerRef: normalizeOptionalString$2(candidate.controllerRef),
+		controllerEnabled: candidate.controllerEnabled === true
 	};
 }
 function resolveSpaceJoinMembershipProfileKind(value) {
@@ -79875,6 +80155,7 @@ function buildLocallyCreatedPendingSpaceJoinMembershipCandidate(profile) {
 		ownerUserId: profile.ownerUserId,
 		ownerName: typeof profile.ownerName === "string" ? profile.ownerName : null,
 		controllerRef: profile.controllerBinding?.controllerRef ?? null,
+		controllerEnabled: profile.controllerBinding?.controllerEnabled === true,
 		alreadyJoined: false,
 		needsActivation: false
 	};
@@ -80086,6 +80367,12 @@ async function applySelectedSpaceAddMembersBeforeJoin(input, dependencies) {
 		});
 	}
 	if (confirmedCandidates.candidates.length === 0) return "completed";
+	if (await dependencies.prepareSpaceMemberCandidatesLocalParticipation({
+		actorProfile: input.actorProfile,
+		candidates: confirmedCandidates.candidates,
+		presenter: input.presenter,
+		resolvedView: input.resolvedView
+	}) === "cancelled") return input.cancelResult;
 	const result = await dependencies.applySpaceAddMembers({
 		actorProfile: input.actorProfile,
 		candidates: confirmedCandidates.candidates,
@@ -80614,6 +80901,7 @@ function buildPostCreateJoinRequest(input) {
 		...typeof input.postCreateJoin?.mentionAlias === "string" ? { mentionAlias: input.postCreateJoin.mentionAlias } : {},
 		...typeof input.postCreateJoin?.rawStream === "boolean" ? { rawStream: input.postCreateJoin.rawStream } : {},
 		...typeof input.postCreateJoin?.skipBringProfilesPrompt === "boolean" ? { skipBringProfilesPrompt: input.postCreateJoin.skipBringProfilesPrompt } : {},
+		serviceIntent: input.postCreateJoin?.serviceIntent ?? "space_create_join",
 		entryChecksHandled: true
 	};
 }
@@ -80643,7 +80931,8 @@ async function runSpaceCreate(input) {
 			command: "create",
 			profile: atsProfile,
 			baseUrl,
-			resolvedView: contextRuntime.resolvedView
+			resolvedView: contextRuntime.resolvedView,
+			humanServiceGuidanceMode: isHumanInteractiveSpaceRuntime(contextRuntime) ? "suppress" : "show"
 		});
 		await ensureSpaceCreateAuthReady({ baseUrl });
 		const createInput = await resolveSpaceCreateInput({
@@ -81743,6 +82032,17 @@ async function runSpaceAddMembersForTarget(input) {
 		selectedProfileIds
 	});
 	if (selectedCandidates.length === 0) return { status: "completed" };
+	if (await ensureSpaceMemberCandidatesLocalParticipationReady({
+		atsProfile: input.atsProfile,
+		candidates: selectedCandidates,
+		presenter: input.presenter,
+		resolvedView: input.runtime.resolvedView,
+		allowPrompt: input.allowPrompt,
+		view: input.view
+	}) === "cancelled") return input.allowBackToCaller ? {
+		status: "repeat_target",
+		authenticatedGatewayUrl
+	} : { status: "cancelled" };
 	const result = await applySpaceAddMembers({
 		actorProfile: input.atsProfile,
 		candidates: selectedCandidates,
@@ -81849,6 +82149,46 @@ async function runSpaceRemoveMembersForTarget(input) {
 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({
+		intent: "space_add_members",
+		humanOnlyParticipation: !explicitSelectedLocalAgents,
+		explicitSelectedLocalAgents,
+		selectedAgentProfilesHaveRunnableLocalSetup: haveAllExplicitLocalAgentCandidatesRunnable(input.candidates),
+		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";
+	}
+	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";
+	}
+	const gateResult = await runDaemonServiceParticipationGate({
+		intent: "space_add_members",
+		presenter: input.presenter,
+		resolvedView: input.resolvedView,
+		allowPrompt: input.allowPrompt,
+		localDemand: await resolveDaemonLocalServiceDemand({ ownerUserId: input.atsProfile.ownerUserId }).catch(() => null),
+		forcePrompt: explicitSelectedLocalAgents,
+		view: input.view
+	});
+	if (gateResult.status === "cancelled") return "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";
+}
 async function runSpaceJoin(input) {
 	let failureRuntime = null;
 	let failurePresenter = null;
@@ -81889,7 +82229,8 @@ async function runSpaceJoin(input) {
 			role: input.role,
 			roleInstructions: input.roleInstructions,
 			mentionAlias: input.mentionAlias,
-			rawStream: input.rawStream === true
+			rawStream: input.rawStream === true,
+			serviceIntent: input.serviceIntent ?? "space_join"
 		});
 	} catch (error) {
 		const runtime = failureRuntime ?? await resolveRuntimeContext({
@@ -81936,7 +82277,8 @@ async function runSpaceJoinTargetLoop(input) {
 						rawStream: input.rawStream,
 						skipBringProfilesPrompt: input.skipBringProfilesPrompt,
 						output: input.output,
-						view: input.view
+						view: input.view,
+						serviceIntent: "space_create_join"
 					}
 				});
 			}
@@ -81948,14 +82290,16 @@ async function runSpaceJoinTargetLoop(input) {
 			space: target.space
 		}), "reading an existing local space config before join");
 		const targetBaseUrl = input.hasExplicitBaseUrlInput ? input.baseUrl : target.baseUrl ?? input.baseUrl;
-		await assertSpaceJoinTargetPreflightReady({
+		if (await assertSpaceJoinTargetPreflightReady({
 			atsProfile: input.atsProfile,
 			baseUrl: targetBaseUrl,
+			allowPrompt: input.canPromptPreJoinActions,
 			localDemand: input.localDemand,
 			presenter: input.presenter,
 			resolvedView: input.runtime.resolvedView,
+			serviceIntent: input.serviceIntent,
 			view: input.view
-		});
+		}) === "cancelled") return "cancelled";
 		authenticatedGatewayUrl = await ensureSpaceCommandGatewayAuthenticationOrCancel({
 			runtime: input.runtime,
 			gatewayUrl: targetBaseUrl,
@@ -81997,6 +82341,14 @@ async function runSpaceJoinTargetLoop(input) {
 			resolveCreateProfileName,
 			resolveAgentProfileSetup,
 			persistAgentTransportSelection,
+			prepareSpaceMemberCandidatesLocalParticipation: async ({ actorProfile, candidates, presenter, resolvedView }) => await ensureSpaceMemberCandidatesLocalParticipationReady({
+				atsProfile: actorProfile,
+				candidates,
+				presenter,
+				resolvedView,
+				allowPrompt: input.canPromptPreJoinActions,
+				view: input.view
+			}),
 			applySpaceAddMembers,
 			persistSpaceAddMembersJoinNotices,
 			emitSpaceAddMembersResult
@@ -83027,6 +83379,7 @@ async function resolveSpaceMemberCandidatesForAdd(input) {
 			ownerUserId: profile.ownerUserId,
 			ownerName: profile.ownerName,
 			controllerRef: profile.controllerBinding?.controllerRef,
+			controllerEnabled: profile.controllerBinding?.controllerEnabled,
 			alreadyJoined: memberProfileIds.has(profile.atsProfileId),
 			needsActivation: false
 		};
@@ -87026,11 +87379,13 @@ async function runStart(input) {
 	const presenter = createPresenter(runtime);
 	const interactive = canUseInteractivePrompts(runtime);
 	if (interactive && runtime.resolvedView === "human") intro(`\n${renderAtsHeader()}`);
-	if (!await runStartDisclaimerStep({
-		runtime,
-		presenter,
-		interactive
-	})) return;
+	if (!input.entryChecksHandled) {
+		if (!await runStartDisclaimerStep({
+			runtime,
+			presenter,
+			interactive
+		})) return;
+	}
 	if (input.startSession) {
 		await runStartHandoff({
 			...input,
@@ -91667,7 +92022,8 @@ async function runStartFromCliOptions(opts) {
 		baseUrl: opts.gatewayUrl,
 		startSession: opts.startSession,
 		skillsMode: opts.skillsMode,
-		view: opts.view
+		view: opts.view,
+		entryChecksHandled: true
 	});
 }
 function withSpaceProfileOption(cmd) {