agent-transport-system 0.1.6 → 0.1.8

package/dist/ats.js

@@ -17,7 +17,7 @@ import WebSocket from "ws";
 import { clearLine, createInterface, cursorTo, moveCursor } from "node:readline";
 
 //#region package.json
-var version$1 = "0.1.6";
+var version$1 = "0.1.8";
 var package_default = {
 	name: "agent-transport-system",
 	version: version$1,
@@ -40,7 +40,9 @@ var package_default = {
 		"build:deps": "pnpm --filter @agent-transport-system/agent-runtime build && pnpm --filter @agent-transport-system/protocol build && pnpm --filter @agent-transport-system/gateway-contract build && pnpm --filter @agent-transport-system/schemas build && pnpm --filter @agent-transport-system/adapter-core build && pnpm --filter @agent-transport-system/adapter-claude-code build && pnpm --filter @agent-transport-system/adapter-codex build && pnpm --filter @agent-transport-system/adapter-openclaw build && pnpm --filter @agent-transport-system/atsd build",
 		"prebuild": "pnpm run build:deps",
 		"build": "tsdown",
-		"prepack": "pnpm run build",
+		"prepack": "pnpm run build && pnpm run verify:pack-readme",
+		"prepublishOnly": "pnpm run verify:pack-readme",
+		"verify:pack-readme": "node scripts/verify-npm-pack-readme.mjs",
 		"pretypecheck": "pnpm run build:deps",
 		"typecheck": "tsc -p tsconfig.json --noEmit",
 		"precheck": "pnpm run build:deps",
@@ -6141,59 +6143,6 @@ const signalTextEnvelopeSchema = object({
 const signalEnvelopeSchema = union([presenceEnvelopeSchema, signalTextEnvelopeSchema]);
 const incomingServerMessageSchema = union([signalEnvelopeSchema, helloAckSchema]);
 
-//#endregion
-//#region src/protocol/urls.ts
-const TRAILING_SLASHES_REGEX = /\/+$/;
-const ROOT_PATH_REGEX = /^\/+$/;
-function normalizeBaseUrl(baseUrl) {
-	const url = new URL(baseUrl);
-	if (!ROOT_PATH_REGEX.test(url.pathname)) throw new Error("baseUrl must be origin-only (no path prefix)");
-	if (url.search || url.hash) throw new Error("baseUrl must be origin-only (no query or hash)");
-	url.pathname = "";
-	url.search = "";
-	url.hash = "";
-	return url.toString().replace(TRAILING_SLASHES_REGEX, "");
-}
-function toSpaceSignalsUrl(baseUrl, space) {
-	const url = new URL(normalizeBaseUrl(baseUrl));
-	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/signals`;
-	return url.toString();
-}
-function toSpaceCreateUrl(baseUrl) {
-	const url = new URL(normalizeBaseUrl(baseUrl));
-	url.pathname = "/v1/spaces";
-	return url.toString();
-}
-function toSpaceDeleteUrl(baseUrl, space) {
-	const url = new URL(normalizeBaseUrl(baseUrl));
-	url.pathname = `/v1/spaces/${encodeURIComponent(space)}`;
-	return url.toString();
-}
-function toSpaceMetaUrl(baseUrl, space) {
-	const url = new URL(normalizeBaseUrl(baseUrl));
-	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/meta`;
-	return url.toString();
-}
-function toSpacePasswordUrl(baseUrl, space) {
-	const url = new URL(normalizeBaseUrl(baseUrl));
-	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/password`;
-	return url.toString();
-}
-function toSpaceCursorUrl(baseUrl, space, profileId) {
-	const url = new URL(normalizeBaseUrl(baseUrl));
-	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/cursors/${encodeURIComponent(profileId)}`;
-	return url.toString();
-}
-function toSpaceWsUrl(baseUrl, space) {
-	const http = new URL(normalizeBaseUrl(baseUrl));
-	let wsScheme;
-	if (http.protocol === "http:") wsScheme = "ws:";
-	else if (http.protocol === "https:") wsScheme = "wss:";
-	else if (http.protocol === "ws:" || http.protocol === "wss:") wsScheme = http.protocol;
-	else throw new Error(`unsupported baseUrl protocol for websocket URL: ${http.protocol}`);
-	return `${wsScheme}//${http.host}/v1/spaces/${encodeURIComponent(space)}/stream`;
-}
-
 //#endregion
 //#region src/config/paths.ts
 const MAX_ACCOUNT_PATH_SEGMENT_LENGTH = 128;
@@ -6452,6 +6401,517 @@ function getErrorCode$2(err) {
 	return typeof code === "string" ? code : void 0;
 }
 
+//#endregion
+//#region src/config/daemon-state.ts
+const DAEMON_STATE_SCHEMA = "ats-daemon-install-v1";
+const DAEMON_SERVICE_RUNTIME_STATE_SCHEMA = "ats-daemon-service-state-v1";
+const DAEMON_SERVICE_RUNTIME_MODE_ENV = "ATS_DAEMON_RUNTIME_MODE";
+const DAEMON_SERVICE_RUNTIME_DETACHED_ENV = "ATS_DAEMON_RUNTIME_DETACHED";
+const DAEMON_SERVICE_RUNTIME_CONTROLLER_ENV = "ATS_DAEMON_SERVICE_CONTROLLER";
+const DAEMON_SERVICE_RUNTIME_AUTO_START_ENV = "ATS_DAEMON_SERVICE_AUTO_START";
+const DAEMON_SERVICE_RUNTIME_SYSTEM_SERVICE_ENV = "ATS_DAEMON_RUNTIME_SYSTEM_SERVICE";
+const DAEMON_TOKEN_SCHEMA = "ats-daemon-token-v1";
+const DAEMON_TOKEN_ROTATE_MAX_AGE_MS = 1440 * 60 * 1e3;
+const DAEMON_HEARTBEAT_STALE_MS = 180 * 1e3;
+const DAEMON_SERVICE_LOCK_PROFILE = "daemon-service";
+const DAEMON_SERVICE_LOCK_KEY = "daemon-service-run";
+const DAEMON_SERVICE_RECONCILE_LOCK_KEY = DAEMON_SERVICE_LOCK_KEY;
+async function getDaemonStatus() {
+	const [state, runtimeExists] = await Promise.all([readDaemonInstallState(), pathExists$1(daemonRuntimeRootPath())]);
+	if (state && runtimeExists) return {
+		installed: true,
+		state
+	};
+	return {
+		installed: false,
+		state: null
+	};
+}
+async function getDaemonRuntimeStatus() {
+	const state = await readDaemonServiceRuntimeState();
+	if (!state) return {
+		status: "not_running",
+		mode: null,
+		pid: null,
+		startedAt: null,
+		updatedAt: null,
+		managedBySystemService: false,
+		serviceController: "unknown",
+		autoStart: false
+	};
+	if (!Number.isInteger(state.pid) || state.pid <= 0) return {
+		status: "stale",
+		mode: state.mode,
+		pid: state.pid,
+		startedAt: state.startedAt,
+		updatedAt: state.updatedAt,
+		managedBySystemService: state.managedBySystemService,
+		serviceController: state.serviceController,
+		autoStart: state.autoStart,
+		reason: "invalid_pid"
+	};
+	if (!isPidAlive$2(state.pid)) return {
+		status: "stale",
+		mode: state.mode,
+		pid: state.pid,
+		startedAt: state.startedAt,
+		updatedAt: state.updatedAt,
+		managedBySystemService: state.managedBySystemService,
+		serviceController: state.serviceController,
+		autoStart: state.autoStart,
+		reason: "process_not_alive"
+	};
+	if (isDaemonHeartbeatStale(state)) return {
+		status: "stale",
+		mode: state.mode,
+		pid: state.pid,
+		startedAt: state.startedAt,
+		updatedAt: state.updatedAt,
+		managedBySystemService: state.managedBySystemService,
+		serviceController: state.serviceController,
+		autoStart: state.autoStart,
+		reason: "heartbeat_stale"
+	};
+	return {
+		status: "running",
+		mode: state.mode,
+		pid: state.pid,
+		startedAt: state.startedAt,
+		updatedAt: state.updatedAt,
+		managedBySystemService: state.managedBySystemService,
+		serviceController: state.serviceController,
+		autoStart: state.autoStart
+	};
+}
+function resolveDaemonServiceRuntimeMetadata(input = {}) {
+	const env = input.env ?? process.env;
+	const managedBySystemService = input.managedBySystemService === true || env[DAEMON_SERVICE_RUNTIME_SYSTEM_SERVICE_ENV] === "1";
+	const serviceControllerInput = typeof input.serviceController === "string" && input.serviceController.length > 0 ? input.serviceController : env[DAEMON_SERVICE_RUNTIME_CONTROLLER_ENV];
+	const autoStart = input.autoStart === true || env[DAEMON_SERVICE_RUNTIME_AUTO_START_ENV] === "1";
+	return {
+		managedBySystemService,
+		serviceController: parseDaemonServiceController(serviceControllerInput),
+		autoStart
+	};
+}
+async function setDaemonServiceRuntimeState(state) {
+	await writeDaemonServiceRuntimeState(state);
+}
+async function clearDaemonServiceRuntimeState() {
+	await rm(daemonServiceRuntimeStatePath(), { force: true });
+}
+async function cleanupDaemonServiceRuntimeState() {
+	const status = await getDaemonRuntimeStatus();
+	if (status.status === "running") return;
+	if (status.status === "not_running") return;
+	await clearDaemonServiceRuntimeState();
+}
+async function withDaemonServiceRunLock(callback) {
+	const lock = await acquireLock({
+		profile: DAEMON_SERVICE_LOCK_PROFILE,
+		key: DAEMON_SERVICE_LOCK_KEY
+	});
+	try {
+		return await callback();
+	} finally {
+		await releaseLock(lock);
+	}
+}
+async function withDaemonServiceReconcileLock(callback) {
+	const lock = await acquireLock({
+		profile: DAEMON_SERVICE_LOCK_PROFILE,
+		key: DAEMON_SERVICE_RECONCILE_LOCK_KEY
+	});
+	try {
+		return await callback();
+	} finally {
+		await releaseLock(lock);
+	}
+}
+async function installDaemon(input) {
+	const existingState = await readDaemonInstallState();
+	const runtimeExists = await pathExists$1(daemonRuntimeRootPath());
+	if (existingState && runtimeExists && existingState.daemonVersion === input.daemonVersion) {
+		await ensureDaemonTokenState();
+		return {
+			status: "already_installed",
+			state: existingState
+		};
+	}
+	await ensureDaemonRuntimeLayout();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const nextState = {
+		v: 1,
+		schema: DAEMON_STATE_SCHEMA,
+		daemonVersion: input.daemonVersion,
+		installSource: input.source,
+		installedAt: existingState?.installedAt ?? now,
+		updatedAt: now
+	};
+	await writeDaemonInstallState(nextState);
+	await ensureDaemonTokenState();
+	return {
+		status: "installed",
+		state: nextState
+	};
+}
+async function uninstallDaemon() {
+	const [hasState, hasRuntimeDir, hasToken] = await Promise.all([
+		pathExists$1(daemonStatePath()),
+		pathExists$1(daemonRuntimeRootPath()),
+		pathExists$1(daemonTokenPath())
+	]);
+	await Promise.all([
+		rm(daemonStatePath(), { force: true }),
+		rm(daemonTokenPath(), { force: true }),
+		rm(daemonServiceRuntimeStatePath(), { force: true }),
+		rm(daemonRuntimeRootPath(), {
+			recursive: true,
+			force: true
+		})
+	]);
+	return { removed: hasState || hasRuntimeDir || hasToken };
+}
+async function refreshDaemonTokenLifecycle() {
+	if (!(await getDaemonStatus()).installed) return null;
+	return { tokenUpdatedAt: (await ensureDaemonTokenState()).updatedAt };
+}
+function daemonStatePath() {
+	return join(systemDir(), "daemon-install.json");
+}
+function daemonRuntimeRootPath() {
+	return join(runtimeDir(), "daemon");
+}
+function daemonServiceRuntimeStatePath() {
+	return join(daemonRuntimeRootPath(), "service-runtime.json");
+}
+function daemonRuntimeDataPath() {
+	return join(daemonRuntimeRootPath(), "data");
+}
+function daemonTokenPath() {
+	return join(systemDir(), "daemon-token.json");
+}
+function isPidAlive$2(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return !(error instanceof Error && error.code === "ESRCH");
+	}
+}
+async function readDaemonServiceRuntimeState() {
+	const raw = await readFile(daemonServiceRuntimeStatePath(), "utf8").catch((error) => {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (raw === null) return null;
+	return parseDaemonServiceRuntimeState(raw);
+}
+function parseDaemonServiceRuntimeState(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!isDaemonServiceRuntimeStateObject(parsed)) return null;
+		return {
+			v: 1,
+			schema: DAEMON_SERVICE_RUNTIME_STATE_SCHEMA,
+			status: "running",
+			pid: parsed.pid,
+			mode: parsed.mode,
+			command: parsed.command,
+			gatewayUrl: parseNullableString(parsed.gatewayUrl),
+			profile: parseNullableString(parsed.profile),
+			stopRequestedAt: parseNullableString(parsed.stopRequestedAt),
+			heartbeatAt: parseNullableString(parsed.heartbeatAt),
+			startedAt: parsed.startedAt,
+			updatedAt: parsed.updatedAt,
+			managedBySystemService: parsed.managedBySystemService === true,
+			serviceController: parseDaemonServiceController(parsed.serviceController),
+			autoStart: parsed.autoStart === true
+		};
+	} catch {
+		return null;
+	}
+}
+function isDaemonServiceRuntimeStateObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate.v === 1 && candidate.schema === DAEMON_SERVICE_RUNTIME_STATE_SCHEMA && candidate.status === "running" && typeof candidate.pid === "number" && candidate.pid > 0 && (candidate.mode === "foreground" || candidate.mode === "background") && typeof candidate.command === "string" && candidate.command.length > 0 && isValidNullableString(candidate.gatewayUrl) && isValidNullableString(candidate.profile) && isValidNullableString(candidate.stopRequestedAt) && isValidNullableString(candidate.heartbeatAt) && typeof candidate.startedAt === "string" && candidate.startedAt.length > 0 && typeof candidate.updatedAt === "string" && candidate.updatedAt.length > 0;
+}
+function parseDaemonServiceController(value) {
+	if (value === "launchd" || value === "systemd" || value === "windows-service" || value === "legacy-detached" || value === "unknown") return value;
+	return "unknown";
+}
+function isValidNullableString(value) {
+	return value === null || typeof value === "string";
+}
+function parseNullableString(value) {
+	if (value === null) return null;
+	if (typeof value !== "string") return null;
+	return value;
+}
+function isDaemonHeartbeatStale(state) {
+	const latestSignalAt = Math.max(parseIsoTimestampOrZero(state.heartbeatAt), parseIsoTimestampOrZero(state.updatedAt));
+	if (latestSignalAt <= 0) return false;
+	return Date.now() - latestSignalAt > DAEMON_HEARTBEAT_STALE_MS;
+}
+function parseIsoTimestampOrZero(value) {
+	if (!value) return 0;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+async function writeDaemonServiceRuntimeState(state) {
+	const path = daemonServiceRuntimeStatePath();
+	await mkdir(daemonRuntimeRootPath(), { recursive: true });
+	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+	let shouldCleanupTemp = true;
+	try {
+		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+		await rename(tempPath, path);
+		await chmod(path, 384);
+		shouldCleanupTemp = false;
+	} finally {
+		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
+	}
+}
+async function ensureDaemonRuntimeLayout() {
+	await Promise.all([
+		mkdir(systemDir(), { recursive: true }),
+		mkdir(join(daemonRuntimeRootPath(), "bin"), { recursive: true }),
+		mkdir(join(daemonRuntimeRootPath(), "data"), { recursive: true }),
+		mkdir(join(daemonRuntimeRootPath(), "logs"), { recursive: true })
+	]);
+}
+async function ensureDaemonTokenState() {
+	const current = await readDaemonTokenState();
+	if (current && !isDaemonTokenExpired(current)) {
+		await chmod(daemonTokenPath(), 384).catch(() => void 0);
+		return current;
+	}
+	const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+	const next = {
+		v: 1,
+		schema: DAEMON_TOKEN_SCHEMA,
+		token: createDaemonTokenValue(),
+		issuedAt: nowIso,
+		updatedAt: nowIso
+	};
+	await writeDaemonTokenState(next);
+	return next;
+}
+async function readDaemonInstallState() {
+	const raw = await readFile(daemonStatePath(), "utf8").catch((error) => {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (raw === null) return null;
+	return parseDaemonInstallState(raw);
+}
+function parseDaemonInstallState(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed.v !== 1) return null;
+		if (parsed.schema !== DAEMON_STATE_SCHEMA) return null;
+		if (typeof parsed.daemonVersion !== "string" || !parsed.daemonVersion) return null;
+		if (!isDaemonInstallSource(parsed.installSource)) return null;
+		if (typeof parsed.installedAt !== "string" || !parsed.installedAt) return null;
+		if (typeof parsed.updatedAt !== "string" || !parsed.updatedAt) return null;
+		return {
+			v: 1,
+			schema: DAEMON_STATE_SCHEMA,
+			daemonVersion: parsed.daemonVersion,
+			installSource: parsed.installSource,
+			installedAt: parsed.installedAt,
+			updatedAt: parsed.updatedAt
+		};
+	} catch {
+		return null;
+	}
+}
+function isDaemonInstallSource(value) {
+	return value === "cli.auto_check" || value === "daemon.command.install";
+}
+async function writeDaemonInstallState(state) {
+	const path = daemonStatePath();
+	await mkdir(systemDir(), { recursive: true });
+	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+	let shouldCleanupTemp = true;
+	try {
+		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+		await rename(tempPath, path);
+		shouldCleanupTemp = false;
+	} finally {
+		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
+	}
+}
+async function readDaemonTokenState() {
+	const raw = await readFile(daemonTokenPath(), "utf8").catch((error) => {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (raw === null) return null;
+	return parseDaemonTokenState(raw);
+}
+function parseDaemonTokenState(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed.v !== 1 || parsed.schema !== DAEMON_TOKEN_SCHEMA) return null;
+		if (typeof parsed.token !== "string" || parsed.token.length < 16) return null;
+		if (typeof parsed.issuedAt !== "string" || !parsed.issuedAt) return null;
+		if (typeof parsed.updatedAt !== "string" || !parsed.updatedAt) return null;
+		return {
+			v: 1,
+			schema: DAEMON_TOKEN_SCHEMA,
+			token: parsed.token,
+			issuedAt: parsed.issuedAt,
+			updatedAt: parsed.updatedAt
+		};
+	} catch {
+		return null;
+	}
+}
+async function writeDaemonTokenState(state) {
+	const path = daemonTokenPath();
+	await mkdir(systemDir(), { recursive: true });
+	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+	let shouldCleanupTemp = true;
+	try {
+		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+		await rename(tempPath, path);
+		await chmod(path, 384);
+		shouldCleanupTemp = false;
+	} finally {
+		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
+	}
+}
+function isDaemonTokenExpired(state) {
+	const updatedAtMs = Date.parse(state.updatedAt);
+	if (!Number.isFinite(updatedAtMs)) return true;
+	return Date.now() - updatedAtMs >= DAEMON_TOKEN_ROTATE_MAX_AGE_MS;
+}
+function createDaemonTokenValue() {
+	return randomBytes(32).toString("base64url");
+}
+async function pathExists$1(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/daemon/state/catalog-sync-signal.ts
+const CATALOG_SYNC_SIGNAL_FILE = "catalog-sync-signal.json";
+const CATALOG_SYNC_SIGNAL_SCHEMA = "ats-daemon-catalog-sync-signal-v1";
+async function touchDaemonCatalogSyncSignal(input) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const signalPath = daemonCatalogSyncSignalPath();
+	await mkdir(daemonRuntimeDataPath(), { recursive: true });
+	const next = {
+		v: 1,
+		schema: CATALOG_SYNC_SIGNAL_SCHEMA,
+		updatedAt: now,
+		reason: normalizeReason(input.reason)
+	};
+	const tempPath = `${signalPath}.tmp-${process.pid}-${Date.now()}`;
+	let shouldCleanupTemp = true;
+	try {
+		await writeFile(tempPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+		await rename(tempPath, signalPath);
+		shouldCleanupTemp = false;
+	} finally {
+		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
+	}
+}
+async function readDaemonCatalogSyncSignal() {
+	const raw = await readFile(daemonCatalogSyncSignalPath(), "utf8").catch(() => null);
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed.v !== 1) return null;
+		if (parsed.schema !== CATALOG_SYNC_SIGNAL_SCHEMA || typeof parsed.updatedAt !== "string" || parsed.updatedAt.trim().length === 0 || typeof parsed.reason !== "string") return null;
+		const updatedAt = parsed.updatedAt.trim();
+		const updatedAtMs = Date.parse(updatedAt);
+		if (!Number.isFinite(updatedAtMs) || updatedAtMs <= 0) return null;
+		return {
+			updatedAt,
+			updatedAtMs,
+			reason: normalizeReason(parsed.reason)
+		};
+	} catch {
+		return null;
+	}
+}
+function daemonCatalogSyncSignalPath() {
+	return join(daemonRuntimeDataPath(), CATALOG_SYNC_SIGNAL_FILE);
+}
+function normalizeReason(value) {
+	const normalized = value.trim();
+	if (normalized.length > 0) return normalized;
+	return "local_state_changed";
+}
+
+//#endregion
+//#region src/protocol/urls.ts
+const TRAILING_SLASHES_REGEX = /\/+$/;
+const ROOT_PATH_REGEX = /^\/+$/;
+function normalizeBaseUrl(baseUrl) {
+	const url = new URL(baseUrl);
+	if (!ROOT_PATH_REGEX.test(url.pathname)) throw new Error("baseUrl must be origin-only (no path prefix)");
+	if (url.search || url.hash) throw new Error("baseUrl must be origin-only (no query or hash)");
+	url.pathname = "";
+	url.search = "";
+	url.hash = "";
+	return url.toString().replace(TRAILING_SLASHES_REGEX, "");
+}
+function toSpaceSignalsUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/signals`;
+	return url.toString();
+}
+function toSpaceCreateUrl(baseUrl) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = "/v1/spaces";
+	return url.toString();
+}
+function toSpaceDeleteUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}`;
+	return url.toString();
+}
+function toSpaceMetaUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/meta`;
+	return url.toString();
+}
+function toSpacePasswordUrl(baseUrl, space) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/password`;
+	return url.toString();
+}
+function toSpaceCursorUrl(baseUrl, space, profileId) {
+	const url = new URL(normalizeBaseUrl(baseUrl));
+	url.pathname = `/v1/spaces/${encodeURIComponent(space)}/cursors/${encodeURIComponent(profileId)}`;
+	return url.toString();
+}
+function toSpaceWsUrl(baseUrl, space) {
+	const http = new URL(normalizeBaseUrl(baseUrl));
+	let wsScheme;
+	if (http.protocol === "http:") wsScheme = "ws:";
+	else if (http.protocol === "https:") wsScheme = "wss:";
+	else if (http.protocol === "ws:" || http.protocol === "wss:") wsScheme = http.protocol;
+	else throw new Error(`unsupported baseUrl protocol for websocket URL: ${http.protocol}`);
+	return `${wsScheme}//${http.host}/v1/spaces/${encodeURIComponent(space)}/stream`;
+}
+
 //#endregion
 //#region src/config/runtime-config.ts
 const DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE = "local-cli";
