@rivus/agent 0.16.2 → 0.16.6

package/dist/chunks/rivus-daemon-cli.js

@@ -1,3839 +0,0 @@
-import { t as createSha256Digest } from "./sha256-digest.js";
-import { f as isRivusRuntimeToolId, o as createRivusHostToolDescriptorProvider, p as deepFreeze, t as createRivusAgentCatalog } from "./rivus-agent-definition-resolver.js";
-import { l as narrowBackgroundSessionDefinition } from "./background-session-authority.js";
-import { createRequire } from "node:module";
-import { Cause, Deferred, Effect, Either, Exit, Option } from "effect";
-import { createHash, randomUUID } from "node:crypto";
-import { access, chmod, constants, lstat, mkdir, open, readFile, readdir, realpath, stat } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { homedir } from "node:os";
-import { pathToFileURL } from "node:url";
-import { constants as constants$1 } from "node:fs";
-//#region src/platform/home/config/runtime/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/platform/home/config/model-management/rivus-model-management-config-migration.ts
-const RIVUS_MODEL_MANAGEMENT_ENABLED_ENV = "RIVUS_MODEL_MANAGEMENT_ENABLED";
-const RIVUS_MODEL_MANAGEMENT_OWNER_OPEN_ID_ENV = "RIVUS_MODEL_MANAGEMENT_OWNER_OPEN_ID";
-const RIVUS_MODEL_MANAGEMENT_TENANT_KEY_ENV = "RIVUS_MODEL_MANAGEMENT_TENANT_KEY";
-const RIVUS_MODEL_MANAGEMENT_REQUIRE_APPROVAL_ENV = "RIVUS_MODEL_MANAGEMENT_REQUIRE_APPROVAL";
-var RivusModelManagementConfigError = class extends Error {
-	code;
-	name = "RivusModelManagementConfigError";
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-	}
-};
-/** Parse the Home capability flags without accepting truthy arbitrary strings. */
-function parseRivusModelManagementHomeConfig(env) {
-	const enabled = parseRivusModelManagementEnabled(env[RIVUS_MODEL_MANAGEMENT_ENABLED_ENV]);
-	const requireApproval = parseStrictBoolean(env[RIVUS_MODEL_MANAGEMENT_REQUIRE_APPROVAL_ENV], RIVUS_MODEL_MANAGEMENT_REQUIRE_APPROVAL_ENV, false);
-	const ownerOpenId = optional$1(env[RIVUS_MODEL_MANAGEMENT_OWNER_OPEN_ID_ENV]);
-	const tenantKey = optional$1(env[RIVUS_MODEL_MANAGEMENT_TENANT_KEY_ENV]);
-	if (enabled && !ownerOpenId) throw new RivusModelManagementConfigError("owner_missing", `${RIVUS_MODEL_MANAGEMENT_OWNER_OPEN_ID_ENV} is required when model management is enabled`);
-	if (enabled && !tenantKey) throw new RivusModelManagementConfigError("tenant_missing", `${RIVUS_MODEL_MANAGEMENT_TENANT_KEY_ENV} is required when model management is enabled`);
-	return Object.freeze({
-		enabled,
-		...ownerOpenId ? { ownerOpenId } : {},
-		requireApproval,
-		...tenantKey ? { tenantKey } : {}
-	});
-}
-function parseRivusModelManagementEnabled(value) {
-	return parseStrictBoolean(value, RIVUS_MODEL_MANAGEMENT_ENABLED_ENV, false);
-}
-function parseStrictBoolean(value, variable, defaultValue) {
-	if (value === void 0) return defaultValue;
-	const normalized = value.trim();
-	if (normalized === "true") return true;
-	if (normalized === "false") return false;
-	throw new RivusModelManagementConfigError("invalid_enabled", `${variable} must be true or false`);
-}
-/**
-* Migrate only the legacy model selection at the explicit enable/disable
-* boundary. The helper does not read or write managed model state.
-*/
-async function migrateRivusModelManagementConfig(input) {
-	if (typeof input.managementEnabled !== "boolean") throw new RivusModelManagementConfigError("invalid_enabled", "model management enabled state must be boolean");
-	if (input.managementEnabled) return enableModelManagement(input);
-	return disableModelManagement(input, parseModelReference(input.knownGoodProvider, input.knownGoodModel));
-}
-async function enableModelManagement(input) {
-	if (hasAmbientModelOverride(input.env)) return {
-		initialModel: parseConfiguredModel(input.env.PI_MODEL),
-		source: "ambient",
-		status: "enabled"
-	};
-	return {
-		initialModel: parseConfiguredModel((await loadEnvFile(requireEnvFilePath(input.envFilePath), input.env)).PI_MODEL),
-		source: "env-file",
-		status: "enabled"
-	};
-}
-async function disableModelManagement(input, knownGood) {
-	const envFilePath = requireEnvFilePath(input.envFilePath);
-	if (hasAmbientModelOverride(input.env)) throw new RivusModelManagementConfigError("ambient_model_override", "ambient PI_MODEL overrides the original env source and prevents verified model readback");
-	const original = await readWritableEnvFile(envFilePath);
-	const existingModel = parseOptionalConfiguredModel((await loadEnvFile(envFilePath, input.env)).PI_MODEL);
-	if (existingModel && sameModel(existingModel, knownGood)) return {
-		restoredModel: knownGood,
-		source: "env-file",
-		status: "unchanged"
-	};
-	const next = replacePiModel(original, knownGood);
-	try {
-		await input.writeAtomicTextFile(envFilePath, next, { durable: true });
-	} catch {
-		throw new RivusModelManagementConfigError("env_source_write_failed", "the original env source write did not complete with a known durable result");
-	}
-	let readBack;
-	try {
-		readBack = parseConfiguredModel((await loadMergedLocalEnvFile(envFilePath, input.env)).PI_MODEL);
-	} catch {
-		throw new RivusModelManagementConfigError("readback_mismatch", "the original env source could not be verified after restoring PI_MODEL");
-	}
-	if (readBack.provider !== knownGood.provider || readBack.model !== knownGood.model) throw new RivusModelManagementConfigError("readback_mismatch", "the original env source did not read back the known-good PI_MODEL");
-	return {
-		restoredModel: knownGood,
-		source: "env-file",
-		status: "exported"
-	};
-}
-function parseModelReference(provider, model) {
-	if (!isModelPart(provider) || !isModelPart(model)) throw new RivusModelManagementConfigError("invalid_model", "known-good model provider and id are invalid");
-	return Object.freeze({
-		model,
-		provider
-	});
-}
-function parseConfiguredModel(value) {
-	const configured = optional$1(value);
-	if (!configured) throw new RivusModelManagementConfigError("model_missing", "PI_MODEL is missing from the effective legacy config");
-	const separator = configured.indexOf("/");
-	if (separator <= 0 || separator === configured.length - 1 || configured.indexOf("/", separator + 1) !== -1) throw new RivusModelManagementConfigError("invalid_model", "PI_MODEL must use provider/model form");
-	return parseModelReference(configured.slice(0, separator), configured.slice(separator + 1));
-}
-function parseOptionalConfiguredModel(value) {
-	if (!optional$1(value)) return void 0;
-	try {
-		return parseConfiguredModel(value);
-	} catch {
-		return;
-	}
-}
-function sameModel(left, right) {
-	return left.provider === right.provider && left.model === right.model;
-}
-async function loadEnvFile(envFilePath, env) {
-	try {
-		return await loadMergedLocalEnvFile(envFilePath, env);
-	} catch {
-		throw new RivusModelManagementConfigError("env_source_unreadable", "the original env source could not be loaded");
-	}
-}
-async function readWritableEnvFile(envFilePath) {
-	try {
-		const contents = await readFile(envFilePath, "utf8");
-		if (((await stat(envFilePath)).mode & 146) === 0) throw new RivusModelManagementConfigError("env_source_unwritable", "the original env source is not writable");
-		await access(envFilePath, constants.W_OK);
-		return contents;
-	} catch (error) {
-		if (error instanceof RivusModelManagementConfigError) throw error;
-		if (isPermissionError(error)) throw new RivusModelManagementConfigError("env_source_unwritable", "the original env source is not writable");
-		throw new RivusModelManagementConfigError("env_source_unreadable", "the original env source is unavailable");
-	}
-}
-function replacePiModel(contents, model) {
-	const modelValue = `${model.provider}/${model.model}`;
-	const parts = contents.split(/(\r\n|\n|\r)/);
-	let replaced = false;
-	for (let index = 0; index < parts.length; index += 2) {
-		const line = parts[index];
-		if (line === void 0) continue;
-		const match = line.match(/^(\s*(?:export\s+)?PI_MODEL\s*=\s*)(.*)$/);
-		if (!match) continue;
-		const inlineComment = match[2].match(/(\s+#.*)$/)?.[1] ?? "";
-		parts[index] = `${match[1]}${modelValue}${inlineComment}`;
-		replaced = true;
-	}
-	if (replaced) return parts.join("");
-	const newline = contents.includes("\r\n") ? "\r\n" : contents.includes("\n") ? "\n" : "\n";
-	if (!contents) return `PI_MODEL=${modelValue}${newline}`;
-	return /(?:\r\n|\n|\r)$/.test(contents) ? `${contents}PI_MODEL=${modelValue}${newline}` : `${contents}${newline}PI_MODEL=${modelValue}`;
-}
-function requireEnvFilePath(value) {
-	const normalized = optional$1(value);
-	if (!normalized) throw new RivusModelManagementConfigError("env_source_missing", "an explicit writable original env source is required for model management migration");
-	return normalized;
-}
-function hasAmbientModelOverride(env) {
-	return Object.prototype.hasOwnProperty.call(env, "PI_MODEL") && env.PI_MODEL !== void 0;
-}
-function isModelPart(value) {
-	return value.trim() === value && value.length > 0 && !/[/\s]/.test(value);
-}
-function optional$1(value) {
-	return value?.trim() || void 0;
-}
-function isPermissionError(error) {
-	return typeof error === "object" && error !== null && "code" in error && (error.code === "EACCES" || error.code === "EPERM" || error.code === "EROFS");
-}
-//#endregion
-//#region src/platform/home/config/model-management/rivus-runtime-management-skill-installer.ts
-const SKILL_NAME = "runtime-management";
-const SKILL_FILE = "SKILL.md";
-const INSTALL_METADATA_FILE = ".rivus-install.json";
-async function installRivusRuntimeManagementSkill(options) {
-	const writeAtomicTextFile = options.writeAtomicTextFile;
-	const skillDirectory = join(options.homeDirectory ?? homedir(), ".agents", "skills", SKILL_NAME);
-	const destination = join(skillDirectory, SKILL_FILE);
-	const metadataPath = join(skillDirectory, INSTALL_METADATA_FILE);
-	const source = await readFile(options.sourcePath, "utf8");
-	const sourceDigest = digest(source);
-	await mkdir(skillDirectory, { recursive: true });
-	const current = await readOptional(destination);
-	if (current === void 0) {
-		await writeAtomicTextFile(destination, source, { mode: 384 });
-		await writeMetadata(metadataPath, sourceDigest, writeAtomicTextFile);
-		return {
-			destination,
-			requiresRefresh: true,
-			sourceDigest,
-			status: "installed"
-		};
-	}
-	const currentDigest = digest(current);
-	if (currentDigest === sourceDigest) {
-		await writeMetadata(metadataPath, sourceDigest, writeAtomicTextFile);
-		return {
-			destination,
-			requiresRefresh: false,
-			sourceDigest,
-			status: "unchanged"
-		};
-	}
-	if ((await readMetadata(metadataPath))?.installedDigest !== currentDigest) return {
-		destination,
-		requiresRefresh: false,
-		sourceDigest,
-		status: "conflict"
-	};
-	await writeAtomicTextFile(destination, source, { mode: 384 });
-	await writeMetadata(metadataPath, sourceDigest, writeAtomicTextFile);
-	return {
-		destination,
-		requiresRefresh: true,
-		sourceDigest,
-		status: "updated"
-	};
-}
-function digest(value) {
-	return createHash("sha256").update(value, "utf8").digest("hex");
-}
-async function readOptional(path) {
-	try {
-		return await readFile(path, "utf8");
-	} catch (error) {
-		if (isMissing$1(error)) return void 0;
-		throw error;
-	}
-}
-async function readMetadata(path) {
-	const contents = await readOptional(path);
-	if (contents === void 0) return void 0;
-	try {
-		const value = JSON.parse(contents);
-		if (!isRecord(value) || typeof value.installedDigest !== "string") return void 0;
-		return { installedDigest: value.installedDigest };
-	} catch {
-		return;
-	}
-}
-async function writeMetadata(path, installedDigest, writeAtomicTextFile) {
-	await writeAtomicTextFile(path, `${JSON.stringify({
-		installedDigest,
-		version: 1
-	}, null, 2)}\n`, { mode: 384 });
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isMissing$1(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-//#endregion
-//#region src/platform/home/config/model-management/rivus-model-management-cli-launcher.ts
-const BIN_DIRECTORY_NAME = "bin";
-const LAUNCHER_NAME = "rivus";
-const PRIVATE_MODE = 448;
-/**
-* Install the private launcher used by model-management child processes.
-*
-* The launcher contains only fixed absolute executable paths. Per-Run
-* context, credentials, and other authority data stay in the spawn
-* environment owned by the Host and are never persisted in this file.
-*/
-async function installRivusModelManagementCliLauncher(options) {
-	assertAbsolutePath("directory", options.directory);
-	assertAbsolutePath("nodeExecutable", options.nodeExecutable);
-	assertAbsolutePath("cliEntryPath", options.cliEntryPath);
-	const binDirectory = join(options.directory, BIN_DIRECTORY_NAME);
-	const launcherPath = join(binDirectory, LAUNCHER_NAME);
-	await mkdir(binDirectory, {
-		mode: PRIVATE_MODE,
-		recursive: true
-	});
-	await chmod(binDirectory, PRIVATE_MODE);
-	await chmodIfPresent(launcherPath, PRIVATE_MODE);
-	await options.writeAtomicTextFile(launcherPath, renderLauncher(options), { mode: PRIVATE_MODE });
-	await chmod(launcherPath, PRIVATE_MODE);
-	return Object.freeze({
-		binDirectory,
-		launcherPath
-	});
-}
-function renderLauncher(options) {
-	return `#!/bin/sh\nexec ${shellQuote(options.nodeExecutable)} ${shellQuote(options.cliEntryPath)} "$@"\n`;
-}
-function shellQuote(value) {
-	if (value.includes("\0")) throw new Error("launcher paths must not contain NUL bytes");
-	return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function assertAbsolutePath(name, value) {
-	if (value.length === 0 || !isAbsolute(value)) throw new Error(`${name} must be an absolute path`);
-	if (value.includes("\0")) throw new Error(`${name} must not contain NUL bytes`);
-}
-async function chmodIfPresent(path, mode) {
-	try {
-		await chmod(path, mode);
-	} catch (error) {
-		if (isMissing(error)) return;
-		throw error;
-	}
-}
-function isMissing(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-//#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/bootstrap/deployment/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/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/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 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/adapters/cli/config/rivus-daemon-config.ts
-async function loadRivusEnvFromOpenClawConfig(filePath, piApiKeyFile) {
-	return createRivusEnvFromOpenClawConfig(JSON.parse(await readFile(filePath, "utf8")), piApiKeyFile ? { piApiKeyFile } : {});
-}
-function toRedactedConfig(config) {
-	return {
-		agentId: config.agentId,
-		feishu: {
-			appIdPresent: Boolean(config.feishu.appId),
-			appSecretPresent: Boolean(config.feishu.appSecret),
-			baseUrl: config.feishu.baseUrl,
-			cardStreamLeaseMs: config.feishu.cardStreamLeaseMs,
-			streamMinIntervalMs: config.feishu.streamMinIntervalMs
-		},
-		pi: {
-			apiKeyPresent: Boolean(config.pi.apiKey),
-			...config.pi.baseUrl ? { baseUrl: config.pi.baseUrl } : {},
-			...config.pi.model ? { model: config.pi.model } : {},
-			...config.pi.thinkingLevel ? { thinkingLevel: config.pi.thinkingLevel } : {}
-		}
-	};
-}
-function toRedactedDeploymentManifest(manifest) {
-	return {
-		agents: manifest.agents.map(({ agentId, endpointIds, pluginId, profileId }) => ({
-			agentId,
-			endpointIds,
-			pluginId,
-			profileId
-		})),
-		automations: (manifest.automations ?? []).map(({ agentId, delivery, enabled, id, required, schedule, templateId, timeZone }) => ({
-			agentId,
-			delivery: {
-				endpointId: delivery.endpointId,
-				targetRef: delivery.targetRef,
-				targetType: delivery.targetType
-			},
-			enabled,
-			id,
-			required,
-			schedule,
-			templateId,
-			timeZone
-		})),
-		...manifest.backgroundSessions ? { backgroundSessions: {
-			enabled: manifest.backgroundSessions.enabled,
-			leaseMs: manifest.backgroundSessions.leaseMs,
-			leaseRenewalIntervalMs: manifest.backgroundSessions.leaseRenewalIntervalMs,
-			maxConsecutiveFailures: manifest.backgroundSessions.maxConsecutiveFailures,
-			maxConcurrentSessions: manifest.backgroundSessions.maxConcurrentSessions,
-			required: manifest.backgroundSessions.required,
-			retryBackoffMs: manifest.backgroundSessions.retryBackoffMs,
-			sessionLifetimeMs: manifest.backgroundSessions.sessionLifetimeMs,
-			stepTimeoutMs: manifest.backgroundSessions.stepTimeoutMs
-		} } : {},
-		defaultAgentId: manifest.defaultAgentId,
-		defaultEndpointId: manifest.defaultEndpointId,
-		endpoints: manifest.endpoints.map(({ agentId, credentialRef, enabled, id, required, sessionNamespace }) => ({
-			agentId,
-			credentialRef,
-			enabled,
-			id,
-			required,
-			sessionNamespace
-		})),
-		plugins: manifest.plugins.map(({ id, module, required }) => ({
-			id,
-			module,
-			required
-		}))
-	};
-}
-async function loadCliEnv(envFilePath, overrideEnv) {
-	if (!envFilePath) return overrideEnv;
-	return loadMergedLocalEnvFile(envFilePath, overrideEnv);
-}
-//#endregion
-//#region src/adapters/cli/recovery/rivus-recovery-cli.ts
-function createRivusRecoveryCliParser() {
-	const input = { recoveryList: false };
-	return {
-		build: () => buildCommand(input),
-		consume: (argument, next) => consumeArgument(input, argument, next)
-	};
-}
-async function runRivusRecoveryCliCommand(control, command) {
-	switch (command.type) {
-		case "inspect": return Effect.runPromise(control.inspect());
-		case "requeue-dead-letter": return Effect.runPromise(control.requeueDeadLetter({
-			actorId: "local-cli",
-			deliveryId: command.deliveryId,
-			endpointId: command.endpointId,
-			expectedRevision: command.expectedRevision,
-			note: await readPrivateTextFile(command.noteFilePath, "Recovery note", 16 * 1024)
-		}));
-		case "resolve-tool-operation": {
-			const note = await readPrivateTextFile(command.noteFilePath, "Recovery note", 16 * 1024);
-			const outcome = command.outcome.status === "applied" ? {
-				result: parseToolResult(await readPrivateTextFile(command.outcome.resultFilePath, "Tool result", 1024 * 1024)),
-				status: "applied"
-			} : command.outcome;
-			return Effect.runPromise(control.resolveToolOperation({
-				actorId: "local-cli",
-				expectedRevision: command.expectedRevision,
-				instanceId: command.instanceId,
-				note,
-				operationId: command.operationId,
-				outcome
-			}));
-		}
-	}
-}
-function consumeArgument(input, argument, next) {
-	if (argument === "--recovery-list") {
-		input.recoveryList = true;
-		return {
-			consumed: 0,
-			handled: true
-		};
-	}
-	for (const [flag, key] of [
-		["--requeue-dead-letter", "requeueDeadLetterId"],
-		["--resolve-tool-operation", "resolveToolOperationId"],
-		["--endpoint-id", "endpointId"],
-		["--instance-id", "instanceId"],
-		["--expected-revision", "expectedRevision"],
-		["--recovery-note-file", "recoveryNoteFile"],
-		["--tool-outcome", "toolOutcome"],
-		["--tool-result-file", "toolResultFile"]
-	]) {
-		if (argument === flag) {
-			if (!next) return {
-				consumed: 0,
-				error: `${flag} requires a value`,
-				handled: true
-			};
-			input[key] = next;
-			return {
-				consumed: 1,
-				handled: true
-			};
-		}
-		if (argument?.startsWith(`${flag}=`)) {
-			const value = argument.slice(flag.length + 1);
-			if (!value) return {
-				consumed: 0,
-				error: `${flag} requires a value`,
-				handled: true
-			};
-			input[key] = value;
-			return {
-				consumed: 0,
-				handled: true
-			};
-		}
-	}
-	return {
-		consumed: 0,
-		handled: false
-	};
-}
-function buildCommand(input) {
-	const actionCount = Number(input.recoveryList) + Number(input.requeueDeadLetterId !== void 0) + Number(input.resolveToolOperationId !== void 0);
-	const hasOptions = input.endpointId !== void 0 || input.expectedRevision !== void 0 || input.instanceId !== void 0 || input.recoveryNoteFile !== void 0 || input.toolOutcome !== void 0 || input.toolResultFile !== void 0;
-	if (actionCount === 0) return hasOptions ? { error: "Recovery options require --recovery-list, --requeue-dead-letter, or --resolve-tool-operation" } : {};
-	if (actionCount > 1) return { error: "Choose only one recovery command" };
-	if (input.recoveryList) return hasOptions ? { error: "--recovery-list does not accept mutation options" } : { command: { type: "inspect" } };
-	const expectedRevision = parsePositiveInteger(input.expectedRevision);
-	if (expectedRevision === void 0) return { error: "Recovery mutations require --expected-revision with a positive integer" };
-	const noteFilePath = input.recoveryNoteFile?.trim();
-	if (!noteFilePath) return { error: "Recovery mutations require --recovery-note-file" };
-	if (input.requeueDeadLetterId !== void 0) return buildDeadLetterCommand(input, expectedRevision, noteFilePath);
-	return buildToolOperationCommand(input, expectedRevision, noteFilePath);
-}
-function buildDeadLetterCommand(input, expectedRevision, noteFilePath) {
-	const endpointId = input.endpointId?.trim();
-	if (!endpointId) return { error: "--requeue-dead-letter requires --endpoint-id" };
-	if (input.instanceId !== void 0 || input.toolOutcome !== void 0 || input.toolResultFile !== void 0) return { error: "--requeue-dead-letter cannot use Tool reconciliation options" };
-	return { command: {
-		deliveryId: input.requeueDeadLetterId,
-		endpointId,
-		expectedRevision,
-		noteFilePath,
-		type: "requeue-dead-letter"
-	} };
-}
-function buildToolOperationCommand(input, expectedRevision, noteFilePath) {
-	const instanceId = input.instanceId?.trim();
-	if (!instanceId) return { error: "--resolve-tool-operation requires --instance-id" };
-	if (input.endpointId !== void 0) return { error: "--resolve-tool-operation cannot use --endpoint-id" };
-	if (input.toolOutcome !== "applied" && input.toolOutcome !== "not-applied") return { error: "--resolve-tool-operation requires --tool-outcome applied or not-applied" };
-	if (input.toolOutcome === "not-applied") {
-		if (input.toolResultFile !== void 0) return { error: "--tool-result-file is only valid when --tool-outcome is applied" };
-		return { command: {
-			expectedRevision,
-			instanceId,
-			noteFilePath,
-			operationId: input.resolveToolOperationId,
-			outcome: { status: "not-applied" },
-			type: "resolve-tool-operation"
-		} };
-	}
-	const resultFilePath = input.toolResultFile?.trim();
-	if (!resultFilePath) return { error: "--tool-outcome applied requires --tool-result-file" };
-	return { command: {
-		expectedRevision,
-		instanceId,
-		noteFilePath,
-		operationId: input.resolveToolOperationId,
-		outcome: {
-			resultFilePath,
-			status: "applied"
-		},
-		type: "resolve-tool-operation"
-	} };
-}
-function parsePositiveInteger(value) {
-	return value && /^[1-9]\d*$/.test(value) ? Number(value) : void 0;
-}
-async function readPrivateTextFile(filePath, label, maxBytes) {
-	const handle = await open(filePath, constants$1.O_RDONLY | constants$1.O_NOFOLLOW);
-	try {
-		const metadata = await handle.stat();
-		if (!metadata.isFile()) throw new Error(`${label} must be a regular file`);
-		if ((metadata.mode & 63) !== 0) throw new Error(`${label} file permissions must be 0600 or stricter`);
-		if (metadata.size > maxBytes) throw new Error(`${label} file exceeds ${maxBytes} bytes`);
-		return (await handle.readFile("utf8")).trim();
-	} finally {
-		await handle.close();
-	}
-}
-function parseToolResult(value) {
-	try {
-		return JSON.parse(value);
-	} catch {
-		throw new Error("Tool result file must contain valid JSON");
-	}
-}
-//#endregion
-//#region src/adapters/cli/command/rivus-daemon-arguments.ts
-const RIVUS_DAEMON_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>]
-  rivus model <status|set|rollback> ...
-
-Options:
-  --bootstrap <module>  Module exporting createRivusDaemonProcess(context)
-  --manifest <path>     Start the manifest-driven multi-agent deployment; bootstrap exports createRivusDeploymentAdapters(context)
-  --env-file <path>     Load local KEY=value config before reading environment
-  --check-config        Print redacted local config JSON and exit
-  --prompt <text>       Run one local prompt through bootstrap promptText() and exit
-  --replay-feishu-event <json>
-                         Replay one Feishu receive-message payload through bootstrap replayReceiveMessage() and exit
-  --replay-feishu-text <text>
-                         Replay one synthetic Feishu receive-message text payload without Feishu side effects and exit
-  --feishu-message-id <id>
-                         Message id for --replay-feishu-text (default om_cli_<timestamp>)
-  --feishu-chat-id <id> Chat id for --replay-feishu-text (default oc_cli)
-  --feishu-thread-id <id>
-                         Thread id for --replay-feishu-text (default omt_cli)
-  --feishu-tenant-key <key>
-                         Tenant key for --replay-feishu-text (default tenant_cli)
-  --print-openclaw-env <json>
-                         Print a Rivus env file from an OpenClaw config JSON and exit
-  --pi-api-key-file <path>
-                         Add PI_API_KEY_FILE when using --print-openclaw-env
-  --session-key <key>   Session key for --prompt (default local:<agent-id>:cli)
-  --status              Print bootstrap status JSON without starting the daemon
-  --recovery-list       List Dead Letters and Tool operations requiring reconciliation
-  --requeue-dead-letter <message-id>
-                         Requeue one Dead Letter; requires --endpoint-id, --expected-revision, and --recovery-note-file
-  --resolve-tool-operation <operation-id>
-                         Resolve one uncertain Tool operation; requires --instance-id, --expected-revision,
-                         --tool-outcome, and --recovery-note-file
-  --endpoint-id <id>    Endpoint owning the Dead Letter
-  --instance-id <id>    Agent Instance owning the Tool operation
-  --expected-revision <n>
-                         Exact record revision required by a recovery mutation
-  --recovery-note-file <path>
-                         Private (0600) file containing the required audit note
-  --tool-outcome <applied|not-applied>
-                         Confirm whether the external Tool effect occurred
-  --tool-result-file <path>
-                         Private (0600) JSON file required when --tool-outcome is applied
-  --status-url <url>    Print live daemon status JSON from a running daemon
-  --wait-receive <kind> Wait with --status-url or a started bootstrap daemon until receive.lastAccepted or receive.lastHandled exists
-  --wait-receive-text <text>
-                         With --wait-receive handled, wait until receive.lastHandled.intake.text contains text
-  --wait-receive-message-id <id>
-                         With --wait-receive, wait until the accepted or handled receive observation has this Feishu message id
-  --wait-receive-observed-after <iso>
-                         With --wait-receive, ignore receive observations at or before this ISO timestamp
-  --wait-timeout-ms <n> Timeout for --wait-receive (default 30000)
-  --wait-poll-ms <n>   Poll interval for --wait-receive (default 500)
-  --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.
-  PI_API_KEY_FILE may point to a local BYOK key file instead of PI_API_KEY.
-`;
-function parseRivusDaemonArguments(argv) {
-	let bootstrap;
-	let checkConfig = false;
-	let envFilePath;
-	let feishuReplayChatId;
-	let feishuReplayMessageId;
-	let feishuReplayTenantKey;
-	let feishuReplayThreadId;
-	let manifestPath;
-	let piApiKeyFile;
-	let prompt;
-	let printOpenClawEnvPath;
-	let replayFeishuEventPath;
-	let replayFeishuText;
-	const recoveryCli = createRivusRecoveryCliParser();
-	let sessionKey;
-	let status = false;
-	let statusUrl;
-	let waitPollMs;
-	let waitReceive;
-	let waitReceiveMessageId;
-	let waitReceiveObservedAfter;
-	let waitReceiveText;
-	let waitTimeoutMs;
-	for (let index = 0; index < argv.length; index += 1) {
-		const arg = argv[index];
-		if (arg === "--help" || arg === "-h") return {
-			help: true,
-			status,
-			...statusUrl ? { statusUrl } : {}
-		};
-		if (arg === "--status") {
-			status = true;
-			continue;
-		}
-		const recoveryArgument = recoveryCli.consume(arg, argv[index + 1]);
-		if (recoveryArgument.handled) {
-			if (recoveryArgument.error) return {
-				error: recoveryArgument.error,
-				help: false,
-				status
-			};
-			index += recoveryArgument.consumed;
-			continue;
-		}
-		if (arg === "--check-config") {
-			checkConfig = true;
-			continue;
-		}
-		if (arg === "--env-file") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--env-file requires a path",
-				help: false,
-				status
-			};
-			envFilePath = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--env-file=")) {
-			envFilePath = arg.slice(11);
-			if (!envFilePath) return {
-				error: "--env-file requires a path",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--prompt") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--prompt requires text",
-				help: false,
-				status
-			};
-			prompt = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--prompt=")) {
-			prompt = arg.slice(9);
-			if (!prompt) return {
-				error: "--prompt requires text",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--session-key") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--session-key requires a value",
-				help: false,
-				status
-			};
-			sessionKey = value;
-			index += 1;
-			continue;
-		}
-		if (arg === "--print-openclaw-env") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--print-openclaw-env requires a JSON file path",
-				help: false,
-				status
-			};
-			printOpenClawEnvPath = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--print-openclaw-env=")) {
-			printOpenClawEnvPath = arg.slice(21);
-			if (!printOpenClawEnvPath) return {
-				error: "--print-openclaw-env requires a JSON file path",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--pi-api-key-file") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--pi-api-key-file requires a path",
-				help: false,
-				status
-			};
-			piApiKeyFile = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--pi-api-key-file=")) {
-			piApiKeyFile = arg.slice(18);
-			if (!piApiKeyFile) return {
-				error: "--pi-api-key-file requires a path",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--replay-feishu-event") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--replay-feishu-event requires a JSON file path",
-				help: false,
-				status
-			};
-			replayFeishuEventPath = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--replay-feishu-event=")) {
-			replayFeishuEventPath = arg.slice(22);
-			if (!replayFeishuEventPath) return {
-				error: "--replay-feishu-event requires a JSON file path",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--replay-feishu-text") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--replay-feishu-text requires text",
-				help: false,
-				status
-			};
-			replayFeishuText = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--replay-feishu-text=")) {
-			replayFeishuText = arg.slice(21);
-			if (!replayFeishuText) return {
-				error: "--replay-feishu-text requires text",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--feishu-message-id") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--feishu-message-id requires a value",
-				help: false,
-				status
-			};
-			feishuReplayMessageId = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--feishu-message-id=")) {
-			feishuReplayMessageId = arg.slice(20);
-			if (!feishuReplayMessageId) return {
-				error: "--feishu-message-id requires a value",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--feishu-chat-id") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--feishu-chat-id requires a value",
-				help: false,
-				status
-			};
-			feishuReplayChatId = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--feishu-chat-id=")) {
-			feishuReplayChatId = arg.slice(17);
-			if (!feishuReplayChatId) return {
-				error: "--feishu-chat-id requires a value",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--feishu-thread-id") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--feishu-thread-id requires a value",
-				help: false,
-				status
-			};
-			feishuReplayThreadId = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--feishu-thread-id=")) {
-			feishuReplayThreadId = arg.slice(19);
-			if (!feishuReplayThreadId) return {
-				error: "--feishu-thread-id requires a value",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--feishu-tenant-key") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--feishu-tenant-key requires a value",
-				help: false,
-				status
-			};
-			feishuReplayTenantKey = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--feishu-tenant-key=")) {
-			feishuReplayTenantKey = arg.slice(20);
-			if (!feishuReplayTenantKey) return {
-				error: "--feishu-tenant-key requires a value",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg?.startsWith("--session-key=")) {
-			sessionKey = arg.slice(14);
-			if (!sessionKey) return {
-				error: "--session-key requires a value",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--status-url") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--status-url requires a URL",
-				help: false,
-				status
-			};
-			statusUrl = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--status-url=")) {
-			statusUrl = arg.slice(13);
-			if (!statusUrl) return {
-				error: "--status-url requires a URL",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--wait-receive") {
-			const parsedWait = parseWaitReceive(argv[index + 1]);
-			if (!parsedWait) return {
-				error: "--wait-receive requires accepted or handled",
-				help: false,
-				status
-			};
-			waitReceive = parsedWait;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--wait-receive=")) {
-			const parsedWait = parseWaitReceive(arg.slice(15));
-			if (!parsedWait) return {
-				error: "--wait-receive requires accepted or handled",
-				help: false,
-				status
-			};
-			waitReceive = parsedWait;
-			continue;
-		}
-		if (arg === "--wait-receive-text") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--wait-receive-text requires text",
-				help: false,
-				status
-			};
-			waitReceiveText = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--wait-receive-text=")) {
-			waitReceiveText = arg.slice(20);
-			if (!waitReceiveText) return {
-				error: "--wait-receive-text requires text",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--wait-receive-message-id") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--wait-receive-message-id requires a message id",
-				help: false,
-				status
-			};
-			waitReceiveMessageId = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--wait-receive-message-id=")) {
-			waitReceiveMessageId = arg.slice(26);
-			if (!waitReceiveMessageId) return {
-				error: "--wait-receive-message-id requires a message id",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg === "--wait-receive-observed-after") {
-			const value = parseIsoTimestampArgument(argv[index + 1]);
-			if (!value) return {
-				error: "--wait-receive-observed-after requires an ISO timestamp",
-				help: false,
-				status
-			};
-			waitReceiveObservedAfter = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--wait-receive-observed-after=")) {
-			const value = parseIsoTimestampArgument(arg.slice(30));
-			if (!value) return {
-				error: "--wait-receive-observed-after requires an ISO timestamp",
-				help: false,
-				status
-			};
-			waitReceiveObservedAfter = value;
-			continue;
-		}
-		if (arg === "--wait-timeout-ms") {
-			const parsedMs = parsePositiveIntegerArgument(argv[index + 1]);
-			if (parsedMs === void 0) return {
-				error: "--wait-timeout-ms requires a positive integer",
-				help: false,
-				status
-			};
-			waitTimeoutMs = parsedMs;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--wait-timeout-ms=")) {
-			const parsedMs = parsePositiveIntegerArgument(arg.slice(18));
-			if (parsedMs === void 0) return {
-				error: "--wait-timeout-ms requires a positive integer",
-				help: false,
-				status
-			};
-			waitTimeoutMs = parsedMs;
-			continue;
-		}
-		if (arg === "--wait-poll-ms") {
-			const parsedMs = parsePositiveIntegerArgument(argv[index + 1]);
-			if (parsedMs === void 0) return {
-				error: "--wait-poll-ms requires a positive integer",
-				help: false,
-				status
-			};
-			waitPollMs = parsedMs;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--wait-poll-ms=")) {
-			const parsedMs = parsePositiveIntegerArgument(arg.slice(15));
-			if (parsedMs === void 0) return {
-				error: "--wait-poll-ms requires a positive integer",
-				help: false,
-				status
-			};
-			waitPollMs = parsedMs;
-			continue;
-		}
-		if (arg === "--bootstrap") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--bootstrap requires a module specifier",
-				help: false,
-				status
-			};
-			bootstrap = value;
-			index += 1;
-			continue;
-		}
-		if (arg === "--manifest") {
-			const value = argv[index + 1];
-			if (!value) return {
-				error: "--manifest requires a path",
-				help: false,
-				status
-			};
-			manifestPath = value;
-			index += 1;
-			continue;
-		}
-		if (arg?.startsWith("--manifest=")) {
-			manifestPath = arg.slice(11);
-			if (!manifestPath) return {
-				error: "--manifest requires a path",
-				help: false,
-				status
-			};
-			continue;
-		}
-		if (arg?.startsWith("--bootstrap=")) {
-			bootstrap = arg.slice(12);
-			if (!bootstrap) return {
-				error: "--bootstrap requires a module specifier",
-				help: false,
-				status
-			};
-			continue;
-		}
-		return {
-			error: `Unknown argument: ${arg}`,
-			help: false,
-			status
-		};
-	}
-	if (prompt !== void 0 && status) return {
-		error: "--prompt cannot be combined with --status",
-		help: false,
-		status
-	};
-	if (checkConfig && status) return {
-		error: "--check-config cannot be combined with --status",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (checkConfig && prompt !== void 0) return {
-		error: "--check-config cannot be combined with --prompt",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (checkConfig && replayFeishuEventPath !== void 0) return {
-		error: "--check-config cannot be combined with --replay-feishu-event",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (checkConfig && replayFeishuText !== void 0) return {
-		error: "--check-config cannot be combined with --replay-feishu-text",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (checkConfig && printOpenClawEnvPath !== void 0) return {
-		error: "--check-config cannot be combined with --print-openclaw-env",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (checkConfig && statusUrl) return {
-		error: "--check-config cannot be combined with --status-url",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (prompt !== void 0 && statusUrl) return {
-		error: "--prompt cannot be combined with --status-url",
-		help: false,
-		status
-	};
-	if (printOpenClawEnvPath !== void 0 && prompt !== void 0) return {
-		error: "--print-openclaw-env cannot be combined with --prompt",
-		help: false,
-		status
-	};
-	if (printOpenClawEnvPath !== void 0 && replayFeishuEventPath !== void 0) return {
-		error: "--print-openclaw-env cannot be combined with --replay-feishu-event",
-		help: false,
-		status
-	};
-	if (printOpenClawEnvPath !== void 0 && replayFeishuText !== void 0) return {
-		error: "--print-openclaw-env cannot be combined with --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (printOpenClawEnvPath !== void 0 && status) return {
-		error: "--print-openclaw-env cannot be combined with --status",
-		help: false,
-		status
-	};
-	if (printOpenClawEnvPath !== void 0 && statusUrl) return {
-		error: "--print-openclaw-env cannot be combined with --status-url",
-		help: false,
-		status
-	};
-	if (piApiKeyFile !== void 0 && printOpenClawEnvPath === void 0) return {
-		error: "--pi-api-key-file requires --print-openclaw-env",
-		help: false,
-		status
-	};
-	if (replayFeishuEventPath !== void 0 && prompt !== void 0) return {
-		error: "--replay-feishu-event cannot be combined with --prompt",
-		help: false,
-		status
-	};
-	if (replayFeishuEventPath !== void 0 && replayFeishuText !== void 0) return {
-		error: "--replay-feishu-event cannot be combined with --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (replayFeishuEventPath !== void 0 && status) return {
-		error: "--replay-feishu-event cannot be combined with --status",
-		help: false,
-		status
-	};
-	if (replayFeishuEventPath !== void 0 && statusUrl) return {
-		error: "--replay-feishu-event cannot be combined with --status-url",
-		help: false,
-		status
-	};
-	if (replayFeishuText !== void 0 && prompt !== void 0) return {
-		error: "--replay-feishu-text cannot be combined with --prompt",
-		help: false,
-		status
-	};
-	if (replayFeishuText !== void 0 && status) return {
-		error: "--replay-feishu-text cannot be combined with --status",
-		help: false,
-		status
-	};
-	if (replayFeishuText !== void 0 && statusUrl) return {
-		error: "--replay-feishu-text cannot be combined with --status-url",
-		help: false,
-		status
-	};
-	if (feishuReplayMessageId !== void 0 && replayFeishuText === void 0) return {
-		error: "--feishu-message-id requires --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (feishuReplayChatId !== void 0 && replayFeishuText === void 0) return {
-		error: "--feishu-chat-id requires --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (feishuReplayThreadId !== void 0 && replayFeishuText === void 0) return {
-		error: "--feishu-thread-id requires --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (feishuReplayTenantKey !== void 0 && replayFeishuText === void 0) return {
-		error: "--feishu-tenant-key requires --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (sessionKey !== void 0 && prompt === void 0) return {
-		error: "--session-key requires --prompt",
-		help: false,
-		status
-	};
-	if (waitReceive !== void 0 && status) return {
-		error: "--wait-receive cannot be combined with --status",
-		help: false,
-		status
-	};
-	if (waitReceive !== void 0 && checkConfig) return {
-		error: "--wait-receive cannot be combined with --check-config",
-		help: false,
-		status,
-		checkConfig
-	};
-	if (waitReceive !== void 0 && prompt !== void 0) return {
-		error: "--wait-receive cannot be combined with --prompt",
-		help: false,
-		status
-	};
-	if (waitReceive !== void 0 && replayFeishuEventPath !== void 0) return {
-		error: "--wait-receive cannot be combined with --replay-feishu-event",
-		help: false,
-		status
-	};
-	if (waitReceive !== void 0 && replayFeishuText !== void 0) return {
-		error: "--wait-receive cannot be combined with --replay-feishu-text",
-		help: false,
-		status
-	};
-	if (waitReceive !== void 0 && printOpenClawEnvPath !== void 0) return {
-		error: "--wait-receive cannot be combined with --print-openclaw-env",
-		help: false,
-		status
-	};
-	if (waitTimeoutMs !== void 0 && waitReceive === void 0) return {
-		error: "--wait-timeout-ms requires --wait-receive",
-		help: false,
-		status
-	};
-	if (waitPollMs !== void 0 && waitReceive === void 0) return {
-		error: "--wait-poll-ms requires --wait-receive",
-		help: false,
-		status
-	};
-	if (waitReceiveText !== void 0 && waitReceive !== "handled") return {
-		error: "--wait-receive-text requires --wait-receive handled",
-		help: false,
-		status
-	};
-	if (waitReceiveMessageId !== void 0 && waitReceive === void 0) return {
-		error: "--wait-receive-message-id requires --wait-receive",
-		help: false,
-		status
-	};
-	if (waitReceiveObservedAfter !== void 0 && waitReceive === void 0) return {
-		error: "--wait-receive-observed-after requires --wait-receive",
-		help: false,
-		status
-	};
-	const recovery = recoveryCli.build();
-	if (recovery.error) return {
-		error: recovery.error,
-		help: false,
-		status
-	};
-	if (recovery.command) {
-		if (!manifestPath) return {
-			error: "Recovery commands require --manifest",
-			help: false,
-			status
-		};
-		if (checkConfig || prompt !== void 0 || printOpenClawEnvPath !== void 0 || replayFeishuEventPath !== void 0 || replayFeishuText !== void 0 || status || statusUrl !== void 0 || waitReceive !== void 0) return {
-			error: "Recovery commands cannot be combined with another one-shot command",
-			help: false,
-			status
-		};
-	}
-	return {
-		...bootstrap ? { bootstrap } : {},
-		checkConfig,
-		...envFilePath ? { envFilePath } : {},
-		...feishuReplayChatId !== void 0 ? { feishuReplayChatId } : {},
-		...feishuReplayMessageId !== void 0 ? { feishuReplayMessageId } : {},
-		...feishuReplayTenantKey !== void 0 ? { feishuReplayTenantKey } : {},
-		...feishuReplayThreadId !== void 0 ? { feishuReplayThreadId } : {},
-		help: false,
-		...manifestPath ? { manifestPath } : {},
-		...piApiKeyFile !== void 0 ? { piApiKeyFile } : {},
-		...prompt !== void 0 ? { prompt } : {},
-		...printOpenClawEnvPath !== void 0 ? { printOpenClawEnvPath } : {},
-		...replayFeishuEventPath !== void 0 ? { replayFeishuEventPath } : {},
-		...replayFeishuText !== void 0 ? { replayFeishuText } : {},
-		...recovery.command ? { recoveryCommand: recovery.command } : {},
-		...sessionKey ? { sessionKey } : {},
-		status,
-		...statusUrl ? { statusUrl } : {},
-		...waitPollMs !== void 0 ? { waitPollMs } : {},
-		...waitReceive !== void 0 ? { waitReceive } : {},
-		...waitReceiveMessageId !== void 0 ? { waitReceiveMessageId } : {},
-		...waitReceiveObservedAfter !== void 0 ? { waitReceiveObservedAfter } : {},
-		...waitReceiveText !== void 0 ? { waitReceiveText } : {},
-		...waitTimeoutMs !== void 0 ? { waitTimeoutMs } : {}
-	};
-}
-function parseWaitReceive(value) {
-	return value === "accepted" || value === "handled" ? value : void 0;
-}
-function parsePositiveIntegerArgument(value) {
-	return value && /^[1-9]\d*$/.test(value) ? Number(value) : void 0;
-}
-function parseIsoTimestampArgument(value) {
-	if (!value) return;
-	const time = Date.parse(value);
-	return Number.isNaN(time) ? void 0 : new Date(time).toISOString();
-}
-//#endregion
-//#region src/adapters/cli/command/rivus-daemon-output.ts
-const RIVUS_DAEMON_STARTED_MESSAGE = "Rivus Agent daemon started\n";
-function formatRivusDaemonUsageError(error) {
-	return `${error}\n\n${RIVUS_DAEMON_USAGE}`;
-}
-function formatRivusDaemonJson(value) {
-	return `${JSON.stringify(value, null, 2)}\n`;
-}
-function formatRivusDaemonLine(text) {
-	return `${text}\n`;
-}
-function formatRivusDaemonWarning(warning) {
-	return `Warning: ${warning}\n`;
-}
-function formatRivusDaemonCapabilityError(capability) {
-	return `${{
-		recovery: "Bootstrap daemon does not expose openRecoveryControl()",
-		status: "Bootstrap daemon does not expose status()",
-		prompt: "Bootstrap daemon does not expose promptText(command)",
-		replay: "Bootstrap daemon does not expose replayReceiveMessage(payload)"
-	}[capability]}\n`;
-}
-function formatRivusDaemonShutdownFailure(signal, error) {
-	return `Failed to stop daemon after ${signal}: ${error}\n`;
-}
-//#endregion
-//#region src/adapters/cli/replay/rivus-daemon-replay.ts
-async function readFeishuReceiveMessagePayload(filePath) {
-	return JSON.parse(await readFile(filePath, "utf8"));
-}
-function createSyntheticFeishuTextReplayPayload(text, options) {
-	return { event: {
-		message: {
-			chat_id: options.chatId ?? "oc_cli",
-			content: JSON.stringify({ text }),
-			message_id: options.messageId ?? `om_cli_${Date.now()}`,
-			message_type: "text",
-			thread_id: options.threadId ?? "omt_cli"
-		},
-		sender: { tenant_key: options.tenantKey ?? "tenant_cli" }
-	} };
-}
-function formatRivusDaemonError(error) {
-	if (error instanceof ReceiveWaitTimeoutError) return `${error.message}\nLast status:\n${JSON.stringify(error.lastStatus, null, 2)}`;
-	return error instanceof Error ? error.message : String(error);
-}
-var ReceiveWaitTimeoutError = class extends Error {
-	target;
-	lastStatus;
-	messageId;
-	observedAfter;
-	text;
-	constructor(target, lastStatus, messageId, observedAfter, text) {
-		super(`Timed out waiting for ${target === "accepted" ? "receive.lastAccepted" : "receive.lastHandled"}${messageId ? ` with message id ${JSON.stringify(messageId)}` : ""}${observedAfter ? ` observed after ${JSON.stringify(observedAfter)}` : ""}${text ? ` containing text ${JSON.stringify(text)}` : ""}`);
-		this.target = target;
-		this.lastStatus = lastStatus;
-		this.messageId = messageId;
-		this.observedAfter = observedAfter;
-		this.text = text;
-		this.name = "ReceiveWaitTimeoutError";
-	}
-};
-async function fetchLiveStatus(url) {
-	const response = await fetch(url, { headers: { accept: "application/json" } });
-	if (!response.ok) throw new Error(`Status request failed with HTTP ${response.status}`);
-	return response.json();
-}
-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 = isStatusRecord(status) ? status.receive : void 0;
-	if (!isStatusRecord(receive)) return false;
-	if (target === "accepted") {
-		const lastAccepted = receive.lastAccepted;
-		if (!isStatusRecord(lastAccepted)) return false;
-		if (criteria.messageId === void 0) return observedAfterMatches(lastAccepted, criteria.observedAfter);
-		const message = lastAccepted.message;
-		return isStatusRecord(message) && message.messageId === criteria.messageId && observedAfterMatches(lastAccepted, criteria.observedAfter);
-	}
-	const lastHandled = receive.lastHandled;
-	if (!isStatusRecord(lastHandled)) return false;
-	if (criteria.messageId !== void 0 && lastHandled.messageId !== criteria.messageId) return false;
-	if (!observedAfterMatches(lastHandled, criteria.observedAfter)) return false;
-	if (criteria.text === void 0) return true;
-	const intake = lastHandled.intake;
-	return isStatusRecord(intake) && typeof intake.text === "string" && intake.text.includes(criteria.text);
-}
-function isStatusRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function observedAfterMatches(observation, observedAfter) {
-	if (observedAfter === void 0) return true;
-	const observedAtMs = readObservedAtMs(observation.observedAt);
-	return observedAtMs !== void 0 && observedAtMs > Date.parse(observedAfter);
-}
-function readObservedAtMs(value) {
-	if (value instanceof Date) {
-		const time = value.getTime();
-		return Number.isNaN(time) ? void 0 : time;
-	}
-	if (typeof value === "string") {
-		const time = Date.parse(value);
-		return Number.isNaN(time) ? void 0 : time;
-	}
-}
-//#endregion
-//#region src/core/application/deployment/manifest/deployment-manifest.ts
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_LEASE_MS = 3e4;
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS = 1e4;
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES = 3;
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS = 4;
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_RETRY_BACKOFF_MS = 3e4;
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_LIFETIME_MS = 1440 * 60 * 1e3;
-const DEFAULT_MANIFEST_BACKGROUND_SESSION_STEP_TIMEOUT_MS = 300 * 1e3;
-const DEFAULT_MANIFEST_CARD_STREAM_LEASE_MS = 51e4;
-const DEFAULT_MANIFEST_CONVERSATION_PROGRESS_DISPLAY = "collapsed";
-const MEMORY_SCOPES = [
-	"conversation",
-	"agent-private",
-	"project",
-	"shared-user-profile"
-];
-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);
-}
-function parseRivusDeploymentManifest(value) {
-	const root = record(value, "manifest");
-	exactKeys(root, [
-		"agents",
-		"automations",
-		"backgroundSessions",
-		"defaultAgentId",
-		"defaultEndpointId",
-		"endpoints",
-		"plugins",
-		"projectSpaces"
-	], "manifest", [
-		"automations",
-		"backgroundSessions",
-		"projectSpaces"
-	]);
-	const plugins = array(root.plugins, "manifest.plugins").map((entry, index) => {
-		const plugin = record(entry, `manifest.plugins[${index}]`);
-		exactKeys(plugin, [
-			"id",
-			"module",
-			"required"
-		], `manifest.plugins[${index}]`);
-		return Object.freeze({
-			id: string(plugin.id, `manifest.plugins[${index}].id`),
-			module: string(plugin.module, `manifest.plugins[${index}].module`),
-			required: boolean(plugin.required, `manifest.plugins[${index}].required`)
-		});
-	});
-	const agents = array(root.agents, "manifest.agents").map((entry, index) => {
-		const agent = record(entry, `manifest.agents[${index}]`);
-		exactKeys(agent, [
-			"agentId",
-			"endpointIds",
-			"memory",
-			"pluginId",
-			"profileId",
-			"projectSpaceId",
-			"runtimeTools",
-			"skills",
-			"tools"
-		], `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}]`))),
-			...memory ? { memory: Object.freeze({
-				scopes: Object.freeze(array(memory.scopes, `manifest.agents[${index}].memory.scopes`).map((item, itemIndex) => memoryScope(item, `manifest.agents[${index}].memory.scopes[${itemIndex}]`))),
-				tool: boolean(memory.tool, `manifest.agents[${index}].memory.tool`)
-			}) } : {},
-			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}]`))) })
-		});
-	});
-	const endpoints = array(root.endpoints, "manifest.endpoints").map((entry, index) => {
-		const endpoint = record(entry, `manifest.endpoints[${index}]`);
-		exactKeys(endpoint, [
-			"agentId",
-			"baseUrl",
-			"cardStreamLeaseMs",
-			"credentialRef",
-			"enabled",
-			"experimental",
-			"groupPolicy",
-			"id",
-			"progressDisplay",
-			"required",
-			"sessionNamespace",
-			"streamMinIntervalMs"
-		], `manifest.endpoints[${index}]`, [
-			"cardStreamLeaseMs",
-			"experimental",
-			"progressDisplay"
-		]);
-		const experimental = endpoint.experimental === void 0 ? void 0 : record(endpoint.experimental, `manifest.endpoints[${index}].experimental`);
-		if (experimental) exactKeys(experimental, ["cotMessages"], `manifest.endpoints[${index}].experimental`);
-		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_MANIFEST_CARD_STREAM_LEASE_MS : 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`) }) } : {},
-			groupPolicy: groupPolicy(endpoint.groupPolicy, `manifest.endpoints[${index}].groupPolicy`),
-			id: string(endpoint.id, `manifest.endpoints[${index}].id`),
-			progressDisplay: endpoint.progressDisplay === void 0 ? DEFAULT_MANIFEST_CONVERSATION_PROGRESS_DISPLAY : progressDisplay(endpoint.progressDisplay, `manifest.endpoints[${index}].progressDisplay`),
-			required: boolean(endpoint.required, `manifest.endpoints[${index}].required`),
-			sessionNamespace: string(endpoint.sessionNamespace, `manifest.endpoints[${index}].sessionNamespace`),
-			streamMinIntervalMs: positiveInteger(endpoint.streamMinIntervalMs, `manifest.endpoints[${index}].streamMinIntervalMs`)
-		});
-	});
-	const automations = array(root.automations ?? [], "manifest.automations").map((entry, index) => {
-		const automation = record(entry, `manifest.automations[${index}]`);
-		exactKeys(automation, [
-			"agentId",
-			"delivery",
-			"enabled",
-			"id",
-			"required",
-			"schedule",
-			"templateId",
-			"timeZone"
-		], `manifest.automations[${index}]`);
-		const delivery = record(automation.delivery, `manifest.automations[${index}].delivery`);
-		exactKeys(delivery, [
-			"endpointId",
-			"targetRef",
-			"targetType"
-		], `manifest.automations[${index}].delivery`);
-		return Object.freeze({
-			agentId: string(automation.agentId, `manifest.automations[${index}].agentId`),
-			delivery: Object.freeze({
-				endpointId: string(delivery.endpointId, `manifest.automations[${index}].delivery.endpointId`),
-				targetRef: string(delivery.targetRef, `manifest.automations[${index}].delivery.targetRef`),
-				targetType: automationTargetType(delivery.targetType, `manifest.automations[${index}].delivery.targetType`)
-			}),
-			enabled: boolean(automation.enabled, `manifest.automations[${index}].enabled`),
-			id: string(automation.id, `manifest.automations[${index}].id`),
-			required: boolean(automation.required, `manifest.automations[${index}].required`),
-			schedule: string(automation.schedule, `manifest.automations[${index}].schedule`),
-			templateId: string(automation.templateId, `manifest.automations[${index}].templateId`),
-			timeZone: string(automation.timeZone, `manifest.automations[${index}].timeZone`)
-		});
-	});
-	const projectSpaces = array(root.projectSpaces ?? [], "manifest.projectSpaces").map((entry, index) => {
-		const projectSpace = record(entry, `manifest.projectSpaces[${index}]`);
-		exactKeys(projectSpace, [
-			"id",
-			"root",
-			"skills",
-			"workingDirectory"
-		], `manifest.projectSpaces[${index}]`);
-		const skills = record(projectSpace.skills, `manifest.projectSpaces[${index}].skills`);
-		exactKeys(skills, ["sources"], `manifest.projectSpaces[${index}].skills`);
-		return Object.freeze({
-			id: string(projectSpace.id, `manifest.projectSpaces[${index}].id`),
-			root: string(projectSpace.root, `manifest.projectSpaces[${index}].root`),
-			skills: Object.freeze({ sources: Object.freeze(array(skills.sources, `manifest.projectSpaces[${index}].skills.sources`).map((item, itemIndex) => string(item, `manifest.projectSpaces[${index}].skills.sources[${itemIndex}]`))) }),
-			workingDirectory: string(projectSpace.workingDirectory, `manifest.projectSpaces[${index}].workingDirectory`)
-		});
-	});
-	const backgroundSessions = root.backgroundSessions === void 0 ? void 0 : parseBackgroundSessions(record(root.backgroundSessions, "manifest.backgroundSessions"));
-	return Object.freeze({
-		agents: Object.freeze(agents),
-		automations: Object.freeze(automations),
-		...backgroundSessions ? { backgroundSessions } : {},
-		defaultAgentId: string(root.defaultAgentId, "manifest.defaultAgentId"),
-		defaultEndpointId: string(root.defaultEndpointId, "manifest.defaultEndpointId"),
-		endpoints: Object.freeze(endpoints),
-		plugins: Object.freeze(plugins),
-		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",
-		"leaseMs",
-		"leaseRenewalIntervalMs",
-		"maxConsecutiveFailures",
-		"maxConcurrentSessions",
-		"required",
-		"retryBackoffMs",
-		"sessionLifetimeMs",
-		"stepTimeoutMs"
-	], "manifest.backgroundSessions", [
-		"leaseMs",
-		"leaseRenewalIntervalMs",
-		"maxConsecutiveFailures",
-		"maxConcurrentSessions",
-		"retryBackoffMs",
-		"sessionLifetimeMs",
-		"stepTimeoutMs"
-	]);
-	return Object.freeze({
-		enabled: boolean(value.enabled, "manifest.backgroundSessions.enabled"),
-		leaseMs: positiveInteger(value.leaseMs ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_LEASE_MS, "manifest.backgroundSessions.leaseMs"),
-		leaseRenewalIntervalMs: positiveInteger(value.leaseRenewalIntervalMs ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS, "manifest.backgroundSessions.leaseRenewalIntervalMs"),
-		maxConsecutiveFailures: positiveInteger(value.maxConsecutiveFailures ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES, "manifest.backgroundSessions.maxConsecutiveFailures"),
-		maxConcurrentSessions: positiveInteger(value.maxConcurrentSessions ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS, "manifest.backgroundSessions.maxConcurrentSessions"),
-		required: boolean(value.required, "manifest.backgroundSessions.required"),
-		retryBackoffMs: positiveInteger(value.retryBackoffMs ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_RETRY_BACKOFF_MS, "manifest.backgroundSessions.retryBackoffMs"),
-		sessionLifetimeMs: positiveInteger(value.sessionLifetimeMs ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_LIFETIME_MS, "manifest.backgroundSessions.sessionLifetimeMs"),
-		stepTimeoutMs: positiveInteger(value.stepTimeoutMs ?? DEFAULT_MANIFEST_BACKGROUND_SESSION_STEP_TIMEOUT_MS, "manifest.backgroundSessions.stepTimeoutMs")
-	});
-}
-function record(value, path) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object`);
-	return value;
-}
-function array(value, path) {
-	if (!Array.isArray(value)) throw new Error(`${path} must be an array`);
-	return value;
-}
-function string(value, path) {
-	if (typeof value !== "string" || value.trim() === "") throw new Error(`${path} must be a non-empty string`);
-	return value;
-}
-function boolean(value, path) {
-	if (typeof value !== "boolean") throw new Error(`${path} must be a boolean`);
-	return value;
-}
-function positiveInteger(value, path) {
-	if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${path} must be a positive integer`);
-	return value;
-}
-function memoryScope(value, path) {
-	if (typeof value !== "string" || !MEMORY_SCOPES.includes(value)) throw new Error(`${path} must be conversation, agent-private, project, or shared-user-profile`);
-	return value;
-}
-function groupPolicy(value, path) {
-	if (value !== "mention-only" && value !== "ignore-unmentioned" && value !== "default-responder") throw new Error(`${path} must be mention-only, ignore-unmentioned, or default-responder`);
-	return value;
-}
-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;
-}
-function exactKeys(value, allowed, path, optional = []) {
-	const unexpected = Object.keys(value).find((key) => !allowed.includes(key));
-	if (unexpected) throw new Error(`${path} contains unsupported field: ${unexpected}`);
-	const missing = allowed.find((key) => !optional.includes(key) && !Object.hasOwn(value, key));
-	if (missing) throw new Error(`${path} is missing required field: ${missing}`);
-}
-//#endregion
-//#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/adapters/deployment/process/process-deployment-adapters.ts
-function createProcessDeploymentAdapterPorts(factories, runEffect) {
-	return {
-		...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) => toEffectAgentRuntime(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(toEffectAgentRuntimeInput(request))),
-				instanceId: input.instanceId,
-				...input.projectSpaceId ? { projectSpaceId: input.projectSpaceId } : {},
-				steer: (request) => runEffect(input.steer(request))
-			}));
-		},
-		catch: toError$3
-	});
-}
-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))
-		})),
-		catch: toError$3
-	});
-}
-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 toLifecycleAdapter(adapter) {
-	return {
-		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 toError$3(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-//#endregion
-//#region src/platform/runtime/runtime-pool.ts
-var RuntimeResourceBusy = class extends Error {
-	name = "RuntimeResourceBusy";
-};
-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 {
-		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/adapters/agent/runtime/effect-agent-runtime-pool.ts
-var AgentInstanceBusy = class extends Error {
-	name = "AgentInstanceBusy";
-};
-var AgentRuntimeDisposed = class extends Error {
-	name = "AgentRuntimeDisposed";
-};
-function createAgentHostRuntimePool(factory, disposeTimeoutMs) {
-	const pool = createEffectRuntimePool({
-		createRuntime: (instance) => factory.create(instance),
-		...disposeTimeoutMs === void 0 ? {} : { disposeTimeoutMs }
-	});
-	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/platform/identity/stable-id.ts
-function createStableId(prefix, value) {
-	return `${prefix}:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
-}
-//#endregion
-//#region src/core/application/agent-host/registry/agent-instance-registry.ts
-var AgentInstanceConflict = class extends Error {
-	name = "AgentInstanceConflict";
-};
-function createEffectAgentInstanceRegistry(identity, options = {}) {
-	const records = /* @__PURE__ */ new Map();
-	for (const record of options.initialRecords ?? []) {
-		if (bindingKey(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, freezeRecord(record));
-	}
-	const resolveBinding = (instanceBinding, 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 key = bindingKey(instanceBinding, definition.agentId);
-			const existing = records.get(key);
-			if (existing) {
-				if (existing.runtimeGenerationId !== runtimeGenerationId) throw new AgentInstanceConflict(`binding ${key} belongs to a different runtime generation`);
-				return existing;
-			}
-			const record = freezeRecord({
-				agentId: definition.agentId,
-				binding: instanceBinding,
-				bindingKey: key,
-				instanceId: identity.createInstanceId({
-					bindingKey: key,
-					runtimeGenerationId
-				}),
-				runtimeGenerationId
-			});
-			records.set(key, record);
-			return record;
-		},
-		catch: (error) => error instanceof AgentInstanceConflict ? error : new AgentInstanceConflict(String(error))
-	});
-	return {
-		resolveAutomation: (automationId, definition) => resolveBinding({
-			automationId,
-			kind: "automation"
-		}, definition),
-		resolveBackgroundSession: (agentId, definition) => resolveBinding({
-			agentId,
-			kind: "background-session"
-		}, definition),
-		resolveEndpoint: (endpointId, definition) => resolveBinding({
-			endpointId,
-			kind: "endpoint"
-		}, definition),
-		snapshot: () => Effect.sync(() => Object.freeze([...records.values()]))
-	};
-}
-function bindingKey(binding, agentId) {
-	const bindingId = binding.kind === "endpoint" ? binding.endpointId : binding.kind === "automation" ? binding.automationId : binding.agentId;
-	return `${binding.kind}:${bindingId}:${agentId}`;
-}
-function freezeRecord(record) {
-	return Object.freeze({
-		...record,
-		binding: Object.freeze({ ...record.binding })
-	});
-}
-//#endregion
-//#region src/core/application/agent-host/routing/agent-host.ts
-var InvalidAgentHostBinding = class extends Error {
-	name = "InvalidAgentHostBinding";
-};
-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/bootstrap/deployment/deployment-control-ports.ts
-const agentCatalogRuntime = Object.freeze({
-	digest: createSha256Digest,
-	deepFreeze
-});
-function createProcessDeploymentControlPorts(factories, backgroundSessions, runEffect) {
-	return {
-		agentCatalog: createRivusAgentCatalog([createRivusHostToolDescriptorProvider({ backgroundSessions })], agentCatalogRuntime),
-		agentHostFactory: { create: (input) => {
-			const registry = createEffectAgentInstanceRegistry({
-				createInstanceId: (identity) => createStableId("instance", identity),
-				createRuntimeGenerationId: (identity) => createStableId("generation", identity)
-			}, input.initialInstanceRecords ? { initialRecords: input.initialInstanceRecords } : {});
-			const runtime = createAgentHostRuntimePool(input.runtimeFactory);
-			return createEffectAgentHost({
-				automations: input.automations,
-				backgroundSessions: input.backgroundSessions,
-				definitions: input.definitions,
-				endpoints: input.endpoints,
-				registry,
-				runtime
-			});
-		} },
-		...createProcessDeploymentAdapterPorts(factories, runEffect)
-	};
-}
-//#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/core/application/deployment/failure/deployment-failure.ts
-function formatDeploymentFailure(failure) {
-	return failure instanceof Error ? failure.message : String(failure);
-}
-function toDeploymentFailure(failure) {
-	return failure instanceof Error ? failure : new Error(String(failure));
-}
-//#endregion
-//#region src/core/application/deployment/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
-		});
-		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
-			});
-			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 ? input.deepFreeze({
-						...baseDefinition,
-						projectSpaceRevision: input.createStableId("project-space-declaration", {
-							id: projectSpace.id,
-							root: projectSpace.root,
-							skills: { sources: projectSpace.skills.sources },
-							workingDirectory: projectSpace.workingDirectory
-						})
-					}) : 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: () => input.deepFreeze({
-					...automation,
-					runtimeDefinition: input.agentCatalog.restrictGrants(agent.definition, {
-						memory: {
-							scopes: [],
-							tool: false
-						},
-						runtimeToolIds: [],
-						skillIds: template.requestedSkillIds,
-						toolIds: template.requestedToolIds
-					}),
-					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/core/application/deployment/lifecycle/deployment-lifecycle.ts
-var InvalidDeploymentLifecycleTransition = class extends Error {
-	name = "InvalidDeploymentLifecycleTransition";
-};
-var RivusDeploymentDaemonLifecycleError = class extends Error {
-	name = "RivusDeploymentDaemonLifecycleError";
-};
-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/core/application/deployment/lifecycle/deployment-preparation.ts
-function prepareDeployment(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), input.digest),
-				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 {
-			automationSlots,
-			...backgroundSessionSlot ? { backgroundSessionSlot } : {},
-			definitions,
-			deployment: effectiveDeployment,
-			endpointSlots,
-			host
-		};
-	});
-}
-function createSlot(definition, agentEnabled) {
-	return {
-		agentEnabled,
-		definition,
-		...!definition.enabled ? { lifecycle: "disabled" } : agentEnabled ? { lifecycle: "stopped" } : {
-			error: "component is unavailable",
-			lifecycle: "degraded"
-		}
-	};
-}
-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/core/application/deployment/lifecycle/deployment-control.ts
-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* () {
-		return makeDeploymentControl({
-			...yield* prepareDeployment(input),
-			...input.automationFactory ? { automationFactory: input.automationFactory } : {},
-			...input.backgroundSessionFactory ? { backgroundSessionFactory: input.backgroundSessionFactory } : {},
-			endpointFactory: input.endpointFactory
-		});
-	});
-}
-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 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 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 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 backgroundStatus(slot) {
-	let supervisor;
-	try {
-		supervisor = slot.adapter?.status?.();
-	} catch (error) {
-		slot.error = formatDeploymentFailure(error);
-	}
-	return Object.freeze({
-		...componentStatus(slot),
-		...supervisor ? { supervisor } : {}
-	});
-}
-function isSlotReady(slot) {
-	return isRequiredDeploymentComponentReady({
-		enabled: slot.definition.enabled,
-		lifecycle: slot.lifecycle,
-		required: slot.definition.required,
-		running: observeRunning(slot).running
-	});
-}
-function observeRunning(slot) {
-	if (!slot.adapter) return { running: false };
-	try {
-		return { running: slot.adapter.running() };
-	} catch (error) {
-		return {
-			error: formatDeploymentFailure(error),
-			running: false
-		};
-	}
-}
-//#endregion
-//#region src/adapters/deployment/project-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")));
-	await Promise.all(skillPaths.map((path) => assertTreeContainsNoSymbolicLinks(path)));
-	return Object.freeze({
-		id: input.declaration.id,
-		revision: createStableId("project-space", {
-			id: input.declaration.id,
-			root,
-			skillPaths,
-			workingDirectory
-		}),
-		root,
-		skillPaths: Object.freeze(skillPaths),
-		workingDirectory
-	});
-}
-async function assertTreeContainsNoSymbolicLinks(path) {
-	const metadata = await lstat(path);
-	if (metadata.isSymbolicLink()) throw new InvalidRivusProjectSpace(`Project Space Skill source contains a symbolic link: ${path}`);
-	if (!metadata.isDirectory()) return;
-	for (const entry of await readdir(path, { withFileTypes: true })) {
-		const child = resolve(path, entry.name);
-		if (entry.isSymbolicLink()) throw new InvalidRivusProjectSpace(`Project Space Skill source contains a symbolic link: ${child}`);
-		if (entry.isDirectory()) await assertTreeContainsNoSymbolicLinks(child);
-	}
-}
-async function resolveContainedDirectory(base, path, owner) {
-	const resolved = await resolveContainedPath(base, path, owner);
-	if (!(await stat(resolved)).isDirectory()) throw new InvalidRivusProjectSpace(`${owner} must be a directory: ${path}`);
-	return resolved;
-}
-async function resolveContainedPath(base, path, owner) {
-	validateRelativePath(path, owner);
-	const candidate = resolve(base, path);
-	assertContained(base, candidate, owner);
-	let resolved;
-	try {
-		resolved = await realpath(candidate);
-	} catch (cause) {
-		throw new InvalidRivusProjectSpace(`${owner} does not exist: ${path}`, { cause });
-	}
-	assertContained(base, resolved, owner);
-	const metadata = await stat(resolved);
-	if (!metadata.isDirectory() && !metadata.isFile()) throw new InvalidRivusProjectSpace(`${owner} must be a file or directory: ${path}`);
-	return resolved;
-}
-async function resolveExistingDirectory(path, owner) {
-	let resolved;
-	try {
-		resolved = await realpath(path);
-	} catch (cause) {
-		throw new InvalidRivusProjectSpace(`${owner} does not exist`, { cause });
-	}
-	if (!(await stat(resolved)).isDirectory()) throw new InvalidRivusProjectSpace(`${owner} must be a directory`);
-	return resolved;
-}
-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) {
-	if (isPathWithin(base, candidate)) return;
-	throw new InvalidRivusProjectSpace(`${owner} escapes its trusted root`);
-}
-//#endregion
-//#region src/adapters/cli/prompt/local-cli-invocation.ts
-function createLocalCliAgentInvocation(input) {
-	const conversationId = trimOptional(input.env.RIVUS_LOCAL_CONVERSATION_ID);
-	return {
-		allowedActorOpenIds: [],
-		endpointId: input.endpointId,
-		kind: "local-cli",
-		memory: {
-			audience: "private",
-			...conversationId ? { conversationId } : {},
-			...input.projectSpaceId ? { projectId: input.projectSpaceId } : {},
-			subjectId: trimOptional(input.env.RIVUS_LOCAL_SUBJECT_ID) ?? "local-operator",
-			tenantId: trimOptional(input.env.RIVUS_MEMORY_TENANT_ID) ?? "local"
-		},
-		sourceMessageId: `cli:${randomUUID()}`,
-		tenantKey: "local"
-	};
-}
-function trimOptional(value) {
-	return value?.trim() || void 0;
-}
-//#endregion
-//#region src/bootstrap/deployment/rivus-deployment-cli-process.ts
-async function createRivusDeploymentCliProcess(factory, context) {
-	const adapters = await factory(context);
-	let adaptersDisposed = false;
-	let recoveryControlPromise;
-	const disposeAdapters = async () => {
-		if (adaptersDisposed) return;
-		adaptersDisposed = true;
-		await adapters.dispose?.();
-	};
-	let daemon;
-	try {
-		daemon = await runDeploymentProcessEffect(loadRivusDeploymentManifest(context.manifestPath).pipe(Effect.flatMap((manifest) => {
-			const assemblyInput = {
-				...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
-				}) }
-			};
-			return resolveRivusDeployment({
-				...assemblyInput,
-				createStableId,
-				deepFreeze
-			}).pipe(Effect.flatMap((deployment) => createRivusDeploymentControl({
-				...assemblyInput,
-				deployment,
-				digest: createSha256Digest
-			})));
-		})));
-	} catch (constructionError) {
-		try {
-			await disposeAdapters();
-		} catch (disposeError) {
-			throw new AggregateError([constructionError, disposeError], "deployment construction and cleanup failed");
-		}
-		throw constructionError;
-	}
-	const start = async () => {
-		if (adaptersDisposed) throw new Error("Rivus deployment process cannot restart after its adapters have been disposed");
-		try {
-			await runDeploymentProcessEffect(daemon.start());
-		} catch (startError) {
-			const cleanupErrors = [];
-			try {
-				await runDeploymentProcessEffect(daemon.stop());
-			} catch (error) {
-				cleanupErrors.push(error);
-			}
-			try {
-				await disposeAdapters();
-			} catch (error) {
-				cleanupErrors.push(error);
-			}
-			if (cleanupErrors.length > 0) throw new AggregateError([startError, ...cleanupErrors], "deployment startup and cleanup failed");
-			throw startError;
-		}
-	};
-	const stop = async () => {
-		const errors = [];
-		try {
-			await runDeploymentProcessEffect(daemon.stop());
-		} catch (error) {
-			errors.push(error);
-		}
-		try {
-			await disposeAdapters();
-		} catch (error) {
-			errors.push(error);
-		}
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, "deployment and adapter cleanup failed");
-	};
-	const process = {
-		defaultSessionKey: `local:${daemon.deployment.manifest.defaultAgentId}:cli`,
-		openRecoveryControl: () => Effect.tryPromise({
-			try: async () => {
-				if (adaptersDisposed) throw new Error("Rivus deployment process cannot open Recovery Control after disposal");
-				if (!adapters.createRecoveryControl) throw new Error("Deployment bootstrap does not expose Recovery Control");
-				recoveryControlPromise ??= Promise.resolve().then(() => adapters.createRecoveryControl());
-				try {
-					return await recoveryControlPromise;
-				} catch (error) {
-					recoveryControlPromise = void 0;
-					throw error;
-				}
-			},
-			catch: (error) => error
-		}),
-		running: () => daemon.running(),
-		start: () => Effect.tryPromise({
-			try: start,
-			catch: (error) => error
-		}),
-		status: () => Effect.sync(() => daemon.status()),
-		stop: () => Effect.tryPromise({
-			try: stop,
-			catch: (error) => error
-		}),
-		promptText: (command) => Effect.tryPromise({
-			try: async () => {
-				if (adaptersDisposed) throw new Error("Rivus deployment process cannot restart after its adapters have been disposed");
-				const projectSpaceId = daemon.deployment.definitions.find(({ agentId }) => agentId === daemon.deployment.manifest.defaultAgentId)?.projectSpaceId;
-				return readPromptFinalText(await runDeploymentProcessEffect(daemon.runDefaultAgent({
-					invocation: createLocalCliAgentInvocation({
-						endpointId: daemon.deployment.manifest.defaultEndpointId,
-						env: context.env,
-						...projectSpaceId ? { projectSpaceId } : {}
-					}),
-					sessionKey: command.sessionKey,
-					text: command.text
-				})));
-			},
-			catch: (error) => error
-		})
-	};
-	const replayReceiveMessage = adapters.replayReceiveMessage;
-	if (replayReceiveMessage) process.replayReceiveMessage = (payload, options) => Effect.tryPromise({
-		try: async () => {
-			if (!daemon.running()) await start();
-		},
-		catch: (error) => error
-	}).pipe(Effect.flatMap(() => replayReceiveMessage((input) => runDeploymentProcessEffect(daemon.handleDefault(toEffectAgentRuntimeInput(input))), payload, options)));
-	return process;
-}
-function readPromptFinalText(result) {
-	if (typeof result === "string") return 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/bootstrap/daemon/rivus-daemon-cli.ts
-function runRivusDaemonCli(options) {
-	return Effect.gen(function* () {
-		const parsed = parseRivusDaemonArguments(options.argv);
-		if (parsed.help) {
-			options.stdout.write(RIVUS_DAEMON_USAGE);
-			return 0;
-		}
-		if (parsed.error) {
-			options.stderr.write(formatRivusDaemonUsageError(parsed.error));
-			return 1;
-		}
-		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, createWaitReceiveOptions(parsed)) : yield* readStatus();
-			options.stdout.write(formatRivusDaemonJson(status));
-			return 0;
-		}
-		if (parsed.printOpenClawEnvPath) {
-			const openClawConfigPath = parsed.printOpenClawEnvPath;
-			const result = yield* Effect.tryPromise({
-				try: () => loadRivusEnvFromOpenClawConfig(openClawConfigPath, parsed.piApiKeyFile),
-				catch: (error) => error
-			});
-			for (const warning of result.warnings) options.stderr.write(formatRivusDaemonWarning(warning));
-			options.stdout.write(formatRivusEnvFile(result.env));
-			return 0;
-		}
-		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(formatRivusDaemonUsageError("Missing --bootstrap <module> or RIVUS_BOOTSTRAP_MODULE"));
-			return 1;
-		}
-		let legacyConfig;
-		if (parsed.manifestPath) {
-			if (parsed.checkConfig) {
-				const manifestPath = parsed.manifestPath;
-				const manifest = yield* loadRivusDeploymentManifest(manifestPath);
-				yield* Effect.try({
-					try: () => validateRivusDeploymentManifest(manifest),
-					catch: (error) => error
-				});
-				options.stdout.write(formatRivusDaemonJson(toRedactedDeploymentManifest(manifest)));
-				return 0;
-			}
-		} else {
-			const configExit = yield* Effect.exit(loadRivusDaemonConfig(env));
-			if (configExit._tag === "Failure") {
-				options.stderr.write(formatRivusDaemonLine(configExit.cause.toString()));
-				return 1;
-			}
-			legacyConfig = configExit.value;
-			if (parsed.checkConfig) {
-				options.stdout.write(formatRivusDaemonJson(toRedactedConfig(legacyConfig)));
-				return 0;
-			}
-		}
-		if (!bootstrapSpecifier) {
-			options.stderr.write(formatRivusDaemonUsageError("Missing --bootstrap <module> or RIVUS_BOOTSTRAP_MODULE"));
-			return 1;
-		}
-		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,
-				...parsed.envFilePath ? { envFilePath: parsed.envFilePath } : {},
-				environmentOverrides: options.env,
-				manifestPath: parsed.manifestPath,
-				...options.pluginPackageManifestPath ? { pluginPackageManifestPath: options.pluginPackageManifestPath } : {}
-			}) : createCliLegacyDaemon(module, {
-				argv: options.argv,
-				config: legacyConfig,
-				env
-			}),
-			catch: (error) => error
-		});
-		if (parsed.recoveryCommand) {
-			const recoveryCommand = parsed.recoveryCommand;
-			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
-				if (!hasRecoveryRunner(daemon)) {
-					options.stderr.write(formatRivusDaemonCapabilityError("recovery"));
-					return 1;
-				}
-				const control = yield* daemon.openRecoveryControl();
-				const result = yield* Effect.tryPromise({
-					try: () => runRivusRecoveryCliCommand(control, recoveryCommand),
-					catch: (error) => error
-				});
-				options.stdout.write(formatRivusDaemonJson(result));
-				return 0;
-			}));
-		}
-		if (parsed.status) return yield* runStatusOneShot(options, daemon, (statusDaemon) => Effect.gen(function* () {
-			const status = yield* statusDaemon.status();
-			options.stdout.write(formatRivusDaemonJson(status));
-			return 0;
-		}));
-		if (parsed.prompt !== void 0) {
-			const prompt = parsed.prompt;
-			return yield* runOneShotDaemon(daemon, () => Effect.gen(function* () {
-				if (!hasPromptRunner(daemon)) {
-					options.stderr.write(formatRivusDaemonCapabilityError("prompt"));
-					return 1;
-				}
-				const text = yield* daemon.promptText({
-					sessionKey: parsed.sessionKey ?? daemon.defaultSessionKey ?? `local:${legacyConfig.agentId}:cli`,
-					text: prompt
-				});
-				options.stdout.write(formatRivusDaemonLine(text));
-				return 0;
-			}));
-		}
-		if (parsed.replayFeishuText !== void 0) {
-			const replayFeishuText = parsed.replayFeishuText;
-			return yield* runReplayOneShot(options, daemon, () => Effect.sync(() => 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 } : {}
-			})), { sideEffects: "disabled" });
-		}
-		if (parsed.replayFeishuEventPath !== void 0) {
-			const replayFeishuEventPath = parsed.replayFeishuEventPath;
-			return yield* runReplayOneShot(options, daemon, () => Effect.tryPromise({
-				try: () => readFeishuReceiveMessagePayload(replayFeishuEventPath),
-				catch: (error) => error
-			}));
-		}
-		if (parsed.waitReceive) {
-			const waitReceive = parsed.waitReceive;
-			return yield* runStatusOneShot(options, daemon, (statusDaemon) => Effect.gen(function* () {
-				yield* Effect.try({
-					try: () => installCliShutdownController(options, statusDaemon),
-					catch: (error) => error
-				});
-				yield* statusDaemon.start();
-				const status = yield* waitForReceiveStatus(() => statusDaemon.status(), waitReceive, createWaitReceiveOptions(parsed));
-				options.stdout.write(formatRivusDaemonJson(status));
-				return 0;
-			}));
-		}
-		yield* Effect.try({
-			try: () => installCliShutdownController(options, daemon),
-			catch: (error) => error
-		});
-		yield* daemon.start();
-		options.stdout.write(RIVUS_DAEMON_STARTED_MESSAGE);
-		return 0;
-	}).pipe(Effect.catchAll((error) => Effect.sync(() => {
-		options.stderr.write(formatRivusDaemonLine(formatRivusDaemonError(error)));
-		return 1;
-	})));
-}
-async function createCliLegacyDaemon(module, context) {
-	const factory = module.createRivusDaemonProcess ?? module.default;
-	if (!factory) throw new Error("Bootstrap module must export createRivusDaemonProcess(context) or a default factory");
-	return factory(context);
-}
-async function createCliDeploymentDaemon(factory, context) {
-	if (!factory) throw new Error("Manifest bootstrap module must export createRivusDeploymentAdapters(context)");
-	return createRivusDeploymentCliProcess(factory, context);
-}
-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 runStatusOneShot(options, daemon, action) {
-	return runOneShotDaemon(daemon, () => Effect.gen(function* () {
-		if (!hasStatusReporter(daemon)) {
-			options.stderr.write(formatRivusDaemonCapabilityError("status"));
-			return 1;
-		}
-		return yield* action(daemon);
-	}));
-}
-function runReplayOneShot(options, daemon, createPayload, replayOptions) {
-	return runOneShotDaemon(daemon, () => Effect.gen(function* () {
-		if (!hasFeishuReplayRunner(daemon)) {
-			options.stderr.write(formatRivusDaemonCapabilityError("replay"));
-			return 1;
-		}
-		const payload = yield* createPayload();
-		const result = replayOptions === void 0 ? yield* daemon.replayReceiveMessage(payload) : yield* daemon.replayReceiveMessage(payload, replayOptions);
-		options.stdout.write(formatRivusDaemonJson(result));
-		return 0;
-	}));
-}
-function createWaitReceiveOptions(parsed) {
-	return {
-		...parsed.waitReceiveMessageId ? { messageId: parsed.waitReceiveMessageId } : {},
-		...parsed.waitReceiveObservedAfter ? { observedAfter: parsed.waitReceiveObservedAfter } : {},
-		pollMs: parsed.waitPollMs ?? 500,
-		...parsed.waitReceiveText ? { text: parsed.waitReceiveText } : {},
-		timeoutMs: parsed.waitTimeoutMs ?? 3e4
-	};
-}
-function installCliShutdownController(options, daemon) {
-	createRivusDaemonShutdownController({
-		daemon,
-		onError: (error, signal) => {
-			options.stderr.write(formatRivusDaemonShutdownFailure(signal, formatRivusDaemonError(error)));
-			options.exitAfterSignal?.(1);
-		},
-		onStopped: () => {
-			options.exitAfterSignal?.(0);
-		},
-		signalSource: options.signalSource
-	}).install();
-}
-function hasStatusReporter(daemon) {
-	return typeof daemon.status === "function";
-}
-function hasPromptRunner(daemon) {
-	return typeof daemon.promptText === "function";
-}
-function hasFeishuReplayRunner(daemon) {
-	return typeof daemon.replayReceiveMessage === "function";
-}
-function hasRecoveryRunner(daemon) {
-	return typeof daemon.openRecoveryControl === "function";
-}
-//#endregion
-export { validateRivusDeploymentManifest as A, createRuntimeCache as B, createStableId as C, RivusDeploymentManifestError as D, createAgentHostRuntimePool as E, FeishuEndpointCredentialError as F, loadRivusDaemonConfig as G, invokeRuntimeControl as H, resolveFeishuEndpointCredentials as I, migrateRivusModelManagementConfig as J, installRivusModelManagementCliLauncher as K, toEffectAgentRuntime as L, OpenClawEnvImportError as M, createRivusEnvFromOpenClawConfig as N, loadRivusDeploymentManifest as O, formatRivusEnvFile as P, toEffectAgentRuntimeInput as R, createEffectAgentInstanceRegistry as S, AgentRuntimeDisposed as T, runDeploymentProcessEffect as U, disposeRuntimeCacheEntries as V, RivusDaemonConfigError as W, loadMergedLocalEnvFile as X, parseRivusModelManagementHomeConfig as Y, resolveRivusPluginModule as _, RivusDeploymentBackgroundSessionReadinessError as a, createEffectAgentHost as b, RivusDeploymentDaemonLifecycleError as c, createNodeRivusPluginModuleLoader as d, loadNodeRivusPluginModule as f, findTrustedPackageRoot as g, isPathWithin as h, RivusDeploymentAutomationReadinessError as i, createRivusDaemonShutdownController as j, InvalidRivusProjectSpace as k, RivusPluginLoadError as l, validateTrustedModulePath as m, createRivusDeploymentCliProcess as n, RivusDeploymentReadinessError as o, resolveNodeRivusPluginModulePath as p, installRivusRuntimeManagementSkill as q, resolveRivusProjectSpace as r, createRivusDeploymentControl as s, runRivusDaemonCli as t, resolveRivusDeployment as u, createProcessDeploymentControlPorts as v, AgentInstanceBusy as w, AgentInstanceConflict as x, InvalidAgentHostBinding as y, toProcessAgentRuntimeInput as z };