agent-transport-system 0.7.31 → 0.7.32

package/dist/ats.js

@@ -27,7 +27,7 @@ import wrapAnsi from "wrap-ansi";
 import { Box, Container, Editor, Key, ProcessTerminal, TUI, Text, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
 
 //#region package.json
-var version = "0.7.31";
+var version = "0.7.32";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -77,7 +77,7 @@ var package_default = {
 		"@agent-transport-system/adapter-openclaw": "workspace:*",
 		"@agent-transport-system/agent-runtime": "workspace:*",
 		"@agent-transport-system/api-client": "workspace:*",
-		"@agent-transport-system/atsd": "workspace:*",
+		"@agent-transport-system/local-execution": "workspace:*",
 		"@agent-transport-system/gateway-contract": "workspace:*",
 		"@agent-transport-system/protocol": "workspace:*",
 		"@agent-transport-system/schemas": "workspace:*",
@@ -16267,6 +16267,56 @@ const createStartApi = (client) => {
 	};
 };
 
+//#endregion
+//#region src/local-service/carrier/heartbeat-loop.ts
+function waitForHeartbeatResponse(input) {
+	if (input.waiters.heartbeatResolver || input.waiters.heartbeatRejecter) return Promise.reject(new DaemonServiceRunError({
+		code: "daemon.run.heartbeat_response_busy",
+		message: "heartbeat response waiter is already pending"
+	}));
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			input.waiters.heartbeatResolver = null;
+			input.waiters.heartbeatRejecter = null;
+			reject(new DaemonServiceRunError({
+				code: "daemon.run.heartbeat_timeout",
+				message: "heartbeat response timeout"
+			}));
+		}, input.timeoutMs);
+		input.waiters.heartbeatResolver = (payload) => {
+			clearTimeout(timeout);
+			input.waiters.heartbeatRejecter = null;
+			resolve(payload);
+		};
+		input.waiters.heartbeatRejecter = (error) => {
+			clearTimeout(timeout);
+			input.waiters.heartbeatResolver = null;
+			input.waiters.heartbeatRejecter = null;
+			reject(error);
+		};
+	});
+}
+function applyAcceptedLeases(input) {
+	input.leasesByProfileId.clear();
+	for (const lease of input.acceptedLeases) input.leasesByProfileId.set(lease.profileId, lease.leaseEpoch);
+}
+function pruneStaleLeases(input) {
+	for (const staleLease of input.staleLeases) if (input.leasesByProfileId.get(staleLease.profileId) === staleLease.leaseEpoch) input.leasesByProfileId.delete(staleLease.profileId);
+}
+function resolveAdaptiveHeartbeatIntervalMs(input) {
+	if (input.hasDispatchActivity) return MIN_HEARTBEAT_INTERVAL_MS;
+	const growthFactor = typeof input.growthFactor === "number" && Number.isFinite(input.growthFactor) ? input.growthFactor : ADAPTIVE_HEARTBEAT_GROWTH_FACTOR;
+	return clampInteger$1(input.currentIntervalMs * growthFactor, MIN_HEARTBEAT_INTERVAL_MS, MAX_HEARTBEAT_INTERVAL_MS);
+}
+function applyIntervalJitterMs(input) {
+	const jitterRatio = typeof input.jitterRatio === "number" && Number.isFinite(input.jitterRatio) ? Math.max(0, input.jitterRatio) : 0;
+	const jitterMultiplier = 1 + ((typeof input.randomValue === "number" && Number.isFinite(input.randomValue) ? Math.min(1, Math.max(0, input.randomValue)) : Math.random()) * 2 - 1) * jitterRatio;
+	return clampInteger$1(input.baseIntervalMs * jitterMultiplier, input.minIntervalMs, input.maxIntervalMs);
+}
+function resolveCatalogSyncIntervalMs(input) {
+	return clampInteger$1(input.heartbeatIntervalMs * CATALOG_SYNC_INTERVAL_MULTIPLIER, MIN_CATALOG_SYNC_INTERVAL_MS, MAX_CATALOG_SYNC_INTERVAL_MS);
+}
+
 //#endregion
 //#region src/agents/controller-identity.ts
 function resolveLocalRegistryAgentIdFromAgentControllerRef(input) {
@@ -19856,56 +19906,6 @@ function resolveProfileWorkspaceStateReason(input) {
 	return "projected agent profile workspaces look good";
 }
 
-//#endregion
-//#region src/daemon/session/heartbeat-loop.ts
-function waitForHeartbeatResponse(input) {
-	if (input.waiters.heartbeatResolver || input.waiters.heartbeatRejecter) return Promise.reject(new DaemonServiceRunError({
-		code: "daemon.run.heartbeat_response_busy",
-		message: "heartbeat response waiter is already pending"
-	}));
-	return new Promise((resolve, reject) => {
-		const timeout = setTimeout(() => {
-			input.waiters.heartbeatResolver = null;
-			input.waiters.heartbeatRejecter = null;
-			reject(new DaemonServiceRunError({
-				code: "daemon.run.heartbeat_timeout",
-				message: "heartbeat response timeout"
-			}));
-		}, input.timeoutMs);
-		input.waiters.heartbeatResolver = (payload) => {
-			clearTimeout(timeout);
-			input.waiters.heartbeatRejecter = null;
-			resolve(payload);
-		};
-		input.waiters.heartbeatRejecter = (error) => {
-			clearTimeout(timeout);
-			input.waiters.heartbeatResolver = null;
-			input.waiters.heartbeatRejecter = null;
-			reject(error);
-		};
-	});
-}
-function applyAcceptedLeases(input) {
-	input.leasesByProfileId.clear();
-	for (const lease of input.acceptedLeases) input.leasesByProfileId.set(lease.profileId, lease.leaseEpoch);
-}
-function pruneStaleLeases(input) {
-	for (const staleLease of input.staleLeases) if (input.leasesByProfileId.get(staleLease.profileId) === staleLease.leaseEpoch) input.leasesByProfileId.delete(staleLease.profileId);
-}
-function resolveAdaptiveHeartbeatIntervalMs(input) {
-	if (input.hasDispatchActivity) return MIN_HEARTBEAT_INTERVAL_MS;
-	const growthFactor = typeof input.growthFactor === "number" && Number.isFinite(input.growthFactor) ? input.growthFactor : ADAPTIVE_HEARTBEAT_GROWTH_FACTOR;
-	return clampInteger$1(input.currentIntervalMs * growthFactor, MIN_HEARTBEAT_INTERVAL_MS, MAX_HEARTBEAT_INTERVAL_MS);
-}
-function applyIntervalJitterMs(input) {
-	const jitterRatio = typeof input.jitterRatio === "number" && Number.isFinite(input.jitterRatio) ? Math.max(0, input.jitterRatio) : 0;
-	const jitterMultiplier = 1 + ((typeof input.randomValue === "number" && Number.isFinite(input.randomValue) ? Math.min(1, Math.max(0, input.randomValue)) : Math.random()) * 2 - 1) * jitterRatio;
-	return clampInteger$1(input.baseIntervalMs * jitterMultiplier, input.minIntervalMs, input.maxIntervalMs);
-}
-function resolveCatalogSyncIntervalMs(input) {
-	return clampInteger$1(input.heartbeatIntervalMs * CATALOG_SYNC_INTERVAL_MULTIPLIER, MIN_CATALOG_SYNC_INTERVAL_MS, MAX_CATALOG_SYNC_INTERVAL_MS);
-}
-
 //#endregion
 //#region src/daemon/routing/resolve-controller-support.ts
 async function readLocalEnabledControllers() {
@@ -28448,7 +28448,7 @@ function shouldCheckNpmCliUpdate(context) {
 const ATS_ACCEPT_DISCLAIMER_ENV = "ATS_ACCEPT_DISCLAIMER";
 const ATS_ONBOARDING_DISCLAIMER_ACCEPT = "__onboarding_disclaimer_accept__";
 const ATS_ONBOARDING_DISCLAIMER_DECLINE = "__onboarding_disclaimer_decline__";
-const ATS_ONBOARDING_DISCLAIMER_TEXT = "ATSD is experimental and changes rapidly. Breaking changes may occur. You are fully responsible for data security and sensitive information handling. Use ATSD only in trusted environments.";
+const ATS_ONBOARDING_DISCLAIMER_TEXT = "ATS local service is experimental and changes rapidly. Breaking changes may occur. You are fully responsible for data security and sensitive information handling. Use ATS only in trusted environments.";
 async function runOnboardingDisclaimerGate(input) {
 	if (await getConfiguredOnboardingDisclaimerAcceptedAt().catch(() => null)) return true;
 	if (shouldBypassDisclaimerWithEnv()) {
@@ -34925,47 +34925,7 @@ function buildDaemonAgentOverviewPayload(command) {
 }
 
 //#endregion
-//#region src/transport/ws.ts
-async function connectWebSocket(url, input) {
-	return await new Promise((resolve, reject) => {
-		const ws = new WebSocket(url, { headers: input?.headers });
-		const closePromise = new Promise((r) => {
-			ws.on("close", () => r());
-			ws.on("error", () => r());
-		});
-		ws.on("open", () => {
-			resolve({
-				send: (data) => ws.send(data),
-				close: (code, reason) => ws.close(code, reason),
-				terminate: () => ws.terminate(),
-				onMessage: (handler) => {
-					ws.on("message", (buf) => handler(toUtf8(buf)));
-				},
-				onClose: (handler) => {
-					ws.on("close", (code, reason) => handler(code, reason.toString("utf8")));
-				},
-				onError: (handler) => {
-					ws.on("error", handler);
-				},
-				waitUntilClosed: async () => {
-					await closePromise;
-				}
-			});
-		});
-		ws.on("error", (err) => {
-			reject(err);
-		});
-	});
-}
-function toUtf8(value) {
-	if (typeof value === "string") return value;
-	if (value instanceof Buffer) return value.toString("utf8");
-	if (Array.isArray(value)) return Buffer.concat(value).toString("utf8");
-	return String(value);
-}
-
-//#endregion
-//#region ../../runtime/atsd/dist/adapter-routing.js
+//#region ../../runtime/local-execution/dist/adapter-routing.js
 const ADAPTER_ROUTE_ERROR_CODES = {
 	adapterUnreachable: "adapter.unreachable",
 	controllerRuntimeMissing: "controller.runtime.missing",
@@ -35085,7 +35045,7 @@ const isAgentControllerRefRegexMatched = (agentControllerRef, matcherValue) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/agent-context-policy.js
+//#region ../../runtime/local-execution/dist/agent-context-policy.js
 const AGENT_CONTEXT_LOOKUP_KEY_SEPARATOR$1 = "|";
 const LEDGER_AGENT_CONTEXT_SOURCE_FIELD = "atsd.agent_context_ledger";
 const encodeLookupKeyPart = (value) => encodeURIComponent(value);
@@ -35285,7 +35245,7 @@ const resolveAgentContextForDispatch = (input) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/control-plane.js
+//#region ../../runtime/local-execution/dist/control-plane.js
 function parseControlPlaneRequest(input) {
 	const parsed = atsdControlPlaneRequestSchema.safeParse(input);
 	if (!parsed.success) throw new Error("invalid daemon control-plane request");
@@ -35467,7 +35427,7 @@ function parseControlPlaneResponse(input) {
 }
 
 //#endregion
-//#region ../../runtime/atsd/dist/control-plane-auth.js
+//#region ../../runtime/local-execution/dist/control-plane-auth.js
 const verifyControlPlaneToken = (input) => input.providedToken === input.expectedToken;
 const buildAuthenticatedControlPlaneResponse = async (input) => {
 	const request = parseControlPlaneRequest(input.request);
@@ -35482,7 +35442,7 @@ const buildAuthenticatedControlPlaneResponse = async (input) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/data-plane-contract.js
+//#region ../../runtime/local-execution/dist/data-plane-contract.js
 const buildIdempotencyKey = buildIdempotencyKey$1;
 const shouldDedupeWithinWindow = (input) => {
 	return shouldDedupeWithinWindow$1({
@@ -35496,7 +35456,7 @@ const shouldBypassDedupeForDeliveryRecoveryReason = (reason) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/heartbeat-policy.js
+//#region ../../runtime/local-execution/dist/heartbeat-policy.js
 const HEARTBEAT_POLICY_DEFAULTS = {
 	watchdogTimeoutMs: 45e3,
 	heartbeatIdleIntervalMs: 6e4,
@@ -35513,7 +35473,7 @@ const HEARTBEAT_POLICY_DEFAULTS = {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/ledger-store.js
+//#region ../../runtime/local-execution/dist/ledger-store.js
 const LEDGER_STATE_VERSION = 1;
 const LEDGER_STATE_INVALID_JSON_ERROR = "ledger.state.invalid_json";
 const LEDGER_STATE_SCHEMA_ERROR = "ledger.state.schema_invalid";
@@ -36080,7 +36040,7 @@ function resolveStoredAgentControllerRef(agentControllerRef) {
 }
 
 //#endregion
-//#region ../../runtime/atsd/dist/trigger-policy.js
+//#region ../../runtime/local-execution/dist/trigger-policy.js
 const shouldDispatchForMentionOnly = (input) => {
 	const triggerMode = input.triggerMode ?? LEGACY_RUNTIME_DISPATCH_POLICY;
 	if (triggerMode === "listen_all") return true;
@@ -36088,7 +36048,7 @@ const shouldDispatchForMentionOnly = (input) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/mention-dispatch-integration.js
+//#region ../../runtime/local-execution/dist/mention-dispatch-integration.js
 const dispatchMentionOnlyTask = async (input) => {
 	if (!shouldDispatchForMentionOnly({
 		mentioned: input.mentioned,
@@ -36164,7 +36124,7 @@ const normalizeAgentControllerConversationId = (value) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/recovery-policy.js
+//#region ../../runtime/local-execution/dist/recovery-policy.js
 const cloneLedgerState = (state) => ({
 	dedupeFirstSeenByKey: { ...state.dedupeFirstSeenByKey },
 	inflightByTaskId: Object.fromEntries(Object.entries(state.inflightByTaskId).map(([taskId, inflight]) => [taskId, { ...inflight }])),
@@ -36263,7 +36223,7 @@ const buildTaskResultPayloadFromOutcome = (input) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/result-envelope.js
+//#region ../../runtime/local-execution/dist/result-envelope.js
 const buildTaskResultEnvelope = (payload) => {
 	const parsed = atsdTaskResultEnvelopeWriteSchema.safeParse({
 		v: ATSD_TASK_RESULT_SCHEMA_VERSION,
@@ -36275,14 +36235,14 @@ const buildTaskResultEnvelope = (payload) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/runtime-health-contract.js
+//#region ../../runtime/local-execution/dist/runtime-health-contract.js
 const RUNTIME_HEALTH_SEVERITY = {
 	error: "error",
 	warn: "warn"
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/runtime-task-lifecycle-contract.js
+//#region ../../runtime/local-execution/dist/runtime-task-lifecycle-contract.js
 const RUNTIME_INFLIGHT_TASK_TRANSITION_MATRIX = {
 	trackNewInflightTask: {
 		kind: "track_new_inflight_task",
@@ -36343,7 +36303,7 @@ const resolveTaskResultTransitionForPayloadStatus = (input) => {
 const resolveRuntimeTaskResultDeliverySemantic = (input) => resolveTaskResultDeliverySemantic({ payloadStatus: input.payloadStatus });
 
 //#endregion
-//#region ../../runtime/atsd/dist/runtime-health-invariant-policy.js
+//#region ../../runtime/local-execution/dist/runtime-health-invariant-policy.js
 const normalizeHumanContext = (humanContext) => humanContext && Object.keys(humanContext).length > 0 ? humanContext : null;
 const buildRuntimeReplayStuckFinding = (input) => ({
 	reasonCode: "runtime.replay_stuck",
@@ -36389,7 +36349,7 @@ const resolveRuntimeResultMappingViolation = (input) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/runtime-health-view.js
+//#region ../../runtime/local-execution/dist/runtime-health-view.js
 const emitRuntimeHealthFinding = (input) => {
 	emitHealthFinding({
 		eventName: input.eventName,
@@ -36399,7 +36359,7 @@ const emitRuntimeHealthFinding = (input) => {
 };
 
 //#endregion
-//#region ../../runtime/atsd/dist/runtime-workspace-fingerprint.js
+//#region ../../runtime/local-execution/dist/runtime-workspace-fingerprint.js
 const SHA256_PREFIX = "sha256:";
 function normalizeWorkspacePath(workspacePath) {
 	const trimmed = workspacePath.trim();
@@ -36412,7 +36372,7 @@ function buildRuntimeWorkspaceFingerprint(workspacePath) {
 }
 
 //#endregion
-//#region ../../runtime/atsd/dist/runtime-task-orchestrator.js
+//#region ../../runtime/local-execution/dist/runtime-task-orchestrator.js
 const mapAdapterErrorType = (errorType) => {
 	if (errorType === "adapter") return "adapter";
 	if (errorType === "auth") return "auth";
@@ -37987,6 +37947,286 @@ function buildDispatchCorrelation(input) {
 	};
 }
 
+//#endregion
+//#region src/daemon/state/context-store.ts
+async function loadContextStore(contextStorePath) {
+	const raw = await readFile(contextStorePath, "utf8").catch(() => "");
+	if (!raw) return /* @__PURE__ */ new Map();
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return /* @__PURE__ */ new Map();
+	const contextStore = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(parsed)) {
+		const normalizedKey = normalizeOptionalText$50(key);
+		const normalizedValue = normalizeOptionalText$50(value);
+		if (!(normalizedKey && normalizedValue)) continue;
+		contextStore.set(normalizedKey, normalizedValue);
+	}
+	return contextStore;
+}
+
+//#endregion
+//#region src/daemon/state/daemon-runtime-state.ts
+function resolveDaemonRunMode$1(inputMode) {
+	if (process.env[DAEMON_SERVICE_RUNTIME_DETACHED_ENV] === "1") return "background";
+	const envMode = parseDaemonRunMode$1(process.env[DAEMON_SERVICE_RUNTIME_MODE_ENV]);
+	if (envMode) return envMode;
+	if (inputMode === "foreground") return "foreground";
+	return "background";
+}
+function parseDaemonRunMode$1(value) {
+	const normalized = normalizeText$9(value).toLowerCase();
+	if (normalized === "foreground" || normalized === "background") return normalized;
+	return null;
+}
+function shouldPersistDaemonRuntimeState(input) {
+	if (input.forcePersist) return true;
+	if ("stopRequestedAt" in input.updates) return true;
+	return input.nowMs - input.lastPersistedAtMs >= RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS;
+}
+function resolveReconnectBackoffMs(attempt) {
+	const next = DEFAULT_RECONNECT_DELAY_MS * 2 ** (Math.max(1, attempt) - 1);
+	return Math.min(MAX_RECONNECT_DELAY_MS, next);
+}
+function toDaemonStreamUrl(baseUrl) {
+	const url = new URL(baseUrl);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	url.pathname = "/v1/daemon/stream";
+	url.search = "";
+	url.hash = "";
+	return url.toString();
+}
+function buildDaemonProcessCommand() {
+	const script = normalizeText$9(process.argv[1]);
+	const args = process.argv.slice(2);
+	const values = script ? [script, ...args] : args;
+	if (values.length === 0) return process.execPath;
+	return `${process.execPath} ${values.join(" ")}`;
+}
+function createDaemonRuntimeState(input) {
+	return {
+		v: 1,
+		schema: DAEMON_SERVICE_RUNTIME_STATE_SCHEMA,
+		status: "running",
+		mode: input.mode,
+		pid: input.pid,
+		command: input.command,
+		gatewayUrl: input.gatewayUrl,
+		atsProfileId: input.atsProfileId,
+		workingDirectory: input.workingDirectory,
+		stopRequestedAt: input.stopRequestedAt,
+		startedAt: input.startedAt,
+		updatedAt: input.updatedAt,
+		heartbeatAt: input.heartbeatAt,
+		managedBySystemService: input.runtimeMetadata.managedBySystemService,
+		serviceController: input.runtimeMetadata.serviceController,
+		autoStart: input.runtimeMetadata.autoStart
+	};
+}
+
+//#endregion
+//#region src/daemon/state/route-catalog-cache.ts
+const ROUTE_CATALOG_CACHE_FILE = "route-catalog-cache.json";
+async function readDaemonRouteCatalogCache(input) {
+	const lane = normalizeCacheLane(input.lane);
+	const ownerUserId = normalizeCacheIdentityField(input.ownerUserId);
+	const serviceBundleId = normalizeServiceBundleId(input.serviceBundleId);
+	if (!(lane && ownerUserId && serviceBundleId)) return null;
+	const cached = await readDaemonLocalStateFile({
+		path: daemonRouteCatalogCachePath(),
+		schema: daemonRouteCatalogCacheSchema
+	});
+	if (!cached || cached.ownerUserId !== ownerUserId || cached.lane !== lane || cached.serviceBundleId !== serviceBundleId) return null;
+	return deserializeRouteCatalog(cached);
+}
+async function writeDaemonRouteCatalogCache(input) {
+	const lane = normalizeCacheLane(input.lane);
+	const ownerUserId = normalizeCacheIdentityField(input.ownerUserId);
+	const serviceBundleId = normalizeServiceBundleId(input.serviceBundleId);
+	if (!(lane && ownerUserId && serviceBundleId)) return;
+	if (input.routeCatalog.profileIds.length === 0) {
+		await clearDaemonRouteCatalogCache();
+		return;
+	}
+	const value = {
+		v: DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_VERSION,
+		schema: DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME,
+		cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		runtimeContractEpoch: CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH,
+		ownerUserId,
+		lane,
+		serviceBundleId,
+		profileIds: [...input.routeCatalog.profileIds],
+		routes: input.routeCatalog.profileIds.map((profileId) => {
+			const route = input.routeCatalog.routeByProfileId.get(profileId);
+			if (!route) throw new Error(`route catalog is missing route for ${profileId}`);
+			return serializeRouteConfig(route);
+		}),
+		skippedProfiles: [...input.routeCatalog.skippedProfiles]
+	};
+	await writeDaemonLocalStateFile({
+		path: daemonRouteCatalogCachePath(),
+		schema: daemonRouteCatalogCacheSchema,
+		value,
+		mode: 384
+	});
+}
+async function clearDaemonRouteCatalogCache() {
+	await rm(daemonRouteCatalogCachePath(), { force: true });
+}
+function daemonRouteCatalogCachePath() {
+	return join(daemonRuntimeDataPath(), ROUTE_CATALOG_CACHE_FILE);
+}
+function normalizeServiceBundleId(value) {
+	return String(value ?? "").trim();
+}
+function normalizeCacheIdentityField(value) {
+	return String(value ?? "").trim();
+}
+function normalizeCacheLane(value) {
+	const parsed = daemonServiceLaneSchema.safeParse(normalizeCacheIdentityField(value));
+	return parsed.success ? parsed.data : null;
+}
+function serializeRouteConfig(route) {
+	return {
+		agentControllerRef: route.agentControllerRef,
+		contextIdMappingSpec: route.contextIdMappingSpec,
+		...route.launchContract ? { launchContract: route.launchContract } : {},
+		profileId: route.profileId,
+		streamingMode: route.streamingMode,
+		transportMode: route.transportMode
+	};
+}
+function deserializeRouteCatalog(cache) {
+	const routeByProfileId = /* @__PURE__ */ new Map();
+	for (const route of cache.routes) routeByProfileId.set(route.profileId, {
+		agentControllerRef: route.agentControllerRef,
+		contextIdMappingSpec: route.contextIdMappingSpec,
+		...route.launchContract ? { launchContract: route.launchContract } : {},
+		profileId: route.profileId,
+		streamingMode: route.streamingMode,
+		transportMode: route.transportMode
+	});
+	return {
+		profileIds: [...cache.profileIds],
+		routeByProfileId,
+		skippedProfiles: [...cache.skippedProfiles]
+	};
+}
+
+//#endregion
+//#region src/daemon/state/runtime-state-tracker.ts
+function createDaemonRuntimeStateTracker(input) {
+	let runtimeState = input.initialState;
+	let lastRuntimeStatePersistAtMs = Date.now();
+	const touchRuntimeState = async (updates, options) => {
+		const nowAt = nowIsoString();
+		runtimeState = {
+			...runtimeState,
+			...updates,
+			updatedAt: updates.updatedAt ?? nowAt
+		};
+		if (!shouldPersistDaemonRuntimeState({
+			forcePersist: options?.forcePersist === true,
+			nowMs: Date.now(),
+			lastPersistedAtMs: lastRuntimeStatePersistAtMs,
+			updates
+		})) return;
+		await setDaemonServiceRuntimeState(runtimeState);
+		if (input.leaseDescriptor) await writeDaemonRuntimeLease(buildDaemonRuntimeLease({
+			descriptor: input.leaseDescriptor,
+			runtimeState
+		}));
+		lastRuntimeStatePersistAtMs = Date.now();
+	};
+	return {
+		getRuntimeState: () => runtimeState,
+		touchRuntimeState
+	};
+}
+async function resolveDaemonRuntimeLeaseDescriptor(input) {
+	const [contract, activeBundle] = await Promise.all([readDaemonServiceContract().catch(() => null), readDaemonActiveBundleState().catch(() => null)]);
+	if (contract) return {
+		generation: contract.generation,
+		bundleId: contract.bundleId
+	};
+	const activeBundleEntryPath = await resolveDaemonBundleEntryPathFromState(activeBundle).catch(() => null);
+	const commandEntryPath = extractDaemonCommandEntryPath(input.command);
+	const bundleId = (commandEntryPath ? resolveDaemonBundleIdFromEntryPath(commandEntryPath) : null) ?? (activeBundleEntryPath ? resolveDaemonBundleIdFromEntryPath(activeBundleEntryPath) : null) ?? activeBundle?.bundleId ?? null;
+	if (!bundleId) return null;
+	return {
+		generation: 0,
+		bundleId
+	};
+}
+function buildDaemonRuntimeLease(input) {
+	return {
+		schema: "ats-daemon-runtime-lease-v1",
+		v: 1,
+		generation: input.descriptor.generation,
+		bundleId: input.descriptor.bundleId,
+		pid: input.runtimeState.pid,
+		mode: input.runtimeState.mode,
+		startedAt: input.runtimeState.startedAt,
+		updatedAt: input.runtimeState.updatedAt,
+		heartbeatAt: input.runtimeState.heartbeatAt,
+		serviceController: input.runtimeState.serviceController,
+		managedBySystemService: input.runtimeState.managedBySystemService
+	};
+}
+
+//#endregion
+//#region src/transport/ws.ts
+async function connectWebSocket(url, input) {
+	return await new Promise((resolve, reject) => {
+		const ws = new WebSocket(url, { headers: input?.headers });
+		const closePromise = new Promise((r) => {
+			ws.on("close", () => r());
+			ws.on("error", () => r());
+		});
+		ws.on("open", () => {
+			resolve({
+				send: (data) => ws.send(data),
+				close: (code, reason) => ws.close(code, reason),
+				terminate: () => ws.terminate(),
+				onMessage: (handler) => {
+					ws.on("message", (buf) => handler(toUtf8(buf)));
+				},
+				onClose: (handler) => {
+					ws.on("close", (code, reason) => handler(code, reason.toString("utf8")));
+				},
+				onError: (handler) => {
+					ws.on("error", handler);
+				},
+				waitUntilClosed: async () => {
+					await closePromise;
+				}
+			});
+		});
+		ws.on("error", (err) => {
+			reject(err);
+		});
+	});
+}
+function toUtf8(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Buffer) return value.toString("utf8");
+	if (Array.isArray(value)) return Buffer.concat(value).toString("utf8");
+	return String(value);
+}
+
+//#endregion
+//#region src/daemon/adapters/resolve-daemon-capabilities.ts
+function resolveDaemonCapabilities(input) {
+	const runtimeAdapters = input.localAdapterContainer.listAdapters().map((entry) => resolveRegistryRuntimeAdapterCapabilitySnapshot(entry.adapterId)).filter((entry) => entry !== null).sort((left, right) => left.adapterId.localeCompare(right.adapterId));
+	if (runtimeAdapters.length === 0) return {};
+	return { runtimeAdapters };
+}
+
 //#endregion
 //#region src/local-service/dispatch/daemon-dispatch-journal.ts
 const DAEMON_DISPATCH_EVENT_TYPES = [
@@ -38069,423 +38309,6 @@ function toJournalErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 
-//#endregion
-//#region src/local-service/execution/local-execution-slots.ts
-const LOCAL_EXECUTION_LANE_CONCURRENCY_LIMIT = 1;
-function createLocalExecutionSlots(input) {
-	const pendingTasks = [];
-	const activeCountByLaneKey = /* @__PURE__ */ new Map();
-	const ownedAttemptKeys = /* @__PURE__ */ new Set();
-	const ownedTaskIds = /* @__PURE__ */ new Map();
-	const drainWaiters = [];
-	let activeGlobal = 0;
-	const resolveActiveForLane = (localExecutionLaneKey) => {
-		return activeCountByLaneKey.get(localExecutionLaneKey) ?? 0;
-	};
-	const buildSnapshot = (localExecutionLaneKey) => {
-		return {
-			activeForLane: resolveActiveForLane(localExecutionLaneKey),
-			activeGlobal,
-			limits: input.limits,
-			queueDepth: pendingTasks.length
-		};
-	};
-	const resolveWaitReason = (inputWait) => {
-		if (activeGlobal >= input.limits.globalConcurrency) return "global_concurrency";
-		if (resolveActiveForLane(inputWait.localExecutionLaneKey) >= LOCAL_EXECUTION_LANE_CONCURRENCY_LIMIT) return "local_execution_lane_concurrency";
-		return "none";
-	};
-	const buildLocalQueueDiagnostics = (inputDiagnostics) => {
-		const waitReason = inputDiagnostics.waitReason ?? resolveWaitReason({ localExecutionLaneKey: inputDiagnostics.localExecutionLaneKey });
-		const status = inputDiagnostics.status ?? (waitReason === "none" ? "starting_runtime" : "queued");
-		return {
-			...buildSnapshot(inputDiagnostics.localExecutionLaneKey),
-			queuePosition: status === "queued" ? inputDiagnostics.queuePosition : null,
-			status,
-			waitReason
-		};
-	};
-	const buildTaskOwnerSnapshot = (owner) => {
-		return {
-			attemptId: owner.attemptId,
-			dispatchId: owner.dispatchId,
-			executionTokenRunId: owner.executionTokenRunId,
-			runtimeCoordinatorExecutionId: owner.runtimeCoordinatorExecutionId,
-			taskId: owner.taskId
-		};
-	};
-	const clearQueuedLifecycle = (pendingTask) => {
-		pendingTask.stopQueuedLifecycle?.();
-		pendingTask.stopQueuedLifecycle = null;
-	};
-	const releaseTaskOwnership = (task) => {
-		ownedAttemptKeys.delete(buildAttemptKey(task.dispatchId, task.attemptId));
-		const activeOwner = ownedTaskIds.get(task.taskId);
-		if (activeOwner && activeOwner.attemptId === task.attemptId && activeOwner.dispatchId === task.dispatchId) ownedTaskIds.delete(task.taskId);
-	};
-	const notifyDrainWaitersIfIdle = () => {
-		if (pendingTasks.length > 0 || activeGlobal > 0) return;
-		while (drainWaiters.length > 0) drainWaiters.shift()?.();
-	};
-	const pump = () => {
-		while (activeGlobal < input.limits.globalConcurrency) {
-			const nextTaskIndex = pendingTasks.findIndex((candidate) => {
-				return resolveActiveForLane(candidate.task.localExecutionLaneKey) < LOCAL_EXECUTION_LANE_CONCURRENCY_LIMIT;
-			});
-			if (nextTaskIndex < 0) break;
-			const selectedPendingTask = pendingTasks.splice(nextTaskIndex, 1)[0];
-			if (!selectedPendingTask) continue;
-			clearQueuedLifecycle(selectedPendingTask);
-			const selectedTask = selectedPendingTask.task;
-			activeGlobal += 1;
-			activeCountByLaneKey.set(selectedTask.localExecutionLaneKey, resolveActiveForLane(selectedTask.localExecutionLaneKey) + 1);
-			const startedEvent = {
-				adapterId: selectedTask.adapterId,
-				attemptId: selectedTask.attemptId,
-				controllerKey: selectedTask.controllerKey,
-				dispatchId: selectedTask.dispatchId,
-				localExecutionLaneKey: selectedTask.localExecutionLaneKey,
-				localQueue: buildLocalQueueDiagnostics({
-					localExecutionLaneKey: selectedTask.localExecutionLaneKey,
-					queuePosition: null,
-					status: "starting_runtime",
-					waitReason: "none"
-				}),
-				profileId: selectedTask.profileId,
-				spaceId: selectedTask.spaceId,
-				taskId: selectedTask.taskId,
-				targetLabel: selectedTask.targetLabel,
-				transportMode: selectedTask.transportMode,
-				...buildSnapshot(selectedTask.localExecutionLaneKey)
-			};
-			input.onTaskStarted?.(startedEvent);
-			const startedAtMs = Date.now();
-			Promise.resolve().then(async () => {
-				const completionResult = resolveTaskCompletionResult(await selectedTask.run());
-				input.onTaskCompleted?.({
-					adapterId: selectedTask.adapterId,
-					attemptId: selectedTask.attemptId,
-					...buildSnapshot(selectedTask.localExecutionLaneKey),
-					controllerKey: selectedTask.controllerKey,
-					dispatchId: selectedTask.dispatchId,
-					durationMs: Math.max(0, Date.now() - startedAtMs),
-					errorCode: completionResult.errorCode,
-					errorMessage: completionResult.errorMessage,
-					localExecutionLaneKey: selectedTask.localExecutionLaneKey,
-					localQueue: buildLocalQueueDiagnostics({
-						localExecutionLaneKey: selectedTask.localExecutionLaneKey,
-						queuePosition: null,
-						status: "starting_runtime",
-						waitReason: "none"
-					}),
-					profileId: selectedTask.profileId,
-					result: completionResult.result,
-					spaceId: selectedTask.spaceId,
-					taskId: selectedTask.taskId,
-					targetLabel: selectedTask.targetLabel,
-					transportMode: selectedTask.transportMode
-				});
-			}).catch((error) => {
-				input.onTaskCompleted?.({
-					adapterId: selectedTask.adapterId,
-					attemptId: selectedTask.attemptId,
-					...buildSnapshot(selectedTask.localExecutionLaneKey),
-					controllerKey: selectedTask.controllerKey,
-					dispatchId: selectedTask.dispatchId,
-					durationMs: Math.max(0, Date.now() - startedAtMs),
-					errorCode: null,
-					errorMessage: toErrorMessage$14(error),
-					localExecutionLaneKey: selectedTask.localExecutionLaneKey,
-					localQueue: buildLocalQueueDiagnostics({
-						localExecutionLaneKey: selectedTask.localExecutionLaneKey,
-						queuePosition: null,
-						status: "starting_runtime",
-						waitReason: "none"
-					}),
-					profileId: selectedTask.profileId,
-					result: "failed",
-					spaceId: selectedTask.spaceId,
-					taskId: selectedTask.taskId,
-					targetLabel: selectedTask.targetLabel,
-					transportMode: selectedTask.transportMode
-				});
-			}).finally(() => {
-				releaseTaskOwnership(selectedTask);
-				activeGlobal = Math.max(0, activeGlobal - 1);
-				const remainingActiveForLane = Math.max(0, resolveActiveForLane(selectedTask.localExecutionLaneKey) - 1);
-				if (remainingActiveForLane === 0) activeCountByLaneKey.delete(selectedTask.localExecutionLaneKey);
-				else activeCountByLaneKey.set(selectedTask.localExecutionLaneKey, remainingActiveForLane);
-				notifyDrainWaitersIfIdle();
-				pump();
-			});
-		}
-	};
-	return {
-		request(task) {
-			const attemptKey = buildAttemptKey(task.dispatchId, task.attemptId);
-			if (ownedAttemptKeys.has(attemptKey)) return {
-				accepted: true,
-				deduped: true,
-				snapshot: buildSnapshot(task.localExecutionLaneKey)
-			};
-			const activeOwner = ownedTaskIds.get(task.taskId);
-			if (activeOwner) return {
-				accepted: false,
-				activeOwner: buildTaskOwnerSnapshot(activeOwner),
-				reason: "task.owner_conflict",
-				snapshot: buildSnapshot(task.localExecutionLaneKey)
-			};
-			if (pendingTasks.length >= input.limits.queueMax) return {
-				accepted: false,
-				reason: "queue.full",
-				snapshot: buildSnapshot(task.localExecutionLaneKey)
-			};
-			ownedAttemptKeys.add(attemptKey);
-			ownedTaskIds.set(task.taskId, {
-				attemptId: task.attemptId,
-				dispatchId: task.dispatchId,
-				executionTokenRunId: task.executionTokenRunId ?? null,
-				runtimeCoordinatorExecutionId: task.runtimeCoordinatorExecutionId ?? null,
-				taskId: task.taskId
-			});
-			const pendingTask = {
-				stopQueuedLifecycle: null,
-				task
-			};
-			pendingTasks.push(pendingTask);
-			const snapshot = buildSnapshot(task.localExecutionLaneKey);
-			if (task.onQueued) try {
-				const queuePosition = pendingTasks.indexOf(pendingTask) + 1;
-				const stopQueuedLifecycle = task.onQueued({
-					adapterId: task.adapterId,
-					attemptId: task.attemptId,
-					controllerKey: task.controllerKey,
-					dispatchId: task.dispatchId,
-					localExecutionLaneKey: task.localExecutionLaneKey,
-					localQueue: buildLocalQueueDiagnostics({
-						localExecutionLaneKey: task.localExecutionLaneKey,
-						queuePosition
-					}),
-					profileId: task.profileId,
-					spaceId: task.spaceId,
-					taskId: task.taskId,
-					targetLabel: task.targetLabel,
-					transportMode: task.transportMode,
-					...snapshot
-				});
-				pendingTask.stopQueuedLifecycle = typeof stopQueuedLifecycle === "function" ? stopQueuedLifecycle : null;
-			} catch (error) {
-				pendingTasks.pop();
-				releaseTaskOwnership(task);
-				throw error;
-			}
-			pump();
-			return {
-				accepted: true,
-				deduped: false,
-				snapshot
-			};
-		},
-		dropPendingTasks(inputDrop) {
-			const reason = toPendingDropReason(inputDrop?.reason);
-			const shouldDrop = inputDrop?.shouldDrop ?? (() => true);
-			let droppedCount = 0;
-			for (let index = pendingTasks.length - 1; index >= 0; index -= 1) {
-				const pendingTask = pendingTasks[index];
-				if (!(pendingTask && shouldDrop(pendingTask.task))) continue;
-				pendingTasks.splice(index, 1);
-				clearQueuedLifecycle(pendingTask);
-				releaseTaskOwnership(pendingTask.task);
-				droppedCount += 1;
-				input.onTaskDropped?.({
-					adapterId: pendingTask.task.adapterId,
-					attemptId: pendingTask.task.attemptId,
-					controllerKey: pendingTask.task.controllerKey,
-					dispatchId: pendingTask.task.dispatchId,
-					localExecutionLaneKey: pendingTask.task.localExecutionLaneKey,
-					localQueue: buildLocalQueueDiagnostics({
-						localExecutionLaneKey: pendingTask.task.localExecutionLaneKey,
-						queuePosition: null,
-						status: "queued"
-					}),
-					profileId: pendingTask.task.profileId,
-					reason,
-					spaceId: pendingTask.task.spaceId,
-					taskId: pendingTask.task.taskId,
-					targetLabel: pendingTask.task.targetLabel,
-					transportMode: pendingTask.task.transportMode,
-					...buildSnapshot(pendingTask.task.profileId)
-				});
-			}
-			notifyDrainWaitersIfIdle();
-			return { droppedCount };
-		},
-		drain() {
-			if (pendingTasks.length === 0 && activeGlobal === 0) return Promise.resolve();
-			return new Promise((resolve) => {
-				drainWaiters.push(resolve);
-			});
-		},
-		getDrainState() {
-			return {
-				activeGlobal,
-				pendingCount: pendingTasks.length
-			};
-		},
-		getSnapshot(localExecutionLaneKey) {
-			return buildSnapshot(localExecutionLaneKey);
-		}
-	};
-}
-function buildAttemptKey(dispatchId, attemptId) {
-	return `${dispatchId}::${attemptId}`;
-}
-function toErrorMessage$14(error) {
-	if (error instanceof Error && error.message.trim().length > 0) return error.message;
-	if (typeof error === "string" && error.trim().length > 0) return error;
-	return "unknown error";
-}
-function resolveTaskCompletionResult(result) {
-	if (!result || typeof result !== "object") return {
-		errorCode: null,
-		errorMessage: null,
-		result: "success"
-	};
-	const normalizedResult = result.result === "failed" || result.result === "partial_success" || result.result === "success" ? result.result : "success";
-	return {
-		errorCode: toOptionalText(result.errorCode),
-		errorMessage: toOptionalText(result.errorMessage),
-		result: normalizedResult
-	};
-}
-function toOptionalText(value) {
-	if (typeof value !== "string") return null;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : null;
-}
-function toPendingDropReason(value) {
-	if (typeof value !== "string") return "queue.drop";
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : "queue.drop";
-}
-
-//#endregion
-//#region src/local-service/inventory/agent-controller-inventory.ts
-async function collectLocalAgentControllerInventory(input = {}) {
-	return { capabilities: (await listAgentTargetStates()).filter((state) => state.targetKind === "builtin").map((state) => resolveLocalAgentControllerInventoryItem({
-		localAdapterContainer: input.localAdapterContainer,
-		state
-	})) };
-}
-function resolveLocalAgentControllerInventoryItem(input) {
-	const agentControllerRef = buildAgentControllerRef({
-		kind: "builtin",
-		id: input.state.agentId
-	});
-	const adapterSupport = input.localAdapterContainer ? resolveLocalRuntimeControllerSupport({
-		agentControllerRef,
-		localAdapterContainer: input.localAdapterContainer
-	}) : null;
-	const launchStatus = input.state.launchStatus ?? (input.state.selectable ? "ready" : "not_available");
-	const launchability = resolveLocalAgentControllerLaunchability({
-		adapterSupported: adapterSupport?.supported ?? true,
-		detected: input.state.detected,
-		launchStatus,
-		runtimeSupported: input.state.runtimeSupported,
-		selectable: input.state.selectable,
-		selectableReason: input.state.selectableReason
-	});
-	return {
-		agentId: input.state.agentId,
-		blockerReasonCodes: resolveLocalAgentControllerBlockerReasonCodes({
-			launchability,
-			selectableReason: input.state.selectableReason
-		}),
-		agentControllerRef,
-		detected: input.state.detected,
-		displayName: input.state.displayName,
-		enabled: input.state.enabled,
-		launchability,
-		launchStatus,
-		launchStatusDetail: input.state.launchStatusDetail ?? null,
-		registered: input.state.registered,
-		selectable: input.state.selectable,
-		selectableReason: input.state.selectableReason
-	};
-}
-function resolveLocalAgentControllerReportDecision(capability, input) {
-	if (input.requireEnabled && !capability.enabled) return {
-		localParticipationState: "needs_agent_prepare",
-		reasonCodes: ["local_agent_preparation.not_enabled"]
-	};
-	if (capability.launchability !== "launchable" || !capability.selectable) return {
-		localParticipationState: "needs_agent_prepare",
-		reasonCodes: capability.blockerReasonCodes.length > 0 ? capability.blockerReasonCodes : [capability.selectableReason ? `local_agent_preparation.${capability.selectableReason}` : "local_agent_preparation.not_selectable"]
-	};
-	return {
-		localParticipationState: "ready",
-		reasonCodes: []
-	};
-}
-function resolveLocalAgentControllerLaunchability(input) {
-	if (!input.detected) return "not_detected";
-	if (!input.runtimeSupported || input.selectableReason === "not_supported_yet") return "not_supported";
-	if (input.launchStatus === "needs_choice") return "needs_choice";
-	if (input.launchStatus === "needs_repair") return "needs_repair";
-	if (input.launchStatus === "ready" && input.selectable && input.adapterSupported !== false) return "launchable";
-	return "blocked";
-}
-function resolveLocalAgentControllerBlockerReasonCodes(input) {
-	if (input.launchability === "launchable") return [];
-	if (input.launchability === "needs_choice") return ["controller.launch.choice_required"];
-	if (input.launchability === "needs_repair") return ["controller.launch.needs_repair"];
-	if (input.launchability === "not_detected") return ["local_agent_preparation.not_detected"];
-	if (input.launchability === "not_supported") return ["local_agent_preparation.not_supported_yet"];
-	if (input.selectableReason) return [`local_agent_preparation.${input.selectableReason}`];
-	return ["local_agent_preparation.not_enabled"];
-}
-
-//#endregion
-//#region src/local-service/reporting/runtime-agent-controller-report-sync.ts
-async function syncLocalServiceRuntimeAgentControllerReports(input) {
-	const reports = (await collectLocalAgentControllerInventory({ localAdapterContainer: input.localAdapterContainer })).capabilities.filter((capability) => capability.registered).map((capability) => {
-		if (!capability.agentControllerRef) return null;
-		const reportDecision = resolveLocalAgentControllerReportDecision(capability, { requireEnabled: true });
-		return {
-			agentControllerRef: capability.agentControllerRef,
-			localParticipationState: reportDecision.localParticipationState,
-			reasonCodes: reportDecision.reasonCodes
-		};
-	}).filter((report) => report !== null);
-	if (reports.length === 0) return {
-		status: "skipped",
-		reasonCodes: ["runtime.agent_controller_report.no_local_controllers"],
-		reportCount: 0,
-		submittedCount: 0,
-		failedCount: 0
-	};
-	return summarizeSubmissions(await submitRuntimeAgentControllerReports({ reports }));
-}
-function summarizeSubmissions(submissions) {
-	const submittedCount = submissions.filter((submission) => submission.status === "submitted" && submission.agentControllerReportStatus === "accepted").length;
-	const failedCount = submissions.length - submittedCount;
-	return {
-		status: "submitted",
-		reasonCodes: [...new Set(submissions.flatMap((submission) => submission.reasonCodes).filter((reasonCode) => reasonCode.trim()))],
-		reportCount: submissions.length,
-		submittedCount,
-		failedCount
-	};
-}
-
-//#endregion
-//#region src/daemon/adapters/resolve-daemon-capabilities.ts
-function resolveDaemonCapabilities(input) {
-	const runtimeAdapters = input.localAdapterContainer.listAdapters().map((entry) => resolveRegistryRuntimeAdapterCapabilitySnapshot(entry.adapterId)).filter((entry) => entry !== null).sort((left, right) => left.adapterId.localeCompare(right.adapterId));
-	if (runtimeAdapters.length === 0) return {};
-	return { runtimeAdapters };
-}
-
 //#endregion
 //#region src/daemon/dispatch/send-dispatch-result.ts
 function sendDispatchResultEnvelopeFrame(input) {
@@ -38838,74 +38661,483 @@ function flushDispatchResultOutbox(input) {
 				taskId: record.taskId,
 				type: "dispatch.result.sent"
 			});
-			changed = true;
+			changed = true;
+			return {
+				...record,
+				attemptCount: record.attemptCount + 1,
+				connectionGeneration: activeConnectionGeneration,
+				lastFailureReason: null,
+				lastSendAtMs: nowMs,
+				nextAttemptAtMs: nowMs + resolveOutboxBackoffMs(record.attemptCount + 1),
+				updatedAtMs: nowMs
+			};
+		} catch (error) {
+			changed = true;
+			return {
+				...record,
+				attemptCount: record.attemptCount + 1,
+				lastFailureReason: toErrorMessage$34(error),
+				nextAttemptAtMs: nowMs + resolveOutboxBackoffMs(record.attemptCount + 1),
+				updatedAtMs: nowMs
+			};
+		}
+	});
+	if (changed) writeOutboxRecords(input.ledgerPaths, nextRecords);
+}
+const sanitizeTaskResultPayload = (payload) => {
+	const { bootstrapTemplateFacts: _bootstrapTemplateFacts, promptTrace: _promptTrace, ...safePayload } = payload;
+	return safePayload;
+};
+const resolveOutboxBackoffMs = (attemptCount) => {
+	const backoffMs = BACKOFF_MS[Math.min(BACKOFF_MS.length - 1, Math.max(0, attemptCount - 1))];
+	return typeof backoffMs === "number" ? backoffMs : 3e4;
+};
+const upsertOutboxRecord = (ledgerPaths, record) => {
+	const records = readOutboxRecords(ledgerPaths);
+	const key = buildRecordKey(record);
+	writeOutboxRecords(ledgerPaths, [...records.filter((candidate) => buildRecordKey(candidate) !== key), record].sort((left, right) => left.createdAtMs - right.createdAtMs));
+};
+const readOutboxRecords = (ledgerPaths) => {
+	const outboxPath = resolveOutboxPath(ledgerPaths);
+	if (!existsSync(outboxPath)) return [];
+	const parsed = JSON.parse(readFileSync(outboxPath, "utf8"));
+	if (parsed.schema !== OUTBOX_SCHEMA || !Array.isArray(parsed.records)) return [];
+	return parsed.records.filter(isDispatchResultOutboxRecord);
+};
+const writeOutboxRecords = (ledgerPaths, records) => {
+	const outboxPath = resolveOutboxPath(ledgerPaths);
+	const tempPath = join(ledgerPaths.rootDirPath, RESULT_OUTBOX_TEMP_FILE_NAME);
+	mkdirSync(dirname(outboxPath), { recursive: true });
+	writeFileSync(tempPath, JSON.stringify({
+		schema: OUTBOX_SCHEMA,
+		v: 1,
+		records,
+		updatedAtMs: Date.now()
+	}, null, 2), "utf8");
+	renameSync(tempPath, outboxPath);
+};
+const resolveOutboxPath = (ledgerPaths) => {
+	return join(ledgerPaths.rootDirPath, RESULT_OUTBOX_FILE_NAME);
+};
+const buildRecordKey = (record) => {
+	return `${record.dispatchId}::${record.attemptId}`;
+};
+const isDispatchResultOutboxRecord = (value) => {
+	const candidate = value;
+	return candidate.schema === OUTBOX_RECORD_SCHEMA && typeof candidate.attemptId === "string" && typeof candidate.dispatchId === "string" && typeof candidate.daemonSessionId === "string" && typeof candidate.executionIdentityEcho === "object" && candidate.executionIdentityEcho !== null && typeof candidate.leaseEpoch === "number" && typeof candidate.connectionGeneration === "number" && typeof candidate.taskId === "string" && typeof candidate.taskResult === "object" && candidate.taskResult !== null && typeof candidate.createdAtMs === "number" && typeof candidate.updatedAtMs === "number" && typeof candidate.nextAttemptAtMs === "number" && typeof candidate.attemptCount === "number";
+};
+
+//#endregion
+//#region src/local-service/execution/local-execution-slots.ts
+const LOCAL_EXECUTION_LANE_CONCURRENCY_LIMIT = 1;
+function createLocalExecutionSlots(input) {
+	const pendingTasks = [];
+	const activeCountByLaneKey = /* @__PURE__ */ new Map();
+	const ownedAttemptKeys = /* @__PURE__ */ new Set();
+	const ownedTaskIds = /* @__PURE__ */ new Map();
+	const drainWaiters = [];
+	let activeGlobal = 0;
+	const resolveActiveForLane = (localExecutionLaneKey) => {
+		return activeCountByLaneKey.get(localExecutionLaneKey) ?? 0;
+	};
+	const buildSnapshot = (localExecutionLaneKey) => {
+		return {
+			activeForLane: resolveActiveForLane(localExecutionLaneKey),
+			activeGlobal,
+			limits: input.limits,
+			queueDepth: pendingTasks.length
+		};
+	};
+	const resolveWaitReason = (inputWait) => {
+		if (activeGlobal >= input.limits.globalConcurrency) return "global_concurrency";
+		if (resolveActiveForLane(inputWait.localExecutionLaneKey) >= LOCAL_EXECUTION_LANE_CONCURRENCY_LIMIT) return "local_execution_lane_concurrency";
+		return "none";
+	};
+	const buildLocalQueueDiagnostics = (inputDiagnostics) => {
+		const waitReason = inputDiagnostics.waitReason ?? resolveWaitReason({ localExecutionLaneKey: inputDiagnostics.localExecutionLaneKey });
+		const status = inputDiagnostics.status ?? (waitReason === "none" ? "starting_runtime" : "queued");
+		return {
+			...buildSnapshot(inputDiagnostics.localExecutionLaneKey),
+			queuePosition: status === "queued" ? inputDiagnostics.queuePosition : null,
+			status,
+			waitReason
+		};
+	};
+	const buildTaskOwnerSnapshot = (owner) => {
+		return {
+			attemptId: owner.attemptId,
+			dispatchId: owner.dispatchId,
+			executionTokenRunId: owner.executionTokenRunId,
+			runtimeCoordinatorExecutionId: owner.runtimeCoordinatorExecutionId,
+			taskId: owner.taskId
+		};
+	};
+	const clearQueuedLifecycle = (pendingTask) => {
+		pendingTask.stopQueuedLifecycle?.();
+		pendingTask.stopQueuedLifecycle = null;
+	};
+	const releaseTaskOwnership = (task) => {
+		ownedAttemptKeys.delete(buildAttemptKey(task.dispatchId, task.attemptId));
+		const activeOwner = ownedTaskIds.get(task.taskId);
+		if (activeOwner && activeOwner.attemptId === task.attemptId && activeOwner.dispatchId === task.dispatchId) ownedTaskIds.delete(task.taskId);
+	};
+	const notifyDrainWaitersIfIdle = () => {
+		if (pendingTasks.length > 0 || activeGlobal > 0) return;
+		while (drainWaiters.length > 0) drainWaiters.shift()?.();
+	};
+	const pump = () => {
+		while (activeGlobal < input.limits.globalConcurrency) {
+			const nextTaskIndex = pendingTasks.findIndex((candidate) => {
+				return resolveActiveForLane(candidate.task.localExecutionLaneKey) < LOCAL_EXECUTION_LANE_CONCURRENCY_LIMIT;
+			});
+			if (nextTaskIndex < 0) break;
+			const selectedPendingTask = pendingTasks.splice(nextTaskIndex, 1)[0];
+			if (!selectedPendingTask) continue;
+			clearQueuedLifecycle(selectedPendingTask);
+			const selectedTask = selectedPendingTask.task;
+			activeGlobal += 1;
+			activeCountByLaneKey.set(selectedTask.localExecutionLaneKey, resolveActiveForLane(selectedTask.localExecutionLaneKey) + 1);
+			const startedEvent = {
+				adapterId: selectedTask.adapterId,
+				attemptId: selectedTask.attemptId,
+				controllerKey: selectedTask.controllerKey,
+				dispatchId: selectedTask.dispatchId,
+				localExecutionLaneKey: selectedTask.localExecutionLaneKey,
+				localQueue: buildLocalQueueDiagnostics({
+					localExecutionLaneKey: selectedTask.localExecutionLaneKey,
+					queuePosition: null,
+					status: "starting_runtime",
+					waitReason: "none"
+				}),
+				profileId: selectedTask.profileId,
+				spaceId: selectedTask.spaceId,
+				taskId: selectedTask.taskId,
+				targetLabel: selectedTask.targetLabel,
+				transportMode: selectedTask.transportMode,
+				...buildSnapshot(selectedTask.localExecutionLaneKey)
+			};
+			input.onTaskStarted?.(startedEvent);
+			const startedAtMs = Date.now();
+			Promise.resolve().then(async () => {
+				const completionResult = resolveTaskCompletionResult(await selectedTask.run());
+				input.onTaskCompleted?.({
+					adapterId: selectedTask.adapterId,
+					attemptId: selectedTask.attemptId,
+					...buildSnapshot(selectedTask.localExecutionLaneKey),
+					controllerKey: selectedTask.controllerKey,
+					dispatchId: selectedTask.dispatchId,
+					durationMs: Math.max(0, Date.now() - startedAtMs),
+					errorCode: completionResult.errorCode,
+					errorMessage: completionResult.errorMessage,
+					localExecutionLaneKey: selectedTask.localExecutionLaneKey,
+					localQueue: buildLocalQueueDiagnostics({
+						localExecutionLaneKey: selectedTask.localExecutionLaneKey,
+						queuePosition: null,
+						status: "starting_runtime",
+						waitReason: "none"
+					}),
+					profileId: selectedTask.profileId,
+					result: completionResult.result,
+					spaceId: selectedTask.spaceId,
+					taskId: selectedTask.taskId,
+					targetLabel: selectedTask.targetLabel,
+					transportMode: selectedTask.transportMode
+				});
+			}).catch((error) => {
+				input.onTaskCompleted?.({
+					adapterId: selectedTask.adapterId,
+					attemptId: selectedTask.attemptId,
+					...buildSnapshot(selectedTask.localExecutionLaneKey),
+					controllerKey: selectedTask.controllerKey,
+					dispatchId: selectedTask.dispatchId,
+					durationMs: Math.max(0, Date.now() - startedAtMs),
+					errorCode: null,
+					errorMessage: toErrorMessage$14(error),
+					localExecutionLaneKey: selectedTask.localExecutionLaneKey,
+					localQueue: buildLocalQueueDiagnostics({
+						localExecutionLaneKey: selectedTask.localExecutionLaneKey,
+						queuePosition: null,
+						status: "starting_runtime",
+						waitReason: "none"
+					}),
+					profileId: selectedTask.profileId,
+					result: "failed",
+					spaceId: selectedTask.spaceId,
+					taskId: selectedTask.taskId,
+					targetLabel: selectedTask.targetLabel,
+					transportMode: selectedTask.transportMode
+				});
+			}).finally(() => {
+				releaseTaskOwnership(selectedTask);
+				activeGlobal = Math.max(0, activeGlobal - 1);
+				const remainingActiveForLane = Math.max(0, resolveActiveForLane(selectedTask.localExecutionLaneKey) - 1);
+				if (remainingActiveForLane === 0) activeCountByLaneKey.delete(selectedTask.localExecutionLaneKey);
+				else activeCountByLaneKey.set(selectedTask.localExecutionLaneKey, remainingActiveForLane);
+				notifyDrainWaitersIfIdle();
+				pump();
+			});
+		}
+	};
+	return {
+		request(task) {
+			const attemptKey = buildAttemptKey(task.dispatchId, task.attemptId);
+			if (ownedAttemptKeys.has(attemptKey)) return {
+				accepted: true,
+				deduped: true,
+				snapshot: buildSnapshot(task.localExecutionLaneKey)
+			};
+			const activeOwner = ownedTaskIds.get(task.taskId);
+			if (activeOwner) return {
+				accepted: false,
+				activeOwner: buildTaskOwnerSnapshot(activeOwner),
+				reason: "task.owner_conflict",
+				snapshot: buildSnapshot(task.localExecutionLaneKey)
+			};
+			if (pendingTasks.length >= input.limits.queueMax) return {
+				accepted: false,
+				reason: "queue.full",
+				snapshot: buildSnapshot(task.localExecutionLaneKey)
+			};
+			ownedAttemptKeys.add(attemptKey);
+			ownedTaskIds.set(task.taskId, {
+				attemptId: task.attemptId,
+				dispatchId: task.dispatchId,
+				executionTokenRunId: task.executionTokenRunId ?? null,
+				runtimeCoordinatorExecutionId: task.runtimeCoordinatorExecutionId ?? null,
+				taskId: task.taskId
+			});
+			const pendingTask = {
+				stopQueuedLifecycle: null,
+				task
+			};
+			pendingTasks.push(pendingTask);
+			const snapshot = buildSnapshot(task.localExecutionLaneKey);
+			if (task.onQueued) try {
+				const queuePosition = pendingTasks.indexOf(pendingTask) + 1;
+				const stopQueuedLifecycle = task.onQueued({
+					adapterId: task.adapterId,
+					attemptId: task.attemptId,
+					controllerKey: task.controllerKey,
+					dispatchId: task.dispatchId,
+					localExecutionLaneKey: task.localExecutionLaneKey,
+					localQueue: buildLocalQueueDiagnostics({
+						localExecutionLaneKey: task.localExecutionLaneKey,
+						queuePosition
+					}),
+					profileId: task.profileId,
+					spaceId: task.spaceId,
+					taskId: task.taskId,
+					targetLabel: task.targetLabel,
+					transportMode: task.transportMode,
+					...snapshot
+				});
+				pendingTask.stopQueuedLifecycle = typeof stopQueuedLifecycle === "function" ? stopQueuedLifecycle : null;
+			} catch (error) {
+				pendingTasks.pop();
+				releaseTaskOwnership(task);
+				throw error;
+			}
+			pump();
 			return {
-				...record,
-				attemptCount: record.attemptCount + 1,
-				connectionGeneration: activeConnectionGeneration,
-				lastFailureReason: null,
-				lastSendAtMs: nowMs,
-				nextAttemptAtMs: nowMs + resolveOutboxBackoffMs(record.attemptCount + 1),
-				updatedAtMs: nowMs
+				accepted: true,
+				deduped: false,
+				snapshot
 			};
-		} catch (error) {
-			changed = true;
+		},
+		dropPendingTasks(inputDrop) {
+			const reason = toPendingDropReason(inputDrop?.reason);
+			const shouldDrop = inputDrop?.shouldDrop ?? (() => true);
+			let droppedCount = 0;
+			for (let index = pendingTasks.length - 1; index >= 0; index -= 1) {
+				const pendingTask = pendingTasks[index];
+				if (!(pendingTask && shouldDrop(pendingTask.task))) continue;
+				pendingTasks.splice(index, 1);
+				clearQueuedLifecycle(pendingTask);
+				releaseTaskOwnership(pendingTask.task);
+				droppedCount += 1;
+				input.onTaskDropped?.({
+					adapterId: pendingTask.task.adapterId,
+					attemptId: pendingTask.task.attemptId,
+					controllerKey: pendingTask.task.controllerKey,
+					dispatchId: pendingTask.task.dispatchId,
+					localExecutionLaneKey: pendingTask.task.localExecutionLaneKey,
+					localQueue: buildLocalQueueDiagnostics({
+						localExecutionLaneKey: pendingTask.task.localExecutionLaneKey,
+						queuePosition: null,
+						status: "queued"
+					}),
+					profileId: pendingTask.task.profileId,
+					reason,
+					spaceId: pendingTask.task.spaceId,
+					taskId: pendingTask.task.taskId,
+					targetLabel: pendingTask.task.targetLabel,
+					transportMode: pendingTask.task.transportMode,
+					...buildSnapshot(pendingTask.task.profileId)
+				});
+			}
+			notifyDrainWaitersIfIdle();
+			return { droppedCount };
+		},
+		drain() {
+			if (pendingTasks.length === 0 && activeGlobal === 0) return Promise.resolve();
+			return new Promise((resolve) => {
+				drainWaiters.push(resolve);
+			});
+		},
+		getDrainState() {
 			return {
-				...record,
-				attemptCount: record.attemptCount + 1,
-				lastFailureReason: toErrorMessage$34(error),
-				nextAttemptAtMs: nowMs + resolveOutboxBackoffMs(record.attemptCount + 1),
-				updatedAtMs: nowMs
+				activeGlobal,
+				pendingCount: pendingTasks.length
 			};
+		},
+		getSnapshot(localExecutionLaneKey) {
+			return buildSnapshot(localExecutionLaneKey);
 		}
+	};
+}
+function buildAttemptKey(dispatchId, attemptId) {
+	return `${dispatchId}::${attemptId}`;
+}
+function toErrorMessage$14(error) {
+	if (error instanceof Error && error.message.trim().length > 0) return error.message;
+	if (typeof error === "string" && error.trim().length > 0) return error;
+	return "unknown error";
+}
+function resolveTaskCompletionResult(result) {
+	if (!result || typeof result !== "object") return {
+		errorCode: null,
+		errorMessage: null,
+		result: "success"
+	};
+	const normalizedResult = result.result === "failed" || result.result === "partial_success" || result.result === "success" ? result.result : "success";
+	return {
+		errorCode: toOptionalText(result.errorCode),
+		errorMessage: toOptionalText(result.errorMessage),
+		result: normalizedResult
+	};
+}
+function toOptionalText(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function toPendingDropReason(value) {
+	if (typeof value !== "string") return "queue.drop";
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : "queue.drop";
+}
+
+//#endregion
+//#region src/local-service/inventory/agent-controller-inventory.ts
+async function collectLocalAgentControllerInventory(input = {}) {
+	return { capabilities: (await listAgentTargetStates()).filter((state) => state.targetKind === "builtin").map((state) => resolveLocalAgentControllerInventoryItem({
+		localAdapterContainer: input.localAdapterContainer,
+		state
+	})) };
+}
+function resolveLocalAgentControllerInventoryItem(input) {
+	const agentControllerRef = buildAgentControllerRef({
+		kind: "builtin",
+		id: input.state.agentId
 	});
-	if (changed) writeOutboxRecords(input.ledgerPaths, nextRecords);
+	const adapterSupport = input.localAdapterContainer ? resolveLocalRuntimeControllerSupport({
+		agentControllerRef,
+		localAdapterContainer: input.localAdapterContainer
+	}) : null;
+	const launchStatus = input.state.launchStatus ?? (input.state.selectable ? "ready" : "not_available");
+	const launchability = resolveLocalAgentControllerLaunchability({
+		adapterSupported: adapterSupport?.supported ?? true,
+		detected: input.state.detected,
+		launchStatus,
+		runtimeSupported: input.state.runtimeSupported,
+		selectable: input.state.selectable,
+		selectableReason: input.state.selectableReason
+	});
+	return {
+		agentId: input.state.agentId,
+		blockerReasonCodes: resolveLocalAgentControllerBlockerReasonCodes({
+			launchability,
+			selectableReason: input.state.selectableReason
+		}),
+		agentControllerRef,
+		detected: input.state.detected,
+		displayName: input.state.displayName,
+		enabled: input.state.enabled,
+		launchability,
+		launchStatus,
+		launchStatusDetail: input.state.launchStatusDetail ?? null,
+		registered: input.state.registered,
+		selectable: input.state.selectable,
+		selectableReason: input.state.selectableReason
+	};
+}
+function resolveLocalAgentControllerReportDecision(capability, input) {
+	if (input.requireEnabled && !capability.enabled) return {
+		localParticipationState: "needs_agent_prepare",
+		reasonCodes: ["local_agent_preparation.not_enabled"]
+	};
+	if (capability.launchability !== "launchable" || !capability.selectable) return {
+		localParticipationState: "needs_agent_prepare",
+		reasonCodes: capability.blockerReasonCodes.length > 0 ? capability.blockerReasonCodes : [capability.selectableReason ? `local_agent_preparation.${capability.selectableReason}` : "local_agent_preparation.not_selectable"]
+	};
+	return {
+		localParticipationState: "ready",
+		reasonCodes: []
+	};
+}
+function resolveLocalAgentControllerLaunchability(input) {
+	if (!input.detected) return "not_detected";
+	if (!input.runtimeSupported || input.selectableReason === "not_supported_yet") return "not_supported";
+	if (input.launchStatus === "needs_choice") return "needs_choice";
+	if (input.launchStatus === "needs_repair") return "needs_repair";
+	if (input.launchStatus === "ready" && input.selectable && input.adapterSupported !== false) return "launchable";
+	return "blocked";
+}
+function resolveLocalAgentControllerBlockerReasonCodes(input) {
+	if (input.launchability === "launchable") return [];
+	if (input.launchability === "needs_choice") return ["controller.launch.choice_required"];
+	if (input.launchability === "needs_repair") return ["controller.launch.needs_repair"];
+	if (input.launchability === "not_detected") return ["local_agent_preparation.not_detected"];
+	if (input.launchability === "not_supported") return ["local_agent_preparation.not_supported_yet"];
+	if (input.selectableReason) return [`local_agent_preparation.${input.selectableReason}`];
+	return ["local_agent_preparation.not_enabled"];
+}
+
+//#endregion
+//#region src/local-service/reporting/runtime-agent-controller-report-sync.ts
+async function syncLocalServiceRuntimeAgentControllerReports(input) {
+	const reports = (await collectLocalAgentControllerInventory({ localAdapterContainer: input.localAdapterContainer })).capabilities.filter((capability) => capability.registered).map((capability) => {
+		if (!capability.agentControllerRef) return null;
+		const reportDecision = resolveLocalAgentControllerReportDecision(capability, { requireEnabled: true });
+		return {
+			agentControllerRef: capability.agentControllerRef,
+			localParticipationState: reportDecision.localParticipationState,
+			reasonCodes: reportDecision.reasonCodes
+		};
+	}).filter((report) => report !== null);
+	if (reports.length === 0) return {
+		status: "skipped",
+		reasonCodes: ["runtime.agent_controller_report.no_local_controllers"],
+		reportCount: 0,
+		submittedCount: 0,
+		failedCount: 0
+	};
+	return summarizeSubmissions(await submitRuntimeAgentControllerReports({ reports }));
+}
+function summarizeSubmissions(submissions) {
+	const submittedCount = submissions.filter((submission) => submission.status === "submitted" && submission.agentControllerReportStatus === "accepted").length;
+	const failedCount = submissions.length - submittedCount;
+	return {
+		status: "submitted",
+		reasonCodes: [...new Set(submissions.flatMap((submission) => submission.reasonCodes).filter((reasonCode) => reasonCode.trim()))],
+		reportCount: submissions.length,
+		submittedCount,
+		failedCount
+	};
 }
-const sanitizeTaskResultPayload = (payload) => {
-	const { bootstrapTemplateFacts: _bootstrapTemplateFacts, promptTrace: _promptTrace, ...safePayload } = payload;
-	return safePayload;
-};
-const resolveOutboxBackoffMs = (attemptCount) => {
-	const backoffMs = BACKOFF_MS[Math.min(BACKOFF_MS.length - 1, Math.max(0, attemptCount - 1))];
-	return typeof backoffMs === "number" ? backoffMs : 3e4;
-};
-const upsertOutboxRecord = (ledgerPaths, record) => {
-	const records = readOutboxRecords(ledgerPaths);
-	const key = buildRecordKey(record);
-	writeOutboxRecords(ledgerPaths, [...records.filter((candidate) => buildRecordKey(candidate) !== key), record].sort((left, right) => left.createdAtMs - right.createdAtMs));
-};
-const readOutboxRecords = (ledgerPaths) => {
-	const outboxPath = resolveOutboxPath(ledgerPaths);
-	if (!existsSync(outboxPath)) return [];
-	const parsed = JSON.parse(readFileSync(outboxPath, "utf8"));
-	if (parsed.schema !== OUTBOX_SCHEMA || !Array.isArray(parsed.records)) return [];
-	return parsed.records.filter(isDispatchResultOutboxRecord);
-};
-const writeOutboxRecords = (ledgerPaths, records) => {
-	const outboxPath = resolveOutboxPath(ledgerPaths);
-	const tempPath = join(ledgerPaths.rootDirPath, RESULT_OUTBOX_TEMP_FILE_NAME);
-	mkdirSync(dirname(outboxPath), { recursive: true });
-	writeFileSync(tempPath, JSON.stringify({
-		schema: OUTBOX_SCHEMA,
-		v: 1,
-		records,
-		updatedAtMs: Date.now()
-	}, null, 2), "utf8");
-	renameSync(tempPath, outboxPath);
-};
-const resolveOutboxPath = (ledgerPaths) => {
-	return join(ledgerPaths.rootDirPath, RESULT_OUTBOX_FILE_NAME);
-};
-const buildRecordKey = (record) => {
-	return `${record.dispatchId}::${record.attemptId}`;
-};
-const isDispatchResultOutboxRecord = (value) => {
-	const candidate = value;
-	return candidate.schema === OUTBOX_RECORD_SCHEMA && typeof candidate.attemptId === "string" && typeof candidate.dispatchId === "string" && typeof candidate.daemonSessionId === "string" && typeof candidate.executionIdentityEcho === "object" && candidate.executionIdentityEcho !== null && typeof candidate.leaseEpoch === "number" && typeof candidate.connectionGeneration === "number" && typeof candidate.taskId === "string" && typeof candidate.taskResult === "object" && candidate.taskResult !== null && typeof candidate.createdAtMs === "number" && typeof candidate.updatedAtMs === "number" && typeof candidate.nextAttemptAtMs === "number" && typeof candidate.attemptCount === "number";
-};
 
 //#endregion
-//#region src/daemon/session/catalog-sync-skipped-profiles.ts
+//#region src/local-service/carrier/catalog-sync-skipped-profiles.ts
 function resolveCatalogSyncSkippedProfilesLogState(input) {
 	if (input.hasProfiles || input.skippedProfiles.length === 0) return {
 		fingerprint: null,
@@ -43078,7 +43310,7 @@ function failMissingCurrentSocket(dispatchId) {
 }
 
 //#endregion
-//#region src/daemon/session/frame-router.ts
+//#region src/local-service/carrier/frame-router.ts
 function parseDaemonFrame(raw) {
 	let parsedJson;
 	try {
@@ -43281,7 +43513,7 @@ function normalizeResultAckStatus(value) {
 }
 
 //#endregion
-//#region src/daemon/session/register-session.ts
+//#region src/local-service/carrier/register-session.ts
 function waitForRegisterResponse(input) {
 	if (input.waiters.registerResolver || input.waiters.registerRejecter) return Promise.reject(new DaemonServiceRunError({
 		code: "daemon.run.register_response_busy",
@@ -43311,7 +43543,7 @@ function waitForRegisterResponse(input) {
 }
 
 //#endregion
-//#region src/daemon/session/run-socket-session.ts
+//#region src/local-service/carrier/run-socket-session.ts
 async function runDaemonSocketSession(input) {
 	const currentSocketRef = input.currentSocketRef ?? {
 		connectionGeneration: null,
@@ -44166,239 +44398,7 @@ function normalizeFrameInteger(value) {
 }
 
 //#endregion
-//#region src/daemon/state/context-store.ts
-async function loadContextStore(contextStorePath) {
-	const raw = await readFile(contextStorePath, "utf8").catch(() => "");
-	if (!raw) return /* @__PURE__ */ new Map();
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return /* @__PURE__ */ new Map();
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return /* @__PURE__ */ new Map();
-	const contextStore = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(parsed)) {
-		const normalizedKey = normalizeOptionalText$50(key);
-		const normalizedValue = normalizeOptionalText$50(value);
-		if (!(normalizedKey && normalizedValue)) continue;
-		contextStore.set(normalizedKey, normalizedValue);
-	}
-	return contextStore;
-}
-
-//#endregion
-//#region src/daemon/state/daemon-runtime-state.ts
-function resolveDaemonRunMode$1(inputMode) {
-	if (process.env[DAEMON_SERVICE_RUNTIME_DETACHED_ENV] === "1") return "background";
-	const envMode = parseDaemonRunMode$1(process.env[DAEMON_SERVICE_RUNTIME_MODE_ENV]);
-	if (envMode) return envMode;
-	if (inputMode === "foreground") return "foreground";
-	return "background";
-}
-function parseDaemonRunMode$1(value) {
-	const normalized = normalizeText$9(value).toLowerCase();
-	if (normalized === "foreground" || normalized === "background") return normalized;
-	return null;
-}
-function shouldPersistDaemonRuntimeState(input) {
-	if (input.forcePersist) return true;
-	if ("stopRequestedAt" in input.updates) return true;
-	return input.nowMs - input.lastPersistedAtMs >= RUNTIME_STATE_PERSIST_MIN_INTERVAL_MS;
-}
-function resolveReconnectBackoffMs(attempt) {
-	const next = DEFAULT_RECONNECT_DELAY_MS * 2 ** (Math.max(1, attempt) - 1);
-	return Math.min(MAX_RECONNECT_DELAY_MS, next);
-}
-function toDaemonStreamUrl(baseUrl) {
-	const url = new URL(baseUrl);
-	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-	url.pathname = "/v1/daemon/stream";
-	url.search = "";
-	url.hash = "";
-	return url.toString();
-}
-function buildDaemonProcessCommand() {
-	const script = normalizeText$9(process.argv[1]);
-	const args = process.argv.slice(2);
-	const values = script ? [script, ...args] : args;
-	if (values.length === 0) return process.execPath;
-	return `${process.execPath} ${values.join(" ")}`;
-}
-function createDaemonRuntimeState(input) {
-	return {
-		v: 1,
-		schema: DAEMON_SERVICE_RUNTIME_STATE_SCHEMA,
-		status: "running",
-		mode: input.mode,
-		pid: input.pid,
-		command: input.command,
-		gatewayUrl: input.gatewayUrl,
-		atsProfileId: input.atsProfileId,
-		workingDirectory: input.workingDirectory,
-		stopRequestedAt: input.stopRequestedAt,
-		startedAt: input.startedAt,
-		updatedAt: input.updatedAt,
-		heartbeatAt: input.heartbeatAt,
-		managedBySystemService: input.runtimeMetadata.managedBySystemService,
-		serviceController: input.runtimeMetadata.serviceController,
-		autoStart: input.runtimeMetadata.autoStart
-	};
-}
-
-//#endregion
-//#region src/daemon/state/route-catalog-cache.ts
-const ROUTE_CATALOG_CACHE_FILE = "route-catalog-cache.json";
-async function readDaemonRouteCatalogCache(input) {
-	const lane = normalizeCacheLane(input.lane);
-	const ownerUserId = normalizeCacheIdentityField(input.ownerUserId);
-	const serviceBundleId = normalizeServiceBundleId(input.serviceBundleId);
-	if (!(lane && ownerUserId && serviceBundleId)) return null;
-	const cached = await readDaemonLocalStateFile({
-		path: daemonRouteCatalogCachePath(),
-		schema: daemonRouteCatalogCacheSchema
-	});
-	if (!cached || cached.ownerUserId !== ownerUserId || cached.lane !== lane || cached.serviceBundleId !== serviceBundleId) return null;
-	return deserializeRouteCatalog(cached);
-}
-async function writeDaemonRouteCatalogCache(input) {
-	const lane = normalizeCacheLane(input.lane);
-	const ownerUserId = normalizeCacheIdentityField(input.ownerUserId);
-	const serviceBundleId = normalizeServiceBundleId(input.serviceBundleId);
-	if (!(lane && ownerUserId && serviceBundleId)) return;
-	if (input.routeCatalog.profileIds.length === 0) {
-		await clearDaemonRouteCatalogCache();
-		return;
-	}
-	const value = {
-		v: DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_VERSION,
-		schema: DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME,
-		cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		runtimeContractEpoch: CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH,
-		ownerUserId,
-		lane,
-		serviceBundleId,
-		profileIds: [...input.routeCatalog.profileIds],
-		routes: input.routeCatalog.profileIds.map((profileId) => {
-			const route = input.routeCatalog.routeByProfileId.get(profileId);
-			if (!route) throw new Error(`route catalog is missing route for ${profileId}`);
-			return serializeRouteConfig(route);
-		}),
-		skippedProfiles: [...input.routeCatalog.skippedProfiles]
-	};
-	await writeDaemonLocalStateFile({
-		path: daemonRouteCatalogCachePath(),
-		schema: daemonRouteCatalogCacheSchema,
-		value,
-		mode: 384
-	});
-}
-async function clearDaemonRouteCatalogCache() {
-	await rm(daemonRouteCatalogCachePath(), { force: true });
-}
-function daemonRouteCatalogCachePath() {
-	return join(daemonRuntimeDataPath(), ROUTE_CATALOG_CACHE_FILE);
-}
-function normalizeServiceBundleId(value) {
-	return String(value ?? "").trim();
-}
-function normalizeCacheIdentityField(value) {
-	return String(value ?? "").trim();
-}
-function normalizeCacheLane(value) {
-	const parsed = daemonServiceLaneSchema.safeParse(normalizeCacheIdentityField(value));
-	return parsed.success ? parsed.data : null;
-}
-function serializeRouteConfig(route) {
-	return {
-		agentControllerRef: route.agentControllerRef,
-		contextIdMappingSpec: route.contextIdMappingSpec,
-		...route.launchContract ? { launchContract: route.launchContract } : {},
-		profileId: route.profileId,
-		streamingMode: route.streamingMode,
-		transportMode: route.transportMode
-	};
-}
-function deserializeRouteCatalog(cache) {
-	const routeByProfileId = /* @__PURE__ */ new Map();
-	for (const route of cache.routes) routeByProfileId.set(route.profileId, {
-		agentControllerRef: route.agentControllerRef,
-		contextIdMappingSpec: route.contextIdMappingSpec,
-		...route.launchContract ? { launchContract: route.launchContract } : {},
-		profileId: route.profileId,
-		streamingMode: route.streamingMode,
-		transportMode: route.transportMode
-	});
-	return {
-		profileIds: [...cache.profileIds],
-		routeByProfileId,
-		skippedProfiles: [...cache.skippedProfiles]
-	};
-}
-
-//#endregion
-//#region src/daemon/state/runtime-state-tracker.ts
-function createDaemonRuntimeStateTracker(input) {
-	let runtimeState = input.initialState;
-	let lastRuntimeStatePersistAtMs = Date.now();
-	const touchRuntimeState = async (updates, options) => {
-		const nowAt = nowIsoString();
-		runtimeState = {
-			...runtimeState,
-			...updates,
-			updatedAt: updates.updatedAt ?? nowAt
-		};
-		if (!shouldPersistDaemonRuntimeState({
-			forcePersist: options?.forcePersist === true,
-			nowMs: Date.now(),
-			lastPersistedAtMs: lastRuntimeStatePersistAtMs,
-			updates
-		})) return;
-		await setDaemonServiceRuntimeState(runtimeState);
-		if (input.leaseDescriptor) await writeDaemonRuntimeLease(buildDaemonRuntimeLease({
-			descriptor: input.leaseDescriptor,
-			runtimeState
-		}));
-		lastRuntimeStatePersistAtMs = Date.now();
-	};
-	return {
-		getRuntimeState: () => runtimeState,
-		touchRuntimeState
-	};
-}
-async function resolveDaemonRuntimeLeaseDescriptor(input) {
-	const [contract, activeBundle] = await Promise.all([readDaemonServiceContract().catch(() => null), readDaemonActiveBundleState().catch(() => null)]);
-	if (contract) return {
-		generation: contract.generation,
-		bundleId: contract.bundleId
-	};
-	const activeBundleEntryPath = await resolveDaemonBundleEntryPathFromState(activeBundle).catch(() => null);
-	const commandEntryPath = extractDaemonCommandEntryPath(input.command);
-	const bundleId = (commandEntryPath ? resolveDaemonBundleIdFromEntryPath(commandEntryPath) : null) ?? (activeBundleEntryPath ? resolveDaemonBundleIdFromEntryPath(activeBundleEntryPath) : null) ?? activeBundle?.bundleId ?? null;
-	if (!bundleId) return null;
-	return {
-		generation: 0,
-		bundleId
-	};
-}
-function buildDaemonRuntimeLease(input) {
-	return {
-		schema: "ats-daemon-runtime-lease-v1",
-		v: 1,
-		generation: input.descriptor.generation,
-		bundleId: input.descriptor.bundleId,
-		pid: input.runtimeState.pid,
-		mode: input.runtimeState.mode,
-		startedAt: input.runtimeState.startedAt,
-		updatedAt: input.runtimeState.updatedAt,
-		heartbeatAt: input.runtimeState.heartbeatAt,
-		serviceController: input.runtimeState.serviceController,
-		managedBySystemService: input.runtimeState.managedBySystemService
-	};
-}
-
-//#endregion
-//#region src/daemon/service-runner.ts
+//#region src/local-service/carrier/service-runner.ts
 async function resolveDaemonServiceOwnerContext(input) {
 	const explicitAtsProfileId = normalizeText$9(input.atsProfileId);
 	if (explicitAtsProfileId) return resolveDaemonServiceOwnerContextFromProfile(await requireAtsProfile({