@rivus/agent 0.13.2 → 0.14.1

package/dist/{rivus-daemon-cli.js → chunks/rivus-daemon-cli.js}

@@ -1,328 +1,18 @@
-import { t as MEMORY_SCOPES } from "./agent-memory.js";
-import { f as narrowBackgroundSessionDefinition } from "./background-session-authority.js";
-import { n as resolveRivusAgentDefinition, r as deepFreeze, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
+import { a as deepFreeze, f as isRivusRuntimeToolId, t as restrictRivusAgentDefinitionGrants, v as MEMORY_SCOPES } from "./api.js";
+import { t as createSha256Digest } from "./sha256-digest.js";
+import { X as narrowBackgroundSessionDefinition } from "./api2.js";
+import { n as createRivusHostToolDescriptorProvider, t as createRivusAgentCatalog } from "./module.js";
 import { createRequire } from "node:module";
-import { Effect } from "effect";
+import { Cause, Deferred, Effect, Either, Exit, Option } from "effect";
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, open, readFile, readdir, realpath, stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { constants } from "node:fs";
-//#region src/application/plugin/rivus-automation-runtime-definition.ts
-function resolveRivusAutomationRuntimeDefinition(definition, requestedToolIds, requestedSkillIds) {
-	const toolIds = Object.freeze([...new Set(requestedToolIds)].sort());
-	const toolsById = new Map(definition.tools.map((tool) => [tool.id, tool]));
-	const tools = Object.freeze(toolIds.map((toolId) => {
-		const tool = toolsById.get(toolId);
-		if (!tool) throw new Error(`Automation Runtime requests ungranted tool: ${toolId}`);
-		return tool;
-	}));
-	const skillIds = Object.freeze([...new Set(requestedSkillIds)].sort());
-	const skillsById = new Map(definition.skills.map((skill) => [skill.id, skill]));
-	const skills = Object.freeze(skillIds.map((skillId) => {
-		const skill = skillsById.get(skillId);
-		if (!skill) throw new Error(`Automation Runtime requests ungranted skill: ${skillId}`);
-		return skill;
-	}));
-	return deepFreeze({
-		...definition,
-		memory: {
-			scopes: [],
-			tool: false
-		},
-		skillGrantSet: {
-			revision: createHash("sha256").update(JSON.stringify({
-				parentRevision: definition.skillGrantSet.revision,
-				skillIds
-			})).digest("hex"),
-			skillIds
-		},
-		skills,
-		toolGrantSet: {
-			revision: createHash("sha256").update(JSON.stringify({
-				parentRevision: definition.toolGrantSet.revision,
-				toolIds
-			})).digest("hex"),
-			toolIds
-		},
-		tools
-	});
-}
-//#endregion
-//#region src/application/plugin/rivus-plugin-loader.ts
-var RivusPluginLoadError = class extends Error {
-	pluginId;
-	moduleSpecifier;
-	name = "RivusPluginLoadError";
-	constructor(pluginId, moduleSpecifier, message, options) {
-		super(message, options);
-		this.pluginId = pluginId;
-		this.moduleSpecifier = moduleSpecifier;
-	}
-};
-async function loadRivusDeployment(options) {
-	validateRivusDeploymentManifest(options.manifest);
-	const catalog = createRivusPluginCatalog();
-	const pluginStatuses = [];
-	const statusByPlugin = /* @__PURE__ */ new Map();
-	for (const declaration of options.manifest.plugins) try {
-		const plugin = await resolvePluginExport(await options.loadModule({
-			deploymentRoot: options.deploymentRoot,
-			module: declaration.module,
-			pluginId: declaration.id
-		}));
-		if (plugin.manifest.id !== declaration.id) throw new Error(`plugin manifest id ${plugin.manifest.id} does not match declaration ${declaration.id}`);
-		catalog.registerPlugin(plugin);
-		const status = Object.freeze({
-			id: declaration.id,
-			module: declaration.module,
-			required: declaration.required,
-			status: "loaded",
-			version: plugin.manifest.version
-		});
-		pluginStatuses.push(status);
-		statusByPlugin.set(declaration.id, status);
-	} catch (cause) {
-		const message = cause instanceof Error ? cause.message : String(cause);
-		if (declaration.required) throw new RivusPluginLoadError(declaration.id, declaration.module, `required plugin ${declaration.id} failed to load: ${message}`, { cause });
-		const status = Object.freeze({
-			error: message,
-			id: declaration.id,
-			module: declaration.module,
-			required: false,
-			status: "failed"
-		});
-		pluginStatuses.push(status);
-		statusByPlugin.set(declaration.id, status);
-	}
-	const agentStatuses = [];
-	const definitions = [];
-	for (const agent of options.manifest.agents) {
-		const pluginStatus = statusByPlugin.get(agent.pluginId);
-		if (pluginStatus.status === "failed") {
-			agentStatuses.push(Object.freeze({
-				agentId: agent.agentId,
-				pluginId: agent.pluginId,
-				profileId: agent.profileId,
-				reason: `plugin ${agent.pluginId} is unavailable: ${pluginStatus.error}`,
-				status: "disabled"
-			}));
-			continue;
-		}
-		try {
-			const baseDefinition = resolveRivusAgentDefinition(catalog, agent, { backgroundSessions: options.manifest.backgroundSessions?.enabled === true });
-			const projectSpace = agent.projectSpaceId ? options.manifest.projectSpaces?.find(({ id }) => id === agent.projectSpaceId) : void 0;
-			const definition = projectSpace ? deepFreeze({
-				...baseDefinition,
-				projectSpaceRevision: `project-space-declaration:${JSON.stringify(projectSpace)}`
-			}) : baseDefinition;
-			definitions.push(definition);
-			agentStatuses.push(Object.freeze({
-				agentId: agent.agentId,
-				definition,
-				pluginId: agent.pluginId,
-				profileId: agent.profileId,
-				status: "enabled"
-			}));
-		} catch (cause) {
-			const declaration = options.manifest.plugins.find(({ id }) => id === agent.pluginId);
-			const message = cause instanceof Error ? cause.message : String(cause);
-			if (declaration.required) throw new RivusPluginLoadError(declaration.id, declaration.module, `deployment ${agent.agentId} failed to resolve: ${message}`, { cause });
-			agentStatuses.push(Object.freeze({
-				agentId: agent.agentId,
-				pluginId: agent.pluginId,
-				profileId: agent.profileId,
-				reason: message,
-				status: "disabled"
-			}));
-		}
-	}
-	const agentStatusById = new Map(agentStatuses.map((agent) => [agent.agentId, agent]));
-	const automationTemplates = new Map(catalog.snapshot().automations.map((template) => [template.id, template]));
-	const automationDefinitions = [];
-	for (const automation of options.manifest.automations ?? []) {
-		const agent = agentStatusById.get(automation.agentId);
-		if (!agent || agent.status === "disabled" || !agent.definition) continue;
-		const deliveryEndpoint = options.manifest.endpoints.find(({ id }) => id === automation.delivery.endpointId);
-		const presentationAgent = agentStatusById.get(deliveryEndpoint.agentId);
-		if (!presentationAgent || presentationAgent.status === "disabled" || !presentationAgent.definition) continue;
-		const template = automationTemplates.get(automation.templateId);
-		if (!template) throw new Error(`automation ${automation.id} references unknown template: ${automation.templateId}`);
-		if (template.pluginId !== agent.pluginId || template.profileId !== agent.profileId) throw new Error(`automation ${automation.id} template is not owned by agent profile ${agent.profileId}`);
-		automationDefinitions.push(deepFreeze({
-			...automation,
-			runtimeDefinition: resolveRivusAutomationRuntimeDefinition(agent.definition, template.requestedToolIds, template.requestedSkillIds),
-			template
-		}));
-	}
-	return Object.freeze({
-		agents: Object.freeze(agentStatuses),
-		automationDefinitions: Object.freeze(automationDefinitions),
-		catalog,
-		definitions: Object.freeze(definitions),
-		manifest: options.manifest,
-		plugins: Object.freeze(pluginStatuses)
-	});
-}
-function validateRivusDeploymentManifest(manifest) {
-	const projectSpaceIds = /* @__PURE__ */ new Set();
-	for (const projectSpace of manifest.projectSpaces ?? []) {
-		if (projectSpaceIds.has(projectSpace.id)) throw new Error(`duplicate project space: ${projectSpace.id}`);
-		projectSpaceIds.add(projectSpace.id);
-		validateRelativeProjectPath(projectSpace.root, `project space ${projectSpace.id} root`);
-		validateRelativeProjectPath(projectSpace.workingDirectory, `project space ${projectSpace.id} working directory`);
-		if (projectSpace.skills.sources.length === 0) throw new Error(`project space ${projectSpace.id} must declare at least one Skill source`);
-		const sources = /* @__PURE__ */ new Set();
-		for (const source of projectSpace.skills.sources) {
-			validateRelativeProjectPath(source, `project space ${projectSpace.id} Skill source`);
-			if (sources.has(source)) throw new Error(`project space ${projectSpace.id} contains duplicate Skill source: ${source}`);
-			sources.add(source);
-		}
-	}
-	const pluginIds = /* @__PURE__ */ new Set();
-	for (const plugin of manifest.plugins) {
-		if (pluginIds.has(plugin.id)) throw new Error(`duplicate plugin declaration: ${plugin.id}`);
-		validateModuleSpecifier(plugin.module);
-		pluginIds.add(plugin.id);
-	}
-	const agentIds = /* @__PURE__ */ new Set();
-	const agentById = /* @__PURE__ */ new Map();
-	for (const agent of manifest.agents) {
-		if (agentIds.has(agent.agentId)) throw new Error(`duplicate agent deployment: ${agent.agentId}`);
-		agentIds.add(agent.agentId);
-		if (!pluginIds.has(agent.pluginId)) throw new Error(`agent ${agent.agentId} references undeclared plugin: ${agent.pluginId}`);
-		if (agent.projectSpaceId && !projectSpaceIds.has(agent.projectSpaceId)) throw new Error(`agent ${agent.agentId} references unknown project space: ${agent.projectSpaceId}`);
-		agentById.set(agent.agentId, agent);
-	}
-	const automationIds = /* @__PURE__ */ new Set();
-	for (const automation of manifest.automations ?? []) {
-		if (automationIds.has(automation.id)) throw new Error(`duplicate automation binding: ${automation.id}`);
-		automationIds.add(automation.id);
-		if (!agentById.get(automation.agentId)) throw new Error(`automation ${automation.id} references unknown agent: ${automation.agentId}`);
-		const endpoint = manifest.endpoints.find(({ id }) => id === automation.delivery.endpointId);
-		if (!endpoint) throw new Error(`automation ${automation.id} references unknown delivery endpoint: ${automation.delivery.endpointId}`);
-		if (automation.enabled && !endpoint.enabled) throw new Error(`automation ${automation.id} delivery endpoint must be enabled`);
-	}
-	const endpointIds = /* @__PURE__ */ new Set();
-	const sessionNamespaces = /* @__PURE__ */ new Set();
-	for (const endpoint of manifest.endpoints) {
-		if (endpointIds.has(endpoint.id)) throw new Error(`duplicate endpoint binding: ${endpoint.id}`);
-		endpointIds.add(endpoint.id);
-		if (sessionNamespaces.has(endpoint.sessionNamespace)) throw new Error(`duplicate endpoint session namespace: ${endpoint.sessionNamespace}`);
-		sessionNamespaces.add(endpoint.sessionNamespace);
-		const agent = agentById.get(endpoint.agentId);
-		if (!agent) throw new Error(`endpoint ${endpoint.id} references unknown agent: ${endpoint.agentId}`);
-		if (!agent.endpointIds.includes(endpoint.id)) throw new Error(`endpoint ${endpoint.id} is not declared by agent ${endpoint.agentId}`);
-	}
-	for (const agent of manifest.agents) for (const endpointId of agent.endpointIds) {
-		const endpoint = manifest.endpoints.find(({ id }) => id === endpointId);
-		if (!endpoint) throw new Error(`agent ${agent.agentId} references unknown endpoint: ${endpointId}`);
-		if (endpoint.agentId !== agent.agentId) throw new Error(`endpoint ${endpointId} is bound to a different agent`);
-	}
-	const defaultAgent = agentById.get(manifest.defaultAgentId);
-	if (!defaultAgent) throw new Error(`default agent does not exist: ${manifest.defaultAgentId}`);
-	const defaultEndpoint = manifest.endpoints.find(({ id }) => id === manifest.defaultEndpointId);
-	if (!defaultEndpoint) throw new Error(`default endpoint does not exist: ${manifest.defaultEndpointId}`);
-	if (defaultEndpoint.agentId !== defaultAgent.agentId) throw new Error("default endpoint is not bound to the default agent");
-	if (!defaultEndpoint.enabled) throw new Error("default endpoint must be enabled");
-	if (manifest.backgroundSessions) validateBackgroundSessions(manifest.backgroundSessions);
-}
-function validateBackgroundSessions(config) {
-	if (config.required && !config.enabled) throw new Error("backgroundSessions.required requires backgroundSessions.enabled");
-	if (config.leaseRenewalIntervalMs >= config.leaseMs) throw new Error("backgroundSessions.leaseRenewalIntervalMs must be shorter than leaseMs");
-	if (config.stepTimeoutMs <= 0 || config.maxConcurrentSessions <= 0 || config.leaseMs <= 0) throw new Error("backgroundSessions durations and concurrency must be positive");
-	if (config.retryBackoffMs <= 0 || config.sessionLifetimeMs <= 0 || config.maxConsecutiveFailures <= 0) throw new Error("backgroundSessions retry and lifetime limits must be positive");
-}
-function validateRelativeProjectPath(value, owner) {
-	if (value.trim() === "" || isAbsolute(value) || value.includes("\0")) throw new Error(`${owner} must be a non-empty relative path`);
-}
-function validateModuleSpecifier(moduleSpecifier) {
-	if (moduleSpecifier.trim() === "" || isAbsolute(moduleSpecifier) || /^[a-z][a-z+.-]*:/i.test(moduleSpecifier) || moduleSpecifier.includes("\0")) throw new Error(`invalid plugin module specifier: ${moduleSpecifier}`);
-	if ((moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../")) && moduleSpecifier.split(/[\\/]/).includes("..")) throw new Error(`plugin module escapes deployment root: ${moduleSpecifier}`);
-}
-async function resolvePluginExport(module) {
-	const candidate = "default" in module ? module.default : module;
-	const plugin = typeof candidate === "function" ? await candidate() : candidate;
-	if (plugin === null || typeof plugin !== "object" || !("manifest" in plugin) || !("register" in plugin) || typeof plugin.register !== "function") throw new Error("plugin module default export is not a RivusPlugin or factory");
-	return plugin;
-}
-//#endregion
-//#region src/infrastructure/config/local-env-file.ts
-var LocalEnvFileError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "LocalEnvFileError";
-	}
-};
-async function loadMergedLocalEnvFile(filePath, overrideEnv) {
-	return mergeRivusDaemonEnv(await loadLocalEnvFile(filePath), overrideEnv);
-}
-async function loadLocalEnvFile(filePath) {
-	return parseLocalEnvFile(await readFile(filePath, "utf8"));
-}
-function parseLocalEnvFile(contents) {
-	const env = {};
-	const lines = contents.split(/\r?\n/);
-	for (let index = 0; index < lines.length; index += 1) {
-		const trimmed = lines[index].trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const match = (trimmed.startsWith("export ") ? trimmed.slice(7).trimStart() : trimmed).match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
-		if (!match) throw new LocalEnvFileError(`Invalid env file line ${index + 1}`);
-		const key = match[1];
-		const rawValue = match[2];
-		env[key] = parseEnvValue(rawValue, index + 1);
-	}
-	return env;
-}
-function mergeRivusDaemonEnv(fileEnv, overrideEnv) {
-	const merged = { ...fileEnv };
-	for (const [key, value] of Object.entries(overrideEnv)) if (value !== void 0) merged[key] = value;
-	return merged;
-}
-function parseEnvValue(rawValue, lineNumber) {
-	const value = rawValue.trim();
-	if (!value) return "";
-	if (value.startsWith("'")) {
-		if (!value.endsWith("'")) throw new LocalEnvFileError(`Invalid single-quoted env value on line ${lineNumber}`);
-		return value.slice(1, -1).replaceAll("'\\''", "'");
-	}
-	if (value.startsWith("\"")) {
-		if (!value.endsWith("\"")) throw new LocalEnvFileError(`Invalid double-quoted env value on line ${lineNumber}`);
-		return unescapeDoubleQuotedValue(value.slice(1, -1));
-	}
-	return value;
-}
-function unescapeDoubleQuotedValue(value) {
-	return value.replace(/\\(["\\nrt])/g, (_match, escaped) => {
-		switch (escaped) {
-			case "n": return "\n";
-			case "r": return "\r";
-			case "t": return "	";
-			default: return escaped;
-		}
-	});
-}
-//#endregion
-//#region src/infrastructure/config/feishu-endpoint-credentials.ts
-var FeishuEndpointCredentialError = class extends Error {
-	name = "FeishuEndpointCredentialError";
-};
-function resolveFeishuEndpointCredentials(credentialRef, env) {
-	if (!credentialRef.startsWith("env:")) throw new FeishuEndpointCredentialError("Feishu endpoint credentialRef must use env:<PREFIX>");
-	const prefix = credentialRef.slice(4);
-	if (!/^[A-Z][A-Z0-9_]*$/.test(prefix)) throw new FeishuEndpointCredentialError(`Invalid environment prefix in credentialRef: ${credentialRef}`);
-	return Object.freeze({
-		appId: required$1(env, `${prefix}_APP_ID`),
-		appSecret: required$1(env, `${prefix}_APP_SECRET`)
-	});
-}
-function required$1(env, variable) {
-	const value = env[variable]?.trim();
-	if (!value) throw new FeishuEndpointCredentialError(`${variable} is required`);
-	return value;
-}
+//#region src/modules/run-presentation/domain/presentation/conversation-progress.ts
+const DEFAULT_CONVERSATION_PROGRESS_DISPLAY = "collapsed";
 //#endregion
-//#region src/domain/card-presentation.ts
+//#region src/modules/card-presentation/domain/presentation/card-presentation.ts
 var CardPresentationTransitionDenied = class extends Error {
 	name = "CardPresentationTransitionDenied";
 };
@@ -424,6 +114,28 @@ function markCardPresentationTerminal(chain, terminalReceiptId) {
 		terminalReceiptId
 	});
 }