@@ -6561,6 +7021,7 @@ async function updateConfiguredDeviceRuntimeState(updater) {
 		const nextDeviceRuntimeState = updater(previousDeviceRuntimeState);
 		if (JSON.stringify(previousDeviceRuntimeState) === JSON.stringify(nextDeviceRuntimeState)) return;
 		await writeRuntimeConfig(buildNextConfig(previous, { deviceRuntimeState: nextDeviceRuntimeState }));
+		await emitDaemonCatalogSyncSignal$1("device_runtime_state_updated");
 	} finally {
 		await releaseLock(lock);
 	}
@@ -6767,6 +7228,9 @@ async function writeRuntimeConfig(next) {
 		throw error;
 	}
 }
+async function emitDaemonCatalogSyncSignal$1(reason) {
+	await touchDaemonCatalogSyncSignal({ reason }).catch(() => void 0);
+}
 function delay$1(ms) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
@@ -8249,7 +8713,7 @@ async function resolveAtsProfile(input) {
 async function createAtsAgentProfile(input) {
 	const profileName = normalizeOptionalString$8(input.profileName);
 	if (!profileName) throw new Error("profile name is required");
-	return parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
+	const created = parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
 		method: "POST",
 		path: "/v1/profiles/agents",
 		body: {
@@ -8259,15 +8723,19 @@ async function createAtsAgentProfile(input) {
 			...typeof input.controllerEnabled === "boolean" ? { controllerEnabled: input.controllerEnabled } : {}
 		}
 	}), "profile"));
+	await emitDaemonCatalogSyncSignal("profile_created");
+	return created;
 }
 async function createAtsHumanProfile(input) {
 	const profileName = normalizeOptionalString$8(input.profileName);
 	if (!profileName) throw new Error("profile name is required");
-	return parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
+	const created = parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
 		method: "POST",
 		path: "/v1/profiles/humans",
 		body: { profileName }
 	}), "profile"));
+	await emitDaemonCatalogSyncSignal("profile_created");
+	return created;
 }
 async function updateAtsProfile(input) {
 	const atsProfileId = normalizeOptionalString$8(input.atsProfileId);
@@ -8280,7 +8748,7 @@ async function updateAtsProfile(input) {
 	const hasControllerEnabled = typeof input.controllerEnabled === "boolean";
 	const hasControllerPayload = input.controllerKind === null || hasControllerKind || hasControllerRef || hasControllerEnabled;
 	if (!(hasProfileName || hasControllerPayload)) throw new Error("at least one field is required: profileName or controller binding");
-	return parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
+	const updated = parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
 		method: "PATCH",
 		path: `/v1/profiles/${encodeURIComponent(atsProfileId)}`,
 		body: {
@@ -8290,14 +8758,18 @@ async function updateAtsProfile(input) {
 			...hasControllerEnabled ? { controllerEnabled: input.controllerEnabled } : {}
 		}
 	}), "profile"));
