@rivus/agent 0.14.4 → 0.15.0

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

@@ -1,144 +1,14 @@
+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 { t as createSha256Digest } from "./sha256-digest.js";
 import { createRequire } from "node:module";
 import { Cause, Deferred, Effect, Either, Exit, Option } from "effect";
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, open, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { 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 { constants } from "node:fs";
+import { homedir } from "node:os";
 import { pathToFileURL } from "node:url";
-//#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
+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) {
@@ -195,6 +65,310 @@ function unescapeDoubleQuotedValue(value) {
 	});
 }
 //#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;
@@ -287,6 +461,145 @@ function optionalThinkingLevel(value) {
 	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";
@@ -723,7 +1036,7 @@ 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.O_RDONLY | constants.O_NOFOLLOW);
+	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`);
@@ -754,6 +1067,7 @@ Project commands:
   rivus check-config
   rivus init [directory]
   rivus doctor [directory] [--env-file <path>]
+  rivus model <status|set|rollback> ...
 
 Options:
   --bootstrap <module>  Module exporting createRivusDaemonProcess(context)
@@ -3158,14 +3472,6 @@ function trimOptional(value) {
 	return value?.trim() || void 0;
 }
 //#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/bootstrap/deployment/rivus-deployment-cli-process.ts
 async function createRivusDeploymentCliProcess(factory, context) {
 	const adapters = await factory(context);
@@ -3387,6 +3693,8 @@ function runRivusDaemonCli(options) {
 			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, {
@@ -3541,4 +3849,4 @@ function hasRecoveryRunner(daemon) {
 	return typeof daemon.openRecoveryControl === "function";
 }
 //#endregion
-export { InvalidRivusProjectSpace as A, loadMergedLocalEnvFile as B, createEffectAgentInstanceRegistry as C, createAgentHostRuntimePool as D, AgentRuntimeDisposed as E, formatRivusEnvFile as F, disposeRuntimeCacheEntries as G, toEffectAgentRuntimeInput as H, FeishuEndpointCredentialError as I, invokeRuntimeControl as K, resolveFeishuEndpointCredentials as L, createRivusDaemonShutdownController as M, OpenClawEnvImportError as N, RivusDeploymentManifestError as O, createRivusEnvFromOpenClawConfig as P, RivusDaemonConfigError as R, AgentInstanceConflict as S, AgentInstanceBusy as T, toProcessAgentRuntimeInput as U, toEffectAgentRuntime as V, createRuntimeCache as W, findTrustedPackageRoot as _, RivusDeploymentAutomationReadinessError as a, InvalidAgentHostBinding as b, createRivusDeploymentControl as c, resolveRivusDeployment as d, createNodeRivusPluginModuleLoader as f, isPathWithin as g, validateTrustedModulePath as h, resolveRivusProjectSpace as i, validateRivusDeploymentManifest as j, loadRivusDeploymentManifest as k, RivusDeploymentDaemonLifecycleError as l, resolveNodeRivusPluginModulePath as m, createRivusDeploymentCliProcess as n, RivusDeploymentBackgroundSessionReadinessError as o, loadNodeRivusPluginModule as p, runDeploymentProcessEffect as r, RivusDeploymentReadinessError as s, runRivusDaemonCli as t, RivusPluginLoadError as u, resolveRivusPluginModule as v, createStableId as w, createEffectAgentHost as x, createProcessDeploymentControlPorts as y, loadRivusDaemonConfig as z };
+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 };