+function validateCardPresentationChain(chain) {
+	if (chain.runId.trim().length === 0 || !Number.isSafeInteger(chain.activeGeneration) || chain.activeGeneration < 0 || chain.activePresentationId.trim().length === 0 || !Number.isSafeInteger(chain.revision) || chain.revision < 1 || chain.presentations.length === 0) throw new CardPresentationTransitionDenied("card presentation chain is invalid");
+	const presentationIds = /* @__PURE__ */ new Set();
+	let previous;
+	for (const [index, presentation] of chain.presentations.entries()) {
+		if (presentation.runId !== chain.runId || presentation.presentationId.trim().length === 0 || presentation.cardId.trim().length === 0 || typeof presentation.sourceMessageId !== "string" || !Number.isSafeInteger(presentation.generation) || presentation.generation !== index || !isCardPresentationStatus(presentation.status) || presentationIds.has(presentation.presentationId)) throw new CardPresentationTransitionDenied(`presentation chain ${chain.runId} contains an invalid entry`);
+		assertTimestamp(presentation.createdAt, "presentation creation time");
+		assertTimestamp(presentation.leaseDeadlineAt, "presentation lease deadline");
+		if (presentation.handoffAt !== void 0) assertTimestamp(presentation.handoffAt, "handoff time");
+		if (presentation.handoffFailedAt !== void 0) assertTimestamp(presentation.handoffFailedAt, "handoff failure time");
+		if (presentation.status === "terminal" && !presentation.terminalReceiptId?.trim()) throw new CardPresentationTransitionDenied(`terminal presentation ${presentation.presentationId} has no terminal receipt`);
+		if (presentation.status !== "terminal" && presentation.terminalReceiptId !== void 0) throw new CardPresentationTransitionDenied(`non-terminal presentation ${presentation.presentationId} carries a terminal receipt`);
+		if (previous === void 0) {
+			if (presentation.predecessorPresentationId !== void 0) throw new CardPresentationTransitionDenied(`first presentation ${presentation.presentationId} has a predecessor`);
+		} else if (presentation.predecessorPresentationId !== previous.presentationId || previous.successorPresentationId !== presentation.presentationId || previous.status !== "closed") throw new CardPresentationTransitionDenied(`presentation chain ${chain.runId} has inconsistent predecessor and successor links`);
+		previous = presentation;
+		presentationIds.add(presentation.presentationId);
+	}
+	const active = activeCardPresentation(chain);
+	if (chain.activeGeneration !== chain.presentations.length - 1 || active.generation !== chain.activeGeneration || active !== chain.presentations.at(-1) || active.successorPresentationId !== void 0) throw new CardPresentationTransitionDenied(`presentation chain ${chain.runId} has an invalid active generation`);
+	return chain;
+}
 function replaceActivePresentation(chain, presentation) {
 	return {
 		...chain,
@@ -434,358 +146,748 @@ function replaceActivePresentation(chain, presentation) {
 function assertTimestamp(value, label) {
 	if (Number.isNaN(Date.parse(value))) throw new CardPresentationTransitionDenied(`${label} must be an ISO timestamp`);
 }
-//#endregion
-//#region src/domain/run-presentation.ts
-const RUN_PRESENTATION_SCHEMA_VERSION = 2;
-function hasInspectableRunProgress(presentation) {
-	return presentation.steps.some((step) => step.kind === "skill" || step.kind === "tool");
+function isCardPresentationStatus(value) {
+	return value === "streaming" || value === "handoff-pending" || value === "active" || value === "closed" || value === "terminal";
 }
 //#endregion
-//#region src/application/feishu/feishu-card-rollover.ts
-const DEFAULT_CARD_STREAM_LEASE_MS = 51e4;
-function createFeishuCardRollover(options) {
-	const leaseMs = options.leaseMs ?? 51e4;
-	if (!Number.isSafeInteger(leaseMs) || leaseMs < 1) throw new Error("Feishu card stream lease must be a positive integer");
-	const counters = createCounters();
-	const latestPresentationByRun = /* @__PURE__ */ new Map();
-	const latestTextByRun = /* @__PURE__ */ new Map();
-	const generationBaselineByRun = /* @__PURE__ */ new Map();
-	const liveRuns = /* @__PURE__ */ new Map();
-	const semaphore = Effect.unsafeMakeSemaphore(1);
-	const exclusive = (effect) => semaphore.withPermits(1)(effect);
-	const record = (event, at) => {
-		counters[event.type] += 1;
-		options.observe?.({
-			...event,
-			at: at.toISOString()
-		});
-	};
-	const recordNow = (event) => options.clock.now.pipe(Effect.map((at) => record(event, at)));
-	const leaseDeadline = (at) => new Date(at.getTime() + leaseMs).toISOString();
-	const presentationId = (runId, generation) => `${runId}#${generation}`;
-	const publishProgress = (action) => Effect.suspend(() => {
-		const chain = options.store.chain(action.runId);
-		if (chain && acceptsCardPresentationProgress(chain)) {
-			if (action.type === "update_text") latestTextByRun.set(action.runId, action.text);
-			else {
-				latestPresentationByRun.set(action.runId, action.presentation);
-				latestTextByRun.set(action.runId, action.presentation.answer.text);
-			}
-			const run = liveRuns.get(action.runId);
-			if (!run) return options.publisher.publish(action);
-			const baseline = generationBaselineByRun.get(action.runId);
-			const text = projectText(latestTextByRun.get(action.runId), baseline?.text);
-			const presentation = projectPresentation(latestPresentationByRun.get(action.runId), baseline);
-			return options.publisher.publish({
-				...presentation === void 0 ? {} : { presentation },
-				runId: action.runId,
-				sessionKey: run.sessionKey,
-				...text === void 0 ? {} : { text },
-				type: "update_presentation"
-			});
-		}
-		return recordNow({
-			...chain ? {
-				generation: chain.activeGeneration,
-				presentationId: chain.activePresentationId
-			} : {},
-			runId: action.runId,
-			type: "stale_update_dropped"
-		});
-	});
-	const publishTerminal = (action) => {
-		const latestText = latestTextByRun.get(action.runId);
-		const latestPresentation = latestPresentationByRun.get(action.runId);
-		const withText = action.type === "cancel" && action.text === void 0 && latestText !== void 0 ? {
-			...action,
-			text: latestText
-		} : action;
-		const projectedAction = projectTerminalAction((withText.type === "cancel" || withText.type === "fail" || withText.type === "finish") && withText.presentation === void 0 && latestPresentation !== void 0 && hasInspectableRunProgress(latestPresentation) ? {
-			...withText,
-			presentation: latestPresentation
-		} : withText, generationBaselineByRun.get(action.runId));
-		return options.publisher.publish(projectedAction).pipe(Effect.tapError((error) => recordNow({
-			error,
-			runId: action.runId,
-			type: "terminal_delivery_failed"
-		})), Effect.tap(() => options.store.markTerminal({
-			runId: action.runId,
-			terminalReceiptId: `${action.runId}:${action.type}`
-		}).pipe(Effect.catchAll((error) => recordNow({
-			error,
-			runId: action.runId,
-			type: "presentation_write_failed"
-		})))), Effect.ensuring(Effect.sync(() => {
-			latestPresentationByRun.delete(action.runId);
-			latestTextByRun.delete(action.runId);
-			generationBaselineByRun.delete(action.runId);
-			liveRuns.delete(action.runId);
-		})));
-	};
-	const publishAction = (action) => {
-		switch (action.type) {
-			case "update_text":
-			case "update_progress": return publishProgress(action);
-			case "update_presentation": return options.publisher.publish(action);
-			default: return publishTerminal(action);
-		}
-	};
-	const runHandoff = (runId) => Effect.gen(function* () {
-		const run = liveRuns.get(runId);
-		if (!run) return {
-			reason: "not-live",
-			status: "skipped"
-		};
-		const startedAt = yield* options.clock.now;
-		const chain = options.store.chain(runId);
-		if (!chain || !isCardPresentationHandoffDue(chain, startedAt.toISOString())) return {
-			reason: "not-due",
-			status: "skipped"
-		};
-		const start = yield* options.store.beginHandoff({
-			handoffAt: startedAt.toISOString(),
-			runId
-		}).pipe(Effect.catchAll(() => Effect.succeed(void 0)));
-		if (!start) return {
-			reason: "not-streaming",
-			status: "skipped"
-		};
-		if (!start.started) return {
-			reason: "already-pending",
-			status: "skipped"
-		};
-		const predecessor = start.presentation;
-		const generation = predecessor.generation + 1;
-		record({
-			cardId: predecessor.cardId,
-			generation,
-			presentationId: predecessor.presentationId,
-			runId,
-			sourceMessageId: predecessor.sourceMessageId,
-			type: "handoff_started"
-		}, startedAt);
-		const successorId = presentationId(runId, generation);
-		const created = yield* options.createSuccessor({
-			generation,
-			presentationId: successorId,
-			run
-		}).pipe(Effect.map((target) => ({ target })), Effect.catchAll((error) => options.store.failHandoff({
-			failedAt: startedAt.toISOString(),
-			runId
-		}).pipe(Effect.catchAll((storeError) => recordNow({
-			error: storeError,
-			runId,
-			type: "presentation_write_failed"
-		})), Effect.flatMap(() => recordNow({
-			cardId: predecessor.cardId,
-			error,
-			generation,
-			presentationId: predecessor.presentationId,
-			runId,
-			type: "handoff_failed"
-		})), Effect.as({ error }))));
-		if ("error" in created) return {
-			error: created.error,
-			status: "failed"
-		};
-		const adoptedAt = yield* options.clock.now;
-		const presentation = yield* options.store.completeHandoff({
-			runId,
-			successor: {
-				cardId: created.target.cardId,
-				createdAt: adoptedAt.toISOString(),
-				...created.target.elementId === void 0 ? {} : { elementId: created.target.elementId },
-				leaseDeadlineAt: leaseDeadline(adoptedAt),
-				presentationId: successorId
-			}
-		});
-		record({
-			cardId: predecessor.cardId,
-			generation,
-			presentationId: successorId,
-			runId,
-			sourceMessageId: predecessor.sourceMessageId,
-			successorCardId: created.target.cardId,
-			type: "handoff_succeeded"
-		}, adoptedAt);
-		generationBaselineByRun.set(runId, {
-			...latestPresentationByRun.has(runId) ? { presentation: latestPresentationByRun.get(runId) } : {},
-			...latestTextByRun.has(runId) ? { text: latestTextByRun.get(runId) } : {}
-		});
-		return {
-			presentation,
-			status: "rolled-over"
+//#region src/modules/card-presentation/application/presentation/card-presentation-service.ts
+var CardPresentationNotFound = class extends Error {
+	runId;
+	_tag = "CardPresentationNotFound";
+	name = "CardPresentationNotFound";
+	constructor(runId) {
+		super(`card presentation for run ${runId} was not found`);
+		this.runId = runId;
+	}
+};
+function createCardPresentationService(repository) {
+	const transition = (runId, apply) => repository.transact((current) => {
+		const chain = findChain(current, runId);
+		if (!chain) throw new CardPresentationNotFound(runId);
+		const next = apply(chain);
+		return next === chain ? { result: activeCardPresentation(chain) } : {
+			next: replaceChain(current, next),
+			result: activeCardPresentation(next)
 		};
 	});
 	return {
-		bindRun: (run, target) => exclusive(Effect.gen(function* () {
-			const createdAt = yield* options.clock.now;
-			const presentation = yield* options.store.bind({
-				cardId: target.cardId,
-				createdAt: createdAt.toISOString(),
-				...target.elementId === void 0 ? {} : { elementId: target.elementId },
-				leaseDeadlineAt: leaseDeadline(createdAt),
-				presentationId: presentationId(run.runId, 0),
-				runId: run.runId,
-				sourceMessageId: run.messageId
-			});
-			latestPresentationByRun.delete(run.runId);
-			latestTextByRun.delete(run.runId);
-			generationBaselineByRun.delete(run.runId);
-			liveRuns.set(run.runId, run);
-			return presentation;
-		})),
-		dueRunIds: (now) => {
-			const nowIso = now.toISOString();
-			return [...liveRuns.keys()].filter((runId) => {
-				const chain = options.store.chain(runId);
-				return chain !== void 0 && isCardPresentationHandoffDue(chain, nowIso);
-			});
-		},
-		flush: (runId) => exclusive(options.publisher.flush(runId)),
-		handoff: (runId) => exclusive(runHandoff(runId)),
-		observeStreamClosed: (cardId) => {
-			counters.stream_closed += 1;
-			options.observe?.({
-				cardId,
-				type: "stream_closed"
+		bind: (binding) => repository.transact((current) => {
+			const chain = findChain(current, binding.runId);
+			if (chain && activeCardPresentation(chain).cardId === binding.cardId) return { result: activeCardPresentation(chain) };
+			const created = createCardPresentationChain(binding);
+			return {
+				next: replaceChain(current, created),
+				result: activeCardPresentation(created)
+			};
+		}),
+		beginHandoff: ({ handoffAt, runId }) => repository.transact((current) => {
+			const chain = findChain(current, runId);
+			if (!chain) throw new CardPresentationNotFound(runId);
+			const next = beginCardPresentationHandoff(chain, handoffAt);
+			const result = {
+				presentation: activeCardPresentation(next),
+				started: next !== chain
+			};
+			return next === chain ? { result } : {
+				next: replaceChain(current, next),
+				result
+			};
+		}),
+		chain: (runId) => findChain(repository.snapshot(), runId),
+		chains: () => repository.snapshot(),
+		compensateInterruptedHandoffs: (compensatedAt) => repository.transact((current) => {
+			const compensated = [];
+			const next = current.map((chain) => {
+				const candidate = compensateCardPresentationHandoff(chain, compensatedAt);
+				if (candidate !== chain) compensated.push(candidate);
+				return candidate;
 			});
-		},
-		publish: (action) => exclusive(publishAction(action)),
-		releaseRun: (runId) => Effect.sync(() => {
-			latestTextByRun.delete(runId);
-			latestPresentationByRun.delete(runId);
-			generationBaselineByRun.delete(runId);
-			liveRuns.delete(runId);
+			return compensated.length === 0 ? { result: [] } : {
+				next,
+				result: compensated
+			};
 		}),
-		recover: () => exclusive(Effect.gen(function* () {
-			const compensatedAt = yield* options.clock.now;
-			const compensated = yield* options.store.compensateInterruptedHandoffs(compensatedAt.toISOString());
-			for (const chain of compensated) record({
-				generation: chain.activeGeneration,
-				presentationId: chain.activePresentationId,
-				runId: chain.runId,
-				type: "handoff_failed"
-			}, compensatedAt);
-			return { compensated: compensated.length };
-		})),
-		status: () => ({
-			counters: { ...counters },
-			leaseMs,
-			live: [...liveRuns.keys()].flatMap((runId) => {
-				const chain = options.store.chain(runId);
-				if (!chain) return [];
-				return chain.presentations.filter((presentation) => presentation.presentationId === chain.activePresentationId);
-			})
-		})
+		completeHandoff: ({ runId, successor }) => transition(runId, (chain) => completeCardPresentationHandoff(chain, successor)),
+		failHandoff: ({ failedAt, runId }) => transition(runId, (chain) => failCardPresentationHandoff(chain, failedAt)).pipe(Effect.asVoid),
+		markTerminal: ({ runId, terminalReceiptId }) => transition(runId, (chain) => markCardPresentationTerminal(chain, terminalReceiptId)).pipe(Effect.asVoid),
+		release: (runId) => repository.transact((current) => {
+			const next = current.filter((chain) => chain.runId !== runId);
+			return next.length === current.length ? { result: void 0 } : {
+				next,
+				result: void 0
+			};
+		}),
+		size: () => repository.snapshot().length
 	};
 }
-function projectText(text, baseline) {
-	if (text === void 0 || baseline === void 0 || baseline.length === 0) return text;
-	if (text === baseline) return "";
-	return text.startsWith(baseline) ? text.slice(baseline.length) : text;
+function findChain(chains, runId) {
+	return chains.find((chain) => chain.runId === runId);
 }
-function projectPresentation(presentation, baseline) {
-	if (!presentation || !baseline) return presentation;
-	const previous = new Map(baseline.presentation?.steps.map((step) => [step.id, JSON.stringify(step)]) ?? []);
-	let skippedCommittedBaselineText = false;
-	const steps = presentation.steps.filter((step) => {
-		if (!skippedCommittedBaselineText && step.kind === "assistant" && baseline.text?.trim() && step.text.trim() === baseline.text.trim() && !previous.has(step.id)) {
-			skippedCommittedBaselineText = true;
-			return false;
-		}
-		return previous.get(step.id) !== JSON.stringify(step);
-	});
-	const answer = projectText(presentation.answer.text, baseline.text) ?? "";
-	if (steps.length === 0 && answer.trim() === "") return void 0;
-	return {
-		...presentation,
-		answer: {
-			...presentation.answer,
-			text: answer
-		},
-		omittedStepCount: 0,
-		steps,
-		totalStepCount: steps.length,
-		totalToolCallCount: steps.filter((step) => step.kind === "tool").length
-	};
-}
-function projectTerminalAction(action, baseline) {
-	if (!baseline || action.type !== "finish" && action.type !== "fail" && action.type !== "cancel") return action;
-	const presentation = action.presentation ? projectPresentation(action.presentation, baseline) : void 0;
-	if (action.type === "finish") return {
-		...presentation === void 0 ? {} : { presentation },
-		runId: action.runId,
-		text: projectText(action.text, baseline.text) ?? action.text,
-		type: "finish"
-	};
-	if (action.type === "cancel") return {
-		...presentation === void 0 ? {} : { presentation },
-		...action.reason === void 0 ? {} : { reason: action.reason },
-		runId: action.runId,
-		...action.text === void 0 ? {} : { text: projectText(action.text, baseline.text) ?? action.text },
-		type: "cancel"
+function replaceChain(chains, replacement) {
+	const index = chains.findIndex((chain) => chain.runId === replacement.runId);
+	if (index === -1) return [...chains, replacement];
+	return chains.map((chain, current) => current === index ? replacement : chain);
+}
+//#endregion
+//#region src/modules/card-presentation/domain/delivery/card-delivery.ts
+var CardDeliveryTransitionDenied = class extends Error {
+	name = "CardDeliveryTransitionDenied";
+};
+function reserveCardDeliverySequence(current, runId) {
+	const record = current ?? initialCardDeliveryRecord(runId);
+	assertCardDeliveryIdentity(record, runId);
+	if (record.terminalPublished) throw new CardDeliveryTransitionDenied(`card delivery for run ${runId} already has a terminal receipt`);
+	const next = {
+		...record,
+		revision: record.revision + 1,
+		sequence: record.sequence + 1
 	};
 	return {
-		errorMessage: action.errorMessage,
-		...presentation === void 0 ? {} : { presentation },
-		runId: action.runId,
-		type: "fail"
+		record: next,
+		sequence: next.sequence
 	};
 }
-function createCounters() {
+function markCardDeliveryTerminal(current, runId) {
+	const record = current ?? initialCardDeliveryRecord(runId);
+	assertCardDeliveryIdentity(record, runId);
+	return record.terminalPublished ? record : {
+		...record,
+		revision: record.revision + 1,
+		terminalPublished: true
+	};
+}
+function validateCardDeliveryRecord(record) {
+	if (record.runId.trim().length === 0 || !Number.isSafeInteger(record.revision) || record.revision < 1 || !Number.isSafeInteger(record.sequence) || record.sequence < 0 || typeof record.terminalPublished !== "boolean") throw new CardDeliveryTransitionDenied("card delivery record is invalid");
+	return { ...record };
+}
+function validateCardDeliveryTransition(previous, next) {
+	validateCardDeliveryRecord(next);
+	if (previous === void 0) {
+		if (!(next.sequence === 1 && !next.terminalPublished || next.sequence === 0 && next.terminalPublished) || next.revision !== 1) throw new CardDeliveryTransitionDenied(`card delivery for run ${next.runId} has an invalid initial revision`);
+		return { ...next };
+	}
+	assertCardDeliveryIdentity(previous, next.runId);
+	if (next.revision !== previous.revision + 1) throw new CardDeliveryTransitionDenied(`card delivery for run ${next.runId} skipped a revision`);
+	if (previous.terminalPublished) throw new CardDeliveryTransitionDenied(`card delivery for run ${next.runId} changed after its terminal receipt`);
+	if (!(next.terminalPublished ? next.sequence === previous.sequence : next.sequence === previous.sequence + 1)) throw new CardDeliveryTransitionDenied(`card delivery for run ${next.runId} has an invalid sequence transition`);
+	return { ...next };
+}
+function initialCardDeliveryRecord(runId) {
+	if (runId.trim().length === 0) throw new CardDeliveryTransitionDenied("card delivery run id must not be empty");
 	return {
-		handoff_failed: 0,
-		handoff_notice_failed: 0,
-		handoff_started: 0,
-		handoff_succeeded: 0,
-		presentation_write_failed: 0,
-		stale_update_dropped: 0,
-		stream_closed: 0,
-		terminal_delivery_failed: 0
+		revision: 0,
+		runId,
+		sequence: 0,
+		terminalPublished: false
 	};
 }
-//#endregion
-//#region src/application/background-session/background-session-config.ts
-const DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS = 300 * 1e3;
-const DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS = 4;
-const DEFAULT_BACKGROUND_SESSION_LEASE_MS = 3e4;
-const DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS = 1e4;
-const DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES = 3;
-const DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS = 3e4;
-const DEFAULT_BACKGROUND_SESSION_LIFETIME_MS = 1440 * 60 * 1e3;
-const DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS = 1e3;
-function resolveBackgroundSessionSupervisorIntervalMs(leaseMs) {
-	return Math.min(5e3, Math.max(200, Math.floor(leaseMs / 10)));
+function assertCardDeliveryIdentity(record, runId) {
+	if (record.runId !== runId) throw new CardDeliveryTransitionDenied(`card delivery identity ${record.runId} does not match requested run ${runId}`);
 }
 //#endregion
-//#region src/domain/conversation-progress.ts
-const DEFAULT_CONVERSATION_PROGRESS_DISPLAY = "collapsed";
+//#region src/modules/card-presentation/domain/presentation/card-presentation-lease.ts
+const DEFAULT_CARD_STREAM_LEASE_MS$1 = 51e4;
+function validateCardPresentationLeaseMs(leaseMs) {
+	if (!Number.isSafeInteger(leaseMs) || leaseMs < 1) throw new CardPresentationTransitionDenied("card presentation lease must be a positive integer");
+	return leaseMs;
+}
+function cardPresentationLeaseDeadline(at, leaseMs) {
+	const atMs = Date.parse(at);
+	if (Number.isNaN(atMs)) throw new CardPresentationTransitionDenied("card presentation lease start must be an ISO timestamp");
+	return new Date(atMs + validateCardPresentationLeaseMs(leaseMs)).toISOString();
+}
 //#endregion
-//#region src/infrastructure/config/rivus-deployment-manifest.ts
-var RivusDeploymentManifestError = class extends Error {
-	manifestPath;
-	name = "RivusDeploymentManifestError";
-	constructor(manifestPath, message, options) {
-		super(message, options);
-		this.manifestPath = manifestPath;
+//#region src/platform/runtime/runtime-cache.ts
+function createRuntimeCache() {
+	const entries = /* @__PURE__ */ new Map();
+	const serial = Effect.unsafeMakeSemaphore(1);
+	const reserve = (key) => serial.withPermits(1)(Effect.gen(function* () {
+		const current = entries.get(key);
+		if (current) return {
+			created: false,
+			entry: current
+		};
+		const entry = {
+			deferred: yield* Deferred.make(),
+			initializationStarted: false,
+			key
+		};
+		entries.set(key, entry);
+		return {
+			created: true,
+			entry
+		};
+	}));
+	const start = (entry, create) => Effect.uninterruptible(Effect.gen(function* () {
+		if (!(yield* serial.withPermits(1)(Effect.sync(() => {
+			if (entry.initializationStarted) return false;
+			entry.initializationStarted = true;
+			return true;
+		})))) return;
+		const initialization = create().pipe(Effect.tapError(() => serial.withPermits(1)(Effect.sync(() => {
+			if (entries.get(entry.key) === entry) entries.delete(entry.key);
+		}))), Effect.exit, Effect.flatMap((exit) => Deferred.done(entry.deferred, exit)), Effect.asVoid);
+		yield* Effect.forkDaemon(initialization);
+	}));
+	const getOrCreate = (key, create) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const selected = yield* reserve(key);
+		yield* start(selected.entry, create);
+		return {
+			entry: selected.entry,
+			runtime: yield* restore(Deferred.await(selected.entry.deferred))
+		};
+	}));
+	return {
+		drain: () => serial.withPermits(1)(Effect.sync(() => {
+			const drained = Object.freeze([...entries.values()]);
+			entries.clear();
+			return drained;
+		})),
+		getExisting: (key) => Effect.gen(function* () {
+			const entry = yield* serial.withPermits(1)(Effect.sync(() => entries.get(key)));
+			if (!entry) return void 0;
+			return {
+				entry,
+				runtime: yield* Deferred.await(entry.deferred)
+			};
+		}),
+		getOrCreate,
+		isCurrent: (key, entry) => serial.withPermits(1)(Effect.sync(() => entries.get(key) === entry)),
+		reserve,
+		size: () => serial.withPermits(1)(Effect.sync(() => entries.size)),
+		start
+	};
+}
+function disposeRuntimeCacheEntries(options) {
+	const disposal = Effect.gen(function* () {
+		const completions = yield* Effect.forEach(options.entries, (entry) => Effect.gen(function* () {
+			const completion = yield* Deferred.make();
+			yield* Effect.forkDaemon(Deferred.await(entry.deferred).pipe(Effect.flatMap(options.dispose), Effect.exit, Effect.flatMap((exit) => Deferred.succeed(completion, exit)), Effect.asVoid));
+			return completion;
+		}), { concurrency: "unbounded" });
+		const failures = (yield* Effect.forEach(completions, Deferred.await, { concurrency: "unbounded" })).filter(Exit.isFailure).map(({ cause }) => Cause.squash(cause));
+		if (failures.length > 0) return yield* Effect.fail(new AggregateError(failures, options.failureMessage));
+	});
+	return options.timeout ? disposal.pipe(Effect.timeoutFail({
+		duration: options.timeout.milliseconds,
+		onTimeout: options.timeout.onTimeout
+	})) : disposal;
+}
+function invokeRuntimeControl(runtime, control) {
+	return runtime.pipe(Effect.flatMap((selected) => selected ? control(selected) ?? Effect.succeed(false) : Effect.succeed(false)));
+}
+//#endregion
+//#region src/adapters/agent/runtime/process-agent-runtime-adapter.ts
+function toEffectAgentRuntimeInput(input) {
+	const onUpdate = input.onUpdate;
+	return {
+		...runtimeInputFields(input),
+		...onUpdate ? { onUpdate: (update) => Effect.tryPromise({
+			try: async () => onUpdate(update),
+			catch: (failure) => failure
+		}) } : {}
+	};
+}
+function toProcessAgentRuntimeInput(input, runEffect) {
+	const onUpdate = input.onUpdate;
+	return {
+		...runtimeInputFields(input),
+		...onUpdate ? { onUpdate: (update) => runEffect(onUpdate(update)) } : {}
+	};
+}
+function toEffectAgentRuntime(runtime, runEffect) {
+	const cancel = runtime.cancel?.bind(runtime);
+	const dispose = runtime.dispose?.bind(runtime);
+	const steer = runtime.steer?.bind(runtime);
+	return {
+		...runtime.concurrency ? { concurrency: runtime.concurrency } : {},
+		...cancel ? { cancel: (input) => Effect.tryPromise({
+			try: () => cancel(input),
+			catch: (failure) => failure
+		}) } : {},
+		...dispose ? { dispose: () => Effect.tryPromise({
+			try: async () => dispose(),
+			catch: (failure) => failure
+		}) } : {},
+		run: (input) => Effect.tryPromise({
+			try: () => runtime.run(toProcessAgentRuntimeInput(input, runEffect)),
+			catch: (failure) => failure
+		}),
+		...steer ? { steer: (input) => Effect.tryPromise({
+			try: () => steer(input),
+			catch: (failure) => failure
+		}) } : {}
+	};
+}
+function runtimeInputFields(input) {
+	return {
+		...input.invocation ? { invocation: input.invocation } : {},
+		...input.payload === void 0 ? {} : { payload: input.payload },
+		sessionKey: input.sessionKey,
+		text: input.text
+	};
+}
+//#endregion
+//#region src/platform/home/config/runtime/local-env-file.ts
+var LocalEnvFileError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LocalEnvFileError";
 	}
 };
-async function loadRivusDeploymentManifest(manifestPath, options = {}) {
-	const maxBytes = options.maxBytes ?? 1024 * 1024;
-	try {
-		const metadata = await stat(manifestPath);
-		if (!metadata.isFile()) throw new Error("deployment manifest must be a regular file");
-		if (metadata.size > maxBytes) throw new Error(`deployment manifest exceeds ${maxBytes} byte limit`);
-		const bytes = await readFile(manifestPath);
-		const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-		return parseManifest(JSON.parse(text));
-	} catch (cause) {
-		if (cause instanceof RivusDeploymentManifestError) throw cause;
-		throw new RivusDeploymentManifestError(manifestPath, `failed to load Rivus deployment manifest: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+async function loadMergedLocalEnvFile(filePath, overrideEnv) {
+	return mergeRivusDaemonEnv(await loadLocalEnvFile(filePath), overrideEnv);
+}
+async function loadLocalEnvFile(filePath) {
+	return parseLocalEnvFile(await readFile(filePath, "utf8"));
+}
+function parseLocalEnvFile(contents) {
+	const env = {};
+	const lines = contents.split(/\r?\n/);
+	for (let index = 0; index < lines.length; index += 1) {
+		const trimmed = lines[index].trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const match = (trimmed.startsWith("export ") ? trimmed.slice(7).trimStart() : trimmed).match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+		if (!match) throw new LocalEnvFileError(`Invalid env file line ${index + 1}`);
+		const key = match[1];
+		const rawValue = match[2];
+		env[key] = parseEnvValue(rawValue, index + 1);
+	}
+	return env;
+}
+function mergeRivusDaemonEnv(fileEnv, overrideEnv) {
+	const merged = { ...fileEnv };
+	for (const [key, value] of Object.entries(overrideEnv)) if (value !== void 0) merged[key] = value;
+	return merged;
+}
+function parseEnvValue(rawValue, lineNumber) {
+	const value = rawValue.trim();
+	if (!value) return "";
+	if (value.startsWith("'")) {
+		if (!value.endsWith("'")) throw new LocalEnvFileError(`Invalid single-quoted env value on line ${lineNumber}`);
+		return value.slice(1, -1).replaceAll("'\\''", "'");
+	}
+	if (value.startsWith("\"")) {
+		if (!value.endsWith("\"")) throw new LocalEnvFileError(`Invalid double-quoted env value on line ${lineNumber}`);
+		return unescapeDoubleQuotedValue(value.slice(1, -1));
+	}
+	return value;
+}
+function unescapeDoubleQuotedValue(value) {
+	return value.replace(/\\(["\\nrt])/g, (_match, escaped) => {
+		switch (escaped) {
+			case "n": return "\n";
+			case "r": return "\r";
+			case "t": return "	";
+			default: return escaped;
+		}
+	});
+}
+//#endregion
+//#region src/platform/home/config/runtime/rivus-daemon-config.ts
+var RivusDaemonConfigError = class {
+	variable;
+	message;
+	_tag = "RivusDaemonConfigError";
+	constructor(variable, message) {
+		this.variable = variable;
+		this.message = message;
+	}
+};
+const DEFAULT_AGENT_ID$1 = "main";
+const DEFAULT_CARD_STREAM_LEASE_MS = 51e4;
+const DEFAULT_FEISHU_BASE_URL$1 = "https://open.feishu.cn";
+const DEFAULT_STREAM_MIN_INTERVAL_MS$1 = 200;
+const THINKING_LEVELS$1 = /* @__PURE__ */ new Set([
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+function loadRivusDaemonConfig(env, options = {}) {
+	return Effect.gen(function* () {
+		const appId = yield* required$1(env, "FEISHU_APP_ID");
+		const appSecret = yield* required$1(env, "FEISHU_APP_SECRET");
+		const streamMinIntervalMs = yield* optionalPositiveInteger(env.FEISHU_STREAM_MIN_INTERVAL_MS, "FEISHU_STREAM_MIN_INTERVAL_MS", DEFAULT_STREAM_MIN_INTERVAL_MS$1);
+		const cardStreamLeaseMs = yield* optionalPositiveInteger(env.FEISHU_CARD_STREAM_LEASE_MS, "FEISHU_CARD_STREAM_LEASE_MS", DEFAULT_CARD_STREAM_LEASE_MS);
+		const thinkingLevel = yield* optionalThinkingLevel(env.PI_THINKING_LEVEL);
+		const apiKey = yield* optionalPiApiKey(env, options.readTextFile ?? readUtf8File);
+		const baseUrl = optional(env.PI_BASE_URL);
+		const model = optional(env.PI_MODEL);
+		return {
+			agentId: optional(env.RIVUS_AGENT_ID) ?? DEFAULT_AGENT_ID$1,
+			feishu: {
+				appId,
+				appSecret,
+				baseUrl: optional(env.FEISHU_BASE_URL) ?? DEFAULT_FEISHU_BASE_URL$1,
+				cardStreamLeaseMs,
+				streamMinIntervalMs
+			},
+			pi: {
+				...apiKey ? { apiKey } : {},
+				...baseUrl ? { baseUrl } : {},
+				...model ? { model } : {},
+				...thinkingLevel ? { thinkingLevel } : {}
+			}
+		};
+	});
+}
+function optional(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function readUtf8File(path) {
+	return readFile(path, "utf8");
+}
+function optionalPiApiKey(env, readTextFile) {
+	const inlineApiKey = optional(env.PI_API_KEY);
+	const apiKeyFile = optional(env.PI_API_KEY_FILE);
+	if (inlineApiKey && apiKeyFile) return Effect.fail(new RivusDaemonConfigError("PI_API_KEY", "PI_API_KEY and PI_API_KEY_FILE cannot both be set"));
+	if (inlineApiKey) return Effect.succeed(inlineApiKey);
+	if (!apiKeyFile) return Effect.succeed(void 0);
+	return Effect.tryPromise({
+		try: async () => readTextFile(apiKeyFile),
+		catch: (error) => new RivusDaemonConfigError("PI_API_KEY_FILE", `PI_API_KEY_FILE could not be read: ${formatConfigError(error)}`)
+	}).pipe(Effect.flatMap((contents) => {
+		const apiKey = optional(contents);
+		return apiKey ? Effect.succeed(apiKey) : Effect.fail(new RivusDaemonConfigError("PI_API_KEY_FILE", "PI_API_KEY_FILE must not be empty"));
+	}));
+}
+function formatConfigError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function optionalPositiveInteger(value, variable, fallback) {
+	const normalized = optional(value);
+	if (!normalized) return Effect.succeed(fallback);
+	if (/^[1-9]\d*$/.test(normalized)) return Effect.succeed(Number(normalized));
+	return Effect.fail(new RivusDaemonConfigError(variable, `${variable} must be a positive integer`));
+}
+function required$1(env, variable) {
+	const value = optional(env[variable]);
+	if (value) return Effect.succeed(value);
+	return Effect.fail(new RivusDaemonConfigError(variable, `${variable} is required`));
+}
+function optionalThinkingLevel(value) {
+	const normalized = optional(value);
+	if (!normalized) return Effect.succeed(void 0);
+	if (THINKING_LEVELS$1.has(normalized)) return Effect.succeed(normalized);
+	return Effect.fail(new RivusDaemonConfigError("PI_THINKING_LEVEL", "PI_THINKING_LEVEL must be one of off, minimal, low, medium, high, xhigh"));
+}
+//#endregion
+//#region src/adapters/feishu/config/feishu-endpoint-credentials.ts
+var FeishuEndpointCredentialError = class extends Error {
+	name = "FeishuEndpointCredentialError";
+};
+function resolveFeishuEndpointCredentials(credentialRef, env) {
+	if (!credentialRef.startsWith("env:")) throw new FeishuEndpointCredentialError("Feishu endpoint credentialRef must use env:<PREFIX>");
+	const prefix = credentialRef.slice(4);
+	if (!/^[A-Z][A-Z0-9_]*$/.test(prefix)) throw new FeishuEndpointCredentialError(`Invalid environment prefix in credentialRef: ${credentialRef}`);
+	return Object.freeze({
+		appId: required(env, `${prefix}_APP_ID`),
+		appSecret: required(env, `${prefix}_APP_SECRET`)
+	});
+}
+function required(env, variable) {
+	const value = env[variable]?.trim();
+	if (!value) throw new FeishuEndpointCredentialError(`${variable} is required`);
+	return value;
+}
+//#endregion
+//#region src/adapters/openclaw/config/openclaw-env-import.ts
+var OpenClawEnvImportError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OpenClawEnvImportError";
+	}
+};
+const DEFAULT_AGENT_ID = "main";
+const DEFAULT_FEISHU_BASE_URL = "https://open.feishu.cn";
+const DEFAULT_LARK_BASE_URL = "https://open.larksuite.com";
+const DEFAULT_STREAM_MIN_INTERVAL_MS = 200;
+const THINKING_LEVELS = /* @__PURE__ */ new Set([
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+const ENV_FILE_ORDER = [
+	"FEISHU_APP_ID",
+	"FEISHU_APP_SECRET",
+	"FEISHU_BASE_URL",
+	"FEISHU_STREAM_MIN_INTERVAL_MS",
+	"RIVUS_AGENT_ID",
+	"PI_API_KEY_FILE",
+	"PI_BASE_URL",
+	"PI_MODEL",
+	"PI_THINKING_LEVEL"
+];
+function createRivusEnvFromOpenClawConfig(openClawConfig, options = {}) {
+	const config = asRecord(openClawConfig, "OpenClaw config");
+	const feishu = asRecord(readPath(config, ["channels", "feishu"]), "channels.feishu");
+	const appId = requiredString(feishu, "appId", "channels.feishu.appId");
+	const appSecret = requiredString(feishu, "appSecret", "channels.feishu.appSecret");
+	const modelReference = findPrimaryModelReference(config);
+	const providerId = modelReference ? parseProviderId(modelReference) : void 0;
+	const provider = providerId ? optionalRecord(readPath(config, [
+		"models",
+		"providers",
+		providerId
+	])) : void 0;
+	const providerBaseUrl = provider ? optionalString(provider.baseUrl) : void 0;
+	const thinkingLevel = modelReference ? findThinkingLevel(config, modelReference) : void 0;
+	const warnings = thinkingLevel?.warning ? [thinkingLevel.warning] : [];
+	return {
+		env: {
+			FEISHU_APP_ID: appId,
+			FEISHU_APP_SECRET: appSecret,
+			FEISHU_BASE_URL: options.feishuBaseUrl ?? inferFeishuBaseUrl(optionalString(feishu.domain)),
+			FEISHU_STREAM_MIN_INTERVAL_MS: String(options.streamMinIntervalMs ?? DEFAULT_STREAM_MIN_INTERVAL_MS),
+			RIVUS_AGENT_ID: findAgentId(config),
+			...options.piApiKeyFile ? { PI_API_KEY_FILE: options.piApiKeyFile } : {},
+			...providerBaseUrl ? { PI_BASE_URL: providerBaseUrl } : {},
+			...modelReference ? { PI_MODEL: modelReference } : {},
+			...thinkingLevel?.level ? { PI_THINKING_LEVEL: thinkingLevel.level } : {}
+		},
+		warnings
+	};
+}
+function formatRivusEnvFile(env) {
+	return `${[...ENV_FILE_ORDER.filter((key) => Object.hasOwn(env, key)), ...Object.keys(env).filter((key) => !ENV_FILE_ORDER.includes(key)).sort()].map((key) => `${key}=${quoteEnvValue(env[key] ?? "")}`).join("\n")}\n`;
+}
+function findAgentId(config) {
+	const agents = optionalRecord(config.agents);
+	return optionalString(optionalRecord((Array.isArray(agents?.list) ? agents.list : [])[0])?.id) ?? DEFAULT_AGENT_ID;
+}
+function findPrimaryModelReference(config) {
+	const primary = optionalString(readPath(config, [
+		"agents",
+		"defaults",
+		"model",
+		"primary"
+	]));
+	if (primary) return primary;
+	const providers = optionalRecord(readPath(config, ["models", "providers"]));
+	if (!providers) return;
+	for (const [providerId, provider] of Object.entries(providers)) {
+		const model = firstModelId(optionalRecord(provider));
+		if (model) return `${providerId}/${model}`;
 	}
 }
-function parseManifest(value) {
+function firstModelId(provider) {
+	return optionalString(optionalRecord((Array.isArray(provider?.models) ? provider.models : [])[0])?.id);
+}
+function parseProviderId(modelReference) {
+	const separator = modelReference.indexOf("/");
+	return separator > 0 ? modelReference.slice(0, separator) : void 0;
+}
+function findThinkingLevel(config, modelReference) {
+	const providerId = parseProviderId(modelReference);
+	const modelId = readModelId(modelReference);
+	const rawLevel = [
+		readPath(config, [
+			"agents",
+			"defaults",
+			"models",
+			modelReference,
+			"thinkingLevel"
+		]),
+		readPath(config, [
+			"agents",
+			"defaults",
+			"models",
+			modelReference,
+			"thinkLevel"
+		]),
+		readPath(config, [
+			"agents",
+			"defaults",
+			"models",
+			modelReference,
+			"reasoningLevel"
+		]),
+		...providerId && modelId ? readProviderModelThinkingCandidates(config, providerId, modelId) : []
+	].map(optionalString).find(Boolean);
+	if (!rawLevel) return;
+	if (THINKING_LEVELS.has(rawLevel)) return { level: rawLevel };
+	return { warning: `Unsupported OpenClaw thinking level '${rawLevel}' was ignored` };
+}
+function readProviderModelThinkingCandidates(config, providerId, modelId) {
+	const providerModels = readPath(config, [
+		"models",
+		"providers",
+		providerId,
+		"models"
+	]);
+	if (!Array.isArray(providerModels)) return [];
+	const model = providerModels.map(optionalRecord).find((candidate) => optionalString(candidate?.id) === modelId);
+	if (!model) return [];
+	return [
+		model.thinkingLevel,
+		model.thinkLevel,
+		model.reasoningLevel,
+		readPath(model, ["reasoning", "level"]),
+		readPath(model, ["reasoning", "thinkingLevel"]),
+		readPath(model, ["reasoning", "thinkLevel"])
+	];
+}
+function readModelId(modelReference) {
+	const separator = modelReference.indexOf("/");
+	return separator >= 0 && separator < modelReference.length - 1 ? modelReference.slice(separator + 1) : void 0;
+}
+function inferFeishuBaseUrl(domain) {
+	return domain === "lark" ? DEFAULT_LARK_BASE_URL : DEFAULT_FEISHU_BASE_URL;
+}
+function quoteEnvValue(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function requiredString(record, key, path) {
+	const value = optionalString(record[key]);
+	if (!value) throw new OpenClawEnvImportError(`${path} is required`);
+	return value;
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function asRecord(value, path) {
+	const record = optionalRecord(value);
+	if (!record) throw new OpenClawEnvImportError(`${path} must be an object`);
+	return record;
+}
+function optionalRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function readPath(record, path) {
+	let value = record;
+	for (const segment of path) {
+		const current = optionalRecord(value);
+		if (!current) return;
+		value = current[segment];
+	}
+	return value;
+}
+//#endregion
+//#region src/platform/daemon/process/rivus-daemon-shutdown-controller.ts
+const DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+function createRivusDaemonShutdownController(options) {
+	let shutdown;
+	const handle = (signal) => {
+		shutdown ??= Effect.runPromise(options.daemon.stop()).then(() => options.onStopped?.(signal)).catch(async (error) => {
+			await options.onError?.(error, signal);
+			throw error;
+		});
+		return shutdown;
+	};
+	return {
+		handle,
+		install: () => {
+			for (const signal of options.signals ?? DEFAULT_SIGNALS) options.signalSource.on(signal, () => {
+				handle(signal);
+			});
+		},
+		stopping: () => shutdown !== void 0
+	};
+}
+//#endregion
+//#region src/modules/project-space/application/workspace/workspace-instructions.ts
+var InvalidWorkspaceRoot = class extends Error {
+	name = "InvalidWorkspaceRoot";
+};
+var WorkspaceInstructionsSourceError = class extends Error {
+	relativePath;
+	reason;
+	name = "WorkspaceInstructionsSourceError";
+	constructor(relativePath, reason) {
+		super(`${relativePath}: ${reason}`);
+		this.relativePath = relativePath;
+		this.reason = reason;
+	}
+};
+function validateWorkspaceInstructionsBudget(maxBytes) {
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new InvalidWorkspaceRoot("workspace instructions maxBytes must be a non-negative integer");
+}
+function assembleWorkspaceInstructions(input) {
+	validateWorkspaceInstructionsBudget(input.maxBytes);
+	const diagnostics = [...input.diagnostics];
+	const selected = [];
+	let usedBytes = 0;
+	for (const source of [...input.sources].reverse()) if (usedBytes + source.bytes <= input.maxBytes) {
+		selected.push(source);
+		usedBytes += source.bytes;
+	} else diagnostics.push({
+		code: "workspace-instructions-source-omitted",
+		reason: `source exceeds remaining byte budget of ${input.maxBytes - usedBytes}`,
+		relativePath: source.relativePath
+	});
+	selected.reverse();
+	const presented = new Set(input.presentedDigests ?? []);
+	const unseen = selected.filter((source) => !presented.has(source.digest));
+	const refreshRequired = input.operation === "mutate" && input.targetPath !== void 0 && unseen.length > 0;
+	if (refreshRequired) diagnostics.push({
+		code: "workspace-instructions-refresh-required",
+		reason: `mutation target has ${unseen.length} workspace instruction source(s) not yet presented`
+	});
+	const view = {
+		content: selected.map((source) => source.content).join("\n"),
+		diagnostics: Object.freeze(diagnostics),
+		digest: createSha256Digest(JSON.stringify(selected.map(({ digest }) => digest))),
+		refreshRequired,
+		sources: Object.freeze(selected),
+		truncated: selected.length !== input.sources.length || input.diagnostics.length > 0
+	};
+	return Object.freeze(view);
+}
+//#endregion
+//#region src/platform/identity/stable-id.ts
+function createStableId(prefix, value) {
+	return `${prefix}:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+}
+//#endregion
+//#region src/modules/project-space/application/space/project-space-declaration.ts
+function createRivusProjectSpaceDeclarationRevision(declaration) {
+	return createStableId("project-space-declaration", {
+		id: declaration.id,
+		root: declaration.root,
+		skills: { sources: declaration.skills.sources },
+		workingDirectory: declaration.workingDirectory
+	});
+}
+//#endregion
+//#region src/modules/project-space/domain/space/project-space.ts
+var InvalidRivusProjectSpace = class extends Error {
+	name = "InvalidRivusProjectSpace";
+};
+function validateRivusProjectSpaceDeployments(declarations) {
+	const projectSpaceIds = /* @__PURE__ */ new Set();
+	for (const declaration of declarations) {
+		if (projectSpaceIds.has(declaration.id)) throw new InvalidRivusProjectSpace(`duplicate project space: ${declaration.id}`);
+		projectSpaceIds.add(declaration.id);
+		validateRivusProjectSpaceDeployment(declaration);
+	}
+	return projectSpaceIds;
+}
+function validateRivusProjectSpaceDeployment(declaration) {
+	validateRelativeProjectPath(declaration.root, `project space ${declaration.id} root`);
+	validateRelativeProjectPath(declaration.workingDirectory, `project space ${declaration.id} working directory`);
+	const sources = /* @__PURE__ */ new Set();
+	for (const source of declaration.skills.sources) {
+		validateRelativeProjectPath(source, `project space ${declaration.id} Skill source`);
+		if (sources.has(source)) throw new InvalidRivusProjectSpace(`project space ${declaration.id} contains duplicate Skill source: ${source}`);
+		sources.add(source);
+	}
+}
+function validateRelativeProjectPath(value, owner) {
+	if (value.trim() === "" || isAbsoluteProjectPath(value) || value.includes("\0")) throw new InvalidRivusProjectSpace(`${owner} must be a non-empty relative path`);
+}
+function isAbsoluteProjectPath(value) {
+	return value.startsWith("/") || value.startsWith("\\") || /^[a-z]:[\\/]/i.test(value);
+}
+//#endregion
+//#region src/modules/deployment-control/domain/manifest/deployment-manifest.ts
+function parseRivusDeploymentManifest(value) {
 	const root = record(value, "manifest");
 	exactKeys(root, [
 		"agents",
@@ -823,15 +925,22 @@ function parseManifest(value) {
 			"pluginId",
 			"profileId",
 			"projectSpaceId",
+			"runtimeTools",
 			"skills",
 			"tools"
-		], `manifest.agents[${index}]`, ["memory", "projectSpaceId"]);
+		], `manifest.agents[${index}]`, [
+			"memory",
+			"projectSpaceId",
+			"runtimeTools"
+		]);
 		const memory = agent.memory === void 0 ? void 0 : record(agent.memory, `manifest.agents[${index}].memory`);
 		if (memory) exactKeys(memory, ["scopes", "tool"], `manifest.agents[${index}].memory`);
 		const skills = record(agent.skills, `manifest.agents[${index}].skills`);
 		exactKeys(skills, ["allow"], `manifest.agents[${index}].skills`);
 		const tools = record(agent.tools, `manifest.agents[${index}].tools`);
 		exactKeys(tools, ["allow"], `manifest.agents[${index}].tools`);
+		const runtimeTools = agent.runtimeTools === void 0 ? void 0 : record(agent.runtimeTools, `manifest.agents[${index}].runtimeTools`);
+		if (runtimeTools) exactKeys(runtimeTools, ["allow"], `manifest.agents[${index}].runtimeTools`);
 		return Object.freeze({
 			agentId: string(agent.agentId, `manifest.agents[${index}].agentId`),
 			endpointIds: Object.freeze(array(agent.endpointIds, `manifest.agents[${index}].endpointIds`).map((item, itemIndex) => string(item, `manifest.agents[${index}].endpointIds[${itemIndex}]`))),
@@ -842,6 +951,7 @@ function parseManifest(value) {
 			pluginId: string(agent.pluginId, `manifest.agents[${index}].pluginId`),
 			profileId: string(agent.profileId, `manifest.agents[${index}].profileId`),
 			...agent.projectSpaceId === void 0 ? {} : { projectSpaceId: string(agent.projectSpaceId, `manifest.agents[${index}].projectSpaceId`) },
+			...runtimeTools ? { runtimeTools: Object.freeze({ allow: Object.freeze(uniqueRuntimeTools(array(runtimeTools.allow, `manifest.agents[${index}].runtimeTools.allow`).map((item, itemIndex) => runtimeToolId(item, `manifest.agents[${index}].runtimeTools.allow[${itemIndex}]`)), `manifest.agents[${index}].runtimeTools.allow`)) }) } : {},
 			skills: Object.freeze({ allow: Object.freeze(array(skills.allow, `manifest.agents[${index}].skills.allow`).map((item, itemIndex) => string(item, `manifest.agents[${index}].skills.allow[${itemIndex}]`))) }),
 			tools: Object.freeze({ allow: Object.freeze(array(tools.allow, `manifest.agents[${index}].tools.allow`).map((item, itemIndex) => string(item, `manifest.agents[${index}].tools.allow[${itemIndex}]`))) })
 		});
@@ -871,7 +981,7 @@ function parseManifest(value) {
 		return Object.freeze({
 			agentId: string(endpoint.agentId, `manifest.endpoints[${index}].agentId`),
 			baseUrl: string(endpoint.baseUrl, `manifest.endpoints[${index}].baseUrl`),
-			cardStreamLeaseMs: endpoint.cardStreamLeaseMs === void 0 ? DEFAULT_CARD_STREAM_LEASE_MS : positiveInteger(endpoint.cardStreamLeaseMs, `manifest.endpoints[${index}].cardStreamLeaseMs`),
+			cardStreamLeaseMs: endpoint.cardStreamLeaseMs === void 0 ? DEFAULT_CARD_STREAM_LEASE_MS$1 : positiveInteger(endpoint.cardStreamLeaseMs, `manifest.endpoints[${index}].cardStreamLeaseMs`),
 			credentialRef: string(endpoint.credentialRef, `manifest.endpoints[${index}].credentialRef`),
 			enabled: boolean(endpoint.enabled, `manifest.endpoints[${index}].enabled`),
 			...experimental ? { experimental: Object.freeze({ cotMessages: boolean(experimental.cotMessages, `manifest.endpoints[${index}].experimental.cotMessages`) }) } : {},
@@ -945,6 +1055,67 @@ function parseManifest(value) {
 		projectSpaces: Object.freeze(projectSpaces)
 	});
 }
+function validateRivusDeploymentManifest(manifest) {
+	const projectSpaceIds = validateRivusProjectSpaceDeployments(manifest.projectSpaces ?? []);
+	const pluginIds = /* @__PURE__ */ new Set();
+	for (const plugin of manifest.plugins) {
+		if (pluginIds.has(plugin.id)) throw new Error(`duplicate plugin declaration: ${plugin.id}`);
+		validateModuleSpecifier(plugin.module);
+		pluginIds.add(plugin.id);
+	}
+	const agentIds = /* @__PURE__ */ new Set();
+	const agentById = /* @__PURE__ */ new Map();
+	for (const agent of manifest.agents) {
+		if (agentIds.has(agent.agentId)) throw new Error(`duplicate agent deployment: ${agent.agentId}`);
+		agentIds.add(agent.agentId);
+		if (!pluginIds.has(agent.pluginId)) throw new Error(`agent ${agent.agentId} references undeclared plugin: ${agent.pluginId}`);
+		if (agent.projectSpaceId && !projectSpaceIds.has(agent.projectSpaceId)) throw new Error(`agent ${agent.agentId} references unknown project space: ${agent.projectSpaceId}`);
+		agentById.set(agent.agentId, agent);
+	}
+	const endpointIds = /* @__PURE__ */ new Set();
+	const sessionNamespaces = /* @__PURE__ */ new Set();
+	for (const endpoint of manifest.endpoints) {
+		if (endpointIds.has(endpoint.id)) throw new Error(`duplicate endpoint binding: ${endpoint.id}`);
+		endpointIds.add(endpoint.id);
+		if (sessionNamespaces.has(endpoint.sessionNamespace)) throw new Error(`duplicate endpoint session namespace: ${endpoint.sessionNamespace}`);
+		sessionNamespaces.add(endpoint.sessionNamespace);
+		const agent = agentById.get(endpoint.agentId);
+		if (!agent) throw new Error(`endpoint ${endpoint.id} references unknown agent: ${endpoint.agentId}`);
+		if (!agent.endpointIds.includes(endpoint.id)) throw new Error(`endpoint ${endpoint.id} is not declared by agent ${endpoint.agentId}`);
+	}
+	for (const agent of manifest.agents) for (const endpointId of agent.endpointIds) {
+		const endpoint = manifest.endpoints.find(({ id }) => id === endpointId);
+		if (!endpoint) throw new Error(`agent ${agent.agentId} references unknown endpoint: ${endpointId}`);
+		if (endpoint.agentId !== agent.agentId) throw new Error(`endpoint ${endpointId} is bound to a different agent`);
+	}
+	const automationIds = /* @__PURE__ */ new Set();
+	for (const automation of manifest.automations ?? []) {
+		if (automationIds.has(automation.id)) throw new Error(`duplicate automation binding: ${automation.id}`);
+		automationIds.add(automation.id);
+		if (!agentById.has(automation.agentId)) throw new Error(`automation ${automation.id} references unknown agent: ${automation.agentId}`);
+		const endpoint = manifest.endpoints.find(({ id }) => id === automation.delivery.endpointId);
+		if (!endpoint) throw new Error(`automation ${automation.id} references unknown delivery endpoint: ${automation.delivery.endpointId}`);
+		if (automation.enabled && !endpoint.enabled) throw new Error(`automation ${automation.id} delivery endpoint must be enabled`);
+	}
+	const defaultAgent = agentById.get(manifest.defaultAgentId);
+	if (!defaultAgent) throw new Error(`default agent does not exist: ${manifest.defaultAgentId}`);
+	const defaultEndpoint = manifest.endpoints.find(({ id }) => id === manifest.defaultEndpointId);
+	if (!defaultEndpoint) throw new Error(`default endpoint does not exist: ${manifest.defaultEndpointId}`);
+	if (defaultEndpoint.agentId !== defaultAgent.agentId) throw new Error("default endpoint is not bound to the default agent");
+	if (!defaultEndpoint.enabled) throw new Error("default endpoint must be enabled");
+	if (manifest.backgroundSessions) validateBackgroundSessions(manifest.backgroundSessions);
+}
+function validateBackgroundSessions(config) {
+	if (config.required && !config.enabled) throw new Error("backgroundSessions.required requires backgroundSessions.enabled");
+	if (config.leaseRenewalIntervalMs >= config.leaseMs) throw new Error("backgroundSessions.leaseRenewalIntervalMs must be shorter than leaseMs");
+	if (config.stepTimeoutMs <= 0 || config.maxConcurrentSessions <= 0 || config.leaseMs <= 0) throw new Error("backgroundSessions durations and concurrency must be positive");
+	if (config.retryBackoffMs <= 0 || config.sessionLifetimeMs <= 0 || config.maxConsecutiveFailures <= 0) throw new Error("backgroundSessions retry and lifetime limits must be positive");
+}
+function validateModuleSpecifier(moduleSpecifier) {
+	const absolutePath = moduleSpecifier.startsWith("/") || moduleSpecifier.startsWith("\\\\") || /^[a-zA-Z]:[\\/]/.test(moduleSpecifier);
+	if (moduleSpecifier.trim() === "" || absolutePath || /^[a-z][a-z+.-]*:/i.test(moduleSpecifier) || moduleSpecifier.includes("\0")) throw new Error(`invalid plugin module specifier: ${moduleSpecifier}`);
+	if ((moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../")) && moduleSpecifier.split(/[\\/]/).includes("..")) throw new Error(`plugin module escapes deployment root: ${moduleSpecifier}`);
+}
 function parseBackgroundSessions(value) {
 	exactKeys(value, [
 		"enabled",
@@ -967,14 +1138,14 @@ function parseBackgroundSessions(value) {
 	]);
 	return Object.freeze({
 		enabled: boolean(value.enabled, "manifest.backgroundSessions.enabled"),
-		required: boolean(value.required, "manifest.backgroundSessions.required"),
-		stepTimeoutMs: positiveInteger(value.stepTimeoutMs ?? 3e5, "manifest.backgroundSessions.stepTimeoutMs"),
-		maxConcurrentSessions: positiveInteger(value.maxConcurrentSessions ?? 4, "manifest.backgroundSessions.maxConcurrentSessions"),
 		leaseMs: positiveInteger(value.leaseMs ?? 3e4, "manifest.backgroundSessions.leaseMs"),
 		leaseRenewalIntervalMs: positiveInteger(value.leaseRenewalIntervalMs ?? 1e4, "manifest.backgroundSessions.leaseRenewalIntervalMs"),
 		maxConsecutiveFailures: positiveInteger(value.maxConsecutiveFailures ?? 3, "manifest.backgroundSessions.maxConsecutiveFailures"),
+		maxConcurrentSessions: positiveInteger(value.maxConcurrentSessions ?? 4, "manifest.backgroundSessions.maxConcurrentSessions"),
+		required: boolean(value.required, "manifest.backgroundSessions.required"),
 		retryBackoffMs: positiveInteger(value.retryBackoffMs ?? 3e4, "manifest.backgroundSessions.retryBackoffMs"),
-		sessionLifetimeMs: positiveInteger(value.sessionLifetimeMs ?? 864e5, "manifest.backgroundSessions.sessionLifetimeMs")
+		sessionLifetimeMs: positiveInteger(value.sessionLifetimeMs ?? 864e5, "manifest.backgroundSessions.sessionLifetimeMs"),
+		stepTimeoutMs: positiveInteger(value.stepTimeoutMs ?? 3e5, "manifest.backgroundSessions.stepTimeoutMs")
 	});
 }
 function record(value, path) {
@@ -1009,6 +1180,19 @@ function progressDisplay(value, path) {
 	if (value !== "hidden" && value !== "collapsed" && value !== "expanded") throw new Error(`${path} must be hidden, collapsed, or expanded`);
 	return value;
 }
+function runtimeToolId(value, path) {
+	const id = string(value, path);
+	if (!isRivusRuntimeToolId(id)) throw new Error(`${path} must be read, bash, edit, write, grep, find, or ls`);
+	return id;
+}
+function uniqueRuntimeTools(ids, path) {
+	const result = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		if (result.has(id)) throw new Error(`${path} contains duplicate Runtime Tool: ${id}`);
+		result.add(id);
+	}
+	return [...result];
+}
 function automationTargetType(value, path) {
 	if (value !== "chat_id" && value !== "open_id" && value !== "user_id" && value !== "union_id" && value !== "email") throw new Error(`${path} must be chat_id, open_id, user_id, union_id, or email`);
 	return value;
@@ -1020,353 +1204,708 @@ function exactKeys(value, allowed, path, optional = []) {
 	if (missing) throw new Error(`${path} is missing required field: ${missing}`);
 }
 //#endregion
-//#region src/infrastructure/plugin/node-rivus-plugin-module-loader.ts
-async function loadNodeRivusPluginModule(request) {
-	return await import(pathToFileURL(await resolveNodeRivusPluginModulePath(request)).href);
-}
-async function resolveNodeRivusPluginModulePath(request) {
-	const deploymentRoot = await realpath(request.deploymentRoot);
-	const resolvedRealpath = await realpath(createRequire(join(deploymentRoot, "package.json")).resolve(request.module));
-	if (!isWithin(deploymentRoot, resolvedRealpath)) throw new Error(`plugin module ${request.module} resolves outside deployment root: ${resolvedRealpath}`);
-	return resolvedRealpath;
+//#region src/modules/deployment-control/application/failure/deployment-failure.ts
+function formatDeploymentFailure(failure) {
+	return failure instanceof Error ? failure.message : String(failure);
 }
-function isWithin(root, candidate) {
-	const child = relative(root, candidate);
-	return child === "" || !child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child);
+function toDeploymentFailure(failure) {
+	return failure instanceof Error ? failure : new Error(String(failure));
 }
 //#endregion
-//#region src/infrastructure/config/rivus-daemon-config.ts
-var RivusDaemonConfigError = class {
-	variable;
-	message;
-	_tag = "RivusDaemonConfigError";
-	constructor(variable, message) {
-		this.variable = variable;
-		this.message = message;
-	}
+//#region src/modules/deployment-control/domain/lifecycle/deployment-lifecycle.ts
+var InvalidDeploymentLifecycleTransition = class extends Error {
+	name = "InvalidDeploymentLifecycleTransition";
 };
-const DEFAULT_AGENT_ID$1 = "main";
-const DEFAULT_FEISHU_BASE_URL$1 = "https://open.feishu.cn";
-const DEFAULT_STREAM_MIN_INTERVAL_MS$1 = 200;
-const THINKING_LEVELS$1 = /* @__PURE__ */ new Set([
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-]);
-function loadRivusDaemonConfig(env, options = {}) {
-	return Effect.gen(function* () {
-		const appId = yield* required(env, "FEISHU_APP_ID");
-		const appSecret = yield* required(env, "FEISHU_APP_SECRET");
-		const streamMinIntervalMs = yield* optionalPositiveInteger(env.FEISHU_STREAM_MIN_INTERVAL_MS, "FEISHU_STREAM_MIN_INTERVAL_MS", DEFAULT_STREAM_MIN_INTERVAL_MS$1);
-		const cardStreamLeaseMs = yield* optionalPositiveInteger(env.FEISHU_CARD_STREAM_LEASE_MS, "FEISHU_CARD_STREAM_LEASE_MS", DEFAULT_CARD_STREAM_LEASE_MS);
-		const thinkingLevel = yield* optionalThinkingLevel(env.PI_THINKING_LEVEL);
-		const apiKey = yield* optionalPiApiKey(env, options.readTextFile ?? readUtf8File);
-		const baseUrl = optional(env.PI_BASE_URL);
-		const model = optional(env.PI_MODEL);
-		return {
-			agentId: optional(env.RIVUS_AGENT_ID) ?? DEFAULT_AGENT_ID$1,
-			feishu: {
-				appId,
-				appSecret,
-				baseUrl: optional(env.FEISHU_BASE_URL) ?? DEFAULT_FEISHU_BASE_URL$1,
-				cardStreamLeaseMs,
-				streamMinIntervalMs
-			},
-			pi: {
-				...apiKey ? { apiKey } : {},
-				...baseUrl ? { baseUrl } : {},
-				...model ? { model } : {},
-				...thinkingLevel ? { thinkingLevel } : {}
-			}
-		};
-	});
-}
-function optional(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
-function readUtf8File(path) {
-	return readFile(path, "utf8");
-}
-function optionalPiApiKey(env, readTextFile) {
-	const inlineApiKey = optional(env.PI_API_KEY);
-	const apiKeyFile = optional(env.PI_API_KEY_FILE);
-	if (inlineApiKey && apiKeyFile) return Effect.fail(new RivusDaemonConfigError("PI_API_KEY", "PI_API_KEY and PI_API_KEY_FILE cannot both be set"));
-	if (inlineApiKey) return Effect.succeed(inlineApiKey);
-	if (!apiKeyFile) return Effect.succeed(void 0);
-	return Effect.tryPromise({
-		try: async () => readTextFile(apiKeyFile),
-		catch: (error) => new RivusDaemonConfigError("PI_API_KEY_FILE", `PI_API_KEY_FILE could not be read: ${formatConfigError(error)}`)
-	}).pipe(Effect.flatMap((contents) => {
-		const apiKey = optional(contents);
-		return apiKey ? Effect.succeed(apiKey) : Effect.fail(new RivusDaemonConfigError("PI_API_KEY_FILE", "PI_API_KEY_FILE must not be empty"));
-	}));
-}
-function formatConfigError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function optionalPositiveInteger(value, variable, fallback) {
-	const normalized = optional(value);
-	if (!normalized) return Effect.succeed(fallback);
-	if (/^[1-9]\d*$/.test(normalized)) return Effect.succeed(Number(normalized));
-	return Effect.fail(new RivusDaemonConfigError(variable, `${variable} must be a positive integer`));
-}
-function required(env, variable) {
-	const value = optional(env[variable]);
-	if (value) return Effect.succeed(value);
-	return Effect.fail(new RivusDaemonConfigError(variable, `${variable} is required`));
-}
-function optionalThinkingLevel(value) {
-	const normalized = optional(value);
-	if (!normalized) return Effect.succeed(void 0);
-	if (THINKING_LEVELS$1.has(normalized)) return Effect.succeed(normalized);
-	return Effect.fail(new RivusDaemonConfigError("PI_THINKING_LEVEL", "PI_THINKING_LEVEL must be one of off, minimal, low, medium, high, xhigh"));
+const componentTransitions = Object.freeze({
+	"cleanup-required": ["cleanup-required", "stopping"],
+	degraded: ["degraded", "stopping"],
+	disabled: ["disabled"],
+	running: [
+		"degraded",
+		"running",
+		"stopping"
+	],
+	starting: ["degraded", "running"],
+	stopped: ["starting", "stopped"],
+	stopping: [
+		"cleanup-required",
+		"disabled",
+		"stopped"
+	]
+});
+const controlTransitions = Object.freeze({
+	"cleanup-required": ["cleanup-required", "stopping"],
+	degraded: ["degraded", "stopping"],
+	running: [
+		"degraded",
+		"running",
+		"stopping"
+	],
+	starting: ["degraded", "running"],
+	stopped: [
+		"starting",
+		"stopped",
+		"stopping"
+	],
+	stopping: ["cleanup-required", "stopped"]
+});
+function transitionDeploymentComponentLifecycle(current, next) {
+	if (!componentTransitions[current].includes(next)) throw new InvalidDeploymentLifecycleTransition(`cannot transition deployment component from ${current} to ${next}`);
+	return next;
+}
+function transitionDeploymentControlLifecycle(current, next) {
+	if (!controlTransitions[current].includes(next)) throw new InvalidDeploymentLifecycleTransition(`cannot transition Deployment Control from ${current} to ${next}`);
+	return next;
+}
+function isRequiredDeploymentComponentReady(input) {
+	return !input.enabled || !input.required || input.lifecycle === "running" && input.running;
 }
 //#endregion
-//#region src/infrastructure/config/openclaw-env-import.ts
-var OpenClawEnvImportError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "OpenClawEnvImportError";
-	}
+//#region src/modules/deployment-control/application/lifecycle/deployment-control.ts
+var RivusDeploymentDaemonLifecycleError = class extends Error {
+	name = "RivusDeploymentDaemonLifecycleError";
 };
-const DEFAULT_AGENT_ID = "main";
-const DEFAULT_FEISHU_BASE_URL = "https://open.feishu.cn";
-const DEFAULT_LARK_BASE_URL = "https://open.larksuite.com";
-const DEFAULT_STREAM_MIN_INTERVAL_MS = 200;
-const THINKING_LEVELS = /* @__PURE__ */ new Set([
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-]);
-const ENV_FILE_ORDER = [
-	"FEISHU_APP_ID",
-	"FEISHU_APP_SECRET",
-	"FEISHU_BASE_URL",
-	"FEISHU_STREAM_MIN_INTERVAL_MS",
-	"RIVUS_AGENT_ID",
-	"PI_API_KEY_FILE",
-	"PI_BASE_URL",
-	"PI_MODEL",
-	"PI_THINKING_LEVEL"
-];
-function createRivusEnvFromOpenClawConfig(openClawConfig, options = {}) {
-	const config = asRecord(openClawConfig, "OpenClaw config");
-	const feishu = asRecord(readPath(config, ["channels", "feishu"]), "channels.feishu");
-	const appId = requiredString(feishu, "appId", "channels.feishu.appId");
-	const appSecret = requiredString(feishu, "appSecret", "channels.feishu.appSecret");
-	const modelReference = findPrimaryModelReference(config);
-	const providerId = modelReference ? parseProviderId(modelReference) : void 0;
-	const provider = providerId ? optionalRecord(readPath(config, [
-		"models",
-		"providers",
-		providerId
-	])) : void 0;
-	const providerBaseUrl = provider ? optionalString(provider.baseUrl) : void 0;
-	const thinkingLevel = modelReference ? findThinkingLevel(config, modelReference) : void 0;
-	const warnings = thinkingLevel?.warning ? [thinkingLevel.warning] : [];
-	return {
-		env: {
-			FEISHU_APP_ID: appId,
-			FEISHU_APP_SECRET: appSecret,
-			FEISHU_BASE_URL: options.feishuBaseUrl ?? inferFeishuBaseUrl(optionalString(feishu.domain)),
-			FEISHU_STREAM_MIN_INTERVAL_MS: String(options.streamMinIntervalMs ?? DEFAULT_STREAM_MIN_INTERVAL_MS),
-			RIVUS_AGENT_ID: findAgentId(config),
-			...options.piApiKeyFile ? { PI_API_KEY_FILE: options.piApiKeyFile } : {},
-			...providerBaseUrl ? { PI_BASE_URL: providerBaseUrl } : {},
-			...modelReference ? { PI_MODEL: modelReference } : {},
-			...thinkingLevel?.level ? { PI_THINKING_LEVEL: thinkingLevel.level } : {}
-		},
-		warnings
-	};
-}
-function formatRivusEnvFile(env) {
-	return `${[...ENV_FILE_ORDER.filter((key) => Object.hasOwn(env, key)), ...Object.keys(env).filter((key) => !ENV_FILE_ORDER.includes(key)).sort()].map((key) => `${key}=${quoteEnvValue(env[key] ?? "")}`).join("\n")}\n`;
-}
-function findAgentId(config) {
-	const agents = optionalRecord(config.agents);
-	return optionalString(optionalRecord((Array.isArray(agents?.list) ? agents.list : [])[0])?.id) ?? DEFAULT_AGENT_ID;
-}
-function findPrimaryModelReference(config) {
-	const primary = optionalString(readPath(config, [
-		"agents",
-		"defaults",
-		"model",
-		"primary"
-	]));
-	if (primary) return primary;
-	const providers = optionalRecord(readPath(config, ["models", "providers"]));
-	if (!providers) return;
-	for (const [providerId, provider] of Object.entries(providers)) {
-		const model = firstModelId(optionalRecord(provider));
-		if (model) return `${providerId}/${model}`;
-	}
-}
-function firstModelId(provider) {
-	return optionalString(optionalRecord((Array.isArray(provider?.models) ? provider.models : [])[0])?.id);
-}
-function parseProviderId(modelReference) {
-	const separator = modelReference.indexOf("/");
-	return separator > 0 ? modelReference.slice(0, separator) : void 0;
-}
-function findThinkingLevel(config, modelReference) {
-	const providerId = parseProviderId(modelReference);
-	const modelId = readModelId(modelReference);
-	const rawLevel = [
-		readPath(config, [
-			"agents",
-			"defaults",
-			"models",
-			modelReference,
-			"thinkingLevel"
-		]),
-		readPath(config, [
-			"agents",
-			"defaults",
-			"models",
-			modelReference,
-			"thinkLevel"
-		]),
-		readPath(config, [
-			"agents",
-			"defaults",
-			"models",
-			modelReference,
-			"reasoningLevel"
-		]),
-		...providerId && modelId ? readProviderModelThinkingCandidates(config, providerId, modelId) : []
-	].map(optionalString).find(Boolean);
-	if (!rawLevel) return;
-	if (THINKING_LEVELS.has(rawLevel)) return { level: rawLevel };
-	return { warning: `Unsupported OpenClaw thinking level '${rawLevel}' was ignored` };
+var RivusDeploymentReadinessError = class extends Error {
+	endpointIds;
+	name = "RivusDeploymentReadinessError";
+	constructor(endpointIds) {
+		super(`required endpoint startup failed: ${endpointIds.join(", ")}`);
+		this.endpointIds = endpointIds;
+	}
+};
+var RivusDeploymentAutomationReadinessError = class extends Error {
+	automationIds;
+	name = "RivusDeploymentAutomationReadinessError";
+	constructor(automationIds) {
+		super(`required automation startup failed: ${automationIds.join(", ")}`);
+		this.automationIds = automationIds;
+	}
+};
+var RivusDeploymentBackgroundSessionReadinessError = class extends Error {
+	name = "RivusDeploymentBackgroundSessionReadinessError";
+	constructor() {
+		super("required Background Session startup failed");
+	}
+};
+function createRivusDeploymentControl(input) {
+	return Effect.gen(function* () {
+		const deployment = input.deployment;
+		if ((deployment.manifest.projectSpaces?.length ?? 0) > 0 && !input.projectSpaceResolver) return yield* Effect.fail(new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide a Project Space resolver"));
+		const projectSpaces = /* @__PURE__ */ new Map();
+		for (const declaration of deployment.manifest.projectSpaces ?? []) {
+			const resolved = yield* input.projectSpaceResolver.resolve({
+				declaration,
+				deploymentRoot: input.deploymentRoot
+			}).pipe(Effect.mapError(toDeploymentFailure));
+			projectSpaces.set(resolved.id, resolved);
+		}
+		const definitions = yield* Effect.try({
+			try: () => new Map(deployment.definitions.map((definition) => {
+				const resolved = bindResolvedProjectSpaceRevision(definition, projectSpaces);
+				return [resolved.agentId, resolved];
+			})),
+			catch: toDeploymentFailure
+		});
+		const automationDefinitions = yield* Effect.try({
+			try: () => new Map(deployment.automationDefinitions.map((definition) => [definition.id, Object.freeze({
+				...definition,
+				runtimeDefinition: bindResolvedProjectSpaceRevision(definition.runtimeDefinition, projectSpaces)
+			})])),
+			catch: toDeploymentFailure
+		});
+		const effectiveDeployment = Object.freeze({
+			...deployment,
+			agents: Object.freeze(deployment.agents.map((agent) => {
+				if (!agent.definition) return agent;
+				const definition = definitions.get(agent.agentId);
+				return definition ? Object.freeze({
+					...agent,
+					definition
+				}) : agent;
+			})),
+			automationDefinitions: Object.freeze([...automationDefinitions.values()]),
+			definitions: Object.freeze([...definitions.values()])
+		});
+		const backgroundConfig = deployment.manifest.backgroundSessions;
+		const backgroundDefinitions = /* @__PURE__ */ new Map();
+		if (backgroundConfig?.enabled) for (const agent of effectiveDeployment.agents) {
+			if (agent.status !== "enabled" || !agent.definition) continue;
+			const narrowed = yield* Effect.try({
+				try: () => narrowBackgroundSessionDefinition(definitions.get(agent.agentId)),
+				catch: toDeploymentFailure
+			});
+			backgroundDefinitions.set(agent.agentId, narrowed);
+		}
+		const agentStatuses = new Map(effectiveDeployment.agents.map((agent) => [agent.agentId, agent]));
+		const endpointSlots = deployment.manifest.endpoints.map((definition) => {
+			return createSlot(definition, agentStatuses.get(definition.agentId)?.status === "enabled");
+		});
+		const automationSlots = (deployment.manifest.automations ?? []).map((definition) => {
+			const agentEnabled = agentStatuses.get(definition.agentId)?.status === "enabled";
+			const resolvedDefinition = automationDefinitions.get(definition.id);
+			return {
+				...createSlot(definition, agentEnabled && resolvedDefinition !== void 0),
+				agentEnabled,
+				...resolvedDefinition ? { resolvedDefinition } : {}
+			};
+		});
+		const backgroundSessionSlot = backgroundConfig ? createSlot(backgroundConfig, backgroundDefinitions.size > 0) : void 0;
+		const host = yield* input.agentHostFactory.create({
+			automations: automationSlots.filter((slot) => slot.definition.enabled && slot.agentEnabled && slot.resolvedDefinition !== void 0).map((slot) => ({
+				definition: slot.resolvedDefinition.runtimeDefinition,
+				id: slot.definition.id
+			})),
+			backgroundSessions: [...backgroundDefinitions].map(([agentId, definition]) => ({
+				agentId,
+				definition
+			})),
+			definitions: [...definitions.values()],
+			endpoints: endpointSlots.filter((slot) => slot.definition.enabled && slot.agentEnabled).map((slot) => ({
+				agentId: slot.definition.agentId,
+				id: slot.definition.id
+			})),
+			...input.initialInstanceRecords ? { initialInstanceRecords: input.initialInstanceRecords } : {},
+			runtimeFactory: { create: (instance) => {
+				const definition = instance.binding.kind === "automation" ? automationDefinitions.get(instance.binding.automationId)?.runtimeDefinition : instance.binding.kind === "background-session" ? backgroundDefinitions.get(instance.agentId) : definitions.get(instance.agentId);
+				if (!definition) return Effect.fail(new RivusDeploymentDaemonLifecycleError(`runtime instance references unknown agent: ${instance.agentId}`));
+				const projectSpace = definition.projectSpaceId ? projectSpaces.get(definition.projectSpaceId) : void 0;
+				return input.runtimeFactory.create({
+					...instance,
+					catalog: effectiveDeployment.catalog,
+					definition,
+					...projectSpace ? { projectSpace } : {}
+				});
+			} }
+		}).pipe(Effect.mapError(toDeploymentFailure));
+		return makeDeploymentControl({
+			...input.automationFactory ? { automationFactory: input.automationFactory } : {},
+			automationSlots,
+			...input.backgroundSessionFactory ? { backgroundSessionFactory: input.backgroundSessionFactory } : {},
+			...backgroundSessionSlot ? { backgroundSessionSlot } : {},
+			definitions,
+			deployment: effectiveDeployment,
+			endpointFactory: input.endpointFactory,
+			endpointSlots,
+			host
+		});
+	});
 }
-function readProviderModelThinkingCandidates(config, providerId, modelId) {
-	const providerModels = readPath(config, [
-		"models",
-		"providers",
-		providerId,
-		"models"
-	]);
-	if (!Array.isArray(providerModels)) return [];
-	const model = providerModels.map(optionalRecord).find((candidate) => optionalString(candidate?.id) === modelId);
-	if (!model) return [];
-	return [
-		model.thinkingLevel,
-		model.thinkLevel,
-		model.reasoningLevel,
-		readPath(model, ["reasoning", "level"]),
-		readPath(model, ["reasoning", "thinkingLevel"]),
-		readPath(model, ["reasoning", "thinkLevel"])
+function makeDeploymentControl(input) {
+	const endpointById = new Map(input.endpointSlots.map((slot) => [slot.definition.id, slot]));
+	const allSlots = [
+		...input.endpointSlots,
+		...input.automationSlots,
+		...input.backgroundSessionSlot ? [input.backgroundSessionSlot] : []
 	];
+	let lifecycle = "stopped";
+	const refreshObservedState = () => {
+		let degraded = false;
+		for (const slot of allSlots) {
+			if (slot.lifecycle !== "running") continue;
+			const observed = observeRunning(slot);
+			if (!observed.running) {
+				slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, "degraded");
+				slot.error = observed.error ?? "component stopped running after startup";
+				degraded = true;
+			}
+		}
+		if (degraded && lifecycle === "running") lifecycle = transitionDeploymentControlLifecycle(lifecycle, "degraded");
+	};
+	const canRunIntake = () => {
+		refreshObservedState();
+		return lifecycle === "running" || lifecycle === "degraded";
+	};
+	const handleEndpoint = (endpointId, request) => Effect.suspend(() => {
+		const slot = endpointById.get(endpointId);
+		if (!slot) return Effect.fail(new RivusDeploymentDaemonLifecycleError(`unknown endpoint: ${endpointId}`));
+		const observed = observeRunning(slot);
+		if (!canRunIntake() || slot.lifecycle !== "running" || !observed.running) return Effect.fail(new RivusDeploymentDaemonLifecycleError(`endpoint ${endpointId} cannot accept intake while Deployment Control is ${lifecycle} and endpoint is ${slot.lifecycle}`));
+		return input.host.handleEndpoint(endpointId, request);
+	});
+	const isReady = () => allSlots.every((slot) => isSlotReady(slot));
+	const readinessFailure = () => {
+		const endpointIds = input.endpointSlots.filter((slot) => slot.definition.enabled && slot.definition.required && !isSlotReady(slot)).map((slot) => slot.definition.id);
+		if (endpointIds.length > 0) return new RivusDeploymentReadinessError(Object.freeze(endpointIds));
+		const automationIds = input.automationSlots.filter((slot) => slot.definition.enabled && slot.definition.required && !isSlotReady(slot)).map((slot) => slot.definition.id);
+		if (automationIds.length > 0) return new RivusDeploymentAutomationReadinessError(Object.freeze(automationIds));
+		if (input.backgroundSessionSlot?.definition.enabled && input.backgroundSessionSlot.definition.required && !isSlotReady(input.backgroundSessionSlot)) return new RivusDeploymentBackgroundSessionReadinessError();
+	};
+	const status = () => {
+		refreshObservedState();
+		return Object.freeze({
+			agents: input.deployment.agents,
+			automations: Object.freeze(input.automationSlots.map((slot) => ({
+				...componentStatus(slot),
+				agentId: slot.definition.agentId,
+				automationId: slot.definition.id
+			}))),
+			...input.backgroundSessionSlot ? { backgroundSessions: backgroundStatus(input.backgroundSessionSlot) } : {},
+			defaultAgentId: input.deployment.manifest.defaultAgentId,
+			defaultEndpointId: input.deployment.manifest.defaultEndpointId,
+			endpoints: Object.freeze(input.endpointSlots.map((slot) => ({
+				...componentStatus(slot),
+				agentId: slot.definition.agentId,
+				endpointId: slot.definition.id
+			}))),
+			lifecycle,
+			plugins: input.deployment.plugins,
+			ready: isReady(),
+			running: lifecycle === "running" || lifecycle === "degraded"
+		});
+	};
+	return {
+		deployment: input.deployment,
+		handleDefault: (request) => handleEndpoint(input.deployment.manifest.defaultEndpointId, request),
+		handleEndpoint,
+		runDefaultAgent: (request) => input.host.handleEndpoint(input.deployment.manifest.defaultEndpointId, request),
+		running: canRunIntake,
+		start: () => Effect.suspend(() => {
+			refreshObservedState();
+			if (lifecycle === "running") return Effect.void;
+			if (lifecycle === "degraded") {
+				const failure = readinessFailure();
+				return failure ? Effect.fail(failure) : Effect.void;
+			}
+			if (lifecycle !== "stopped") return Effect.fail(new RivusDeploymentDaemonLifecycleError(`cannot start deployment daemon while ${lifecycle}`));
+			lifecycle = transitionDeploymentControlLifecycle(lifecycle, "starting");
+			return Effect.gen(function* () {
+				let degraded = input.deployment.plugins.some(({ status: pluginStatus }) => pluginStatus === "failed");
+				for (const slot of input.endpointSlots) degraded = (yield* startSlot(slot, slot.agentEnabled, `endpoint ${slot.definition.id}`, () => Effect.gen(function* () {
+					const instance = yield* input.host.resolveEndpoint(slot.definition.id);
+					return yield* input.endpointFactory.create({
+						agentId: slot.definition.agentId,
+						cancel: (request) => input.host.cancelEndpoint(slot.definition.id, request),
+						definition: slot.definition,
+						endpointId: slot.definition.id,
+						handle: (request) => handleEndpoint(slot.definition.id, request),
+						instanceId: instance.instanceId,
+						...input.definitions.get(slot.definition.agentId)?.projectSpaceId ? { projectSpaceId: input.definitions.get(slot.definition.agentId).projectSpaceId } : {},
+						steer: (request) => input.host.steerEndpoint(slot.definition.id, request)
+					});
+				}))) || degraded;
+				for (const slot of input.automationSlots) {
+					const resolvedDefinition = slot.resolvedDefinition;
+					const deliverySlot = endpointById.get(slot.definition.delivery.endpointId);
+					const deliveryRunning = observeRunning(deliverySlot).running && deliverySlot.lifecycle === "running";
+					degraded = (yield* startSlot(slot, slot.agentEnabled && resolvedDefinition !== void 0 && deliveryRunning, `automation ${slot.definition.id}`, () => Effect.gen(function* () {
+						if (!input.automationFactory) return yield* Effect.fail(new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide Automation adapters"));
+						if (!resolvedDefinition) return yield* Effect.fail(new RivusDeploymentDaemonLifecycleError(`automation definition not resolved: ${slot.definition.id}`));
+						const instance = yield* input.host.resolveAutomation(slot.definition.id);
+						return yield* input.automationFactory.create({
+							automationId: slot.definition.id,
+							definition: resolvedDefinition,
+							deliveryEndpoint: deliverySlot.definition,
+							instanceId: instance.instanceId,
+							run: (request) => input.host.handleAutomation(slot.definition.id, {
+								invocation: {
+									allowedActorOpenIds: [],
+									automationId: slot.definition.id,
+									endpointId: slot.definition.delivery.endpointId,
+									kind: "automation",
+									sourceMessageId: request.tickId,
+									tenantKey: "automation",
+									tickId: request.tickId
+								},
+								sessionKey: request.sessionKey,
+								text: request.text
+							})
+						});
+					}))) || degraded;
+				}
+				if (input.backgroundSessionSlot) {
+					const slot = input.backgroundSessionSlot;
+					degraded = (yield* startSlot(slot, slot.agentEnabled, "Background Session", () => Effect.gen(function* () {
+						if (!input.backgroundSessionFactory) return yield* Effect.fail(new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide Background Session adapters"));
+						return yield* input.backgroundSessionFactory.create({
+							agentIds: [...input.definitions.keys()].filter((agentId) => input.deployment.agents.some((agent) => agent.agentId === agentId && agent.status === "enabled")),
+							cancel: (request) => input.host.cancelBackgroundSession(request.agentId, request),
+							config: slot.definition,
+							run: (request) => input.host.handleBackgroundSession(request.agentId, {
+								...request.invocation ? { invocation: request.invocation } : {},
+								...request.onUpdate ? { onUpdate: request.onUpdate } : {},
+								sessionKey: request.sessionKey,
+								text: request.text
+							})
+						});
+					}))) || degraded;
+				}
+				lifecycle = transitionDeploymentControlLifecycle(lifecycle, degraded ? "degraded" : "running");
+				const failure = readinessFailure();
+				if (failure) return yield* Effect.fail(failure);
+			});
+		}),
+		status,
+		stop: () => Effect.suspend(() => {
+			if (lifecycle !== "stopped" && lifecycle !== "running" && lifecycle !== "degraded" && lifecycle !== "cleanup-required") return Effect.fail(new RivusDeploymentDaemonLifecycleError(`cannot stop deployment daemon while ${lifecycle}`));
+			lifecycle = transitionDeploymentControlLifecycle(lifecycle, "stopping");
+			return Effect.gen(function* () {
+				const errors = [];
+				yield* stopSlots(input.automationSlots, errors);
+				if (input.backgroundSessionSlot) yield* stopSlots([input.backgroundSessionSlot], errors);
+				yield* stopSlots(input.endpointSlots, errors);
+				const hostExit = yield* Effect.exit(input.host.dispose());
+				if (Exit.isFailure(hostExit)) errors.push(Cause.squash(hostExit.cause));
+				lifecycle = transitionDeploymentControlLifecycle(lifecycle, errors.length === 0 ? "stopped" : "cleanup-required");
+				if (errors.length === 1) return yield* Effect.fail(errors[0]);
+				if (errors.length > 1) return yield* Effect.fail(new AggregateError(errors, "deployment daemon cleanup failed"));
+			});
+		})
+	};
 }
-function readModelId(modelReference) {
-	const separator = modelReference.indexOf("/");
-	return separator >= 0 && separator < modelReference.length - 1 ? modelReference.slice(separator + 1) : void 0;
-}
-function inferFeishuBaseUrl(domain) {
-	return domain === "lark" ? DEFAULT_LARK_BASE_URL : DEFAULT_FEISHU_BASE_URL;
+function createSlot(definition, agentEnabled) {
+	return {
+		agentEnabled,
+		definition,
+		...!definition.enabled ? { lifecycle: "disabled" } : agentEnabled ? { lifecycle: "stopped" } : {
+			error: "component is unavailable",
+			lifecycle: "degraded"
+		}
+	};
 }
-function quoteEnvValue(value) {
-	return `'${value.replaceAll("'", "'\\''")}'`;
+function startSlot(slot, available, label, create) {
+	return Effect.gen(function* () {
+		if (!slot.definition.enabled) {
+			slot.lifecycle = "disabled";
+			return false;
+		}
+		if (!available) {
+			slot.lifecycle = "degraded";
+			slot.error = `${label} is unavailable`;
+			return true;
+		}
+		if (slot.lifecycle !== "stopped") return yield* Effect.fail(new RivusDeploymentDaemonLifecycleError(`cannot start ${label} while ${slot.lifecycle}`));
+		slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, "starting");
+		delete slot.error;
+		const started = yield* Effect.gen(function* () {
+			slot.adapter ??= yield* create();
+			yield* slot.adapter.start();
+			if (!(yield* Effect.try({
+				try: () => slot.adapter.running(),
+				catch: toDeploymentFailure
+			}))) return yield* Effect.fail(/* @__PURE__ */ new Error(`${label} start completed but the adapter is not running`));
+		}).pipe(Effect.exit);
+		if (Exit.isFailure(started)) {
+			slot.error = formatDeploymentFailure(Cause.squash(started.cause));
+			slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, "degraded");
+			return true;
+		}
+		slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, "running");
+		return false;
+	});
 }
-function requiredString(record, key, path) {
-	const value = optionalString(record[key]);
-	if (!value) throw new OpenClawEnvImportError(`${path} is required`);
-	return value;
+function stopSlots(slots, errors) {
+	return Effect.gen(function* () {
+		for (const slot of [...slots].reverse()) {
+			if (slot.lifecycle === "stopped" || slot.lifecycle === "disabled") continue;
+			slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, "stopping");
+			if (!slot.adapter) {
+				slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, slot.definition.enabled && slot.agentEnabled ? "stopped" : "disabled");
+				delete slot.error;
+				continue;
+			}
+			const stopped = yield* Effect.gen(function* () {
+				yield* slot.adapter.stop();
+				if (yield* Effect.try({
+					try: () => slot.adapter.running(),
+					catch: toDeploymentFailure
+				})) return yield* Effect.fail(/* @__PURE__ */ new Error("component stop completed but the adapter is still running"));
+			}).pipe(Effect.exit);
+			if (Exit.isFailure(stopped)) {
+				const error = Cause.squash(stopped.cause);
+				errors.push(error);
+				slot.error = formatDeploymentFailure(error);
+				slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, "cleanup-required");
+				continue;
+			}
+			slot.lifecycle = transitionDeploymentComponentLifecycle(slot.lifecycle, slot.definition.enabled && slot.agentEnabled ? "stopped" : "disabled");
+			delete slot.error;
+		}
+	});
 }
-function optionalString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+function componentStatus(slot) {
+	const observed = observeRunning(slot);
+	return Object.freeze({
+		enabled: slot.definition.enabled,
+		...slot.error ? { error: slot.error } : {},
+		lifecycle: slot.lifecycle,
+		required: slot.definition.required,
+		running: slot.lifecycle === "running" && observed.running
+	});
 }
-function asRecord(value, path) {
-	const record = optionalRecord(value);
-	if (!record) throw new OpenClawEnvImportError(`${path} must be an object`);
-	return record;
+function backgroundStatus(slot) {
+	let supervisor;
+	try {
+		supervisor = slot.adapter?.status?.();
+	} catch (error) {
+		slot.error = formatDeploymentFailure(error);
+	}
+	return Object.freeze({
+		...componentStatus(slot),
+		...supervisor ? { supervisor } : {}
+	});
 }
-function optionalRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+function isSlotReady(slot) {
+	return isRequiredDeploymentComponentReady({
+		enabled: slot.definition.enabled,
+		lifecycle: slot.lifecycle,
+		required: slot.definition.required,
+		running: observeRunning(slot).running
+	});
 }
-function readPath(record, path) {
-	let value = record;
-	for (const segment of path) {
-		const current = optionalRecord(value);
-		if (!current) return;
-		value = current[segment];
+function observeRunning(slot) {
+	if (!slot.adapter) return { running: false };
+	try {
+		return { running: slot.adapter.running() };
+	} catch (error) {
+		return {
+			error: formatDeploymentFailure(error),
+			running: false
+		};
 	}
-	return value;
+}
+function bindResolvedProjectSpaceRevision(definition, projectSpaces) {
+	if (!definition.projectSpaceId) return definition;
+	const projectSpace = projectSpaces.get(definition.projectSpaceId);
+	if (!projectSpace) throw new RivusDeploymentDaemonLifecycleError(`agent ${definition.agentId} references unresolved Project Space: ${definition.projectSpaceId}`);
+	return Object.freeze({
+		...definition,
+		projectSpaceRevision: projectSpace.revision
+	});
 }
 //#endregion
-//#region src/application/daemon/rivus-daemon-shutdown-controller.ts
-const DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
-function createRivusDaemonShutdownController(options) {
-	let shutdown;
-	const handle = (signal) => {
-		shutdown ??= Effect.runPromise(options.daemon.stop()).then(() => options.onStopped?.(signal)).catch(async (error) => {
-			await options.onError?.(error, signal);
-			throw error;
+//#region src/modules/deployment-control/application/resolution/automation-runtime-definition.ts
+function resolveRivusAutomationRuntimeDefinition(definition, requestedToolIds, requestedSkillIds) {
+	return restrictRivusAgentDefinitionGrants(definition, {
+		memory: {
+			scopes: [],
+			tool: false
+		},
+		runtimeToolIds: [],
+		skillIds: requestedSkillIds,
+		toolIds: requestedToolIds
+	});
+}
+//#endregion
+//#region src/modules/deployment-control/application/resolution/deployment-resolution.ts
+var RivusPluginLoadError = class extends Error {
+	pluginId;
+	moduleSpecifier;
+	name = "RivusPluginLoadError";
+	constructor(pluginId, moduleSpecifier, message, options) {
+		super(message, options);
+		this.pluginId = pluginId;
+		this.moduleSpecifier = moduleSpecifier;
+	}
+};
+function resolveRivusDeployment(input) {
+	return Effect.gen(function* () {
+		yield* Effect.try({
+			try: () => validateRivusDeploymentManifest(input.manifest),
+			catch: toDeploymentFailure
 		});
-		return shutdown;
-	};
-	return {
-		handle,
-		install: () => {
-			for (const signal of options.signals ?? DEFAULT_SIGNALS) options.signalSource.on(signal, () => {
-				handle(signal);
+		const catalog = input.agentCatalog.createPluginCatalog();
+		const pluginStatuses = [];
+		const statusByPlugin = /* @__PURE__ */ new Map();
+		for (const declaration of input.manifest.plugins) {
+			const loaded = yield* input.pluginLoader.load({
+				deploymentRoot: input.deploymentRoot,
+				module: declaration.module,
+				pluginId: declaration.id
+			}).pipe(Effect.flatMap((plugin) => Effect.try({
+				try: () => {
+					if (plugin.manifest.id !== declaration.id) throw new Error(`plugin manifest id ${plugin.manifest.id} does not match declaration ${declaration.id}`);
+					catalog.registerPlugin(plugin);
+					return plugin;
+				},
+				catch: toDeploymentFailure
+			})), Effect.either);
+			if (Either.isLeft(loaded)) {
+				const message = formatDeploymentFailure(loaded.left);
+				if (declaration.required) return yield* Effect.fail(new RivusPluginLoadError(declaration.id, declaration.module, `required plugin ${declaration.id} failed to load: ${message}`, { cause: loaded.left }));
+				const status = Object.freeze({
+					error: message,
+					id: declaration.id,
+					module: declaration.module,
+					required: false,
+					status: "failed"
+				});
+				pluginStatuses.push(status);
+				statusByPlugin.set(declaration.id, status);
+				continue;
+			}
+			const status = Object.freeze({
+				id: declaration.id,
+				module: declaration.module,
+				required: declaration.required,
+				status: "loaded",
+				version: loaded.right.manifest.version
 			});
-		},
-		stopping: () => shutdown !== void 0
-	};
+			pluginStatuses.push(status);
+			statusByPlugin.set(declaration.id, status);
+		}
+		const agentStatuses = [];
+		const definitions = [];
+		for (const agent of input.manifest.agents) {
+			const pluginStatus = statusByPlugin.get(agent.pluginId);
+			if (pluginStatus.status === "failed") {
+				agentStatuses.push(Object.freeze({
+					agentId: agent.agentId,
+					pluginId: agent.pluginId,
+					profileId: agent.profileId,
+					reason: `plugin ${agent.pluginId} is unavailable: ${pluginStatus.error}`,
+					status: "disabled"
+				}));
+				continue;
+			}
+			const resolved = yield* Effect.try({
+				try: () => {
+					const baseDefinition = input.agentCatalog.resolve(catalog, agent);
+					const projectSpace = agent.projectSpaceId ? input.manifest.projectSpaces?.find(({ id }) => id === agent.projectSpaceId) : void 0;
+					return projectSpace ? deepFreeze({
+						...baseDefinition,
+						projectSpaceRevision: createRivusProjectSpaceDeclarationRevision(projectSpace)
+					}) : baseDefinition;
+				},
+				catch: toDeploymentFailure
+			}).pipe(Effect.either);
+			if (Either.isLeft(resolved)) {
+				const declaration = input.manifest.plugins.find(({ id }) => id === agent.pluginId);
+				if (declaration.required) return yield* Effect.fail(new RivusPluginLoadError(declaration.id, declaration.module, `deployment ${agent.agentId} failed to resolve: ${resolved.left.message}`, { cause: resolved.left }));
+				agentStatuses.push(Object.freeze({
+					agentId: agent.agentId,
+					pluginId: agent.pluginId,
+					profileId: agent.profileId,
+					reason: resolved.left.message,
+					status: "disabled"
+				}));
+				continue;
+			}
+			definitions.push(resolved.right);
+			agentStatuses.push(Object.freeze({
+				agentId: agent.agentId,
+				definition: resolved.right,
+				pluginId: agent.pluginId,
+				profileId: agent.profileId,
+				status: "enabled"
+			}));
+		}
+		const agentStatusById = new Map(agentStatuses.map((agent) => [agent.agentId, agent]));
+		const automationTemplates = new Map(catalog.snapshot().automations.map((template) => [template.id, template]));
+		const automationDefinitions = [];
+		for (const automation of input.manifest.automations ?? []) {
+			const agent = agentStatusById.get(automation.agentId);
+			if (!agent || agent.status === "disabled" || !agent.definition) continue;
+			const deliveryEndpoint = input.manifest.endpoints.find(({ id }) => id === automation.delivery.endpointId);
+			const presentationAgent = agentStatusById.get(deliveryEndpoint.agentId);
+			if (!presentationAgent || presentationAgent.status === "disabled" || !presentationAgent.definition) continue;
+			const template = automationTemplates.get(automation.templateId);
+			if (!template) return yield* Effect.fail(/* @__PURE__ */ new Error(`automation ${automation.id} references unknown template: ${automation.templateId}`));
+			if (template.pluginId !== agent.pluginId || template.profileId !== agent.profileId) return yield* Effect.fail(/* @__PURE__ */ new Error(`automation ${automation.id} template is not owned by agent profile ${agent.profileId}`));
+			const definition = yield* Effect.try({
+				try: () => deepFreeze({
+					...automation,
+					runtimeDefinition: resolveRivusAutomationRuntimeDefinition(agent.definition, template.requestedToolIds, template.requestedSkillIds),
+					template
+				}),
+				catch: toDeploymentFailure
+			});
+			automationDefinitions.push(definition);
+		}
+		return Object.freeze({
+			agents: Object.freeze(agentStatuses),
+			automationDefinitions: Object.freeze(automationDefinitions),
+			catalog,
+			definitions: Object.freeze(definitions),
+			manifest: input.manifest,
+			plugins: Object.freeze(pluginStatuses)
+		});
+	});
 }
 //#endregion
-//#region src/application/support/stable-id.ts
-function createStableId(prefix, value) {
-	return `${prefix}:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+//#region src/adapters/deployment/manifest/node-rivus-deployment-manifest.ts
+var RivusDeploymentManifestError = class extends Error {
+	manifestPath;
+	name = "RivusDeploymentManifestError";
+	constructor(manifestPath, message, options) {
+		super(message, options);
+		this.manifestPath = manifestPath;
+	}
+};
+function loadRivusDeploymentManifest(manifestPath, options = {}) {
+	const maxBytes = options.maxBytes ?? 1024 * 1024;
+	return Effect.tryPromise({
+		try: async () => {
+			const metadata = await stat(manifestPath);
+			if (!metadata.isFile()) throw new Error("deployment manifest must be a regular file");
+			if (metadata.size > maxBytes) throw new Error(`deployment manifest exceeds ${maxBytes} byte limit`);
+			const bytes = await readFile(manifestPath);
+			const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+			return parseRivusDeploymentManifest(JSON.parse(text));
+		},
+		catch: (cause) => cause instanceof RivusDeploymentManifestError ? cause : new RivusDeploymentManifestError(manifestPath, `failed to load Rivus deployment manifest: ${cause instanceof Error ? cause.message : String(cause)}`, { cause })
+	});
 }
 //#endregion
-//#region src/application/host/agent-instance-registry.ts
+//#region src/modules/agent-host/domain/instance/agent-instance.ts
 var AgentInstanceConflict = class extends Error {
 	name = "AgentInstanceConflict";
 };
-function createAgentInstanceRegistry(options = {}) {
+function agentInstanceBindingKey(binding, agentId) {
+	const bindingId = binding.kind === "endpoint" ? binding.endpointId : binding.kind === "automation" ? binding.automationId : binding.agentId;
+	return `${binding.kind}:${bindingId}:${agentId}`;
+}
+function createAgentInstanceRecord(input) {
+	return Object.freeze({
+		agentId: input.agentId,
+		binding: Object.freeze({ ...input.binding }),
+		bindingKey: agentInstanceBindingKey(input.binding, input.agentId),
+		instanceId: input.instanceId,
+		runtimeGenerationId: input.runtimeGenerationId
+	});
+}
+//#endregion
+//#region src/modules/agent-host/application/registry/agent-instance-registry.ts
+function createEffectAgentInstanceRegistry(identity, options = {}) {
 	const records = /* @__PURE__ */ new Map();
 	for (const record of options.initialRecords ?? []) {
+		if (agentInstanceBindingKey(record.binding, record.agentId) !== record.bindingKey) throw new AgentInstanceConflict(`invalid binding key: ${record.bindingKey}`);
 		if (records.has(record.bindingKey)) throw new AgentInstanceConflict(`duplicate binding: ${record.bindingKey}`);
-		records.set(record.bindingKey, Object.freeze({ ...record }));
+		records.set(record.bindingKey, Object.freeze({
+			...record,
+			binding: Object.freeze({ ...record.binding })
+		}));
 	}
-	const resolveBinding = (binding, definition) => {
-		const runtimeGenerationId = createStableId("generation", {
-			agentId: definition.agentId,
-			profileRevision: definition.profileRevision,
-			projectSpaceId: definition.projectSpaceId ?? null,
-			projectSpaceRevision: definition.projectSpaceRevision ?? null,
-			skillGrantRevision: definition.skillGrantSet.revision,
-			toolGrantRevision: definition.toolGrantSet.revision
-		});
-		const bindingId = binding.kind === "endpoint" ? binding.endpointId : binding.kind === "automation" ? binding.automationId : binding.agentId;
-		const bindingKey = `${binding.kind}:${bindingId}:${definition.agentId}`;
-		const existing = records.get(bindingKey);
-		if (existing) {
-			if (existing.runtimeGenerationId !== runtimeGenerationId) throw new AgentInstanceConflict(`binding ${bindingKey} belongs to a different runtime generation`);
-			return existing;
-		}
-		const record = Object.freeze({
-			agentId: definition.agentId,
-			binding: Object.freeze({ ...binding }),
-			bindingKey,
-			instanceId: createStableId("instance", {
-				bindingKey,
+	const resolveBinding = (binding, definition) => Effect.try({
+		try: () => {
+			const runtimeGenerationId = identity.createRuntimeGenerationId({
+				agentId: definition.agentId,
+				profileRevision: definition.profileRevision,
+				projectSpaceId: definition.projectSpaceId ?? null,
+				projectSpaceRevision: definition.projectSpaceRevision ?? null,
+				runtimeToolGrantRevision: definition.runtimeToolGrantSet.revision,
+				skillGrantRevision: definition.skillGrantSet.revision,
+				toolGrantRevision: definition.toolGrantSet.revision
+			});
+			const bindingKey = agentInstanceBindingKey(binding, definition.agentId);
+			const existing = records.get(bindingKey);
+			if (existing) {
+				if (existing.runtimeGenerationId !== runtimeGenerationId) throw new AgentInstanceConflict(`binding ${bindingKey} belongs to a different runtime generation`);
+				return existing;
+			}
+			const record = createAgentInstanceRecord({
+				agentId: definition.agentId,
+				binding,
+				instanceId: identity.createInstanceId({
+					bindingKey,
+					runtimeGenerationId
+				}),
 				runtimeGenerationId
-			}),
-			runtimeGenerationId
-		});
-		records.set(bindingKey, record);
-		return record;
-	};
+			});
+			records.set(bindingKey, record);
+			return record;
+		},
+		catch: (error) => error instanceof AgentInstanceConflict ? error : new AgentInstanceConflict(String(error))
+	});
 	return {
 		resolveAutomation: (automationId, definition) => resolveBinding({
 			automationId,
@@ -1380,425 +1919,529 @@ function createAgentInstanceRegistry(options = {}) {
 			endpointId,
 			kind: "endpoint"
 		}, definition),
-		snapshot: () => Object.freeze([...records.values()])
+		snapshot: () => Effect.sync(() => Object.freeze([...records.values()]))
 	};
 }
 //#endregion
-//#region src/application/host/agent-runtime-pool.ts
-var AgentInstanceBusy = class extends Error {
-	name = "AgentInstanceBusy";
+//#region src/modules/agent-host/application/routing/agent-host.ts
+var InvalidAgentHostBinding = class extends Error {
+	name = "InvalidAgentHostBinding";
 };
-var AgentRuntimeDisposed = class extends Error {
-	name = "AgentRuntimeDisposed";
-};
-const DEFAULT_RUNTIME_DISPOSE_TIMEOUT_MS = 1e4;
-function createAgentRuntimePool(options) {
-	const runtimes = /* @__PURE__ */ new Map();
-	const active = /* @__PURE__ */ new Map();
-	const resolveRuntime = (instance) => {
-		const current = runtimes.get(instance.instanceId);
-		if (current) return current;
-		let created;
-		created = Promise.resolve(options.createRuntime(instance)).catch((error) => {
-			if (runtimes.get(instance.instanceId) === created) runtimes.delete(instance.instanceId);
-			throw error;
-		});
-		runtimes.set(instance.instanceId, created);
-		return created;
-	};
-	return {
-		registry: options.registry,
-		cancel: async (instance, input) => {
-			const runtime = runtimes.get(instance.instanceId);
-			return runtime ? (await runtime).cancel?.(input) ?? false : false;
-		},
-		steer: async (instance, input) => {
-			const runtime = runtimes.get(instance.instanceId);
-			return runtime ? (await runtime).steer?.(input) ?? false : false;
-		},
-		disposeAll: async () => {
-			const pendingRuntimes = [...runtimes.values()];
-			runtimes.clear();
-			active.clear();
-			await withTimeout(Promise.all(pendingRuntimes.map(async (runtime) => {
-				await (await runtime).dispose?.();
-			})), options.disposeTimeoutMs ?? DEFAULT_RUNTIME_DISPOSE_TIMEOUT_MS, "Agent runtime disposal timed out");
-		},
-		run: async (instance, input) => {
-			const pendingRuntime = resolveRuntime(instance);
-			const runtime = await pendingRuntime;
-			if (runtimes.get(instance.instanceId) !== pendingRuntime) throw new AgentRuntimeDisposed(`agent runtime was disposed before run start: ${instance.instanceId}`);
-			if (runtime.concurrency === "managed") return runtime.run(input);
-			if (active.has(instance.instanceId)) throw new AgentInstanceBusy(`agent instance already has an active run: ${instance.instanceId}`);
-			const activeToken = Symbol(instance.instanceId);
-			active.set(instance.instanceId, activeToken);
-			try {
-				return await runtime.run(input);
-			} finally {
-				if (active.get(instance.instanceId) === activeToken) active.delete(instance.instanceId);
-			}
-		}
-	};
-}
-async function withTimeout(promise, timeoutMs, message) {
-	let timeout;
-	try {
-		return await Promise.race([promise, new Promise((_resolve, reject) => {
-			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`${message} after ${timeoutMs}ms`)), timeoutMs);
-		})]);
-	} finally {
-		if (timeout) clearTimeout(timeout);
-	}
+function createEffectAgentHost(options) {
+	return Effect.gen(function* () {
+		const definitions = new Map(options.definitions.map((definition) => [definition.agentId, definition]));
+		const endpoints = /* @__PURE__ */ new Map();
+		const automations = /* @__PURE__ */ new Map();
+		const backgroundSessions = /* @__PURE__ */ new Map();
+		for (const endpoint of options.endpoints) {
+			if (endpoints.has(endpoint.id)) return yield* Effect.fail(new InvalidAgentHostBinding(`duplicate endpoint: ${endpoint.id}`));
+			const definition = definitions.get(endpoint.agentId);
+			if (!definition) return yield* Effect.fail(new InvalidAgentHostBinding(`unknown endpoint agent: ${endpoint.agentId}`));
+			if (!definition.endpointIds.includes(endpoint.id)) return yield* Effect.fail(new InvalidAgentHostBinding(`endpoint ${endpoint.id} is not declared by ${endpoint.agentId}`));
+			endpoints.set(endpoint.id, yield* options.registry.resolveEndpoint(endpoint.id, definition));
+		}
+		for (const automation of options.automations ?? []) {
+			if (automations.has(automation.id)) return yield* Effect.fail(new InvalidAgentHostBinding(`duplicate automation: ${automation.id}`));
+			if (!definitions.has(automation.definition.agentId)) return yield* Effect.fail(new InvalidAgentHostBinding(`unknown automation agent: ${automation.definition.agentId}`));
+			automations.set(automation.id, yield* options.registry.resolveAutomation(automation.id, automation.definition));
+		}
+		for (const backgroundSession of options.backgroundSessions ?? []) {
+			if (backgroundSession.definition.agentId !== backgroundSession.agentId) return yield* Effect.fail(new InvalidAgentHostBinding(`background session ${backgroundSession.agentId} cannot bind definition ${backgroundSession.definition.agentId}`));
+			if (backgroundSessions.has(backgroundSession.agentId)) return yield* Effect.fail(new InvalidAgentHostBinding(`duplicate background session agent: ${backgroundSession.agentId}`));
+			if (!definitions.has(backgroundSession.agentId)) return yield* Effect.fail(new InvalidAgentHostBinding(`unknown background session agent: ${backgroundSession.agentId}`));
+			backgroundSessions.set(backgroundSession.agentId, yield* options.registry.resolveBackgroundSession(backgroundSession.agentId, backgroundSession.definition));
+		}
+		const resolve = (records, id, message) => {
+			const instance = records.get(id);
+			return instance ? Effect.succeed(instance) : Effect.fail(new InvalidAgentHostBinding(message));
+		};
+		const resolveEndpoint = (endpointId) => resolve(endpoints, endpointId, `unknown endpoint: ${endpointId}`);
+		const resolveAutomation = (automationId) => resolve(automations, automationId, `unknown automation: ${automationId}`);
+		const resolveBackgroundSession = (agentId) => resolve(backgroundSessions, agentId, `unknown background session agent: ${agentId}`);
+		return {
+			cancelBackgroundSession: (agentId, input) => resolveBackgroundSession(agentId).pipe(Effect.flatMap((instance) => options.runtime.cancel(instance, input))),
+			cancelEndpoint: (endpointId, input) => resolveEndpoint(endpointId).pipe(Effect.flatMap((instance) => options.runtime.cancel(instance, input))),
+			dispose: () => options.runtime.disposeAll(),
+			handleAutomation: (automationId, input) => resolveAutomation(automationId).pipe(Effect.flatMap((instance) => options.runtime.run(instance, input))),
+			handleBackgroundSession: (agentId, input) => resolveBackgroundSession(agentId).pipe(Effect.flatMap((instance) => options.runtime.run(instance, input))),
+			handleEndpoint: (endpointId, input) => resolveEndpoint(endpointId).pipe(Effect.flatMap((instance) => options.runtime.run(instance, input))),
+			resolveAutomation,
+			resolveBackgroundSession,
+			resolveEndpoint,
+			steerEndpoint: (endpointId, input) => resolveEndpoint(endpointId).pipe(Effect.flatMap((instance) => options.runtime.steer(instance, input)))
+		};
+	});
 }
 //#endregion
-//#region src/application/host/rivus-agent-host.ts
-var InvalidRivusEndpointBinding = class extends Error {
-	name = "InvalidRivusEndpointBinding";
+//#region src/platform/runtime/runtime-pool.ts
+var RuntimeResourceBusy = class extends Error {
+	name = "RuntimeResourceBusy";
 };
-function createRivusAgentHost(options) {
-	const definitions = new Map(options.definitions.map((definition) => [definition.agentId, definition]));
-	const endpoints = /* @__PURE__ */ new Map();
-	const automations = /* @__PURE__ */ new Map();
-	const backgroundSessions = /* @__PURE__ */ new Map();
-	for (const endpoint of options.endpoints) {
-		if (endpoints.has(endpoint.id)) throw new InvalidRivusEndpointBinding(`duplicate endpoint: ${endpoint.id}`);
-		const definition = definitions.get(endpoint.agentId);
-		if (!definition) throw new InvalidRivusEndpointBinding(`unknown endpoint agent: ${endpoint.agentId}`);
-		if (!definition.endpointIds.includes(endpoint.id)) throw new InvalidRivusEndpointBinding(`endpoint ${endpoint.id} is not declared by ${endpoint.agentId}`);
-		endpoints.set(endpoint.id, options.runtimePool.registry.resolveEndpoint(endpoint.id, definition));
-	}
-	for (const automation of options.automations ?? []) {
-		if (automations.has(automation.id)) throw new InvalidRivusEndpointBinding(`duplicate automation: ${automation.id}`);
-		if (!definitions.has(automation.definition.agentId)) throw new InvalidRivusEndpointBinding(`unknown automation agent: ${automation.definition.agentId}`);
-		automations.set(automation.id, options.runtimePool.registry.resolveAutomation(automation.id, automation.definition));
-	}
-	for (const backgroundSession of options.backgroundSessions ?? []) {
-		if (backgroundSessions.has(backgroundSession.agentId)) throw new InvalidRivusEndpointBinding(`duplicate background session agent: ${backgroundSession.agentId}`);
-		if (!definitions.has(backgroundSession.agentId)) throw new InvalidRivusEndpointBinding(`unknown background session agent: ${backgroundSession.agentId}`);
-		backgroundSessions.set(backgroundSession.agentId, options.runtimePool.registry.resolveBackgroundSession(backgroundSession.agentId, backgroundSession.definition));
-	}
-	const resolveEndpoint = (endpointId) => {
-		const instance = endpoints.get(endpointId);
-		if (!instance) throw new InvalidRivusEndpointBinding(`unknown endpoint: ${endpointId}`);
-		return instance;
-	};
-	const resolveAutomation = (automationId) => {
-		const instance = automations.get(automationId);
-		if (!instance) throw new InvalidRivusEndpointBinding(`unknown automation: ${automationId}`);
-		return instance;
-	};
-	const resolveBackgroundSession = (agentId) => {
-		const instance = backgroundSessions.get(agentId);
-		if (!instance) throw new InvalidRivusEndpointBinding(`unknown background session agent: ${agentId}`);
-		return instance;
-	};
+var RuntimeResourceDisposed = class extends Error {
+	name = "RuntimeResourceDisposed";
+};
+var RuntimePoolDisposalTimedOut = class extends Error {
+	name = "RuntimePoolDisposalTimedOut";
+};
+const DEFAULT_RUNTIME_DISPOSE_TIMEOUT_MS = 1e4;
+function createEffectRuntimePool(options) {
+	const runtimes = createRuntimeCache();
+	const active = /* @__PURE__ */ new Map();
+	const lifecycle = Effect.unsafeMakeSemaphore(1);
+	const existingRuntime = (instance) => Effect.gen(function* () {
+		const selected = yield* runtimes.getExisting(instance.instanceId);
+		if (!selected || !(yield* runtimes.isCurrent(instance.instanceId, selected.entry))) return void 0;
+		return selected.runtime;
+	});
 	return {
-		cancelBackgroundSession: (agentId, input) => options.runtimePool.cancel(resolveBackgroundSession(agentId), input),
-		cancelEndpoint: (endpointId, input) => options.runtimePool.cancel(resolveEndpoint(endpointId), input),
-		steerEndpoint: (endpointId, input) => options.runtimePool.steer(resolveEndpoint(endpointId), input),
-		handleAutomation: (automationId, input) => options.runtimePool.run(resolveAutomation(automationId), input),
-		handleBackgroundSession: (agentId, input) => options.runtimePool.run(resolveBackgroundSession(agentId), input),
-		handleEndpoint: (endpointId, input) => options.runtimePool.run(resolveEndpoint(endpointId), input),
-		resolveAutomation,
-		resolveBackgroundSession,
-		resolveEndpoint
+		cancel: (instance, input) => invokeRuntimeControl(existingRuntime(instance), (runtime) => runtime.cancel?.(input)),
+		disposeAll: () => Effect.gen(function* () {
+			const entries = yield* runtimes.drain();
+			yield* lifecycle.withPermits(1)(Effect.sync(() => active.clear()));
+			yield* disposeRuntimeCacheEntries({
+				dispose: (runtime) => runtime.dispose?.() ?? Effect.void,
+				entries,
+				failureMessage: "runtime pool disposal failed",
+				timeout: {
+					milliseconds: options.disposeTimeoutMs ?? DEFAULT_RUNTIME_DISPOSE_TIMEOUT_MS,
+					onTimeout: () => new RuntimePoolDisposalTimedOut(`runtime pool disposal timed out after ${options.disposeTimeoutMs ?? DEFAULT_RUNTIME_DISPOSE_TIMEOUT_MS}ms`)
+				}
+			});
+		}),
+		run: (instance, input) => Effect.gen(function* () {
+			const selected = yield* runtimes.getOrCreate(instance.instanceId, () => options.createRuntime(instance));
+			if (!(yield* runtimes.isCurrent(instance.instanceId, selected.entry))) return yield* Effect.fail(new RuntimeResourceDisposed(`runtime was disposed before run start: ${instance.instanceId}`));
+			if (selected.runtime.concurrency === "managed") return yield* selected.runtime.run(input);
+			const token = yield* lifecycle.withPermits(1)(Effect.gen(function* () {
+				if (!(yield* runtimes.isCurrent(instance.instanceId, selected.entry))) return yield* Effect.fail(new RuntimeResourceDisposed(`runtime was disposed before run start: ${instance.instanceId}`));
+				if (active.has(instance.instanceId)) return yield* Effect.fail(new RuntimeResourceBusy(`runtime already has an active run: ${instance.instanceId}`));
+				const activeToken = Symbol(instance.instanceId);
+				active.set(instance.instanceId, activeToken);
+				return activeToken;
+			}));
+			return yield* selected.runtime.run(input).pipe(Effect.ensuring(lifecycle.withPermits(1)(Effect.sync(() => {
+				if (active.get(instance.instanceId) === token) active.delete(instance.instanceId);
+			}))));
+		}),
+		steer: (instance, input) => invokeRuntimeControl(existingRuntime(instance), (runtime) => runtime.steer?.(input))
 	};
 }
 //#endregion
-//#region src/application/deployment/rivus-deployment-daemon.ts
-var RivusDeploymentDaemonLifecycleError = class extends Error {
-	name = "RivusDeploymentDaemonLifecycleError";
-};
-var RivusDeploymentReadinessError = class extends Error {
-	endpointIds;
-	name = "RivusDeploymentReadinessError";
-	constructor(endpointIds) {
-		super(`required endpoint startup failed: ${endpointIds.join(", ")}`);
-		this.endpointIds = endpointIds;
-	}
+//#region src/modules/agent-host/application/runtime/agent-host-runtime.ts
+var AgentInstanceBusy = class extends Error {
+	name = "AgentInstanceBusy";
 };
-var RivusDeploymentAutomationReadinessError = class extends Error {
-	automationIds;
-	name = "RivusDeploymentAutomationReadinessError";
-	constructor(automationIds) {
-		super(`required automation startup failed: ${automationIds.join(", ")}`);
-		this.automationIds = automationIds;
-	}
+var AgentRuntimeDisposed = class extends Error {
+	name = "AgentRuntimeDisposed";
 };
-async function createRivusDeploymentDaemon(options) {
-	const deployment = await loadRivusDeployment(options);
-	if ((deployment.manifest.projectSpaces?.length ?? 0) > 0 && !options.resolveProjectSpace) throw new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide a Project Space resolver");
-	const projectSpaces = new Map(await Promise.all((deployment.manifest.projectSpaces ?? []).map(async (declaration) => {
-		const projectSpace = await options.resolveProjectSpace({
-			declaration,
-			deploymentRoot: options.deploymentRoot
-		});
-		return [projectSpace.id, projectSpace];
-	})));
-	const definitions = new Map(deployment.definitions.map((definition) => [definition.agentId, definition]));
-	const automationDefinitions = new Map(deployment.automationDefinitions.map((definition) => [definition.id, definition]));
-	const backgroundSessionsConfig = deployment.manifest.backgroundSessions;
-	const backgroundDefinitions = /* @__PURE__ */ new Map();
-	if (backgroundSessionsConfig?.enabled) for (const agent of deployment.agents) {
-		if (agent.status !== "enabled" || !agent.definition) continue;
-		backgroundDefinitions.set(agent.agentId, narrowBackgroundSessionDefinition(agent.definition));
-	}
-	const runtimePool = createAgentRuntimePool({
-		createRuntime: (instance) => {
-			const definition = instance.binding.kind === "automation" ? automationDefinitions.get(instance.binding.automationId)?.runtimeDefinition : instance.binding.kind === "background-session" ? backgroundDefinitions.get(instance.agentId) : definitions.get(instance.agentId);
-			if (!definition) throw new RivusDeploymentDaemonLifecycleError(`runtime instance references unknown agent: ${instance.agentId}`);
-			const projectSpace = definition.projectSpaceId ? projectSpaces.get(definition.projectSpaceId) : void 0;
-			return options.createRuntime({
-				...instance,
-				catalog: deployment.catalog,
-				definition,
-				...projectSpace ? { projectSpace } : {}
-			});
-		},
-		registry: createAgentInstanceRegistry(options.initialInstanceRecords ? { initialRecords: options.initialInstanceRecords } : {})
+//#endregion
+//#region src/modules/agent-host/infrastructure/runtime/effect-agent-runtime-pool.ts
+function createAgentHostRuntimePool(factory, disposeTimeoutMs) {
+	const pool = createEffectRuntimePool({
+		createRuntime: (instance) => factory.create(instance),
+		...disposeTimeoutMs === void 0 ? {} : { disposeTimeoutMs }
 	});
-	const agentStatuses = new Map(deployment.agents.map((agent) => [agent.agentId, agent]));
-	const slots = deployment.manifest.endpoints.map((definition) => {
-		const agentEnabled = agentStatuses.get(definition.agentId)?.status === "enabled";
-		return {
-			agentEnabled,
-			definition,
-			lifecycle: definition.enabled && agentEnabled ? "stopped" : "disabled"
-		};
+	return {
+		cancel: (instance, input) => pool.cancel(instance, input),
+		disposeAll: () => pool.disposeAll().pipe(Effect.mapError(mapRuntimePoolError)),
+		run: (instance, input) => pool.run(instance, input).pipe(Effect.mapError(mapRuntimePoolError)),
+		steer: (instance, input) => pool.steer(instance, input)
+	};
+}
+function mapRuntimePoolError(error) {
+	if (error instanceof RuntimeResourceBusy) return new AgentInstanceBusy(error.message.replace(/^runtime /, "agent instance "));
+	if (error instanceof RuntimeResourceDisposed) return new AgentRuntimeDisposed(error.message.replace(/^runtime /, "agent runtime "));
+	if (error instanceof RuntimePoolDisposalTimedOut) return new AgentRuntimeDisposed(error.message.replace(/^runtime pool /, "agent runtime "));
+	return error;
+}
+//#endregion
+//#region src/modules/agent-host/module.ts
+function createAgentInstanceRegistryModule(options = {}) {
+	return createEffectAgentInstanceRegistry({
+		createInstanceId: (input) => createStableId("instance", input),
+		createRuntimeGenerationId: (input) => createStableId("generation", input)
+	}, options);
+}
+function createAgentHostFromRuntimePort(options) {
+	return createEffectAgentHost(options);
+}
+function createAgentHostRuntimePort(factory, disposeTimeoutMs) {
+	return createAgentHostRuntimePool(factory, disposeTimeoutMs);
+}
+function createAgentHostModule(options) {
+	const registry = createAgentInstanceRegistryModule(options.initialInstanceRecords ? { initialRecords: options.initialInstanceRecords } : {});
+	const runtime = createAgentHostRuntimePort(options.runtimeFactory, options.disposeTimeoutMs);
+	return createEffectAgentHost({
+		...options.automations ? { automations: options.automations } : {},
+		...options.backgroundSessions ? { backgroundSessions: options.backgroundSessions } : {},
+		definitions: options.definitions,
+		endpoints: options.endpoints,
+		registry,
+		runtime
 	});
-	const automationSlots = (deployment.manifest.automations ?? []).map((definition) => {
-		const agentEnabled = agentStatuses.get(definition.agentId)?.status === "enabled";
-		const resolvedDefinition = automationDefinitions.get(definition.id);
-		return {
-			agentEnabled,
-			definition,
-			...resolvedDefinition ? { resolvedDefinition } : {},
-			lifecycle: definition.enabled && agentEnabled ? "stopped" : "disabled"
-		};
+}
+//#endregion
+//#region src/adapters/deployment/bootstrap/process-deployment-adapters.ts
+function createProcessDeploymentControlPorts(factories, backgroundSessions, runEffect) {
+	return {
+		agentCatalog: createRivusAgentCatalog({ toolDescriptorProviders: [createRivusHostToolDescriptorProvider({ backgroundSessions })] }),
+		agentHostFactory: { create: (input) => createAgentHostModule({
+			automations: input.automations,
+			backgroundSessions: input.backgroundSessions,
+			definitions: input.definitions,
+			endpoints: input.endpoints,
+			...input.initialInstanceRecords ? { initialInstanceRecords: input.initialInstanceRecords } : {},
+			runtimeFactory: input.runtimeFactory
+		}) },
+		...factories.createAutomation ? { automationFactory: { create: (input) => adaptAutomationFactory(factories.createAutomation, input, runEffect) } } : {},
+		...factories.createBackgroundSession ? { backgroundSessionFactory: { create: (input) => adaptBackgroundSessionFactory(factories.createBackgroundSession, input, runEffect) } } : {},
+		endpointFactory: { create: (input) => adaptEndpointFactory(factories.createEndpoint, input, runEffect) },
+		runtimeFactory: { create: (input) => Effect.tryPromise({
+			try: () => Promise.resolve(factories.createRuntime(input)),
+			catch: toError$3
+		}).pipe(Effect.map((runtime) => toDeploymentRuntime(runtime, runEffect))) }
+	};
+}
+function adaptEndpointFactory(create, input, runEffect) {
+	return Effect.tryPromise({
+		try: async () => {
+			return toLifecycleAdapter(await create({
+				agentId: input.agentId,
+				cancel: (request) => runEffect(input.cancel(request)),
+				definition: input.definition,
+				endpointId: input.endpointId,
+				handle: (request) => runEffect(input.handle(toEffectProcessAgentRuntimeInput(request))),
+				instanceId: input.instanceId,
+				...input.projectSpaceId ? { projectSpaceId: input.projectSpaceId } : {},
+				steer: (request) => runEffect(input.steer(request))
+			}));
+		},
+		catch: toError$3
 	});
-	const backgroundSessionSlot = backgroundSessionsConfig ? {
-		agentEnabled: backgroundDefinitions.size > 0,
-		definition: backgroundSessionsConfig,
-		lifecycle: backgroundSessionsConfig.enabled && backgroundDefinitions.size > 0 ? "stopped" : "disabled"
-	} : void 0;
-	const host = createRivusAgentHost({
-		automations: automationSlots.filter((slot) => slot.definition.enabled && slot.agentEnabled && slot.resolvedDefinition !== void 0).map((slot) => ({
-			definition: slot.resolvedDefinition.runtimeDefinition,
-			id: slot.definition.id
-		})),
-		...backgroundSessionSlot ? { backgroundSessions: [...backgroundDefinitions].map(([agentId, definition]) => ({
-			agentId,
-			definition
-		})) } : {},
-		definitions: deployment.definitions,
-		endpoints: slots.filter((slot) => slot.definition.enabled && slot.agentEnabled).map((slot) => ({
-			agentId: slot.definition.agentId,
-			id: slot.definition.id
+}
+function adaptAutomationFactory(create, input, runEffect) {
+	return Effect.tryPromise({
+		try: async () => toLifecycleAdapter(await create({
+			automationId: input.automationId,
+			definition: input.definition,
+			deliveryEndpoint: input.deliveryEndpoint,
+			instanceId: input.instanceId,
+			run: (request) => runEffect(input.run(request))
 		})),
-		runtimePool
-	});
-	const slotById = new Map(slots.map((slot) => [slot.definition.id, slot]));
-	let lifecycle = "stopped";
-	const canRunIntake = () => lifecycle === "running" || lifecycle === "degraded";
-	const canRunEndpointIntake = (slot) => (canRunIntake() || lifecycle === "starting") && (slot.lifecycle === "running" || slot.lifecycle === "starting") && (slot.adapter?.running() ?? false);
-	const handleEndpoint = async (endpointId, input) => {
-		const slot = slotById.get(endpointId);
-		if (!slot) throw new RivusDeploymentDaemonLifecycleError(`unknown endpoint: ${endpointId}`);
-		if (!canRunEndpointIntake(slot)) throw new RivusDeploymentDaemonLifecycleError(`endpoint ${endpointId} cannot accept intake while ${slot.lifecycle}`);
-		return host.handleEndpoint(endpointId, input);
-	};
-	const endpointStatus = (slot) => Object.freeze({
-		...componentStatus(slot),
-		agentId: slot.definition.agentId,
-		endpointId: slot.definition.id
-	});
-	const automationStatus = (slot) => Object.freeze({
-		...componentStatus(slot),
-		agentId: slot.definition.agentId,
-		automationId: slot.definition.id
-	});
-	const backgroundSessionStatus = (slot) => Object.freeze({
-		...componentStatus(slot),
-		...slot.adapter?.status ? { supervisor: slot.adapter.status() } : {}
+		catch: toError$3
 	});
-	const allSlots = [
-		...slots,
-		...automationSlots,
-		...backgroundSessionSlot ? [backgroundSessionSlot] : []
-	];
-	const isReady = () => allSlots.every(isSlotReady);
-	const failedRequiredEndpointIds = () => slots.filter((slot) => slot.definition.enabled && slot.definition.required && slot.lifecycle !== "running").map((slot) => slot.definition.id);
-	const failedRequiredAutomationIds = () => automationSlots.filter((slot) => slot.definition.enabled && slot.definition.required && slot.lifecycle !== "running").map((slot) => slot.definition.id);
-	const assertRequiredReadiness = () => {
-		const endpointIds = failedRequiredEndpointIds();
-		if (endpointIds.length > 0) throw new RivusDeploymentReadinessError(Object.freeze(endpointIds));
-		const automationIds = failedRequiredAutomationIds();
-		if (automationIds.length > 0) throw new RivusDeploymentAutomationReadinessError(Object.freeze(automationIds));
-	};
-	const status = () => Object.freeze({
-		agents: deployment.agents,
-		automations: Object.freeze(automationSlots.map(automationStatus)),
-		...backgroundSessionSlot ? { backgroundSessions: backgroundSessionStatus(backgroundSessionSlot) } : {},
-		defaultAgentId: deployment.manifest.defaultAgentId,
-		defaultEndpointId: deployment.manifest.defaultEndpointId,
-		endpoints: Object.freeze(slots.map(endpointStatus)),
-		lifecycle,
-		plugins: deployment.plugins,
-		ready: isReady(),
-		running: canRunIntake()
+}
+function adaptBackgroundSessionFactory(create, input, runEffect) {
+	return Effect.tryPromise({
+		try: async () => {
+			const adapter = await create({
+				agentIds: input.agentIds,
+				cancel: (request) => runEffect(input.cancel(request)),
+				config: input.config,
+				run: (request) => runEffect(input.run({
+					agentId: request.agentId,
+					invocation: request.invocation,
+					...request.onUpdate ? { onUpdate: (update) => Effect.tryPromise({
+						try: async () => request.onUpdate(update),
+						catch: toError$3
+					}) } : {},
+					sessionKey: request.sessionKey,
+					text: request.text
+				}))
+			});
+			return {
+				...toLifecycleAdapter(adapter),
+				...adapter.status ? { status: () => adapter.status() } : {}
+			};
+		},
+		catch: toError$3
 	});
+}
+function toDeploymentRuntime(runtime, runEffect) {
+	const adapted = toEffectAgentRuntime(runtime, runEffect);
+	const cancel = adapted.cancel?.bind(adapted);
+	const dispose = adapted.dispose?.bind(adapted);
+	const steer = adapted.steer?.bind(adapted);
 	return {
-		deployment,
-		handleDefault: (input) => handleEndpoint(deployment.manifest.defaultEndpointId, input),
-		handleEndpoint,
-		runDefaultAgent: (input) => host.handleEndpoint(deployment.manifest.defaultEndpointId, input),
-		running: canRunIntake,
-		start: async () => {
-			if (lifecycle === "running") return;
-			if (lifecycle === "degraded") {
-				assertRequiredReadiness();
-				return;
-			}
-			if (lifecycle !== "stopped") throw new RivusDeploymentDaemonLifecycleError(`cannot start deployment daemon while ${lifecycle}`);
-			lifecycle = "starting";
-			let degraded = false;
-			for (const slot of slots) {
-				const slotDegraded = await startSlot(slot, slot.agentEnabled, () => options.createEndpoint({
-					agentId: slot.definition.agentId,
-					cancel: (input) => host.cancelEndpoint(slot.definition.id, input),
-					definition: slot.definition,
-					endpointId: slot.definition.id,
-					handle: (input) => handleEndpoint(slot.definition.id, input),
-					instanceId: host.resolveEndpoint(slot.definition.id).instanceId,
-					steer: (input) => host.steerEndpoint(slot.definition.id, input),
-					...definitions.get(slot.definition.agentId)?.projectSpaceId ? { projectSpaceId: definitions.get(slot.definition.agentId).projectSpaceId } : {}
-				}));
-				degraded ||= slotDegraded;
-			}
-			for (const slot of automationSlots) {
-				const resolvedDefinition = slot.resolvedDefinition;
-				const deliverySlot = slotById.get(slot.definition.delivery.endpointId);
-				const presentationReady = deliverySlot.lifecycle === "running" && (deliverySlot.adapter?.running() ?? false);
-				const slotDegraded = await startSlot(slot, slot.agentEnabled && resolvedDefinition !== void 0 && presentationReady, async () => {
-					if (!options.createAutomation) throw new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide Automation adapters");
-					if (!resolvedDefinition) throw new RivusDeploymentDaemonLifecycleError(`automation definition not resolved: ${slot.definition.id}`);
-					return options.createAutomation({
-						automationId: slot.definition.id,
-						definition: resolvedDefinition,
-						deliveryEndpoint: deliverySlot.definition,
-						instanceId: host.resolveAutomation(slot.definition.id).instanceId,
-						run: (input) => host.handleAutomation(slot.definition.id, {
-							invocation: {
-								allowedActorOpenIds: [],
-								automationId: slot.definition.id,
-								endpointId: slot.definition.delivery.endpointId,
-								kind: "automation",
-								sourceMessageId: input.tickId,
-								tenantKey: "automation",
-								tickId: input.tickId
-							},
-							sessionKey: input.sessionKey,
-							text: input.text
-						})
-					});
-				});
-				degraded ||= slotDegraded;
-			}
-			if (backgroundSessionSlot) {
-				const slotDegraded = await startSlot(backgroundSessionSlot, true, async () => {
-					if (!options.createBackgroundSession) throw new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide Background Session adapters");
-					return options.createBackgroundSession({
-						agentIds: [...backgroundDefinitions.keys()],
-						cancel: (input) => host.cancelBackgroundSession(input.agentId, input),
-						config: backgroundSessionSlot.definition,
-						run: (input) => host.handleBackgroundSession(input.agentId, input)
-					});
-				});
-				degraded ||= slotDegraded;
-			}
-			lifecycle = degraded ? "degraded" : "running";
-			assertRequiredReadiness();
-		},
-		status,
-		stop: async () => {
-			if (lifecycle === "stopped") {
-				await runtimePool.disposeAll();
-				return;
-			}
-			if (lifecycle !== "running" && lifecycle !== "degraded" && lifecycle !== "cleanup-required") throw new RivusDeploymentDaemonLifecycleError(`cannot stop deployment daemon while ${lifecycle}`);
-			lifecycle = "stopping";
-			const errors = [];
-			await stopSlots(automationSlots, errors);
-			if (backgroundSessionSlot) await stopSlots([backgroundSessionSlot], errors);
-			await stopSlots(slots, errors);
-			try {
-				await runtimePool.disposeAll();
-			} catch (error) {
-				errors.push(error);
-			}
-			lifecycle = errors.length === 0 ? "stopped" : "cleanup-required";
-			if (errors.length === 1) throw errors[0];
-			if (errors.length > 1) throw new AggregateError(errors, "deployment daemon cleanup failed");
-		}
+		...adapted.concurrency ? { concurrency: adapted.concurrency } : {},
+		...cancel ? { cancel: (input) => cancel(input).pipe(Effect.mapError(toError$3)) } : {},
+		...dispose ? { dispose: () => dispose().pipe(Effect.mapError(toError$3)) } : {},
+		run: (input) => adapted.run(input).pipe(Effect.mapError(toError$3)),
+		...steer ? { steer: (input) => steer(input).pipe(Effect.mapError(toError$3)) } : {}
 	};
 }
-function componentStatus(slot) {
+function toLifecycleAdapter(adapter) {
 	return {
-		enabled: slot.definition.enabled,
-		...slot.error ? { error: slot.error } : {},
-		lifecycle: slot.lifecycle,
-		required: slot.definition.required,
-		running: slot.lifecycle === "running" && (slot.adapter?.running() ?? false)
+		running: () => adapter.running(),
+		start: () => Effect.tryPromise({
+			try: () => Promise.resolve(adapter.start()),
+			catch: toError$3
+		}),
+		stop: () => Effect.tryPromise({
+			try: () => Promise.resolve(adapter.stop()),
+			catch: toError$3
+		})
 	};
 }
-function isSlotReady(slot) {
-	return !slot.definition.enabled || !slot.definition.required || slot.lifecycle === "running" && (slot.adapter?.running() ?? false);
+function toEffectProcessAgentRuntimeInput(input) {
+	return toEffectAgentRuntimeInput(input);
 }
-async function startSlot(slot, available, create) {
-	if (!slot.definition.enabled) {
-		slot.lifecycle = "disabled";
-		return false;
+function toError$3(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+//#region src/adapters/deployment/plugin/rivus-plugin-module.ts
+function resolveRivusPluginModule(module) {
+	const candidate = "default" in module ? module.default : module;
+	return (typeof candidate === "function" ? Effect.tryPromise({
+		try: () => Promise.resolve(candidate()),
+		catch: toError$2
+	}) : Effect.succeed(candidate)).pipe(Effect.flatMap((plugin) => isRivusPlugin(plugin) ? Effect.succeed(plugin) : Effect.fail(/* @__PURE__ */ new Error("plugin module default export is not a RivusPlugin or factory"))));
+}
+function isRivusPlugin(value) {
+	return value !== null && typeof value === "object" && "manifest" in value && "register" in value && typeof value.register === "function";
+}
+function toError$2(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+//#region src/adapters/deployment/plugin/trusted-package-root.ts
+function findTrustedPackageRoot(packageManifestPath) {
+	return Effect.tryPromise({
+		try: async () => {
+			const packageRoot = dirname(await realpath(packageManifestPath));
+			let current = packageRoot;
+			for (;;) {
+				if (basename(current) === "node_modules") return current;
+				const parent = dirname(current);
+				if (parent === current) return packageRoot;
+				current = parent;
+			}
+		},
+		catch: (error) => error instanceof Error ? error : new Error(String(error))
+	});
+}
+//#endregion
+//#region src/platform/filesystem/path-boundary.ts
+function isPathWithin(root, candidate) {
+	const child = relative(root, candidate);
+	return child === "" || !child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child);
+}
+function assertPathWithin(root, candidate, message) {
+	if (!isPathWithin(root, candidate)) throw new Error(message);
+}
+//#endregion
+//#region src/adapters/deployment/plugin/trusted-module-path.ts
+function validateTrustedModulePath(trustedRoot, resolvedPath, subject) {
+	return Effect.try({
+		try: () => {
+			assertPathWithin(trustedRoot, resolvedPath, `${subject} resolves outside trusted module root: ${resolvedPath}`);
+			return resolvedPath;
+		},
+		catch: (failure) => failure instanceof Error ? failure : new Error(String(failure))
+	});
+}
+//#endregion
+//#region src/adapters/deployment/plugin/node-rivus-plugin-module-loader.ts
+function createNodeRivusPluginModuleLoader(options = {}) {
+	return { load: (request) => loadNodeRivusPluginModule(request, options).pipe(Effect.flatMap(resolveRivusPluginModule)) };
+}
+function loadNodeRivusPluginModule(request, options = {}) {
+	return resolveNodeRivusPluginModulePath(request, options).pipe(Effect.flatMap((resolvedRealpath) => Effect.tryPromise({
+		try: () => import(pathToFileURL(resolvedRealpath).href),
+		catch: toError$1
+	})));
+}
+function resolveNodeRivusPluginModulePath(request, options = {}) {
+	return Effect.gen(function* () {
+		const deploymentRoot = yield* Effect.tryPromise({
+			try: () => realpath(request.deploymentRoot),
+			catch: toError$1
+		});
+		const relativeModule = request.module.startsWith("./") || request.module.startsWith("../");
+		const resolutionManifest = relativeModule ? join(deploymentRoot, "package.json") : options.packageManifestPath ?? join(deploymentRoot, "package.json");
+		const resolved = yield* Effect.try({
+			try: () => createRequire(resolutionManifest).resolve(request.module),
+			catch: toError$1
+		});
+		const resolvedRealpath = yield* Effect.tryPromise({
+			try: () => realpath(resolved),
+			catch: toError$1
+		});
+		return yield* validateTrustedModulePath(relativeModule ? deploymentRoot : options.packageManifestPath ? yield* findTrustedPackageRoot(options.packageManifestPath) : deploymentRoot, resolvedRealpath, `plugin module ${request.module}`);
+	});
+}
+function toError$1(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+//#region src/modules/deployment-control/module.ts
+function resolveRivusDeploymentModule(options) {
+	return resolveRivusDeployment(options);
+}
+function createRivusDeploymentControlModule(options) {
+	return Effect.gen(function* () {
+		const deployment = yield* resolveRivusDeploymentModule(options);
+		return yield* createRivusDeploymentControl({
+			agentHostFactory: options.agentHostFactory,
+			...options.automationFactory ? { automationFactory: options.automationFactory } : {},
+			...options.backgroundSessionFactory ? { backgroundSessionFactory: options.backgroundSessionFactory } : {},
+			deployment,
+			deploymentRoot: options.deploymentRoot,
+			endpointFactory: options.endpointFactory,
+			...options.initialInstanceRecords ? { initialInstanceRecords: options.initialInstanceRecords } : {},
+			...options.projectSpaceResolver ? { projectSpaceResolver: options.projectSpaceResolver } : {},
+			runtimeFactory: options.runtimeFactory
+		});
+	});
+}
+//#endregion
+//#region src/modules/project-space/application/workspace/workspace-instructions-resolver.ts
+function createWorkspaceInstructionsResolver(source) {
+	return { resolve: (request) => Effect.gen(function* () {
+		yield* Effect.try({
+			catch: (error) => error,
+			try: () => validateWorkspaceInstructionsBudget(request.maxBytes)
+		});
+		const loaded = yield* source.load({
+			maxBytes: request.maxBytes,
+			...request.targetPath !== void 0 ? { targetPath: request.targetPath } : {},
+			workingDirectory: request.workingDirectory,
+			workspaceRoot: request.workspaceRoot
+		});
+		return assembleWorkspaceInstructions({
+			diagnostics: loaded.diagnostics,
+			maxBytes: request.maxBytes,
+			...request.operation ? { operation: request.operation } : {},
+			...request.presentedDigests ? { presentedDigests: request.presentedDigests } : {},
+			sources: loaded.sources,
+			...request.targetPath !== void 0 ? { targetPath: request.targetPath } : {}
+		});
+	}) };
+}
+//#endregion
+//#region src/modules/project-space/infrastructure/workspace/node-workspace-root-registry.ts
+const workspaceRoots = /* @__PURE__ */ new WeakMap();
+async function createWorkspaceRootHandle(rootPath) {
+	const resolved = await realpath(rootPath);
+	if (!(await stat(resolved)).isDirectory()) throw new InvalidWorkspaceRoot("workspace root must be a directory");
+	const handle = Object.freeze({ id: `workspace:${createHash("sha256").update(resolved).digest("hex")}` });
+	workspaceRoots.set(handle, resolved);
+	return handle;
+}
+function resolveWorkspaceRootPath(handle) {
+	const rootPath = workspaceRoots.get(handle);
+	if (!rootPath) throw new InvalidWorkspaceRoot("workspace root handle was not created by this host");
+	return rootPath;
+}
+//#endregion
+//#region src/modules/project-space/infrastructure/instructions/agents-md-instructions-source.ts
+function createAgentsMdInstructionsSource() {
+	return { load: (request) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => loadAgentsMdInstructions(request)
+	}) };
+}
+async function loadAgentsMdInstructions(request) {
+	const rootPath = resolveWorkspaceRootPath(request.workspaceRoot);
+	const workingDirectory = await resolveBoundDirectory(rootPath, request.workingDirectory, false);
+	const targetDirectory = request.targetPath ? await resolveBoundDirectory(rootPath, request.targetPath, true) : workingDirectory;
+	if (!isPathWithin(rootPath, workingDirectory) || !isPathWithin(rootPath, targetDirectory)) throw new InvalidWorkspaceRoot("workspace path escapes the bound root");
+	const discovered = [];
+	const diagnostics = [];
+	for (const directory of directoriesFromRoot(rootPath, targetDirectory)) {
+		const result = await readSource(rootPath, join(directory, "AGENTS.md"), request.maxBytes);
+		if (result?.source) discovered.push(result.source);
+		if (result?.diagnostic) diagnostics.push(result.diagnostic);
+	}
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		sources: Object.freeze(discovered)
+	});
+}
+async function resolveBoundDirectory(rootPath, path, useParentForFile) {
+	validateRelativePath$1(path);
+	const candidate = resolve(rootPath, path || ".");
+	if (!isPathWithin(rootPath, candidate)) throw new InvalidWorkspaceRoot("workspace path escapes the bound root");
+	let existing = candidate;
+	let metadata;
+	while (isPathWithin(rootPath, existing)) try {
+		metadata = await stat(existing);
+		break;
+	} catch (error) {
+		if (!isMissing(error)) throw error;
+		if (existing === rootPath) break;
+		existing = dirname(existing);
 	}
-	if (!available) {
-		slot.lifecycle = "disabled";
-		return slot.definition.required;
+	if (!metadata) throw new InvalidWorkspaceRoot(`workspace path does not have an existing parent: ${path}`);
+	const resolvedExisting = await realpath(existing);
+	if (!isPathWithin(rootPath, resolvedExisting)) throw new InvalidWorkspaceRoot("workspace path resolves outside the bound root");
+	if (existing !== candidate) {
+		if (!useParentForFile) throw new InvalidWorkspaceRoot(`working directory does not exist: ${path}`);
+		return resolvedExisting;
 	}
-	slot.lifecycle = "starting";
-	delete slot.error;
+	if (metadata.isDirectory()) return resolvedExisting;
+	if (!useParentForFile || !metadata.isFile()) throw new InvalidWorkspaceRoot(`workspace path must resolve to a directory: ${path}`);
+	return dirname(resolvedExisting);
+}
+async function readSource(rootPath, sourcePath, maxBytes) {
+	let metadata;
 	try {
-		slot.adapter ??= await create();
-		await slot.adapter.start();
-		slot.lifecycle = "running";
-		return false;
+		metadata = await lstat(sourcePath);
 	} catch (error) {
-		slot.error = error instanceof Error ? error.message : String(error);
-		slot.lifecycle = "degraded";
-		return true;
+		if (isMissing(error)) return void 0;
+		throw error;
 	}
-}
-async function stopSlots(slots, errors) {
-	for (const slot of [...slots].reverse()) {
-		if (!slot.adapter || slot.lifecycle === "stopped" || slot.lifecycle === "disabled") continue;
-		slot.lifecycle = "stopping";
-		try {
-			await slot.adapter.stop();
-			slot.lifecycle = slot.definition.enabled && slot.agentEnabled ? "stopped" : "disabled";
-			delete slot.error;
-		} catch (error) {
-			errors.push(error);
-			slot.error = error instanceof Error ? error.message : String(error);
-			slot.lifecycle = "cleanup-required";
-		}
+	const relativePath = toRelative(rootPath, sourcePath);
+	if (metadata.isSymbolicLink() || !metadata.isFile()) throw new WorkspaceInstructionsSourceError(relativePath, "source must be a regular non-symlink file");
+	if (metadata.size > maxBytes) return { diagnostic: {
+		code: "workspace-instructions-source-omitted",
+		reason: `source size ${metadata.size} exceeds byte budget ${maxBytes}`,
+		relativePath
+	} };
+	const resolvedSource = await realpath(sourcePath);
+	if (!isPathWithin(rootPath, resolvedSource)) throw new WorkspaceInstructionsSourceError(relativePath, "source resolves outside workspace root");
+	const bytes = await readFile(resolvedSource);
+	let content;
+	try {
+		content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		throw new WorkspaceInstructionsSourceError(relativePath, "source is not valid UTF-8");
+	}
+	return { source: Object.freeze({
+		bytes: bytes.byteLength,
+		content,
+		digest: createSourceDigest(bytes),
+		relativePath
+	}) };
+}
+function validateRelativePath$1(path) {
+	if (isAbsolute(path) || path.split(/[\\/]/).includes("..")) throw new InvalidWorkspaceRoot("workspace path must be relative and cannot contain ..");
+}
+function directoriesFromRoot(rootPath, targetDirectory) {
+	const suffix = relative(rootPath, targetDirectory);
+	const directories = [rootPath];
+	if (!suffix) return directories;
+	let current = rootPath;
+	for (const segment of suffix.split(sep)) {
+		current = join(current, segment);
+		directories.push(current);
 	}
+	return directories;
+}
+function toRelative(rootPath, path) {
+	return relative(rootPath, path).split(sep).join("/");
+}
+function createSourceDigest(bytes) {
+	return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+function isMissing(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 //#endregion
-//#region src/domain/project-space.ts
-var InvalidRivusProjectSpace = class extends Error {
-	name = "InvalidRivusProjectSpace";
-};
-//#endregion
-//#region src/infrastructure/workspace/rivus-project-space.ts
+//#region src/modules/project-space/infrastructure/space/node-project-space-resolver.ts
 async function resolveRivusProjectSpace(input) {
+	validateRivusProjectSpaceDeployment(input.declaration);
 	const root = await resolveContainedDirectory(await resolveExistingDirectory(input.deploymentRoot, "deployment root"), input.declaration.root, "Project Space root");
 	const workingDirectory = await resolveContainedDirectory(root, input.declaration.workingDirectory, "Project Space working directory");
 	const skillPaths = await Promise.all(input.declaration.skills.sources.map((source) => resolveContainedPath(root, source, "Project Space Skill source")));
@@ -1860,25 +2503,21 @@ function validateRelativePath(path, owner) {
 	if (!path.trim() || path.includes("\0") || isAbsolute(path)) throw new InvalidRivusProjectSpace(`${owner} must be a non-empty relative path`);
 }
 function assertContained(base, candidate, owner) {
-	const relation = relative(base, candidate);
-	if (relation === "" || !relation.startsWith("..") && !isAbsolute(relation)) return;
+	if (isPathWithin(base, candidate)) return;
 	throw new InvalidRivusProjectSpace(`${owner} escapes its trusted root`);
 }
 //#endregion
-//#region src/infrastructure/runtime/configured-rivus-deployment-daemon.ts
-async function createConfiguredRivusDeploymentDaemon(options) {
-	const manifest = await loadRivusDeploymentManifest(options.manifestPath, options.manifestOptions);
-	return createRivusDeploymentDaemon({
-		...options.createAutomation ? { createAutomation: options.createAutomation } : {},
-		...options.createBackgroundSession ? { createBackgroundSession: options.createBackgroundSession } : {},
-		createEndpoint: options.createEndpoint,
-		createRuntime: options.createRuntime,
-		deploymentRoot: dirname(options.manifestPath),
-		...options.initialInstanceRecords ? { initialInstanceRecords: options.initialInstanceRecords } : {},
-		loadModule: loadNodeRivusPluginModule,
-		manifest,
-		resolveProjectSpace: (input) => resolveRivusProjectSpace(input)
-	});
+//#region src/modules/project-space/module.ts
+function createAgentsMdInstructionsResolver() {
+	return createWorkspaceInstructionsResolver(createAgentsMdInstructionsSource());
+}
+//#endregion
+//#region src/composition/runtime/deployment-process-effect-runner.ts
+async function runDeploymentProcessEffect(effect) {
+	const exit = await Effect.runPromiseExit(effect);
+	if (Exit.isSuccess(exit)) return exit.value;
+	const failure = Cause.failureOption(exit.cause);
+	throw Option.isSome(failure) ? failure.value : Cause.squash(exit.cause);
 }
 //#endregion
 //#region src/composition/rivus-deployment-cli-process.ts
@@ -1893,14 +2532,24 @@ async function createRivusDeploymentCliProcess(factory, context) {
 	};
 	let daemon;
 	try {
-		daemon = await createConfiguredRivusDeploymentDaemon({
-			...adapters.createAutomation ? { createAutomation: adapters.createAutomation } : {},
-			...adapters.createBackgroundSession ? { createBackgroundSession: adapters.createBackgroundSession } : {},
-			createEndpoint: adapters.createEndpoint,
-			createRuntime: adapters.createRuntime,
-			...adapters.initialInstanceRecords ? { initialInstanceRecords: adapters.initialInstanceRecords } : {},
-			manifestPath: context.manifestPath
-		});
+		daemon = await runDeploymentProcessEffect(loadRivusDeploymentManifest(context.manifestPath).pipe(Effect.flatMap((manifest) => {
+			return createRivusDeploymentControlModule({
+				...createProcessDeploymentControlPorts({
+					...adapters.createAutomation ? { createAutomation: adapters.createAutomation } : {},
+					...adapters.createBackgroundSession ? { createBackgroundSession: adapters.createBackgroundSession } : {},
+					createEndpoint: adapters.createEndpoint,
+					createRuntime: adapters.createRuntime
+				}, manifest.backgroundSessions?.enabled === true, runDeploymentProcessEffect),
+				deploymentRoot: dirname(context.manifestPath),
+				...adapters.initialInstanceRecords ? { initialInstanceRecords: adapters.initialInstanceRecords } : {},
+				manifest,
+				pluginLoader: createNodeRivusPluginModuleLoader(context.pluginPackageManifestPath ? { packageManifestPath: context.pluginPackageManifestPath } : {}),
+				projectSpaceResolver: { resolve: (input) => Effect.tryPromise({
+					try: () => resolveRivusProjectSpace(input),
+					catch: toError
+				}) }
+			});
+		})));
 	} catch (constructionError) {
 		try {
 			await disposeAdapters();
@@ -1912,11 +2561,11 @@ async function createRivusDeploymentCliProcess(factory, context) {
 	const start = async () => {
 		if (adaptersDisposed) throw new Error("Rivus deployment process cannot restart after its adapters have been disposed");
 		try {
-			await daemon.start();
+			await runDeploymentProcessEffect(daemon.start());
 		} catch (startError) {
 			const cleanupErrors = [];
 			try {
-				await daemon.stop();
+				await runDeploymentProcessEffect(daemon.stop());
 			} catch (error) {
 				cleanupErrors.push(error);
 			}
@@ -1932,7 +2581,7 @@ async function createRivusDeploymentCliProcess(factory, context) {
 	const stop = async () => {
 		const errors = [];
 		try {
-			await daemon.stop();
+			await runDeploymentProcessEffect(daemon.stop());
 		} catch (error) {
 			errors.push(error);
 		}
@@ -1973,7 +2622,7 @@ async function createRivusDeploymentCliProcess(factory, context) {
 		promptText: (command) => Effect.tryPromise({
 			try: async () => {
 				if (adaptersDisposed) throw new Error("Rivus deployment process cannot restart after its adapters have been disposed");
-				return readPromptFinalText(await daemon.runDefaultAgent({
+				return readPromptFinalText(await runDeploymentProcessEffect(daemon.runDefaultAgent({
 					invocation: {
 						allowedActorOpenIds: [],
 						endpointId: daemon.deployment.manifest.defaultEndpointId,
@@ -1990,7 +2639,7 @@ async function createRivusDeploymentCliProcess(factory, context) {
 					},
 					sessionKey: command.sessionKey,
 					text: command.text
-				}));
+				})));
 			},
 			catch: (error) => error
 		})
@@ -2001,7 +2650,7 @@ async function createRivusDeploymentCliProcess(factory, context) {
 			if (!daemon.running()) await start();
 		},
 		catch: (error) => error
-	}).pipe(Effect.flatMap(() => replayReceiveMessage((input) => daemon.handleDefault(input), payload, options)));
+	}).pipe(Effect.flatMap(() => replayReceiveMessage((input) => runDeploymentProcessEffect(daemon.handleDefault(toEffectProcessAgentRuntimeInput(input))), payload, options)));
 	return process;
 }
 function readPromptFinalText(result) {
@@ -2009,6 +2658,9 @@ function readPromptFinalText(result) {
 	if (typeof result === "object" && result !== null && "finalText" in result && typeof result.finalText === "string") return result.finalText;
 	throw new Error("Default deployment prompt result must be a string or contain finalText");
 }
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
 //#endregion
 //#region src/composition/rivus-recovery-cli.ts
 function createRivusRecoveryCliParser() {
@@ -2178,6 +2830,10 @@ const USAGE = `Usage: rivus --bootstrap <module> [--manifest <rivus.config.json>
 Starts a local Rivus Agent daemon from an injected bootstrap module.
 
 Project commands:
+  rivus setup [directory]
+  rivus start
+  rivus status
+  rivus check-config
   rivus init [directory]
   rivus doctor [directory] [--env-file <path>]
 
@@ -2233,6 +2889,7 @@ Options:
   --help               Show this help
 
 Environment:
+  RIVUS_HOME selects Rivus Home (default ~/.rivus-agent) for Home commands.
   RIVUS_BOOTSTRAP_MODULE may be used instead of --bootstrap.
   FEISHU_APP_ID and FEISHU_APP_SECRET are required by the default config loader.
   FEISHU_CARD_STREAM_LEASE_MS shortens or extends the proactive CardKit rollover threshold.
@@ -2241,7 +2898,7 @@ Environment:
 const DEFAULT_WAIT_RECEIVE_TIMEOUT_MS = 3e4;
 const DEFAULT_WAIT_RECEIVE_POLL_MS = 500;
 function runRivusDaemonCli(options) {
-	return Effect.promise(async () => {
+	return Effect.gen(function* () {
 		const parsed = parseArgs(options.argv);
 		if (parsed.help) {
 			options.stdout.write(USAGE);
@@ -2251,36 +2908,38 @@ function runRivusDaemonCli(options) {
 			options.stderr.write(`${parsed.error}\n\n${USAGE}`);
 			return 1;
 		}
-		if (parsed.statusUrl) try {
-			const status = parsed.waitReceive ? await waitForLiveReceiveStatus(parsed.statusUrl, parsed.waitReceive, {
+		if (parsed.statusUrl) {
+			const statusUrl = parsed.statusUrl;
+			const readStatus = () => Effect.tryPromise({
+				try: () => fetchLiveStatus(statusUrl),
+				catch: (error) => error
+			});
+			const status = parsed.waitReceive ? yield* waitForReceiveStatus(readStatus, parsed.waitReceive, {
 				...parsed.waitReceiveMessageId ? { messageId: parsed.waitReceiveMessageId } : {},
 				...parsed.waitReceiveObservedAfter ? { observedAfter: parsed.waitReceiveObservedAfter } : {},
 				pollMs: parsed.waitPollMs ?? DEFAULT_WAIT_RECEIVE_POLL_MS,
 				...parsed.waitReceiveText ? { text: parsed.waitReceiveText } : {},
 				timeoutMs: parsed.waitTimeoutMs ?? DEFAULT_WAIT_RECEIVE_TIMEOUT_MS
-			}) : await fetchLiveStatus(parsed.statusUrl);
+			}) : yield* readStatus();
 			options.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
 			return 0;
-		} catch (error) {
-			options.stderr.write(`${formatCliError(error)}\n`);
-			return 1;
 		}
-		if (parsed.printOpenClawEnvPath) try {
-			const result = createRivusEnvFromOpenClawConfig(JSON.parse(await readFile(parsed.printOpenClawEnvPath, "utf8")), parsed.piApiKeyFile ? { piApiKeyFile: parsed.piApiKeyFile } : {});
+		if (parsed.printOpenClawEnvPath) {
+			const openClawConfigPath = parsed.printOpenClawEnvPath;
+			const result = yield* Effect.tryPromise({
+				try: async () => {
+					return createRivusEnvFromOpenClawConfig(JSON.parse(await readFile(openClawConfigPath, "utf8")), parsed.piApiKeyFile ? { piApiKeyFile: parsed.piApiKeyFile } : {});
+				},
+				catch: (error) => error
+			});
 			for (const warning of result.warnings) options.stderr.write(`Warning: ${warning}\n`);
 			options.stdout.write(formatRivusEnvFile(result.env));
 			return 0;
-		} catch (error) {
-			options.stderr.write(`${formatCliError(error)}\n`);
-			return 1;
-		}
-		let env;
-		try {
-			env = await loadCliEnv(parsed.envFilePath, options.env);
-		} catch (error) {
-			options.stderr.write(`${formatCliError(error)}\n`);
-			return 1;
 		}
+		const env = yield* Effect.tryPromise({
+			try: () => loadCliEnv(parsed.envFilePath, options.env),
+			catch: (error) => error
+		});
 		const bootstrapSpecifier = parsed.bootstrap ?? env.RIVUS_BOOTSTRAP_MODULE?.trim();
 		if (!parsed.checkConfig && !bootstrapSpecifier) {
 			options.stderr.write(`Missing --bootstrap <module> or RIVUS_BOOTSTRAP_MODULE\n\n${USAGE}`);
@@ -2288,17 +2947,18 @@ function runRivusDaemonCli(options) {
 		}
 		let legacyConfig;
 		if (parsed.manifestPath) {
-			if (parsed.checkConfig) try {
-				const manifest = await loadRivusDeploymentManifest(parsed.manifestPath);
-				validateRivusDeploymentManifest(manifest);
+			if (parsed.checkConfig) {
+				const manifestPath = parsed.manifestPath;
+				const manifest = yield* loadRivusDeploymentManifest(manifestPath);
+				yield* Effect.try({
+					try: () => validateRivusDeploymentManifest(manifest),
+					catch: (error) => error
+				});
 				options.stdout.write(`${JSON.stringify(toRedactedDeploymentManifest(manifest), null, 2)}\n`);
 				return 0;
-			} catch (error) {
-				options.stderr.write(`${formatCliError(error)}\n`);
-				return 1;
 			}
 		} else {
-			const configExit = await Effect.runPromiseExit(loadRivusDaemonConfig(env));
+			const configExit = yield* Effect.exit(loadRivusDaemonConfig(env));
 			if (configExit._tag === "Failure") {
 				options.stderr.write(`${configExit.cause.toString()}\n`);
 				return 1;
@@ -2313,113 +2973,132 @@ function runRivusDaemonCli(options) {
 			options.stderr.write(`Missing --bootstrap <module> or RIVUS_BOOTSTRAP_MODULE\n\n${USAGE}`);
 			return 1;
 		}
-		try {
-			const module = await (options.loadBootstrap ?? ((specifier) => import(specifier)))(bootstrapSpecifier);
-			const daemon = parsed.manifestPath ? await createCliDeploymentDaemon(module.createRivusDeploymentAdapters, {
+		const loadBootstrap = options.loadBootstrap ?? ((specifier) => import(specifier));
+		const module = yield* Effect.tryPromise({
+			try: () => loadBootstrap(bootstrapSpecifier),
+			catch: (error) => error
+		});
+		const daemon = yield* Effect.tryPromise({
+			try: () => parsed.manifestPath ? createCliDeploymentDaemon(module.createRivusDeploymentAdapters, {
 				argv: options.argv,
 				env,
-				manifestPath: parsed.manifestPath
-			}) : await createCliLegacyDaemon(module, {
+				manifestPath: parsed.manifestPath,
+				...options.pluginPackageManifestPath ? { pluginPackageManifestPath: options.pluginPackageManifestPath } : {}
+			}) : createCliLegacyDaemon(module, {
 				argv: options.argv,
 				config: legacyConfig,
 				env
-			});
-			if (parsed.recoveryCommand) {
-				const recoveryCommand = parsed.recoveryCommand;
-				return await runOneShotDaemon(daemon, async () => {
-					if (!hasRecoveryRunner(daemon)) {
-						options.stderr.write(`Bootstrap daemon does not expose openRecoveryControl()\n`);
-						return 1;
-					}
-					const result = await runRivusRecoveryCliCommand(await Effect.runPromise(daemon.openRecoveryControl()), recoveryCommand);
-					options.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-					return 0;
+			}),
+			catch: (error) => error
+		});
+		if (parsed.recoveryCommand) {
+			const recoveryCommand = parsed.recoveryCommand;
+			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
+				if (!hasRecoveryRunner(daemon)) {
+					options.stderr.write(`Bootstrap daemon does not expose openRecoveryControl()\n`);
+					return 1;
+				}
+				const control = yield* daemon.openRecoveryControl();
+				const result = yield* Effect.tryPromise({
+					try: () => runRivusRecoveryCliCommand(control, recoveryCommand),
+					catch: (error) => error
 				});
+				options.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+				return 0;
+			}));
+		}
+		if (parsed.status) return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
+			if (!hasStatusReporter(daemon)) {
+				options.stderr.write(`Bootstrap daemon does not expose status()\n`);
+				return 1;
 			}
-			if (parsed.status) return await runOneShotDaemon(daemon, async () => {
-				if (!hasStatusReporter(daemon)) {
-					options.stderr.write(`Bootstrap daemon does not expose status()\n`);
+			const status = yield* daemon.status();
+			options.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+			return 0;
+		}));
+		if (parsed.prompt !== void 0) {
+			const prompt = parsed.prompt;
+			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
+				if (!hasPromptRunner(daemon)) {
+					options.stderr.write(`Bootstrap daemon does not expose promptText(command)\n`);
 					return 1;
 				}
-				const status = await Effect.runPromise(daemon.status());
-				options.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+				const text = yield* daemon.promptText({
+					sessionKey: parsed.sessionKey ?? daemon.defaultSessionKey ?? `local:${legacyConfig.agentId}:cli`,
+					text: prompt
+				});
+				options.stdout.write(`${text}\n`);
 				return 0;
-			});
-			if (parsed.prompt !== void 0) {
-				const prompt = parsed.prompt;
-				return await runOneShotDaemon(daemon, async () => {
-					if (!hasPromptRunner(daemon)) {
-						options.stderr.write(`Bootstrap daemon does not expose promptText(command)\n`);
-						return 1;
-					}
-					const text = await Effect.runPromise(daemon.promptText({
-						sessionKey: parsed.sessionKey ?? daemon.defaultSessionKey ?? `local:${legacyConfig.agentId}:cli`,
-						text: prompt
-					}));
-					options.stdout.write(`${text}\n`);
-					return 0;
+			}));
+		}
+		if (parsed.replayFeishuText !== void 0) {
+			const replayFeishuText = parsed.replayFeishuText;
+			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
+				if (!hasFeishuReplayRunner(daemon)) {
+					options.stderr.write(`Bootstrap daemon does not expose replayReceiveMessage(payload)\n`);
+					return 1;
+				}
+				const payload = createSyntheticFeishuTextReplayPayload(replayFeishuText, {
+					...parsed.feishuReplayChatId !== void 0 ? { chatId: parsed.feishuReplayChatId } : {},
+					...parsed.feishuReplayMessageId !== void 0 ? { messageId: parsed.feishuReplayMessageId } : {},
+					...parsed.feishuReplayTenantKey !== void 0 ? { tenantKey: parsed.feishuReplayTenantKey } : {},
+					...parsed.feishuReplayThreadId !== void 0 ? { threadId: parsed.feishuReplayThreadId } : {}
 				});
-			}
-			if (parsed.replayFeishuText !== void 0) {
-				const replayFeishuText = parsed.replayFeishuText;
-				return await runOneShotDaemon(daemon, async () => {
-					if (!hasFeishuReplayRunner(daemon)) {
-						options.stderr.write(`Bootstrap daemon does not expose replayReceiveMessage(payload)\n`);
-						return 1;
-					}
-					const payload = createSyntheticFeishuTextReplayPayload(replayFeishuText, {
-						...parsed.feishuReplayChatId !== void 0 ? { chatId: parsed.feishuReplayChatId } : {},
-						...parsed.feishuReplayMessageId !== void 0 ? { messageId: parsed.feishuReplayMessageId } : {},
-						...parsed.feishuReplayTenantKey !== void 0 ? { tenantKey: parsed.feishuReplayTenantKey } : {},
-						...parsed.feishuReplayThreadId !== void 0 ? { threadId: parsed.feishuReplayThreadId } : {}
-					});
-					const result = await Effect.runPromise(daemon.replayReceiveMessage(payload, { sideEffects: "disabled" }));
-					options.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-					return 0;
+				const result = yield* daemon.replayReceiveMessage(payload, { sideEffects: "disabled" });
+				options.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+				return 0;
+			}));
+		}
+		if (parsed.replayFeishuEventPath !== void 0) {
+			const replayFeishuEventPath = parsed.replayFeishuEventPath;
+			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
+				if (!hasFeishuReplayRunner(daemon)) {
+					options.stderr.write(`Bootstrap daemon does not expose replayReceiveMessage(payload)\n`);
+					return 1;
+				}
+				const payload = yield* Effect.tryPromise({
+					try: () => readFeishuReceiveMessagePayload(replayFeishuEventPath),
+					catch: (error) => error
 				});
-			}
-			if (parsed.replayFeishuEventPath !== void 0) {
-				const replayFeishuEventPath = parsed.replayFeishuEventPath;
-				return await runOneShotDaemon(daemon, async () => {
-					if (!hasFeishuReplayRunner(daemon)) {
-						options.stderr.write(`Bootstrap daemon does not expose replayReceiveMessage(payload)\n`);
-						return 1;
-					}
-					const payload = await readFeishuReceiveMessagePayload(replayFeishuEventPath);
-					const result = await Effect.runPromise(daemon.replayReceiveMessage(payload));
-					options.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-					return 0;
+				const result = yield* daemon.replayReceiveMessage(payload);
+				options.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+				return 0;
+			}));
+		}
+		if (parsed.waitReceive) {
+			const waitReceive = parsed.waitReceive;
+			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
+				if (!hasStatusReporter(daemon)) {
+					options.stderr.write(`Bootstrap daemon does not expose status()\n`);
+					return 1;
+				}
+				yield* Effect.try({
+					try: () => installCliShutdownController(options, daemon),
+					catch: (error) => error
 				});
-			}
-			if (parsed.waitReceive) {
-				const waitReceive = parsed.waitReceive;
-				return await runOneShotDaemon(daemon, async () => {
-					if (!hasStatusReporter(daemon)) {
-						options.stderr.write(`Bootstrap daemon does not expose status()\n`);
-						return 1;
-					}
-					installCliShutdownController(options, daemon);
-					await Effect.runPromise(daemon.start());
-					const status = await waitForReceiveStatus(() => Effect.runPromise(daemon.status()), waitReceive, {
-						...parsed.waitReceiveMessageId ? { messageId: parsed.waitReceiveMessageId } : {},
-						...parsed.waitReceiveObservedAfter ? { observedAfter: parsed.waitReceiveObservedAfter } : {},
-						pollMs: parsed.waitPollMs ?? DEFAULT_WAIT_RECEIVE_POLL_MS,
-						...parsed.waitReceiveText ? { text: parsed.waitReceiveText } : {},
-						timeoutMs: parsed.waitTimeoutMs ?? DEFAULT_WAIT_RECEIVE_TIMEOUT_MS
-					});
-					options.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
-					return 0;
+				yield* daemon.start();
+				const status = yield* waitForReceiveStatus(() => daemon.status(), waitReceive, {
+					...parsed.waitReceiveMessageId ? { messageId: parsed.waitReceiveMessageId } : {},
+					...parsed.waitReceiveObservedAfter ? { observedAfter: parsed.waitReceiveObservedAfter } : {},
+					pollMs: parsed.waitPollMs ?? DEFAULT_WAIT_RECEIVE_POLL_MS,
+					...parsed.waitReceiveText ? { text: parsed.waitReceiveText } : {},
+					timeoutMs: parsed.waitTimeoutMs ?? DEFAULT_WAIT_RECEIVE_TIMEOUT_MS
 				});
-			}
-			installCliShutdownController(options, daemon);
-			await Effect.runPromise(daemon.start());
-			options.stdout.write("Rivus Agent daemon started\n");
-			return 0;
-		} catch (error) {
-			options.stderr.write(`${formatCliError(error)}\n`);
-			return 1;
+				options.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+				return 0;
+			}));
 		}
-	});
+		yield* Effect.try({
+			try: () => installCliShutdownController(options, daemon),
+			catch: (error) => error
+		});
+		yield* daemon.start();
+		options.stdout.write("Rivus Agent daemon started\n");
+		return 0;
+	}).pipe(Effect.catchAll((error) => Effect.sync(() => {
+		options.stderr.write(`${formatCliError(error)}\n`);
+		return 1;
+	})));
 }
 async function createCliLegacyDaemon(module, context) {
 	const factory = module.createRivusDaemonProcess ?? module.default;
@@ -2430,12 +3109,8 @@ async function createCliDeploymentDaemon(factory, context) {
 	if (!factory) throw new Error("Manifest bootstrap module must export createRivusDeploymentAdapters(context)");
 	return createRivusDeploymentCliProcess(factory, context);
 }
-async function runOneShotDaemon(daemon, action) {
-	try {
-		return await action();
-	} finally {
-		await Effect.runPromise(daemon.stop());
-	}
+function runOneShotDaemon(daemon, action) {
+	return Effect.exit(Effect.suspend(action)).pipe(Effect.flatMap((exit) => daemon.stop().pipe(Effect.flatMap(() => exit._tag === "Success" ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)))));
 }
 function installCliShutdownController(options, daemon) {
 	createRivusDaemonShutdownController({
@@ -3258,23 +3933,22 @@ async function fetchLiveStatus(url) {
 	if (!response.ok) throw new Error(`Status request failed with HTTP ${response.status}`);
 	return response.json();
 }
-async function waitForLiveReceiveStatus(url, target, options) {
-	return waitForReceiveStatus(() => fetchLiveStatus(url), target, options);
-}
-async function waitForReceiveStatus(readStatus, target, options) {
-	const startedAt = Date.now();
-	let lastStatus;
-	while (true) {
-		const status = await readStatus();
-		lastStatus = status;
-		if (hasReceiveObservation(status, target, {
-			...options.messageId ? { messageId: options.messageId } : {},
-			...options.observedAfter ? { observedAfter: options.observedAfter } : {},
-			...options.text ? { text: options.text } : {}
-		})) return status;
-		if (Date.now() - startedAt >= options.timeoutMs) throw new ReceiveWaitTimeoutError(target, lastStatus, options.messageId, options.observedAfter, options.text);
-		await sleep(options.pollMs);
-	}
+function waitForReceiveStatus(readStatus, target, options) {
+	return Effect.suspend(() => {
+		const startedAt = Date.now();
+		let lastStatus;
+		const poll = () => readStatus().pipe(Effect.flatMap((status) => {
+			lastStatus = status;
+			if (hasReceiveObservation(status, target, {
+				...options.messageId ? { messageId: options.messageId } : {},
+				...options.observedAfter ? { observedAfter: options.observedAfter } : {},
+				...options.text ? { text: options.text } : {}
+			})) return Effect.succeed(status);
+			if (Date.now() - startedAt >= options.timeoutMs) return Effect.fail(new ReceiveWaitTimeoutError(target, lastStatus, options.messageId, options.observedAfter, options.text));
+			return Effect.sleep(options.pollMs).pipe(Effect.flatMap(poll));
+		}));
+		return poll();
+	});
 }
 function hasReceiveObservation(status, target, criteria) {
 	const receive = readRecord(status)?.receive;
@@ -3311,9 +3985,6 @@ function readObservedAtMs(value) {
 		return Number.isNaN(time) ? void 0 : time;
 	}
 }
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function parseWaitReceive(value) {
 	return value === "accepted" || value === "handled" ? value : void 0;
 }
@@ -3338,4 +4009,4 @@ function hasRecoveryRunner(daemon) {
 	return typeof daemon.openRecoveryControl === "function";
 }
 //#endregion
-export { resolveFeishuEndpointCredentials as $, DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS as A, RUN_PRESENTATION_SCHEMA_VERSION as B, loadRivusDaemonConfig as C, loadRivusDeploymentManifest as D, RivusDeploymentManifestError as E, DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS as F, beginCardPresentationHandoff as G, CardPresentationTransitionDenied as H, DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS as I, createCardPresentationChain as J, compensateCardPresentationHandoff as K, resolveBackgroundSessionSupervisorIntervalMs as L, DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS as M, DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES as N, DEFAULT_CONVERSATION_PROGRESS_DISPLAY as O, DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS as P, FeishuEndpointCredentialError as Q, DEFAULT_CARD_STREAM_LEASE_MS as R, RivusDaemonConfigError as S, resolveNodeRivusPluginModulePath as T, acceptsCardPresentationProgress as U, hasInspectableRunProgress as V, activeCardPresentation as W, isCardPresentationHandoffDue as X, failCardPresentationHandoff as Y, markCardPresentationTerminal as Z, createStableId as _, InvalidRivusProjectSpace as a, createRivusEnvFromOpenClawConfig as b, RivusDeploymentReadinessError as c, createRivusAgentHost as d, loadMergedLocalEnvFile as et, AgentInstanceBusy as f, createAgentInstanceRegistry as g, AgentInstanceConflict as h, resolveRivusProjectSpace as i, DEFAULT_BACKGROUND_SESSION_LIFETIME_MS as j, DEFAULT_BACKGROUND_SESSION_LEASE_MS as k, createRivusDeploymentDaemon as l, createAgentRuntimePool as m, createRivusDeploymentCliProcess as n, loadRivusDeployment as nt, RivusDeploymentAutomationReadinessError as o, AgentRuntimeDisposed as p, completeCardPresentationHandoff as q, createConfiguredRivusDeploymentDaemon as r, validateRivusDeploymentManifest as rt, RivusDeploymentDaemonLifecycleError as s, runRivusDaemonCli as t, RivusPluginLoadError as tt, InvalidRivusEndpointBinding as u, createRivusDaemonShutdownController as v, loadNodeRivusPluginModule as w, formatRivusEnvFile as x, OpenClawEnvImportError as y, createFeishuCardRollover as z };
+export { validateCardPresentationLeaseMs as $, RivusDeploymentReadinessError as A, FeishuEndpointCredentialError as B, AgentInstanceConflict as C, RivusDeploymentAutomationReadinessError as D, RivusPluginLoadError as E, WorkspaceInstructionsSourceError as F, toEffectAgentRuntime as G, RivusDaemonConfigError as H, createRivusDaemonShutdownController as I, createRuntimeCache as J, toEffectAgentRuntimeInput as K, OpenClawEnvImportError as L, InvalidRivusProjectSpace as M, createStableId as N, RivusDeploymentBackgroundSessionReadinessError as O, InvalidWorkspaceRoot as P, cardPresentationLeaseDeadline as Q, createRivusEnvFromOpenClawConfig as R, InvalidAgentHostBinding as S, loadRivusDeploymentManifest as T, loadRivusDaemonConfig as U, resolveFeishuEndpointCredentials as V, loadMergedLocalEnvFile as W, invokeRuntimeControl as X, disposeRuntimeCacheEntries as Y, DEFAULT_CARD_STREAM_LEASE_MS$1 as Z, createAgentHostFromRuntimePort as _, createWorkspaceRootHandle as a, createCardPresentationService as at, AgentInstanceBusy as b, createNodeRivusPluginModuleLoader as c, activeCardPresentation as ct, validateTrustedModulePath as d, validateCardPresentationChain as dt, markCardDeliveryTerminal as et, isPathWithin as f, DEFAULT_CONVERSATION_PROGRESS_DISPLAY as ft, toEffectProcessAgentRuntimeInput as g, createProcessDeploymentControlPorts as h, resolveRivusProjectSpace as i, CardPresentationNotFound as it, validateRivusDeploymentManifest as j, RivusDeploymentDaemonLifecycleError as k, loadNodeRivusPluginModule as l, createCardPresentationChain as lt, resolveRivusPluginModule as m, createRivusDeploymentCliProcess as n, validateCardDeliveryRecord as nt, createRivusDeploymentControlModule as o, CardPresentationTransitionDenied as ot, findTrustedPackageRoot as p, toProcessAgentRuntimeInput as q, createAgentsMdInstructionsResolver as r, validateCardDeliveryTransition as rt, resolveRivusDeploymentModule as s, acceptsCardPresentationProgress as st, runRivusDaemonCli as t, reserveCardDeliverySequence as tt, resolveNodeRivusPluginModulePath as u, isCardPresentationHandoffDue as ut, createAgentHostRuntimePort as v, RivusDeploymentManifestError as w, AgentRuntimeDisposed as x, createAgentInstanceRegistryModule as y, formatRivusEnvFile as z };