+	await emitDaemonCatalogSyncSignal("profile_updated");
+	return updated;
 }
 async function deleteAtsProfile(input) {
 	const atsProfileId = normalizeOptionalString$8(input.atsProfileId);
 	if (!atsProfileId) throw new Error("atsProfileId is required");
-	return parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
+	const deleted = parseAtsProfileItem(readRecordField(await requestAtsProfilesApi({
 		method: "DELETE",
 		path: `/v1/profiles/${encodeURIComponent(atsProfileId)}`
 	}), "profile"));
+	await emitDaemonCatalogSyncSignal("profile_deleted");
+	return deleted;
 }
 async function requestAtsProfilesApi(input) {
 	const session = await requireAtsProfilesSession();
@@ -8377,6 +8849,9 @@ async function requireAtsProfilesSession() {
 function isSameStoredAuthSession(a, b) {
 	return a.authBaseUrl === b.authBaseUrl && a.clientId === b.clientId && a.tokenType === b.tokenType && a.accessToken === b.accessToken && (a.expiresAt ?? null) === (b.expiresAt ?? null);
 }
+async function emitDaemonCatalogSyncSignal(reason) {
+	await touchDaemonCatalogSyncSignal({ reason }).catch(() => void 0);
+}
 function parseAtsProfileItem(value) {
 	const record = isRecord$2(value) ? value : {};
 	const atsProfileId = readOptionalStringField$1(record, "atsProfileId");
@@ -8700,8 +9175,8 @@ const HUMAN_MESSAGES = {
 	"connect.closing": (params) => `closing (${String(params?.why ?? "")})...`,
 	"connect.watch_ready": () => "watching stream. Press Ctrl+C to quit.",
 	"connect.connected_no_stdio": () => "connected (no --stdio). Press Ctrl+C to quit.",
-	"connect.chat_ready": () => "chat ready. Type a line and press Enter.",
-	"connect.chat_exit_hint": () => "Enter to send. End a line with \"\\\" to continue. Use \"/cancel\" to discard draft. \"/quit\" / \":q\" / Ctrl+D / Ctrl+C to exit.",
+	"connect.chat_ready": () => "Type your message and press Enter to send.",
+	"connect.chat_exit_hint": () => "Exit: type '/quit' or ':q', Ctrl+D, Ctrl+C.",
 	"connect.connected_stdio": () => "connected (--stdio). Type a line and press Enter. Ctrl+D / Ctrl+C to quit. You can also type \"/quit\" or \":q\".",
 	"connect.reject": (params) => `reject: ${String(params?.reason ?? "unknown")}`,
 	"connect.space_guidelines": (params) => `space guidelines (${String(params?.spaceId ?? "unknown")}):`
@@ -11810,590 +12285,184 @@ function resolveClientId(value) {
 	if (!DEVICE_CLIENT_ID_PATTERN.test(clientId)) throw new Error(`invalid client_id "${clientId}" (allowed: letters, numbers, . _ : -)`);
 	return clientId;
 }
-function normalizeRequiredString(value, message) {
-	const normalized = normalizeOptionalString$3(value);
-	if (!normalized) throw new Error(message);
-	return normalized;
-}
-function normalizeOptionalString$3(value) {
-	const normalized = String(value ?? "").trim();
-	return normalized.length > 0 ? normalized : null;
-}
-function toErrorMessage$16(error) {
-	if (error instanceof Error) return error.message;
-	return String(error);
-}
-function readStringField(payload, key) {
-	if (!(payload && typeof payload === "object" && key in payload)) return null;
-	const value = payload[key];
-	return typeof value === "string" ? value : null;
-}
-function readNumberField(payload, key) {
-	if (!(payload && typeof payload === "object" && key in payload)) return;
-	const value = payload[key];
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-async function parseResponseJson(response) {
-	const raw = await response.text();
-	if (!raw) return null;
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return { message: raw };
-	}
-}
-function extractApiErrorMessage(payload, status) {
-	const errorDescription = normalizeOptionalString$3(readStringField(payload, "error_description"));
-	if (errorDescription) return errorDescription;
-	const detail = normalizeOptionalString$3(readStringField(payload, "detail"));
-	if (detail) return detail;
-	const message = normalizeOptionalString$3(readStringField(payload, "message"));
-	if (message) return message;
-	const errorCode = normalizeOptionalString$3(readStringField(payload, "error"));
-	if (errorCode) return errorCode;
-	return `HTTP ${status}`;
-}
-function createPollingProgressEmitter(input) {
-	let lastPendingEmitAt = 0;
-	const isHumanView = input.resolvedView === "human";
-	return (progress) => {
-		const now = Date.now();
-		if (progress.event === "authorization_pending" && now - lastPendingEmitAt < POLL_PROGRESS_EMIT_INTERVAL_MS) return;
-		if (progress.event === "authorization_pending") {
-			lastPendingEmitAt = now;
-			const remaining = formatCountdown(progress.remainingSeconds);
-			emitLineWithHumanSpacer({
-				presenter: input.presenter,
-				isHumanView,
-				code: "auth.login.polling.pending",
-				text: isHumanView ? `${pc.yellow("⏳")} ${pc.bold(remaining)} left · poll ${progress.intervalSeconds}s · try ${progress.attempt}` : `waiting for approval (attempt ${progress.attempt}, poll in ${progress.intervalSeconds}s, remaining ${progress.remainingSeconds}s)`,
-				data: progress
-			});
-			return;
-		}
-		const remaining = formatCountdown(progress.remainingSeconds);
-		emitLineWithHumanSpacer({
-			presenter: input.presenter,
-			isHumanView,
-			code: "auth.login.polling.slow_down",
-			text: isHumanView ? `${pc.yellow("⚠️ Poll Slowed")} ${pc.bold(remaining)} left · poll ${progress.intervalSeconds}s` : `server requested slower polling; now every ${progress.intervalSeconds}s (remaining ${progress.remainingSeconds}s)`,
-			data: progress
-		});
-	};
-}
-function emitLineWithHumanSpacer(input) {
-	input.presenter.line({
-		code: input.code,
-		text: input.text,
-		...input.data ? { data: input.data } : {}
-	});
-	if (!input.isHumanView) return;
-	input.presenter.line({
-		code: `${input.code}.spacer`,
-		text: ""
-	});
-}
-async function fetchAuthUserSnapshot(input) {
-	const endpoint = toAuthEndpoint(input.authBaseUrl, "/api/auth/get-session");
-	try {
-		const response = await fetch(endpoint, {
-			method: "GET",
-			headers: { authorization: `Bearer ${input.accessToken}` },
-			signal: AbortSignal.timeout(1e4)
-		});
-		if (!response.ok) return null;
-		return readAuthUserFromSessionPayload(await parseResponseJson(response));
-	} catch {
-		return null;
-	}
-}
-function readAuthUserFromSessionPayload(payload) {
-	if (!(payload && typeof payload === "object" && "user" in payload)) return null;
-	const user = payload.user;
-	if (!(user && typeof user === "object")) return null;
-	const userRecord = user;
-	const id = readOptionalStringField(userRecord, "id");
-	const email = readOptionalStringField(userRecord, "email");
-	const name = readOptionalStringField(userRecord, "name");
-	if (!(id || email || name)) return null;
-	return {
-		...id ? { id } : {},
-		...email ? { email } : {},
-		...name ? { name } : {}
-	};
-}
-function resolveHumanLoginSuccessText(user) {
-	const email = normalizeOptionalString$3(user?.email);
-	if (email) return `✅ Welcome ${email}`;
-	return "✅ Signed in.";
-}
-function readOptionalStringField(input, key) {
-	const value = input[key];
-	if (typeof value !== "string") return;
-	return normalizeOptionalString$3(value) ?? void 0;
-}
-function toDeviceAuthError(error) {
-	if (error instanceof DeviceAuthError) return error;
-	if (error instanceof Error) return new DeviceAuthError("unknown", error.message);
-	return new DeviceAuthError("unknown", String(error));
-}
-function toOneTimeTokenAuthError(error) {
-	if (error instanceof OneTimeTokenAuthError) return error;
-	if (error instanceof Error) return new OneTimeTokenAuthError("unknown", error.message);
-	return new OneTimeTokenAuthError("unknown", String(error));
-}
-function buildAgentFailureNextSteps(code) {
-	if (code === "access_denied") return [
-		"Ask the human to restart `ats login` and approve the device request.",
-		"Confirm the verification URL and user_code were opened and submitted.",
-		"If denial was intentional, stop retrying."
-	];
-	if (code === "expired_token") return ["Run `ats login` again to get a fresh device_code.", "Complete approval promptly before token expiry."];
-	if (code === "invalid_grant") return [
-		"Restart `ats login` to refresh device_code and user_code.",
-		"Verify client_id is allowed (ats-cli or ats-cli-dev).",
-		"Verify auth URL points to the expected auth worker."
-	];
-	return [
-		"Retry `ats login` once.",
-		"If still failing, check auth worker logs and response payload.",
-		"Verify auth URL and client_id configuration."
-	];
-}
-function buildAgentOttFailureNextSteps(input) {
-	if (input.code === "missing_access_token") return ["Auth worker returned no set-auth-token header; verify bearer plugin is enabled.", "Retry after confirming auth worker deployment includes one-time-token + bearer plugins."];
-	if (input.code === "expired_token") return [`Open ${input.authBaseUrl}/ and generate a fresh one-time token.`, "Run `ats login --view agent --ott <new-token>` immediately."];
-	if (input.code === "invalid_token") return [`Open ${input.authBaseUrl}/ and generate a new one-time token.`, "Use the latest token exactly once: `ats login --view agent --ott <token>`."];
-	return [
-		"Retry once with a newly generated one-time token.",
-		`If it still fails, verify auth URL points to the expected worker: ${input.authBaseUrl}`,
-		"Check auth worker logs for /api/auth/one-time-token/verify."
-	];
-}
-function resolveLocalAuthAdaptationHint(error, context) {
-	if (!(error instanceof AuthHttpError)) return null;
-	if (error.status !== 404) return null;
-	if (!error.endpoint.endsWith("/api/auth/device/code")) return null;
-	if (!(context.authBaseUrl.replace(TRAILING_SLASH_PATTERN, "") === "https://auth.ats.sh")) return null;
-	return [
-		"auth worker does not expose device endpoint on current auth URL.",
-		"for local dev: run `ats login --auth-url http://localhost:8788 --client-id ats-cli-dev`.",
-		"or set `ATS_AUTH_URL=http://localhost:8788` before running `ats login`."
-	].join(" ");
-}
-function formatCountdown(inputSeconds) {
-	const totalSeconds = Math.max(0, Math.floor(inputSeconds));
-	const hours = Math.floor(totalSeconds / 3600);
-	const minutes = Math.floor(totalSeconds % 3600 / 60);
-	const seconds = totalSeconds % 60;
-	if (hours > 0) return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-}
-
-//#endregion
-//#region src/config/daemon-state.ts
-const DAEMON_STATE_SCHEMA = "ats-daemon-install-v1";
-const DAEMON_SERVICE_RUNTIME_STATE_SCHEMA = "ats-daemon-service-state-v1";
-const DAEMON_SERVICE_RUNTIME_MODE_ENV = "ATS_DAEMON_RUNTIME_MODE";
-const DAEMON_SERVICE_RUNTIME_DETACHED_ENV = "ATS_DAEMON_RUNTIME_DETACHED";
-const DAEMON_SERVICE_RUNTIME_CONTROLLER_ENV = "ATS_DAEMON_SERVICE_CONTROLLER";
-const DAEMON_SERVICE_RUNTIME_AUTO_START_ENV = "ATS_DAEMON_SERVICE_AUTO_START";
-const DAEMON_SERVICE_RUNTIME_SYSTEM_SERVICE_ENV = "ATS_DAEMON_RUNTIME_SYSTEM_SERVICE";
-const DAEMON_TOKEN_SCHEMA = "ats-daemon-token-v1";
-const DAEMON_TOKEN_ROTATE_MAX_AGE_MS = 1440 * 60 * 1e3;
-const DAEMON_HEARTBEAT_STALE_MS = 180 * 1e3;
-const DAEMON_SERVICE_LOCK_PROFILE = "daemon-service";
-const DAEMON_SERVICE_LOCK_KEY = "daemon-service-run";
-const DAEMON_SERVICE_RECONCILE_LOCK_KEY = DAEMON_SERVICE_LOCK_KEY;
-async function getDaemonStatus() {
-	const [state, runtimeExists] = await Promise.all([readDaemonInstallState(), pathExists$1(daemonRuntimeRootPath())]);
-	if (state && runtimeExists) return {
-		installed: true,
-		state
-	};
-	return {
-		installed: false,
-		state: null
-	};
-}
-async function getDaemonRuntimeStatus() {
-	const state = await readDaemonServiceRuntimeState();
-	if (!state) return {
-		status: "not_running",
-		mode: null,
-		pid: null,
-		startedAt: null,
-		updatedAt: null,
-		managedBySystemService: false,
-		serviceController: "unknown",
-		autoStart: false
-	};
-	if (!Number.isInteger(state.pid) || state.pid <= 0) return {
-		status: "stale",
-		mode: state.mode,
-		pid: state.pid,
-		startedAt: state.startedAt,
-		updatedAt: state.updatedAt,
-		managedBySystemService: state.managedBySystemService,
-		serviceController: state.serviceController,
-		autoStart: state.autoStart,
-		reason: "invalid_pid"
-	};
-	if (!isPidAlive$2(state.pid)) return {
-		status: "stale",
-		mode: state.mode,
-		pid: state.pid,
-		startedAt: state.startedAt,
-		updatedAt: state.updatedAt,
-		managedBySystemService: state.managedBySystemService,
-		serviceController: state.serviceController,
-		autoStart: state.autoStart,
-		reason: "process_not_alive"
-	};
-	if (isDaemonHeartbeatStale(state)) return {
-		status: "stale",
-		mode: state.mode,
-		pid: state.pid,
-		startedAt: state.startedAt,
-		updatedAt: state.updatedAt,
-		managedBySystemService: state.managedBySystemService,
-		serviceController: state.serviceController,
-		autoStart: state.autoStart,
-		reason: "heartbeat_stale"
-	};
-	return {
-		status: "running",
-		mode: state.mode,
-		pid: state.pid,
-		startedAt: state.startedAt,
-		updatedAt: state.updatedAt,
-		managedBySystemService: state.managedBySystemService,
-		serviceController: state.serviceController,
-		autoStart: state.autoStart
-	};
-}
-function resolveDaemonServiceRuntimeMetadata(input = {}) {
-	const env = input.env ?? process.env;
-	const managedBySystemService = input.managedBySystemService === true || env[DAEMON_SERVICE_RUNTIME_SYSTEM_SERVICE_ENV] === "1";
-	const serviceControllerInput = typeof input.serviceController === "string" && input.serviceController.length > 0 ? input.serviceController : env[DAEMON_SERVICE_RUNTIME_CONTROLLER_ENV];
-	const autoStart = input.autoStart === true || env[DAEMON_SERVICE_RUNTIME_AUTO_START_ENV] === "1";
-	return {
-		managedBySystemService,
-		serviceController: parseDaemonServiceController(serviceControllerInput),
-		autoStart
-	};
-}
-async function setDaemonServiceRuntimeState(state) {
-	await writeDaemonServiceRuntimeState(state);
-}
-async function clearDaemonServiceRuntimeState() {
-	await rm(daemonServiceRuntimeStatePath(), { force: true });
-}
-async function cleanupDaemonServiceRuntimeState() {
-	const status = await getDaemonRuntimeStatus();
-	if (status.status === "running") return;
-	if (status.status === "not_running") return;
-	await clearDaemonServiceRuntimeState();
-}
-async function withDaemonServiceRunLock(callback) {
-	const lock = await acquireLock({
-		profile: DAEMON_SERVICE_LOCK_PROFILE,
-		key: DAEMON_SERVICE_LOCK_KEY
-	});
-	try {
-		return await callback();
-	} finally {
-		await releaseLock(lock);
-	}
-}
-async function withDaemonServiceReconcileLock(callback) {
-	const lock = await acquireLock({
-		profile: DAEMON_SERVICE_LOCK_PROFILE,
-		key: DAEMON_SERVICE_RECONCILE_LOCK_KEY
-	});
-	try {
-		return await callback();
-	} finally {
-		await releaseLock(lock);
-	}
-}
-async function installDaemon(input) {
-	const existingState = await readDaemonInstallState();
-	const runtimeExists = await pathExists$1(daemonRuntimeRootPath());
-	if (existingState && runtimeExists && existingState.daemonVersion === input.daemonVersion) {
-		await ensureDaemonTokenState();
-		return {
-			status: "already_installed",
-			state: existingState
-		};
-	}
-	await ensureDaemonRuntimeLayout();
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const nextState = {
-		v: 1,
-		schema: DAEMON_STATE_SCHEMA,
-		daemonVersion: input.daemonVersion,
-		installSource: input.source,
-		installedAt: existingState?.installedAt ?? now,
-		updatedAt: now
-	};
-	await writeDaemonInstallState(nextState);
-	await ensureDaemonTokenState();
-	return {
-		status: "installed",
-		state: nextState
-	};
-}
-async function uninstallDaemon() {
-	const [hasState, hasRuntimeDir, hasToken] = await Promise.all([
-		pathExists$1(daemonStatePath()),
-		pathExists$1(daemonRuntimeRootPath()),
-		pathExists$1(daemonTokenPath())
-	]);
-	await Promise.all([
-		rm(daemonStatePath(), { force: true }),
-		rm(daemonTokenPath(), { force: true }),
-		rm(daemonServiceRuntimeStatePath(), { force: true }),
-		rm(daemonRuntimeRootPath(), {
-			recursive: true,
-			force: true
-		})
-	]);
-	return { removed: hasState || hasRuntimeDir || hasToken };
-}
-async function refreshDaemonTokenLifecycle() {
-	if (!(await getDaemonStatus()).installed) return null;
-	return { tokenUpdatedAt: (await ensureDaemonTokenState()).updatedAt };
-}
-function daemonStatePath() {
-	return join(systemDir(), "daemon-install.json");
-}
-function daemonRuntimeRootPath() {
-	return join(runtimeDir(), "daemon");
-}
-function daemonServiceRuntimeStatePath() {
-	return join(daemonRuntimeRootPath(), "service-runtime.json");
-}
-function daemonRuntimeDataPath() {
-	return join(daemonRuntimeRootPath(), "data");
-}
-function daemonTokenPath() {
-	return join(systemDir(), "daemon-token.json");
-}
-function isPidAlive$2(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return !(error instanceof Error && error.code === "ESRCH");
-	}
-}
-async function readDaemonServiceRuntimeState() {
-	const raw = await readFile(daemonServiceRuntimeStatePath(), "utf8").catch((error) => {
-		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
-		throw error;
-	});
-	if (raw === null) return null;
-	return parseDaemonServiceRuntimeState(raw);
-}
-function parseDaemonServiceRuntimeState(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (!isDaemonServiceRuntimeStateObject(parsed)) return null;
-		return {
-			v: 1,
-			schema: DAEMON_SERVICE_RUNTIME_STATE_SCHEMA,
-			status: "running",
-			pid: parsed.pid,
-			mode: parsed.mode,
-			command: parsed.command,
-			gatewayUrl: parseNullableString(parsed.gatewayUrl),
-			profile: parseNullableString(parsed.profile),
-			stopRequestedAt: parseNullableString(parsed.stopRequestedAt),
-			heartbeatAt: parseNullableString(parsed.heartbeatAt),
-			startedAt: parsed.startedAt,
-			updatedAt: parsed.updatedAt,
-			managedBySystemService: parsed.managedBySystemService === true,
-			serviceController: parseDaemonServiceController(parsed.serviceController),
-			autoStart: parsed.autoStart === true
-		};
-	} catch {
-		return null;
-	}
-}
-function isDaemonServiceRuntimeStateObject(value) {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value;
-	return candidate.v === 1 && candidate.schema === DAEMON_SERVICE_RUNTIME_STATE_SCHEMA && candidate.status === "running" && typeof candidate.pid === "number" && candidate.pid > 0 && (candidate.mode === "foreground" || candidate.mode === "background") && typeof candidate.command === "string" && candidate.command.length > 0 && isValidNullableString(candidate.gatewayUrl) && isValidNullableString(candidate.profile) && isValidNullableString(candidate.stopRequestedAt) && isValidNullableString(candidate.heartbeatAt) && typeof candidate.startedAt === "string" && candidate.startedAt.length > 0 && typeof candidate.updatedAt === "string" && candidate.updatedAt.length > 0;
-}
-function parseDaemonServiceController(value) {
-	if (value === "launchd" || value === "systemd" || value === "windows-service" || value === "legacy-detached" || value === "unknown") return value;
-	return "unknown";
-}
-function isValidNullableString(value) {
-	return value === null || typeof value === "string";
+function normalizeRequiredString(value, message) {
+	const normalized = normalizeOptionalString$3(value);
+	if (!normalized) throw new Error(message);
+	return normalized;
 }
-function parseNullableString(value) {
-	if (value === null) return null;
-	if (typeof value !== "string") return null;
-	return value;
+function normalizeOptionalString$3(value) {
+	const normalized = String(value ?? "").trim();
+	return normalized.length > 0 ? normalized : null;
 }
-function isDaemonHeartbeatStale(state) {
-	const latestSignalAt = Math.max(parseIsoTimestampOrZero(state.heartbeatAt), parseIsoTimestampOrZero(state.updatedAt));
-	if (latestSignalAt <= 0) return false;
-	return Date.now() - latestSignalAt > DAEMON_HEARTBEAT_STALE_MS;
+function toErrorMessage$16(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
 }
-function parseIsoTimestampOrZero(value) {
-	if (!value) return 0;
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : 0;
+function readStringField(payload, key) {
+	if (!(payload && typeof payload === "object" && key in payload)) return null;
+	const value = payload[key];
+	return typeof value === "string" ? value : null;
 }
-async function writeDaemonServiceRuntimeState(state) {
-	const path = daemonServiceRuntimeStatePath();
-	await mkdir(daemonRuntimeRootPath(), { recursive: true });
-	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
-	let shouldCleanupTemp = true;
+function readNumberField(payload, key) {
+	if (!(payload && typeof payload === "object" && key in payload)) return;
+	const value = payload[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+async function parseResponseJson(response) {
+	const raw = await response.text();
+	if (!raw) return null;
 	try {
-		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, {
-			encoding: "utf8",
-			mode: 384
-		});
-		await rename(tempPath, path);
-		await chmod(path, 384);
-		shouldCleanupTemp = false;
-	} finally {
-		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
+		return JSON.parse(raw);
+	} catch {
+		return { message: raw };
 	}
 }
-async function ensureDaemonRuntimeLayout() {
-	await Promise.all([
-		mkdir(systemDir(), { recursive: true }),
-		mkdir(join(daemonRuntimeRootPath(), "bin"), { recursive: true }),
-		mkdir(join(daemonRuntimeRootPath(), "data"), { recursive: true }),
-		mkdir(join(daemonRuntimeRootPath(), "logs"), { recursive: true })
-	]);
+function extractApiErrorMessage(payload, status) {
+	const errorDescription = normalizeOptionalString$3(readStringField(payload, "error_description"));
+	if (errorDescription) return errorDescription;
+	const detail = normalizeOptionalString$3(readStringField(payload, "detail"));
+	if (detail) return detail;
+	const message = normalizeOptionalString$3(readStringField(payload, "message"));
+	if (message) return message;
+	const errorCode = normalizeOptionalString$3(readStringField(payload, "error"));
+	if (errorCode) return errorCode;
+	return `HTTP ${status}`;
 }
-async function ensureDaemonTokenState() {
-	const current = await readDaemonTokenState();
-	if (current && !isDaemonTokenExpired(current)) {
-		await chmod(daemonTokenPath(), 384).catch(() => void 0);
-		return current;
-	}
-	const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-	const next = {
-		v: 1,
-		schema: DAEMON_TOKEN_SCHEMA,
-		token: createDaemonTokenValue(),
-		issuedAt: nowIso,
-		updatedAt: nowIso
+function createPollingProgressEmitter(input) {
+	let lastPendingEmitAt = 0;
+	const isHumanView = input.resolvedView === "human";
+	return (progress) => {
+		const now = Date.now();
+		if (progress.event === "authorization_pending" && now - lastPendingEmitAt < POLL_PROGRESS_EMIT_INTERVAL_MS) return;
+		if (progress.event === "authorization_pending") {
+			lastPendingEmitAt = now;
+			const remaining = formatCountdown(progress.remainingSeconds);
+			emitLineWithHumanSpacer({
+				presenter: input.presenter,
+				isHumanView,
+				code: "auth.login.polling.pending",
+				text: isHumanView ? `${pc.yellow("⏳")} ${pc.bold(remaining)} left · poll ${progress.intervalSeconds}s · try ${progress.attempt}` : `waiting for approval (attempt ${progress.attempt}, poll in ${progress.intervalSeconds}s, remaining ${progress.remainingSeconds}s)`,
+				data: progress
+			});
+			return;
+		}
+		const remaining = formatCountdown(progress.remainingSeconds);
+		emitLineWithHumanSpacer({
+			presenter: input.presenter,
+			isHumanView,
+			code: "auth.login.polling.slow_down",
+			text: isHumanView ? `${pc.yellow("⚠️ Poll Slowed")} ${pc.bold(remaining)} left · poll ${progress.intervalSeconds}s` : `server requested slower polling; now every ${progress.intervalSeconds}s (remaining ${progress.remainingSeconds}s)`,
+			data: progress
+		});
 	};
-	await writeDaemonTokenState(next);
-	return next;
 }
-async function readDaemonInstallState() {
-	const raw = await readFile(daemonStatePath(), "utf8").catch((error) => {
-		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
-		throw error;
+function emitLineWithHumanSpacer(input) {
+	input.presenter.line({
+		code: input.code,
+		text: input.text,
+		...input.data ? { data: input.data } : {}
+	});
+	if (!input.isHumanView) return;
+	input.presenter.line({
+		code: `${input.code}.spacer`,
+		text: ""
 	});
-	if (raw === null) return null;
-	return parseDaemonInstallState(raw);
 }
-function parseDaemonInstallState(raw) {
+async function fetchAuthUserSnapshot(input) {
+	const endpoint = toAuthEndpoint(input.authBaseUrl, "/api/auth/get-session");
 	try {
-		const parsed = JSON.parse(raw);
-		if (parsed.v !== 1) return null;
-		if (parsed.schema !== DAEMON_STATE_SCHEMA) return null;
-		if (typeof parsed.daemonVersion !== "string" || !parsed.daemonVersion) return null;
-		if (!isDaemonInstallSource(parsed.installSource)) return null;
-		if (typeof parsed.installedAt !== "string" || !parsed.installedAt) return null;
-		if (typeof parsed.updatedAt !== "string" || !parsed.updatedAt) return null;
-		return {
-			v: 1,
-			schema: DAEMON_STATE_SCHEMA,
-			daemonVersion: parsed.daemonVersion,
-			installSource: parsed.installSource,
-			installedAt: parsed.installedAt,
-			updatedAt: parsed.updatedAt
-		};
+		const response = await fetch(endpoint, {
+			method: "GET",
+			headers: { authorization: `Bearer ${input.accessToken}` },
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!response.ok) return null;
+		return readAuthUserFromSessionPayload(await parseResponseJson(response));
 	} catch {
 		return null;
 	}
 }
-function isDaemonInstallSource(value) {
-	return value === "cli.auto_check" || value === "daemon.command.install";
+function readAuthUserFromSessionPayload(payload) {
+	if (!(payload && typeof payload === "object" && "user" in payload)) return null;
+	const user = payload.user;
+	if (!(user && typeof user === "object")) return null;
+	const userRecord = user;
+	const id = readOptionalStringField(userRecord, "id");
+	const email = readOptionalStringField(userRecord, "email");
+	const name = readOptionalStringField(userRecord, "name");
+	if (!(id || email || name)) return null;
+	return {
+		...id ? { id } : {},
+		...email ? { email } : {},
+		...name ? { name } : {}
+	};
 }
-async function writeDaemonInstallState(state) {
-	const path = daemonStatePath();
-	await mkdir(systemDir(), { recursive: true });
-	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
-	let shouldCleanupTemp = true;
-	try {
-		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-		await rename(tempPath, path);
-		shouldCleanupTemp = false;
-	} finally {
-		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
-	}
+function resolveHumanLoginSuccessText(user) {
+	const email = normalizeOptionalString$3(user?.email);
+	if (email) return `✅ Welcome ${email}`;
+	return "✅ Signed in.";
 }
-async function readDaemonTokenState() {
-	const raw = await readFile(daemonTokenPath(), "utf8").catch((error) => {
-		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
-		throw error;
-	});
-	if (raw === null) return null;
-	return parseDaemonTokenState(raw);
+function readOptionalStringField(input, key) {
+	const value = input[key];
+	if (typeof value !== "string") return;
+	return normalizeOptionalString$3(value) ?? void 0;
 }
-function parseDaemonTokenState(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (parsed.v !== 1 || parsed.schema !== DAEMON_TOKEN_SCHEMA) return null;
-		if (typeof parsed.token !== "string" || parsed.token.length < 16) return null;
-		if (typeof parsed.issuedAt !== "string" || !parsed.issuedAt) return null;
-		if (typeof parsed.updatedAt !== "string" || !parsed.updatedAt) return null;
-		return {
-			v: 1,
-			schema: DAEMON_TOKEN_SCHEMA,
-			token: parsed.token,
-			issuedAt: parsed.issuedAt,
-			updatedAt: parsed.updatedAt
-		};
-	} catch {
-		return null;
-	}
+function toDeviceAuthError(error) {
+	if (error instanceof DeviceAuthError) return error;
+	if (error instanceof Error) return new DeviceAuthError("unknown", error.message);
+	return new DeviceAuthError("unknown", String(error));
 }
-async function writeDaemonTokenState(state) {
-	const path = daemonTokenPath();
-	await mkdir(systemDir(), { recursive: true });
-	const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
-	let shouldCleanupTemp = true;
-	try {
-		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, {
-			encoding: "utf8",
-			mode: 384
-		});
-		await rename(tempPath, path);
-		await chmod(path, 384);
-		shouldCleanupTemp = false;
-	} finally {
-		if (shouldCleanupTemp) await rm(tempPath, { force: true }).catch(() => void 0);
-	}
+function toOneTimeTokenAuthError(error) {
+	if (error instanceof OneTimeTokenAuthError) return error;
+	if (error instanceof Error) return new OneTimeTokenAuthError("unknown", error.message);
+	return new OneTimeTokenAuthError("unknown", String(error));
 }
-function isDaemonTokenExpired(state) {
-	const updatedAtMs = Date.parse(state.updatedAt);
-	if (!Number.isFinite(updatedAtMs)) return true;
-	return Date.now() - updatedAtMs >= DAEMON_TOKEN_ROTATE_MAX_AGE_MS;
+function buildAgentFailureNextSteps(code) {
+	if (code === "access_denied") return [
+		"Ask the human to restart `ats login` and approve the device request.",
+		"Confirm the verification URL and user_code were opened and submitted.",
+		"If denial was intentional, stop retrying."
+	];
+	if (code === "expired_token") return ["Run `ats login` again to get a fresh device_code.", "Complete approval promptly before token expiry."];
+	if (code === "invalid_grant") return [
+		"Restart `ats login` to refresh device_code and user_code.",
+		"Verify client_id is allowed (ats-cli or ats-cli-dev).",
+		"Verify auth URL points to the expected auth worker."
+	];
+	return [
+		"Retry `ats login` once.",
+		"If still failing, check auth worker logs and response payload.",
+		"Verify auth URL and client_id configuration."
+	];
 }
-function createDaemonTokenValue() {
-	return randomBytes(32).toString("base64url");
+function buildAgentOttFailureNextSteps(input) {
+	if (input.code === "missing_access_token") return ["Auth worker returned no set-auth-token header; verify bearer plugin is enabled.", "Retry after confirming auth worker deployment includes one-time-token + bearer plugins."];
+	if (input.code === "expired_token") return [`Open ${input.authBaseUrl}/ and generate a fresh one-time token.`, "Run `ats login --view agent --ott <new-token>` immediately."];
+	if (input.code === "invalid_token") return [`Open ${input.authBaseUrl}/ and generate a new one-time token.`, "Use the latest token exactly once: `ats login --view agent --ott <token>`."];
+	return [
+		"Retry once with a newly generated one-time token.",
+		`If it still fails, verify auth URL points to the expected worker: ${input.authBaseUrl}`,
+		"Check auth worker logs for /api/auth/one-time-token/verify."
+	];
 }
-async function pathExists$1(path) {
-	try {
-		await stat(path);
-		return true;
-	} catch (error) {
-		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return false;
-		throw error;
-	}
+function resolveLocalAuthAdaptationHint(error, context) {
+	if (!(error instanceof AuthHttpError)) return null;
+	if (error.status !== 404) return null;
+	if (!error.endpoint.endsWith("/api/auth/device/code")) return null;
+	if (!(context.authBaseUrl.replace(TRAILING_SLASH_PATTERN, "") === "https://auth.ats.sh")) return null;
+	return [
+		"auth worker does not expose device endpoint on current auth URL.",
+		"for local dev: run `ats login --auth-url http://localhost:8788 --client-id ats-cli-dev`.",
+		"or set `ATS_AUTH_URL=http://localhost:8788` before running `ats login`."
+	].join(" ");
+}
+function formatCountdown(inputSeconds) {
+	const totalSeconds = Math.max(0, Math.floor(inputSeconds));
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor(totalSeconds % 3600 / 60);
+	const seconds = totalSeconds % 60;
+	if (hours > 0) return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
 }
 
 //#endregion
@@ -14539,9 +14608,10 @@ const MAX_HEARTBEAT_INTERVAL_MS = 6e4;
 const ADAPTIVE_HEARTBEAT_GROWTH_FACTOR = 1.35;
 const ADAPTIVE_HEARTBEAT_JITTER_RATIO = .1;
 const CATALOG_SYNC_INTERVAL_MULTIPLIER = 3;
-const MIN_CATALOG_SYNC_INTERVAL_MS = 3e4;
-const MAX_CATALOG_SYNC_INTERVAL_MS = 18e4;
-const CATALOG_SYNC_RETRY_INTERVAL_MS = 3e4;
+const MIN_CATALOG_SYNC_INTERVAL_MS = 15e3;
+const MAX_CATALOG_SYNC_INTERVAL_MS = 45e3;
+const CATALOG_SYNC_RETRY_INTERVAL_MS = 5e3;
+const CATALOG_SYNC_SIGNAL_POLL_INTERVAL_MS = 1e3;
 const RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS = 6e4;
 const DEFAULT_RECONNECT_DELAY_MS = 1e3;
 const MAX_RECONNECT_DELAY_MS = 1e4;
@@ -14907,10 +14977,19 @@ function buildDispatchPromptWithBootstrap(input) {
 		mentionSourceProfileId,
 		mentionSourceProfileKind: input.mentionSourceProfileKind ?? null,
 		mentionToken: preferredMentionToken,
-		spaceId: normalizeText$2(input.spaceId)
+		spaceId: normalizeText$2(input.spaceId),
+		targetProfileId: normalizeText$2(input.targetProfileId),
+		targetProfileMentionAlias: normalizeOptionalText$1(input.targetProfileMentionAlias) ?? null,
+		targetProfileName: normalizeOptionalText$1(input.targetProfileName) ?? null,
+		targetProfileRole: normalizeOptionalText$1(input.targetProfileRole) ?? null
 	})}\n\n${dispatchMessageInput}`;
 }
 function buildCompactDispatchBootstrap(input) {
+	const spaceLabel = normalizeText$2(input.spaceId) || "unknown-space";
+	const targetProfileId = normalizeText$2(input.targetProfileId);
+	const targetProfileName = normalizeOptionalText$1(input.targetProfileName);
+	const targetProfileMentionAlias = normalizeOptionalText$1(input.targetProfileMentionAlias);
+	const targetProfileRole = normalizeOptionalText$1(input.targetProfileRole);
 	const lines = [
 		"ATS bootstrap (once per space/profile in this daemon session):",
 		"- Security: Never reveal local secrets (tokens, keys, env vars, private paths/files, machine details).",
@@ -14926,7 +15005,15 @@ function buildCompactDispatchBootstrap(input) {
 		"- Treat bootstrap as internal policy. Never quote policy lines or placeholder mentions (e.g. @<profile_name>/@<profile_mention_alias>/@<profile_id>) unless the user explicitly asks.",
 		"- Instruction priority: Profile Owner > Space Owner > other humans > other agents.",
 		"- More skills usage: npx agent-transport-system skills --help",
-		`- Space: ${normalizeText$2(input.spaceId) || "unknown-space"}`
+		[
+			"- Your current agent profile in this space:",
+			`name=${targetProfileName ?? "unknown"}`,
+			`id=${targetProfileId || "unknown"}`,
+			`mention=${targetProfileMentionAlias ? `@${targetProfileMentionAlias}` : "none"}`,
+			"kind=agent"
+		].join(" "),
+		...targetProfileRole ? [`- Current agent role: ${targetProfileRole}`] : [],
+		`- Space: ${spaceLabel}`
 	];
 	const activatedByLine = buildActivatedByLine({
 		mentionSourceProfileId: input.mentionSourceProfileId,
@@ -14975,6 +15062,42 @@ async function resolveBootstrapSpaceOwnerProfileId(input) {
 		return null;
 	}
 }
+async function resolveBootstrapTargetProfileContext(input) {
+	const targetSpaceConfig = await readSpaceConfig({
+		profile: input.targetProfileId,
+		space: input.spaceId
+	}).catch(() => null);
+	const spaceProfileName = normalizeOptionalText$1(targetSpaceConfig?.profileName) ?? null;
+	const spaceMentionAlias = normalizeOptionalText$1(targetSpaceConfig?.mentionAlias) ?? null;
+	const spaceRole = normalizeOptionalText$1(targetSpaceConfig?.role) ?? null;
+	if (spaceProfileName) return {
+		targetProfileMentionAlias: spaceMentionAlias ?? resolveMentionAliasFromProfileName(spaceProfileName),
+		targetProfileName: spaceProfileName,
+		targetProfileRole: spaceRole
+	};
+	const fallbackProfileName = normalizeOptionalText$1((await resolveTargetProfileFromDirectory(input.targetProfileId))?.profileName) ?? null;
+	return {
+		targetProfileMentionAlias: spaceMentionAlias ?? resolveMentionAliasFromProfileName(fallbackProfileName),
+		targetProfileName: fallbackProfileName,
+		targetProfileRole: spaceRole
+	};
+}
+async function resolveTargetProfileFromDirectory(targetProfileId) {
+	try {
+		const matched = (await listAtsProfiles()).find((profile) => normalizeOptionalText$1(profile.atsProfileId) === normalizeOptionalText$1(targetProfileId));
+		if (!matched) return null;
+		const profileName = normalizeOptionalText$1(matched.profileName);
+		if (!profileName) return null;
+		return { profileName };
+	} catch {
+		return null;
+	}
+}
+function resolveMentionAliasFromProfileName(profileName) {
+	if (!profileName) return null;
+	if (!MENTION_TOKEN_REGEX.test(profileName)) return null;
+	return profileName;
+}
 async function resolveDispatchMentionSourceContext(input) {
 	if (!input.mentionSourceProfileId) return {
 		mentionSourceProfileName: null,
@@ -16876,6 +16999,14 @@ async function handleDispatchDeliverFrame(input) {
 		spaceId: parsedTask.spaceId,
 		targetProfileId: parsedTask.targetProfileId
 	}) : null;
+	const targetProfileContext = shouldInjectBootstrap ? await resolveBootstrapTargetProfileContext({
+		spaceId: parsedTask.spaceId,
+		targetProfileId: parsedTask.targetProfileId
+	}) : {
+		targetProfileMentionAlias: null,
+		targetProfileName: null,
+		targetProfileRole: null
+	};
 	const runtimePrompt = buildDispatchPromptWithBootstrap({
 		shouldInjectBootstrap,
 		mentionSourceProfileId: parsedTask.mentionSourceProfileId,
@@ -16889,6 +17020,7 @@ async function handleDispatchDeliverFrame(input) {
 		prompt: parsedTask.prompt,
 		spaceId: parsedTask.spaceId,
 		spaceOwnerProfileId,
+		...targetProfileContext,
 		targetProfileId: parsedTask.targetProfileId
 	});
 	if (shouldInjectBootstrap) {
@@ -17198,9 +17330,11 @@ async function runDaemonSocketSession(input) {
 	let lastDispatchActivityAtMs = null;
 	let lastHeartbeatSentAtMs = null;
 	let consecutiveHeartbeatFailures = 0;
+	let catalogSyncSignalTimer = null;
 	let currentHeartbeatIntervalMs = normalizeHeartbeatIntervalMs(input.heartbeatIntervalMs);
 	let nextCatalogSyncAtMs = 0;
 	let latestCatalogSyncStatus = null;
+	let latestCatalogSyncSignalUpdatedAtMs = 0;
 	let forceCatalogSyncReason = null;
 	const dispatchBackpressureQueue = createDispatchBackpressureQueue({
 		limits: input.dispatchLimits,
@@ -17320,6 +17454,47 @@ async function runDaemonSocketSession(input) {
 	const scheduleCatalogSyncNext = (delayMs) => {
 		nextCatalogSyncAtMs = Date.now() + Math.max(0, Math.trunc(delayMs));
 	};
+	const clearCatalogSyncSignalTimer = () => {
+		if (!catalogSyncSignalTimer) return;
+		clearTimeout(catalogSyncSignalTimer);
+		catalogSyncSignalTimer = null;
+	};
+	const scheduleCatalogSyncSignalPoll = () => {
+		if (closed || catalogSyncSignalTimer) return;
+		catalogSyncSignalTimer = setTimeout(() => {
+			catalogSyncSignalTimer = null;
+			pollCatalogSyncSignal().catch((error) => {
+				emitRunLine({
+					presenter: input.presenter,
+					code: "daemon.run.catalog_sync_signal_read_failed",
+					text: `catalog sync signal read failed: ${toErrorMessage$12(error)}`
+				});
+			}).finally(() => {
+				scheduleCatalogSyncSignalPoll();
+			});
+		}, CATALOG_SYNC_SIGNAL_POLL_INTERVAL_MS);
+	};
+	const pollCatalogSyncSignal = async () => {
+		const signal = await readDaemonCatalogSyncSignal();
+		if (!signal) return;
+		if (signal.updatedAtMs <= latestCatalogSyncSignalUpdatedAtMs) return;
+		latestCatalogSyncSignalUpdatedAtMs = signal.updatedAtMs;
+		forceCatalogSyncReason = "local_state_changed";
+		nextCatalogSyncAtMs = 0;
+		emitRunLine({
+			presenter: input.presenter,
+			code: "daemon.run.catalog_sync_signal_detected",
+			text: `catalog sync signal detected (${signal.reason}); scheduling immediate heartbeat`,
+			payload: {
+				reason: signal.reason,
+				updatedAt: signal.updatedAt
+			}
+		});
+		scheduleHeartbeat({
+			delayMs: 0,
+			reason: "catalog_sync_signal"
+		});
+	};
 	let hasLoggedWaitingForProfiles = input.routeCatalogState.profileIds.length === 0;
 	const registerDaemonSession = async (profileIds) => {
 		const registerPayload = daemonHubRegisterSessionRequestSchema.safeParse({
@@ -17485,6 +17660,8 @@ async function runDaemonSocketSession(input) {
 		forceCatalogSyncReason = "register_conflict";
 		nextCatalogSyncAtMs = 0;
 	} else scheduleCatalogSyncNext(resolveCatalogSyncIntervalMs({ heartbeatIntervalMs: currentHeartbeatIntervalMs }));
+	latestCatalogSyncSignalUpdatedAtMs = (await readDaemonCatalogSyncSignal().catch(() => null))?.updatedAtMs ?? 0;
+	scheduleCatalogSyncSignalPoll();
 	const sendHeartbeat = async () => {
 		if (closed || heartbeatInFlight) return;
 		heartbeatInFlight = true;
@@ -17578,6 +17755,7 @@ async function runDaemonSocketSession(input) {
 	await sendHeartbeat();
 	await waitForClose;
 	clearHeartbeatTimer();
+	clearCatalogSyncSignalTimer();
 	await dispatchBackpressureQueue.drain();
 	if (closeCode === 1e3 && closeReason === "shutdown") return;
 	throw new DaemonServiceRunError({
@@ -23151,7 +23329,9 @@ const LEADING_V_PREFIX_REGEX = /^v/;
 const SEMVER_CORE_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+.*)?$/;
 const NUMERIC_SEMVER_IDENTIFIER_REGEX = /^\d+$/;
 const versionCache = /* @__PURE__ */ new Map();
+const versionMetadataCache = /* @__PURE__ */ new Map();
 const inFlightVersionRequests = /* @__PURE__ */ new Map();
+const inFlightVersionMetadataRequests = /* @__PURE__ */ new Map();
 function versionStatePath() {
 	return join(atsRootDir(), VERSION_STATE_FILENAME);
 }
@@ -23226,6 +23406,31 @@ async function fetchLatestPackageVersion(packageName) {
 		inFlightVersionRequests.delete(packageName);
 	}
 }
+async function fetchPackageVersionMetadata(input) {
+	const packageName = input.packageName.trim();
+	const version = input.version.trim();
+	const cacheKey = `${packageName}@${version}`;
+	const now = Date.now();
+	const cached = versionMetadataCache.get(cacheKey);
+	if (cached && now - cached.fetchedAt < VERSION_CHECK_CACHE_TTL_MS) return cached.metadata;
+	const inFlight = inFlightVersionMetadataRequests.get(cacheKey);
+	if (inFlight) return inFlight;
+	const request = requestPackageVersionMetadata({
+		packageName,
+		version
+	});
+	inFlightVersionMetadataRequests.set(cacheKey, request);
+	try {
+		const metadata = await request;
+		versionMetadataCache.set(cacheKey, {
+			metadata,
+			fetchedAt: Date.now()
+		});
+		return metadata;
+	} finally {
+		inFlightVersionMetadataRequests.delete(cacheKey);
+	}
+}
 async function requestLatestPackageVersion(packageName) {
 	const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, {
 		method: "GET",
@@ -23242,6 +23447,23 @@ async function requestLatestPackageVersion(packageName) {
 		throw new Error(`version check failed: invalid registry response: ${toErrorMessage$7(error)}`);
 	}
 }
+async function requestPackageVersionMetadata(input) {
+	const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(input.packageName)}/${encodeURIComponent(input.version)}`, {
+		method: "GET",
+		signal: AbortSignal.timeout(NPM_REGISTRY_LATEST_TIMEOUT_MS)
+	});
+	const raw = await response.text();
+	if (!response.ok) throw new Error(`version check failed: HTTP ${response.status}: ${raw}`);
+	try {
+		const parsed = JSON.parse(raw);
+		return {
+			version: typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : input.version,
+			deprecated: typeof parsed.deprecated === "string" && parsed.deprecated.trim().length > 0 ? parsed.deprecated.trim() : null
+		};
+	} catch (error) {
+		throw new Error(`version check failed: invalid registry response: ${toErrorMessage$7(error)}`);
+	}
+}
 function compareSemver(a, b) {
 	const left = parseSemver(a);
 	const right = parseSemver(b);
@@ -25890,7 +26112,15 @@ const SPACE_MEMBER_JOIN_NOTICE_META_PURPOSE$2 = "space_membership_join_notice";
 const MENTION_DISPATCH_HINT_META_PURPOSE = "mention_dispatch_hint";
 const MENTION_FAILURE_HINT_PREFIX = "Mention skipped for \"";
 const MENTION_FAILURE_HINT_LEGACY_PREFIX = "Mention skipped. Try this:";
+const ATS_SYSTEM_PROFILE_ID$1 = "ats-system";
+const ATS_SYSTEM_PROFILE_NAME$1 = "ats system";
+const ADD_MEMBERS_AGENT_NOTICE_REGEX$1 = /^.+\s+\(agent(?:,\s+[^)]+)?\)\s+joined the space via add-members\.$/i;
+const ADD_MEMBERS_AGENT_MENTION_HINT = "You may @ this agent name to talk.";
+const SYSTEM_BROADCAST_LABEL = pc.cyan("📣 system");
+const ADD_MEMBERS_NOTICE_CARD_TITLE = `${pc.cyan("* 📣 system")} notice`;
+const ADD_MEMBERS_NOTICE_CARD_MIN_CONTENT_WIDTH = 64;
 const AGENT_SPEAKER_AVATAR = "🤖";
+const HUMAN_SPEAKER_AVATAR = "👤";
 let daemonWorkingDirectoryCache = null;
 function formatInputPrompt(profileIdentity) {
 	const profileName = resolveHumanProfileLabel(profileIdentity);
@@ -26049,35 +26279,44 @@ function formatHumanSpeaker(profileIdentity, input) {
 	const profileKind = resolveHumanProfileKind(profileIdentity);
 	const profileKindLabel = resolveHumanProfileKindLabel(profileIdentity);
 	const speaker = colorizeProfileLabel(input?.includeKind && profileKindLabel ? `${profileName} (${profileKindLabel})` : profileName, profileIdentity);
-	if (profileKind !== "agent") return speaker;
-	return `${AGENT_SPEAKER_AVATAR} ${speaker}`;
+	if (profileKind === "agent") return `${AGENT_SPEAKER_AVATAR} ${speaker}`;
+	if (profileKind === "human") return `${HUMAN_SPEAKER_AVATAR} ${speaker}`;
+	return speaker;
 }
 function formatHelloAck(event, options) {
-	if (options.view === "human") {
-		const acknowledgedName = resolveHumanProfileLabel(event.profile);
-		return `* ${pc.cyan("system")}: connected as ${acknowledgedName}.`;
-	}
+	if (options.view === "human") return `* ${SYSTEM_BROADCAST_LABEL}: connected as ${resolveHumanProfileLabel(event.profile)}.`;
 	const profileDescriptor = resolveAgentViewProfileDescriptor(event.profile);
 	return `${pc.cyan("system")}: hello.ack ${profileDescriptor}`;
 }
 function formatPresenceJoin(event, options) {
-	if (options.view === "human") return `* ${formatHumanSpeaker(event.profile, { includeKind: true })} joined the space.`;
+	if (options.view === "human") return `* ${formatHumanSpeaker(event.profile, { includeKind: true })} ${formatSignalTimestamp(event.ts)} joined the space.`;
 	return `${pc.green("+")} ${resolveAgentViewProfileDescriptor(event.profile)}`;
 }
 function formatPresenceQuit(event, options) {
-	if (options.view === "human") return `* ${formatHumanSpeaker(event.profile, { includeKind: true })} left the space.`;
+	if (options.view === "human") return `* ${formatHumanSpeaker(event.profile, { includeKind: true })} ${formatSignalTimestamp(event.ts)} left the space.`;
 	return `${pc.red("-")} ${resolveAgentViewProfileDescriptor(event.profile)}`;
 }
 function formatSignalText(event, options) {
 	if (isTransientSignalTextHintClearEvent(event)) return null;
 	const text = typeof event.data?.text === "string" ? event.data.text : "";
 	if (isTransientSignalTextHint(event)) return null;
-	const memberJoinNoticeText = resolveSpaceMemberJoinNoticeText(event);
-	if (memberJoinNoticeText) {
-		if (options.view === "human") return `* ${pc.cyan("system")}: ${memberJoinNoticeText}`;
-		return `${pc.cyan("system")}: ${memberJoinNoticeText}`;
+	const renderedSystemNotice = resolveRenderedSystemNotice({
+		event,
+		text
+	});
+	if (renderedSystemNotice) {
+		if (options.view === "human") {
+			if (renderedSystemNotice.kind === "add_members_agent") return formatAddMembersSystemNoticeCard(renderedSystemNotice.text);
+			return `* ${SYSTEM_BROADCAST_LABEL}: ${renderedSystemNotice.text}`;
+		}
+		const lineText = renderedSystemNotice.kind === "add_members_agent" ? appendAddMembersAgentMentionHint(renderedSystemNotice.text) : renderedSystemNotice.text;
+		return `${pc.cyan("system")}: ${lineText}`;
 	}
 	if (options.view === "human" && isMentionFailureHintSignalText(event, text)) return null;
+	if (options.view === "human" && isSystemProfileIdentity(event.profile)) {
+		const normalizedText = text.trim();
+		return normalizedText ? `* ${SYSTEM_BROADCAST_LABEL}: ${normalizedText}` : null;
+	}
 	if (options.view === "human") return `- ${formatHumanSpeaker(event.profile, { includeKind: true })} ${formatSignalTimestamp(event.ts)}: ${text}`;
 	const label = resolveAgentViewProfileDescriptor(event.profile);
 	return `${pc.bold(label)}: ${text}`;
@@ -26090,6 +26329,11 @@ function isMentionFailureHintSignalText(event, text) {
 	if (!normalized) return false;
 	return normalized.startsWith(MENTION_FAILURE_HINT_PREFIX) || normalized.startsWith(MENTION_FAILURE_HINT_LEGACY_PREFIX);
 }
+function isSystemProfileIdentity(profileIdentity) {
+	if (String(profileIdentity?.kind ?? "").trim().toLowerCase() === "system") return true;
+	if (String(profileIdentity?.profileId ?? "").trim().toLowerCase() === ATS_SYSTEM_PROFILE_ID$1) return true;
+	return String(profileIdentity?.profileName ?? "").trim().toLowerCase() === ATS_SYSTEM_PROFILE_NAME$1;
+}
 function isTransientSignalTextHint(event) {
 	const rawMeta = resolveSignalTextMeta(event);
 	if (!rawMeta) return false;
@@ -26116,6 +26360,52 @@ function resolveSpaceMemberJoinNoticeText(event) {
 	const text = String(event.data?.text ?? "").trim();
 	return text.length > 0 ? text : null;
 }
+function resolveRenderedSystemNotice(input) {
+	const memberJoinNoticeText = resolveSpaceMemberJoinNoticeText(input.event);
+	if (memberJoinNoticeText) {
+		const addMembersNoticeText = resolveAddMembersAgentNoticeText(memberJoinNoticeText);
+		if (addMembersNoticeText) return {
+			kind: "add_members_agent",
+			text: addMembersNoticeText
+		};
+		return {
+			kind: "default",
+			text: memberJoinNoticeText
+		};
+	}
+	const legacyAddMembersNoticeText = resolveAddMembersAgentNoticeText(input.text);
+	if (legacyAddMembersNoticeText) return {
+		kind: "add_members_agent",
+		text: legacyAddMembersNoticeText
+	};
+	return null;
+}
+function resolveAddMembersAgentNoticeText(text) {
+	const normalizedText = text.trim();
+	if (!normalizedText) return null;
+	if (!ADD_MEMBERS_AGENT_NOTICE_REGEX$1.test(normalizedText)) return null;
+	return normalizedText;
+}
+function appendAddMembersAgentMentionHint(text) {
+	const normalizedText = text.trim();
+	if (!normalizedText) return "";
+	if (normalizedText.includes(ADD_MEMBERS_AGENT_MENTION_HINT)) return normalizedText;
+	return `${normalizedText} ${ADD_MEMBERS_AGENT_MENTION_HINT}`;
+}
+function formatAddMembersSystemNoticeCard(noticeText) {
+	const frame = buildUnifiedCardFrame({
+		title: ADD_MEMBERS_NOTICE_CARD_TITLE,
+		rowTextList: [noticeText, pc.dim(ADD_MEMBERS_AGENT_MENTION_HINT)],
+		minContentWidth: ADD_MEMBERS_NOTICE_CARD_MIN_CONTENT_WIDTH
+	});
+	return [
+		frame.top,
+		frame.empty,
+		...frame.rows,
+		frame.empty,
+		frame.bottom
+	].join("\n");
+}
 function resolveAgentViewProfileDescriptor(profileIdentity) {
 	const profileId = String(profileIdentity?.profileId ?? "").trim() || "unknown";
 	const metadata = resolveAgentViewProfileMetadata(profileIdentity);
@@ -26135,10 +26425,10 @@ function resolveHumanProfileKindLabel(profileIdentity) {
 	const kind = resolveHumanProfileKind(profileIdentity);
 	if (kind !== "agent") return kind;
 	const details = [];
-	const ownerDisplay = resolveHumanReadableOwner(profileIdentity);
-	if (ownerDisplay) details.push(`owner: ${ownerDisplay}`);
 	const controllerRef = resolveControllerRef(profileIdentity);
 	if (controllerRef) details.push(`controller: ${controllerRef}`);
+	const ownerDisplay = resolveHumanReadableOwner(profileIdentity);
+	if (ownerDisplay) details.push(`owner: ${ownerDisplay}`);
 	const agentContextId = resolveAgentContextId(profileIdentity);
 	if (agentContextId) {
 		const contextDisplay = controllerRef ? resolveAgentContextDisplay({
@@ -26300,8 +26590,13 @@ function toAnsiTrueColorColorize(color) {
 }
 function formatSignalTimestamp(ts) {
 	const date = new Date(ts);
-	if (Number.isNaN(date.getTime())) return "00000000 00:00";
-	return `${String(date.getFullYear())}${String(date.getMonth() + 1).padStart(2, "0")}${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+	if (Number.isNaN(date.getTime())) return pc.dim("00000000 00:00");
+	const year = String(date.getFullYear());
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	const hour = String(date.getHours()).padStart(2, "0");
+	const minute = String(date.getMinutes()).padStart(2, "0");
+	return pc.dim(`${year}${month}${day} ${hour}:${minute}`);
 }
 
 //#endregion
@@ -26442,13 +26737,19 @@ const MENTION_FALLBACK_LOCAL_ECHO_PATTERN = /^@[^\s]+/;
 const TRANSIENT_HINT_START_PURPOSE = "agent_replying";
 const TRANSIENT_HINT_END_PURPOSE = "agent_replying_end";
 const SPACE_MEMBER_JOIN_NOTICE_META_PURPOSE$1 = "space_membership_join_notice";
+const ADD_MEMBERS_AGENT_NOTICE_REGEX = /^.+\s+\(agent(?:,\s+[^)]+)?\)\s+joined the space via add-members\.$/i;
 const REPLYING_HINT_FALLBACK_CLEAR_MS = 18e4;
-const REPLYING_STATUS_SYSTEM_LABEL = "ATS System";
+const REPLYING_STATUS_SYSTEM_LABEL = "📣 system";
+const REPLYING_STATUS_AGENT_LABEL = "🤖";
+const REPLYING_STATUS_PROMPT_GAP_LINES = 1;
 const SYSTEM_MESSAGE_GROUP_KEY = "system";
 const CHAT_GROUP_DIVIDER_MARGIN = 2;
 const CHAT_GROUP_DIVIDER_MIN_WIDTH = 24;
 const CHAT_GROUP_DIVIDER_MAX_WIDTH = 120;
-const CHAT_GROUP_DIVIDER_CHAR = "─";
+const CHAT_GROUP_DIVIDER_CHAR = "╌";
+const CHAT_GROUP_DIVIDER_SIDE_GAP_LINES = 1;
+const ATS_SYSTEM_PROFILE_ID = "ats-system";
+const ATS_SYSTEM_PROFILE_NAME = "ats system";
 const LEAVE_CARD_FALLBACK_CONTENT_WIDTH = 68;
 const LEAVE_CARD_MAX_CONTENT_WIDTH = 72;
 const LEAVE_CARD_MIN_CONTENT_WIDTH = 8;
@@ -26483,6 +26784,15 @@ async function runConnect(input) {
 		...controllerRef ? { controllerRef } : {},
 		...agentContextId ? { agentContextId } : {}
 	};
+	const ownerDisplayNameByUserId = /* @__PURE__ */ new Map();
+	const rememberOwnerDisplayName = (ownerUserIdRaw, ownerDisplayRaw) => {
+		const ownerUserId = String(ownerUserIdRaw ?? "").trim();
+		const ownerDisplay = String(ownerDisplayRaw ?? "").trim();
+		if (!(ownerUserId && ownerDisplay)) return;
+		ownerDisplayNameByUserId.set(ownerUserId, ownerDisplay);
+	};
+	rememberOwnerDisplayName(atsProfile.ownerUserId, atsProfile.ownerName);
+	if (atsProfile.profileKind === "human") rememberOwnerDisplayName(atsProfile.ownerUserId, atsProfile.profileName);
 	const lock = await acquireLock({
 		profile,
 		key: `${new URL(baseUrl).host}__${space}__${profileIdentity.profileId}`
@@ -26619,6 +26929,7 @@ async function runConnect(input) {
 		let rl = null;
 		let hasPrintedTextLine = false;
 		let lastPrintedTextLineGroupKey = null;
+		let nextDividerGapPlacement = "top";
 		let allowLiveCursorPersistence = true;
 		let persistedLastSeenFloorTs = initialLiveFloorTs;
 		const pauseLiveCursorPersistence = () => {
@@ -26665,9 +26976,11 @@ async function runConnect(input) {
 			if (!canRenderReplyingStatusLine() || visibleReplyingStatusLine.length === 0) return;
 			clearLine(process.stdout, 0);
 			cursorTo(process.stdout, 0);
-			moveCursor(process.stdout, 0, -1);
-			clearLine(process.stdout, 0);
-			cursorTo(process.stdout, 0);
+			for (let lineOffset = 0; lineOffset < REPLYING_STATUS_PROMPT_GAP_LINES + 1; lineOffset += 1) {
+				moveCursor(process.stdout, 0, -1);
+				clearLine(process.stdout, 0);
+				cursorTo(process.stdout, 0);
+			}
 			visibleReplyingStatusLine = "";
 		};
 		const renderVisibleReplyingStatusLine = (text) => {
@@ -26680,13 +26993,15 @@ async function runConnect(input) {
 			if (visibleReplyingStatusLine === normalizedText) return;
 			clearVisibleReplyingStatusLine();
 			clearPromptLineBeforeExternalWrite();
-			process.stdout.write(`${normalizedText}\n`);
+			process.stdout.write(`${normalizedText}${"\n".repeat(REPLYING_STATUS_PROMPT_GAP_LINES + 1)}`);
 			visibleReplyingStatusLine = normalizedText;
 		};
 		const syncReplyingStatusPresentation = () => {
 			const promptStatus = resolveReplyingPromptStatus();
-			if (promptStatus) renderVisibleReplyingStatusLine(`${pc.dim(REPLYING_STATUS_SYSTEM_LABEL)} ${pc.dim("·")} ${pc.dim(promptStatus)}`);
-			else clearVisibleReplyingStatusLine();
+			if (promptStatus) {
+				const decoratedReplyingStatus = `${REPLYING_STATUS_AGENT_LABEL} ${promptStatus}`;
+				renderVisibleReplyingStatusLine(`${pc.dim(`* ${REPLYING_STATUS_SYSTEM_LABEL}`)} ${pc.dim("·")} ${pc.dim(decoratedReplyingStatus)}`);
+			} else clearVisibleReplyingStatusLine();
 			refreshInputPrompt();
 		};
 		const scheduleReplyingStatusSweep = () => {
@@ -26782,21 +27097,48 @@ async function runConnect(input) {
 			if (!dequeueLocalSelfEchoIfHeadMatch(localSelfEchoQueue, typeof event.data?.text === "string" ? event.data.text : "")) return false;
 			return true;
 		};
-		const emitTextLine = (inputLine) => {
-			if (runtime.resolvedView === "human") {
-				clearPromptLineBeforeExternalWrite();
-				if (hasPrintedTextLine && lastPrintedTextLineGroupKey !== inputLine.groupKey) {
-					const dividerLine = buildChatGroupDividerLine();
-					if (dividerLine) process.stdout.write(`${dividerLine}\n`);
-					else process.stdout.write("\n");
+		const resolveTextRenderEvent = (event) => {
+			if (!isSignalEnvelope(event) || event.profile?.kind !== "agent") return event;
+			const ownerUserId = String(event.profile.owner ?? "").trim();
+			if (!ownerUserId) return event;
+			const currentOwnerName = String(event.profile.ownerName ?? "").trim();
+			if (currentOwnerName) rememberOwnerDisplayName(ownerUserId, currentOwnerName);
+			const resolvedOwnerName = ownerDisplayNameByUserId.get(ownerUserId) ?? currentOwnerName;
+			if (!(resolvedOwnerName && resolvedOwnerName !== currentOwnerName)) return event;
+			return {
+				...event,
+				profile: {
+					...event.profile,
+					ownerName: resolvedOwnerName
 				}
+			};
+		};
+		const emitTextGroupDivider = () => {
+			const dividerLine = buildChatGroupDividerLine();
+			if (!dividerLine) {
+				process.stdout.write("\n");
+				return;
+			}
+			const useTopGap = nextDividerGapPlacement === "top";
+			const topGapLines = useTopGap ? CHAT_GROUP_DIVIDER_SIDE_GAP_LINES : 0;
+			const bottomGapLines = useTopGap ? 0 : CHAT_GROUP_DIVIDER_SIDE_GAP_LINES;
+			process.stdout.write(`${"\n".repeat(topGapLines)}${dividerLine}\n${"\n".repeat(bottomGapLines)}`);
+			nextDividerGapPlacement = useTopGap ? "bottom" : "top";
+		};
+		const emitTextLine = (inputLine) => {
+			if (runtime.resolvedView !== "human") {
 				process.stdout.write(`${inputLine.line}\n`);
-				hasPrintedTextLine = true;
-				lastPrintedTextLineGroupKey = inputLine.groupKey;
-				if (inputLine.refreshPrompt !== false && rl) refreshInputPrompt();
 				return;
 			}
+			clearPromptLineBeforeExternalWrite();
+			if (hasPrintedTextLine && lastPrintedTextLineGroupKey !== inputLine.groupKey) emitTextGroupDivider();
 			process.stdout.write(`${inputLine.line}\n`);
+			hasPrintedTextLine = true;
+			lastPrintedTextLineGroupKey = inputLine.groupKey;
+			if (inputLine.refreshPrompt !== false && rl) {
+				process.stdout.write("\n");
+				refreshInputPrompt();
+			}
 		};
 		const clearSubmittedInputLine = () => {
 			if (!(shouldHideSubmittedInputLine && process.stdout.isTTY)) return;
@@ -26822,13 +27164,14 @@ async function runConnect(input) {
 				outJsonLine(event);
 				return;
 			}
-			const line = formatTextEvent(event, {
+			const textRenderEvent = resolveTextRenderEvent(event);
+			const line = formatTextEvent(textRenderEvent, {
 				view: runtime.resolvedView,
 				selfProfileId: profileIdentity.profileId
 			});
 			if (line) emitTextLine({
 				line,
-				groupKey: resolveTextLineGroupKey(event)
+				groupKey: resolveTextLineGroupKey(textRenderEvent)
 			});
 		};
 		const sessionMeta = resolveSessionMeta(space, spaceMeta, localSpaceConfig?.name, localSpaceConfig?.spaceCreatedAt);
@@ -27019,8 +27362,11 @@ async function runConnect(input) {
 			return;
 		}
 		if (output === "text") {
-			presenter.event("info", "connect.chat_ready");
-			presenter.event("info", "connect.chat_exit_hint");
+			if (runtime.resolvedView === "human") process.stdout.write("\n");
+			const chatReadyText = formatMessage(runtime.resolvedView, "connect.chat_ready");
+			const chatExitHintText = formatMessage(runtime.resolvedView, "connect.chat_exit_hint");
+			process.stdout.write(`${pc.dim(chatReadyText)}\n`);
+			process.stdout.write(`${pc.dim(chatExitHintText)}\n`);
 			if (runtime.resolvedView === "human") process.stdout.write("\n");
 		} else presenter.event("info", "connect.connected_stdio");
 		rl = createInterface({
@@ -27063,7 +27409,7 @@ async function runConnect(input) {
 			const shouldEmitLocalEcho = enableLocalEcho || shouldEnableFallbackLocalEchoForText(outboundText);
 			if (shouldEmitLocalEcho) {
 				enqueueLocalSelfEcho(localSelfEchoQueue, outboundText);
-				const localEvent = {
+				const localTextRenderEvent = resolveTextRenderEvent({
 					v: 1,
 					id: "local-self",
 					spaceId: space,
@@ -27075,14 +27421,14 @@ async function runConnect(input) {
 					},
 					type: "signal.text",
 					data: { text: outboundText }
-				};
-				const localLine = formatTextEvent(localEvent, {
+				});
+				const localLine = formatTextEvent(localTextRenderEvent, {
 					view: runtime.resolvedView,
 					selfProfileId: profileIdentity.profileId
 				});
 				if (localLine) emitTextLine({
 					line: localLine,
-					groupKey: resolveTextLineGroupKey(localEvent),
+					groupKey: resolveTextLineGroupKey(localTextRenderEvent),
 					refreshPrompt: false
 				});
 			}
@@ -27885,7 +28231,7 @@ function buildChatGroupDividerLine() {
 	if (process.stdout.isTTY !== true) return "";
 	const width = clampNumber(resolveTerminalColumns() - CHAT_GROUP_DIVIDER_MARGIN * 2, CHAT_GROUP_DIVIDER_MIN_WIDTH, CHAT_GROUP_DIVIDER_MAX_WIDTH);
 	const margin = " ".repeat(CHAT_GROUP_DIVIDER_MARGIN);
-	return pc.dim(`${margin}${CHAT_GROUP_DIVIDER_CHAR.repeat(width)}`);
+	return pc.dim(pc.gray(`${margin}${CHAT_GROUP_DIVIDER_CHAR.repeat(width)}`));
 }
 function resolveTerminalColumns() {
 	const rawColumns = process.stdout.columns;
@@ -27907,8 +28253,17 @@ function resolveProfileGroupKey(profile, fallbackType) {
 }
 function isSystemRenderedSignalTextEvent(event) {
 	if (event.type !== "signal.text") return false;
+	if (isSystemProfileForTextGrouping(event.profile)) return true;
 	const meta = resolveSignalTextMetaFromEnvelope(event);
-	return String(meta?.purpose ?? "").trim() === SPACE_MEMBER_JOIN_NOTICE_META_PURPOSE$1;
+	if (String(meta?.purpose ?? "").trim() === SPACE_MEMBER_JOIN_NOTICE_META_PURPOSE$1) return true;
+	const text = String(event.data?.text ?? "").trim();
+	if (!text) return false;
+	return ADD_MEMBERS_AGENT_NOTICE_REGEX.test(text);
+}
+function isSystemProfileForTextGrouping(profile) {
+	if (String(profile?.kind ?? "").trim().toLowerCase() === "system") return true;
+	if (String(profile?.profileId ?? "").trim().toLowerCase() === ATS_SYSTEM_PROFILE_ID) return true;
+	return String(profile?.profileName ?? "").trim().toLowerCase() === ATS_SYSTEM_PROFILE_NAME;
 }
 function resolveReplyingHintEvent(event) {
 	if (event.type !== "signal.text") return null;
@@ -29849,7 +30204,9 @@ async function resolveSpaceAddMembersTarget(input) {
 	});
 }
 async function resolveSpaceMemberCandidatesForAdd(input) {
-	const candidateProfiles = (await listAtsProfiles()).filter((profile) => profile.status === "active" && profile.atsProfileId !== input.currentProfileId).filter((profile) => typeof input.currentOwnerUserId !== "string" || input.currentOwnerUserId.trim().length === 0 || profile.ownerUserId === input.currentOwnerUserId);
+	const profiles = await listAtsProfiles();
+	const ownerProfileNameByOwnerUserId = buildOwnerProfileNameByOwnerUserId(profiles);
+	const candidateProfiles = profiles.filter((profile) => profile.status === "active" && profile.atsProfileId !== input.currentProfileId).filter((profile) => typeof input.currentOwnerUserId !== "string" || input.currentOwnerUserId.trim().length === 0 || profile.ownerUserId === input.currentOwnerUserId);
 	if (candidateProfiles.length === 0) return [];
 	const membershipStatusMap = await resolveSpaceMemberMembershipStatusMap({
 		space: input.space,
@@ -29870,6 +30227,10 @@ async function resolveSpaceMemberCandidatesForAdd(input) {
 			profileId: profile.atsProfileId,
 			profileName: profile.profileName,
 			profileKind: profile.profileKind,
+			ownerProfileName: ownerProfileNameByOwnerUserId.get(profile.ownerUserId),
+			ownerUserId: profile.ownerUserId,
+			ownerName: profile.ownerName,
+			controllerRef: profile.controllerBinding?.controllerRef,
 			alreadyJoined,
 			needsActivation
 		};
@@ -29879,6 +30240,21 @@ async function resolveSpaceMemberCandidatesForAdd(input) {
 		return left.profileId.localeCompare(right.profileId);
 	});
 }
+function buildOwnerProfileNameByOwnerUserId(profiles) {
+	const ownerProfileMap = /* @__PURE__ */ new Map();
+	const activeHumanProfiles = profiles.filter((profile) => profile.status === "active").filter((profile) => profile.profileKind === "human");
+	for (const profile of activeHumanProfiles) {
+		const ownerUserId = normalizeOptionalString$1(profile.ownerUserId);
+		const profileName = normalizeOptionalString$1(profile.profileName);
+		if (!(ownerUserId && profileName)) continue;
+		if (!ownerProfileMap.has(ownerUserId)) {
+			ownerProfileMap.set(ownerUserId, profileName);
+			continue;
+		}
+		if (profile.isDefault === true) ownerProfileMap.set(ownerUserId, profileName);
+	}
+	return ownerProfileMap;
+}
 async function resolveSpaceMemberMembershipStatusMap(input) {
 	const targetSpaceKey = normalizeKnownSpaceMergeKey(input.space);
 	const pairs = await Promise.all(input.candidates.map(async (candidate) => {
@@ -29952,7 +30328,10 @@ async function resolveSpaceAddMemberSelection(input) {
 	}
 	const selected = await multiselect({
 		message: "Choose profile(s) to add as members",
-		options: input.candidates.map((candidate) => ({
+		options: sortSpaceMemberCandidatesForPrompt({
+			candidates: input.candidates,
+			initialSelectedProfileIds
+		}).map((candidate) => ({
 			value: candidate.profileId,
 			label: formatSpaceMemberCandidateLabel(candidate),
 			hint: formatSpaceMemberCandidateHint(candidate),
@@ -29968,6 +30347,15 @@ async function resolveSpaceAddMemberSelection(input) {
 	const normalized = normalizeRequestedMemberIds(selected);
 	return normalized.length > 0 ? normalized : [];
 }
+function sortSpaceMemberCandidatesForPrompt(input) {
+	if (input.initialSelectedProfileIds.length === 0) return input.candidates;
+	const selectedProfileIds = new Set(input.initialSelectedProfileIds);
+	return [...input.candidates].sort((left, right) => {
+		const leftSelected = selectedProfileIds.has(left.profileId);
+		if (leftSelected === selectedProfileIds.has(right.profileId)) return 0;
+		return leftSelected ? -1 : 1;
+	});
+}
 async function applySpaceAddMembers(input) {
 	const result = {
 		added: [],
@@ -30165,7 +30553,20 @@ async function postSpaceAddMemberJoinNotice(input) {
 	if (!response.ok) throw new Error(`HTTP ${response.status}: ${raw}`);
 }
 function buildSpaceAddMemberJoinNoticeText(member) {
-	return `${member.profileName} (${member.profileKind}) joined the space via add-members.`;
+	return `${resolveSpaceAddMemberNoticeProfileNameLabel(member)} (${resolveSpaceAddMemberNoticeProfileKindLabel(member)}) joined the space via add-members.`;
+}
+function resolveSpaceAddMemberNoticeProfileNameLabel(member) {
+	if (member.profileKind !== "agent") return member.profileName;
+	return `🤖 ${member.profileName}`;
+}
+function resolveSpaceAddMemberNoticeProfileKindLabel(member) {
+	if (member.profileKind !== "agent") return member.profileKind;
+	const detailSegments = [];
+	const ownerDisplay = normalizeOptionalString$1(member.ownerProfileName) ?? normalizeOptionalString$1(member.ownerName) ?? normalizeOptionalString$1(member.ownerUserId);
+	const controllerRef = normalizeOptionalString$1(member.controllerRef);
+	if (controllerRef) detailSegments.push(`controller: ${controllerRef}`);
+	if (ownerDisplay) detailSegments.push(`owner: ${ownerDisplay}`);
+	return detailSegments.length > 0 ? `agent, ${detailSegments.join(", ")}` : "agent";
 }
 function formatSpaceMemberCandidateLabel(candidate) {
 	const label = `${candidate.profileName} (${candidate.profileKind}) · ${candidate.profileId}`;
@@ -32938,7 +33339,7 @@ function toErrorMessage$2(error) {
 
 //#endregion
 //#region src/commands/upgrade.ts
-const ATS_PACKAGE_NAME = "agent-transport-system";
+const ATS_PACKAGE_NAME$1 = "agent-transport-system";
 async function runUpgrade(input) {
 	const runtime = await resolveRuntimeContext({ view: input.view });
 	const presenter = createPresenter(runtime);
@@ -33025,7 +33426,7 @@ async function runUpgrade(input) {
 }
 async function resolveUpgradeStatus(input) {
 	try {
-		const latestVersion = await fetchLatestPackageVersion(ATS_PACKAGE_NAME);
+		const latestVersion = await fetchLatestPackageVersion(ATS_PACKAGE_NAME$1);
 		return {
 			status: compareSemver(input.currentVersion, latestVersion) < 0 ? "outdated" : "up_to_date",
 			currentVersion: input.currentVersion,
@@ -33063,7 +33464,7 @@ async function installLatestPackage() {
 	const args = [
 		"install",
 		"-g",
-		`${ATS_PACKAGE_NAME}@latest`
+		`${ATS_PACKAGE_NAME$1}@latest`
 	];
 	const result = await new Promise((resolve, reject) => {
 		const child = spawn(command, args, {
@@ -33668,6 +34069,129 @@ function buildDaemonBootstrapRecommendationResult(input) {
 	return parsed.data;
 }
 
+//#endregion
+//#region src/system/startup-upgrade-check.ts
+const ATS_PACKAGE_NAME = "agent-transport-system";
+const STARTUP_UPGRADE_SKIP_COMMANDS = new Set(["upgrade"]);
+const STARTUP_INTERNAL_SKIP_ENV = "ATS_INTERNAL_SKIP_STARTUP_UPGRADE";
+const STARTUP_AUTO_UPGRADE_ENV = "ATS_STARTUP_AUTO_UPGRADE";
+async function maybeRunStartupUpgradeCheck(input) {
+	if (shouldSkipStartupUpgradeCheckByEnv()) return {
+		upgraded: false,
+		resolvedView: null,
+		deprecatedWarning: null,
+		trigger: null,
+		latestVersion: null
+	};
+	const firstCommand = parseFirstCommandTokenFromArgv(input.argv);
+	if (!firstCommand) return {
+		upgraded: false,
+		resolvedView: null,
+		deprecatedWarning: null,
+		trigger: null,
+		latestVersion: null
+	};
+	if (!input.isKnownTopLevelCommand(firstCommand)) return {
+		upgraded: false,
+		resolvedView: null,
+		deprecatedWarning: null,
+		trigger: null,
+		latestVersion: null
+	};
+	if (STARTUP_UPGRADE_SKIP_COMMANDS.has(firstCommand)) return {
+		upgraded: false,
+		resolvedView: null,
+		deprecatedWarning: null,
+		trigger: null,
+		latestVersion: null
+	};
+	const explicitView = parseViewFromArgv(input.argv, { allowMissingValue: true });
+	const runtime = await resolveRuntimeContext({ ...explicitView ? { view: explicitView } : {} });
+	const currentVersion = version$1;
+	const deprecatedWarning = await resolveDeprecatedVersionWarning({ currentVersion });
+	if (!(runtime.resolvedView === "human" && runtime.interactive || isStartupAutoUpgradeEnabled())) return {
+		upgraded: false,
+		resolvedView: runtime.resolvedView,
+		deprecatedWarning,
+		trigger: null,
+		latestVersion: null
+	};
+	const latestVersion = await fetchLatestPackageVersion(ATS_PACKAGE_NAME).catch(() => null);
+	if (!latestVersion || compareSemver(currentVersion, latestVersion) >= 0) return {
+		upgraded: false,
+		resolvedView: runtime.resolvedView,
+		deprecatedWarning,
+		trigger: null,
+		...latestVersion ? { latestVersion } : { latestVersion: null }
+	};
+	if (runtime.resolvedView === "human" && runtime.interactive) {
+		const selected = await confirm({
+			message: `Upgrade ATS CLI from ${currentVersion} to ${latestVersion}?`,
+			initialValue: true
+		});
+		if (isCancel(selected) || !selected) return {
+			upgraded: false,
+			resolvedView: runtime.resolvedView,
+			deprecatedWarning,
+			trigger: null,
+			latestVersion
+		};
+		await ensureVersionStateReady(currentVersion);
+		await runUpgrade({
+			yes: true,
+			view: runtime.resolvedView
+		});
+		return {
+			upgraded: true,
+			resolvedView: runtime.resolvedView,
+			deprecatedWarning,
+			trigger: "interactive_prompt",
+			latestVersion
+		};
+	}
+	await ensureVersionStateReady(currentVersion);
+	await runUpgrade({
+		yes: true,
+		view: runtime.resolvedView
+	});
+	return {
+		upgraded: true,
+		resolvedView: runtime.resolvedView,
+		deprecatedWarning,
+		trigger: "non_interactive_auto",
+		latestVersion
+	};
+}
+async function resolveDeprecatedVersionWarning(input) {
+	try {
+		const metadata = await fetchPackageVersionMetadata({
+			packageName: ATS_PACKAGE_NAME,
+			version: input.currentVersion
+		});
+		if (!metadata.deprecated) return null;
+		return {
+			currentVersion: input.currentVersion,
+			deprecatedMessage: metadata.deprecated,
+			upgradeCommand: "ats upgrade"
+		};
+	} catch {
+		return null;
+	}
+}
+async function ensureVersionStateReady(currentVersion) {
+	if (await readVersionState()) return;
+	await writeVersionState(createInitialVersionState({ currentVersion }));
+}
+function shouldSkipStartupUpgradeCheckByEnv() {
+	return String(process.env[STARTUP_INTERNAL_SKIP_ENV] ?? "").trim() === "1";
+}
+function isStartupAutoUpgradeEnabled() {
+	const raw = String(process.env[STARTUP_AUTO_UPGRADE_ENV] ?? "").trim();
+	if (!raw) return true;
+	const normalized = raw.toLowerCase();
+	return !(normalized === "0" || normalized === "false" || normalized === "off" || normalized === "no");
+}
+
 //#endregion
 //#region src/ats.ts
 const program = new Command();
@@ -33687,6 +34211,7 @@ const CLI_NAME = resolveCliNameFromPackageJson(package_default);
 const DEFAULT_AGENT_EXAMPLE_ID = resolveAgentExampleIds(1)[0] ?? "<agent-id>";
 const DEFAULT_AGENT_EXAMPLE_PAIR = resolveAgentExampleIds(2).join(" ") || "<agent-a> <agent-b>";
 const AGENT_VIEW_PROFILE_CONTROLLER_RULE_TEXT = "Agent-view profile rule: when creating/updating an agent profile, use the controller that matches your current runtime agent when supported (for example codex->codex, claude-code->claude-code). If your runtime agent is unsupported, continue as unbound (no controller) and explicitly tell the user.";
+const STARTUP_INTERNAL_SKIP_UPGRADE_ENV = "ATS_INTERNAL_SKIP_STARTUP_UPGRADE";
 function resolveCliNameFromPackageJson(manifest) {
 	if (typeof manifest.bin === "string") {
 		const cliNameFromPath = parse(manifest.bin).name.trim();
@@ -34286,6 +34811,31 @@ async function main() {
 	try {
 		await ensureSystemLayout();
 		await runDaemonStartupCheck(argv);
+		const startupUpgradeCheck = await maybeRunStartupUpgradeCheck({
+			argv,
+			isKnownTopLevelCommand
+		}).catch(async (error) => {
+			emitStartupAutoUpgradeFailed({
+				view: await resolveEffectiveViewForOutput().catch(() => {
+					return "human";
+				}),
+				errorMessage: toErrorMessage(error)
+			});
+			throw new Error(`startup auto-upgrade failed: ${toErrorMessage(error)}\nRun \`ats upgrade --yes\` and retry.`);
+		});
+		emitStartupDeprecatedVersionWarning({
+			warning: startupUpgradeCheck.deprecatedWarning,
+			view: startupUpgradeCheck.resolvedView
+		});
+		if (startupUpgradeCheck.upgraded) {
+			await rerunCommandAfterStartupUpgrade({
+				argv,
+				trigger: startupUpgradeCheck.trigger,
+				view: startupUpgradeCheck.resolvedView,
+				latestVersion: startupUpgradeCheck.latestVersion
+			});
+			return;
+		}
 		if (argv.length <= 2) {
 			printAtsBanner();
 			return;
@@ -34337,6 +34887,25 @@ async function main() {
 		process.exitCode = 1;
 	}
 }
+function emitStartupDeprecatedVersionWarning(input) {
+	if (!(input.warning && input.view)) return;
+	if (input.view === "agent") {
+		outJsonLine({
+			type: "line",
+			code: "upgrade.version_deprecated",
+			text: "current ATS CLI version is deprecated; run `ats upgrade` immediately.",
+			data: {
+				severity: "warning",
+				currentVersion: input.warning.currentVersion,
+				deprecatedMessage: input.warning.deprecatedMessage,
+				upgradeCommand: input.warning.upgradeCommand
+			}
+		});
+		return;
+	}
+	outLine(`🚨 ATS CLI v${input.warning.currentVersion} is deprecated: ${input.warning.deprecatedMessage}`);
+	outLine("⚠️ Please run `ats upgrade` immediately.");
+}
 async function runDaemonStartupCheck(argv) {
 	const firstCommand = parseFirstCommandTokenFromArgv(argv);
 	if (firstCommand && !isKnownTopLevelCommand(firstCommand)) return;
@@ -34741,6 +35310,87 @@ function rerunCommandInHumanView(argv) {
 		});
 	});
 }
+async function rerunCommandAfterStartupUpgrade(input) {
+	const resolvedView = input.view ?? await resolveEffectiveViewForOutput();
+	if (input.trigger === "non_interactive_auto") emitStartupAutoUpgradeApplied({
+		latestVersion: input.latestVersion,
+		view: resolvedView
+	});
+	emitStartupAutoUpgradeRerun({ view: resolvedView });
+	const retryExitCode = await rerunCurrentCommandWithEnv({
+		argv: input.argv,
+		env: { [STARTUP_INTERNAL_SKIP_UPGRADE_ENV]: "1" }
+	});
+	process.exitCode = retryExitCode;
+}
+function emitStartupAutoUpgradeApplied(input) {
+	if (input.view === "agent") {
+		outJsonLine({
+			type: "line",
+			code: "upgrade.startup.auto_upgrade.applied",
+			text: "startup auto-upgrade applied.",
+			data: { ...input.latestVersion ? { latestVersion: input.latestVersion } : {} }
+		});
+		return;
+	}
+	if (input.latestVersion) {
+		outLine(`Startup auto-upgrade applied. ATS CLI is now on v${input.latestVersion}.`);
+		return;
+	}
+	outLine("Startup auto-upgrade applied.");
+}
+function emitStartupAutoUpgradeRerun(input) {
+	if (input.view === "agent") {
+		outJsonLine({
+			type: "line",
+			code: "upgrade.startup.auto_upgrade.rerun",
+			text: "re-running original command after startup upgrade."
+		});
+		return;
+	}
+	outLine("Re-running your original command with the upgraded ATS CLI...");
+}
+function emitStartupAutoUpgradeFailed(input) {
+	if (input.view === "agent") {
+		outJsonLine({
+			type: "line",
+			code: "upgrade.startup.auto_upgrade.failed",
+			text: "startup auto-upgrade failed; run `ats upgrade --yes`.",
+			data: {
+				errorMessage: input.errorMessage,
+				recoveryCommand: "ats upgrade --yes"
+			}
+		});
+		return;
+	}
+	outLine(`⚠️ Startup auto-upgrade failed: ${input.errorMessage}\nRun \`ats upgrade --yes\` and retry.`);
+}
+function rerunCurrentCommandWithEnv(input) {
+	const scriptPath = input.argv[1];
+	if (!scriptPath) return Promise.resolve(1);
+	const runtimeSession = resolveRuntimeSession();
+	const env = {
+		...runtimeSession ? {
+			...process.env,
+			ATS_AGENT_SESSION_ID: runtimeSession.runtimeSessionId
+		} : process.env,
+		...input.env
+	};
+	return new Promise((resolve) => {
+		const child = spawn(process.execPath, [scriptPath, ...input.argv.slice(2)], {
+			stdio: "inherit",
+			env
+		});
+		child.once("error", () => resolve(1));
+		child.once("exit", (code, signal) => {
+			if (signal) {
+				resolve(1);
+				return;
+			}
+			resolve(code ?? 0);
+		});
+	});
+}
 function buildFallbackAgentViewGuideMessage(message) {
 	const normalizedMessage = normalizeErrorSummaryForGuide(message);
 	return buildDualViewGuideMessage({