@rivus/gateway 0.16.2

package/dist/chunks/node-rivus-deployment-manifest.js

@@ -0,0 +1,1650 @@
+import { Cause, Deferred, Effect, Exit, Option } from "effect";
+import { isRivusRuntimeToolId } from "@rivus/runtime";
+import { createHash, randomUUID } from "node:crypto";
+import { access, chmod, constants, mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { dirname, isAbsolute, join } from "node:path";
+import { readPersistenceFile } from "@rivus/platform/persistence";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+//#region src/platform/runtime-pool/runtime-cache.ts
+function createRuntimeCache() {
+	const entries = /* @__PURE__ */ new Map();
+	const serial = Effect.unsafeMakeSemaphore(1);
+	const reserve = (key) => serial.withPermits(1)(Effect.gen(function* () {
+		const current = entries.get(key);
+		if (current) return {
+			created: false,
+			entry: current
+		};
+		const entry = {
+			deferred: yield* Deferred.make(),
+			initializationStarted: false,
+			key
+		};
+		entries.set(key, entry);
+		return {
+			created: true,
+			entry
+		};
+	}));
+	const start = (entry, create) => Effect.uninterruptible(Effect.gen(function* () {
+		if (!(yield* serial.withPermits(1)(Effect.sync(() => {
+			if (entry.initializationStarted) return false;
+			entry.initializationStarted = true;
+			return true;
+		})))) return;
+		const initialization = create().pipe(Effect.tapError(() => serial.withPermits(1)(Effect.sync(() => {
+			if (entries.get(entry.key) === entry) entries.delete(entry.key);
+		}))), Effect.exit, Effect.flatMap((exit) => Deferred.done(entry.deferred, exit)), Effect.asVoid);
+		yield* Effect.forkDaemon(initialization);
+	}));
+	const getOrCreate = (key, create) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const selected = yield* reserve(key);
+		yield* start(selected.entry, create);
+		return {
+			entry: selected.entry,
+			runtime: yield* restore(Deferred.await(selected.entry.deferred))
+		};
+	}));
+	return {
+		drain: () => serial.withPermits(1)(Effect.sync(() => {
+			const drained = Object.freeze([...entries.values()]);
+			entries.clear();
+			return drained;
+		})),
+		getExisting: (key) => Effect.gen(function* () {
+			const entry = yield* serial.withPermits(1)(Effect.sync(() => entries.get(key)));
+			if (!entry) return void 0;
+			return {
+				entry,
+				runtime: yield* Deferred.await(entry.deferred)
+			};
+		}),
+		getOrCreate,
+		isCurrent: (key, entry) => serial.withPermits(1)(Effect.sync(() => entries.get(key) === entry)),
+		reserve,
+		size: () => serial.withPermits(1)(Effect.sync(() => entries.size)),
+		start
+	};
+}
+function disposeRuntimeCacheEntries(options) {
+	const disposal = Effect.gen(function* () {
+		const completions = yield* Effect.forEach(options.entries, (entry) => Effect.gen(function* () {
+			const completion = yield* Deferred.make();
+			yield* Effect.forkDaemon(Deferred.await(entry.deferred).pipe(Effect.flatMap(options.dispose), Effect.exit, Effect.flatMap((exit) => Deferred.succeed(completion, exit)), Effect.asVoid));
+			return completion;
+		}), { concurrency: "unbounded" });
+		const failures = (yield* Effect.forEach(completions, Deferred.await, { concurrency: "unbounded" })).filter(Exit.isFailure).map(({ cause }) => Cause.squash(cause));
+		if (failures.length > 0) return yield* Effect.fail(new AggregateError(failures, options.failureMessage));
+	});
+	return options.timeout ? disposal.pipe(Effect.timeoutFail({
+		duration: options.timeout.milliseconds,
+		onTimeout: options.timeout.onTimeout
+	})) : disposal;
+}
+function invokeRuntimeControl(runtime, control) {
+	return runtime.pipe(Effect.flatMap((selected) => selected ? control(selected) ?? Effect.succeed(false) : Effect.succeed(false)));
+}
+//#endregion
+//#region src/adapters/agent/runtime/process-agent-runtime-adapter.ts
+function toEffectAgentRuntimeInput(input) {
+	const onUpdate = input.onUpdate;
+	return {
+		...runtimeInputFields(input),
+		...onUpdate ? { onUpdate: (update) => Effect.tryPromise({
+			try: async () => onUpdate(update),
+			catch: (failure) => failure
+		}) } : {}
+	};
+}
+function toProcessAgentRuntimeInput(input, runEffect) {
+	const onUpdate = input.onUpdate;
+	return {
+		...runtimeInputFields(input),
+		...onUpdate ? { onUpdate: (update) => runEffect(onUpdate(update)) } : {}
+	};
+}
+function toEffectAgentRuntime(runtime, runEffect) {
+	const cancel = runtime.cancel?.bind(runtime);
+	const dispose = runtime.dispose?.bind(runtime);
+	const steer = runtime.steer?.bind(runtime);
+	return {
+		...runtime.concurrency ? { concurrency: runtime.concurrency } : {},
+		...cancel ? { cancel: (input) => Effect.tryPromise({
+			try: () => cancel(input),
+			catch: (failure) => failure
+		}) } : {},
+		...dispose ? { dispose: () => Effect.tryPromise({
+			try: async () => dispose(),
+			catch: (failure) => failure
+		}) } : {},
+		run: (input) => Effect.tryPromise({
+			try: () => runtime.run(toProcessAgentRuntimeInput(input, runEffect)),
+			catch: (failure) => failure
+		}),
+		...steer ? { steer: (input) => Effect.tryPromise({
+			try: () => steer(input),
+			catch: (failure) => failure
+		}) } : {}
+	};
+}
+function runtimeInputFields(input) {
+	return {
+		...input.invocation ? { invocation: input.invocation } : {},
+		...input.payload === void 0 ? {} : { payload: input.payload },
+		sessionKey: input.sessionKey,
+		text: input.text
+	};
+}
+//#endregion
+//#region src/platform/values/deep-freeze.ts
+function deepFreeze(value) {
+	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const child of Object.values(value)) deepFreeze(child);
+	}
+	return value;
+}
+//#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/adapters/cli/model/rivus-model-cli-protocol.ts
+const RIVUS_MODEL_CLI_USAGE = `Usage:
+  rivus model status --json [--request <id>] [--verbose]
+  rivus model set --model <provider/model> --expected-revision <n> --request <id> --json [--verbose]
+  rivus model rollback --expected-revision <n> --request <id> --json [--verbose]
+
+Commands:
+  status    Read the effective and persistent model selection
+  set       Submit one authorized model change
+  rollback  Submit one authorized change to the previous model
+
+All command results are JSON. A successful set or rollback call means the request
+was accepted; query status by request id for the final outcome.
+`;
+function parseRivusModelCliArguments(argv) {
+	if (argv.includes("--help") || argv.includes("-h")) return { help: true };
+	const operation = argv[0];
+	if (operation !== "status" && operation !== "set" && operation !== "rollback") return { error: "model requires one of status, set, rollback" };
+	let expectedRevision;
+	let json = false;
+	let model;
+	let requestId;
+	let verbose = false;
+	for (let index = 1; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (argument === "--json") {
+			if (json) return { error: "--json may only be provided once" };
+			json = true;
+			continue;
+		}
+		if (argument === "--verbose") {
+			if (verbose) return { error: "--verbose may only be provided once" };
+			verbose = true;
+			continue;
+		}
+		if (argument === "--request") {
+			if (requestId !== void 0) return { error: "--request may only be provided once" };
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) return { error: "--request requires an id" };
+			requestId = value;
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("--request=")) {
+			if (requestId !== void 0) return { error: "--request may only be provided once" };
+			requestId = argument.slice(10);
+			if (!requestId) return { error: "--request requires an id" };
+			continue;
+		}
+		if (argument === "--expected-revision") {
+			if (expectedRevision !== void 0) return { error: "--expected-revision may only be provided once" };
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) return { error: "--expected-revision requires a non-negative integer" };
+			const parsed = parseRevision(value);
+			if (parsed === void 0) return { error: "--expected-revision requires a non-negative integer" };
+			expectedRevision = parsed;
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("--expected-revision=")) {
+			if (expectedRevision !== void 0) return { error: "--expected-revision may only be provided once" };
+			const parsed = parseRevision(argument.slice(20));
+			if (parsed === void 0) return { error: "--expected-revision requires a non-negative integer" };
+			expectedRevision = parsed;
+			continue;
+		}
+		if (argument === "--model") {
+			if (model !== void 0) return { error: "--model may only be provided once" };
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) return { error: "--model requires provider/model" };
+			if (!isModelReference(value)) return { error: "--model must be provider/model" };
+			model = value;
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("--model=")) {
+			if (model !== void 0) return { error: "--model may only be provided once" };
+			const value = argument.slice(8);
+			if (!isModelReference(value)) return { error: "--model must be provider/model" };
+			model = value;
+			continue;
+		}
+		return { error: `Unknown model option: ${argument}` };
+	}
+	if (!json) return { error: "model commands require --json" };
+	if (operation === "status") {
+		if (model !== void 0) return { error: "status does not accept --model" };
+		if (expectedRevision !== void 0) return { error: "status does not accept --expected-revision" };
+		return {
+			json: true,
+			operation,
+			...requestId !== void 0 ? { requestId } : {},
+			...verbose ? { verbose: true } : {}
+		};
+	}
+	if (requestId === void 0) return { error: "--request is required for model changes" };
+	if (expectedRevision === void 0) return { error: "--expected-revision is required for model changes" };
+	if (operation === "set" && model === void 0) return { error: "--model is required for model set" };
+	if (operation === "rollback" && model !== void 0) return { error: "rollback does not accept --model" };
+	return operation === "set" ? {
+		expectedRevision,
+		json: true,
+		model,
+		operation,
+		requestId,
+		...verbose ? { verbose: true } : {}
+	} : {
+		expectedRevision,
+		json: true,
+		operation,
+		requestId,
+		...verbose ? { verbose: true } : {}
+	};
+}
+function renderRivusModelCliHelp() {
+	return RIVUS_MODEL_CLI_USAGE;
+}
+function renderRivusModelCliArgumentError(error) {
+	return `${error}\n\n${RIVUS_MODEL_CLI_USAGE}`;
+}
+function isModelReference(value) {
+	return /^[^/\s]+\/[^/\s]+$/.test(value);
+}
+function parseRevision(value) {
+	if (!/^\d+$/.test(value)) return void 0;
+	const revision = Number(value);
+	return Number.isSafeInteger(revision) ? revision : void 0;
+}
+//#endregion
+//#region src/adapters/cli/model/rivus-model-management-wire.ts
+function createRivusModelManagementWireRequest(command, env) {
+	const context = optionalString(env.RIVUS_MODEL_CONTEXT);
+	return {
+		...command,
+		...context ? { context } : {}
+	};
+}
+function parseRivusModelManagementWireRequest(value) {
+	if (!isRecord$2(value)) throw new Error("model request must be a JSON object");
+	const operation = value.operation;
+	if (operation !== "status" && operation !== "set" && operation !== "rollback") throw new Error("model request operation is invalid");
+	const context = optionalString(value.context);
+	const requestId = optionalString(value.requestId);
+	const verbose = value.verbose === true ? true : void 0;
+	if (operation === "status") {
+		if (value.json !== true) throw new Error("model request must require JSON output");
+		return {
+			json: true,
+			operation,
+			...context ? { context } : {},
+			...requestId ? { requestId } : {},
+			...verbose ? { verbose: true } : {}
+		};
+	}
+	const expectedRevision = value.expectedRevision;
+	if (value.json !== true || typeof expectedRevision !== "number" || !Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new Error("model request has an invalid expected revision or output mode");
+	if (!requestId) throw new Error("model request requires a request id");
+	if (operation === "set") {
+		const model = optionalString(value.model);
+		if (!model || !/^[^/\s]+\/[^/\s]+$/.test(model)) throw new Error("model request target is invalid");
+		return {
+			expectedRevision,
+			json: true,
+			model,
+			operation,
+			requestId,
+			...context ? { context } : {},
+			...verbose ? { verbose: true } : {}
+		};
+	}
+	return {
+		expectedRevision,
+		json: true,
+		operation,
+		requestId,
+		...context ? { context } : {},
+		...verbose ? { verbose: true } : {}
+	};
+}
+function toRivusModelManagementSubmission(request) {
+	const target = request.operation === "set" ? parseTarget(request.model) : void 0;
+	return {
+		expectedRevision: request.expectedRevision,
+		operation: request.operation,
+		requestId: request.requestId,
+		...target ? { target } : {},
+		...request.verbose ? { verbose: true } : {}
+	};
+}
+function projectRivusModelCliResponse(value, operation) {
+	if (!isRecord$2(value)) throw new Error("model handler must return a JSON object");
+	const response = { schemaVersion: 1 };
+	copyScalar(response, value, "requestId");
+	copyScalar(response, value, "revision");
+	copyScalar(response, value, "source");
+	copyScalar(response, value, "protocolVersion");
+	copyScalar(response, value, "runtimeVersion");
+	copyScalar(response, value, "operation");
+	copyScalar(response, value, "expectedRevision");
+	copyScalar(response, value, "phase");
+	copyScalar(response, value, "reason");
+	for (const key of [
+		"actual",
+		"current",
+		"persisted",
+		"previous",
+		"target"
+	]) {
+		const model = projectModelReference(value[key]);
+		if (model) response[key] = model;
+	}
+	const budget = projectBudget(value.budget);
+	if (budget) response.budget = budget;
+	const pending = projectPending(value.pending);
+	if (pending) response.pending = pending;
+	const request = projectReceipt(value.request);
+	if (request) response.request = request;
+	const error = projectError(value.error);
+	if (error) response.error = error;
+	const recoveryRequired = projectError(value.recoveryRequired);
+	if (recoveryRequired) response.recoveryRequired = recoveryRequired;
+	const notification = projectNotification(value.notification);
+	if (notification) response.notification = notification;
+	const status = value.status;
+	response.status = isPublicStatus(status) ? status : value.recoveryRequired !== void 0 ? "recovery-required" : operation === "status" && value.pending !== void 0 ? "pending" : operation === "status" ? "applied" : "failed";
+	return response;
+}
+function createRivusModelManagementFailure(code, message) {
+	return {
+		error: {
+			code,
+			message
+		},
+		schemaVersion: 1,
+		status: "failed"
+	};
+}
+function projectModelReference(value) {
+	if (!isRecord$2(value) || typeof value.provider !== "string" || typeof value.model !== "string") return void 0;
+	const result = {
+		model: value.model,
+		provider: value.provider
+	};
+	if (typeof value.label === "string") return {
+		...result,
+		label: value.label
+	};
+	if (typeof value.bindingRevision === "string") return {
+		...result,
+		bindingRevision: value.bindingRevision
+	};
+	return result;
+}
+function projectPending(value) {
+	if (!isRecord$2(value)) return void 0;
+	const result = {};
+	copyScalar(result, value, "phase");
+	copyScalar(result, value, "reason");
+	if (result.reason === void 0 && typeof result.phase === "string") result.reason = result.phase;
+	copyScalar(result, value, "requestId");
+	copyScalar(result, value, "updatedAt");
+	const request = projectReceipt(value.request);
+	if (request) result.request = request;
+	const target = projectModelReference(value.target);
+	if (target) result.target = target;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function projectReceipt(value) {
+	if (!isRecord$2(value)) return void 0;
+	const result = {};
+	for (const key of [
+		"requestId",
+		"revision",
+		"status",
+		"phase",
+		"operation",
+		"expectedRevision",
+		"acceptedAt",
+		"updatedAt"
+	]) copyScalar(result, value, key);
+	const current = projectModelReference(value.current);
+	if (current) result.current = current;
+	const previous = projectModelReference(value.previous);
+	if (previous) result.previous = previous;
+	const target = projectModelReference(value.target);
+	if (target) result.target = target;
+	const budget = projectBudget(value.budget);
+	if (budget) result.budget = budget;
+	const error = projectError(value.error);
+	if (error) result.error = error;
+	const notification = projectNotification(value.notification);
+	if (notification) result.notification = notification;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function projectBudget(value) {
+	if (!isRecord$2(value)) return void 0;
+	const result = {};
+	for (const key of [
+		"deadlineAt",
+		"maxOutputTokens",
+		"maxPaidRequests",
+		"outputTokens",
+		"paidRequests"
+	]) copyScalar(result, value, key);
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function projectError(value) {
+	if (!isRecord$2(value) || typeof value.code !== "string" || typeof value.message !== "string") return void 0;
+	return {
+		code: value.code,
+		message: value.message
+	};
+}
+function projectNotification(value) {
+	if (!isRecord$2(value)) return void 0;
+	const result = {};
+	copyScalar(result, value, "attempts");
+	copyScalar(result, value, "lastAttemptAt");
+	copyScalar(result, value, "status");
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function copyScalar(target, source, key) {
+	const value = source[key];
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") target[key] = value;
+}
+function parseTarget(value) {
+	if (!value) throw new Error("model request target is missing");
+	const separator = value.indexOf("/");
+	return {
+		model: value.slice(separator + 1),
+		provider: value.slice(0, separator)
+	};
+}
+function isPublicStatus(value) {
+	return value === "applied" || value === "failed" || value === "pending" || value === "recovery-required" || value === "restored";
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/adapters/cli/model/rivus-model-management-socket-server.ts
+const MAX_FRAME_BYTES = 64 * 1024;
+function createRivusModelManagementSocketServer(options) {
+	assertAbsoluteSocketPath(options.socketPath);
+	let server;
+	let socketIdentity;
+	let listening = false;
+	let startPromise;
+	return {
+		close: async () => {
+			if (startPromise) await startPromise.catch(() => void 0);
+			const current = server;
+			const identity = socketIdentity;
+			server = void 0;
+			socketIdentity = void 0;
+			if (current && listening) await closeServer(current);
+			listening = false;
+			if (identity) await unlinkOwnedSocket(options.socketPath, identity);
+		},
+		listening: () => listening,
+		start: async () => {
+			if (listening) return;
+			if (startPromise) return startPromise;
+			startPromise = startServer(options, (next, identity) => {
+				server = next;
+				socketIdentity = identity;
+				listening = true;
+			});
+			try {
+				await startPromise;
+			} finally {
+				startPromise = void 0;
+			}
+		}
+	};
+}
+async function startServer(options, onStarted) {
+	await prepareSocketParentDirectory(options.socketPath);
+	const lockPath = `${options.socketPath}.lock`;
+	const lock = await acquireStartLock(lockPath);
+	const next = createServer((socket) => handleConnection(socket, options));
+	let bound = false;
+	try {
+		await prepareSocketPath(options.socketPath);
+		await listen(next, options.socketPath);
+		bound = true;
+		await chmod(options.socketPath, 384);
+		onStarted(next, await readSocketIdentity(options.socketPath));
+	} catch (error) {
+		await closeServer(next).catch(() => void 0);
+		if (bound) await unlinkSocketIfPresent(options.socketPath);
+		throw error;
+	} finally {
+		await releaseStartLock(lock, lockPath);
+	}
+}
+async function handleConnection(socket, options) {
+	let buffer = "";
+	let handled = false;
+	socket.setEncoding("utf8");
+	socket.on("data", (chunk) => {
+		if (handled) return;
+		buffer += chunk;
+		if (Buffer.byteLength(buffer, "utf8") > MAX_FRAME_BYTES) {
+			handled = true;
+			writeResponse(socket, createRivusModelManagementFailure("request_too_large", "model management request is too large"));
+			return;
+		}
+		const newline = buffer.indexOf("\n");
+		if (newline < 0) return;
+		handled = true;
+		handleFrame(buffer.slice(0, newline).trim(), socket, options);
+	});
+	socket.on("end", () => {
+		if (handled || buffer.trim() === "") return;
+		handled = true;
+		handleFrame(buffer.trim(), socket, options);
+	});
+	socket.on("error", () => {
+		handled = true;
+	});
+}
+async function handleFrame(frame, socket, options) {
+	let response;
+	let request;
+	try {
+		request = parseRivusModelManagementWireRequest(JSON.parse(frame));
+	} catch (error) {
+		response = createRivusModelManagementFailure("invalid_request", error instanceof Error ? error.message : "invalid model request");
+		writeResponse(socket, response);
+		return;
+	}
+	try {
+		if (request.operation === "status") response = projectRivusModelCliResponse(await options.handlers.status({
+			...request.requestId ? { requestId: request.requestId } : {},
+			...request.verbose ? { verbose: true } : {}
+		}), request.operation);
+		else response = await handleMutation(request, options);
+	} catch {
+		response = createRivusModelManagementFailure("handler_failed", "the model management request could not be completed");
+	}
+	writeResponse(socket, response);
+}
+async function handleMutation(request, options) {
+	if (!request.context || !options.resolveTrustedRun) return createRivusModelManagementFailure("trusted_context_required", "a trusted Run context is required for model changes");
+	let trustedRun;
+	try {
+		trustedRun = await options.resolveTrustedRun.resolve(request.context);
+	} catch {
+		trustedRun = void 0;
+	}
+	if (trustedRun === void 0 || trustedRun === null) return createRivusModelManagementFailure("trusted_context_invalid", "the trusted Run context is invalid or expired");
+	try {
+		return projectRivusModelCliResponse(await options.handlers.handle(toRivusModelManagementSubmission(request), trustedRun), request.operation);
+	} catch {
+		return createRivusModelManagementFailure("handler_failed", "the model management request could not be completed");
+	}
+}
+function writeResponse(socket, response) {
+	try {
+		socket.end(`${JSON.stringify(response)}\n`);
+	} catch {
+		socket.destroy();
+	}
+}
+async function prepareSocketPath(socketPath) {
+	try {
+		const metadata = await stat(socketPath);
+		if (!metadata.isSocket()) throw new Error(`refusing to replace non-socket model path: ${socketPath}`);
+		if (await socketIsLive(socketPath)) throw new Error(`model management socket is already active: ${socketPath}`);
+		const current = await stat(socketPath);
+		if (current.dev !== metadata.dev || current.ino !== metadata.ino) throw new Error(`model management socket changed while starting: ${socketPath}`);
+		await unlink(socketPath);
+	} catch (error) {
+		if (!isMissing$2(error)) throw error;
+	}
+}
+async function prepareSocketParentDirectory(socketPath) {
+	const parent = dirname(socketPath);
+	await mkdir(parent, {
+		mode: 448,
+		recursive: true
+	});
+	await chmod(parent, 448);
+}
+async function socketIsLive(socketPath) {
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		let settled = false;
+		const finish = (result, error) => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			if (error) reject(error);
+			else resolve(result);
+		};
+		socket.setTimeout(250, () => finish(false, /* @__PURE__ */ new Error("model management socket liveness could not be verified")));
+		socket.once("connect", () => finish(true));
+		socket.once("error", (error) => {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOENT") finish(false);
+			else finish(false, error);
+		});
+	});
+}
+async function acquireStartLock(path) {
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		let handle;
+		try {
+			handle = await open(path, "wx", 384);
+			await handle.writeFile(`${process.pid}\n`, "utf8");
+			const metadata = await handle.stat();
+			return {
+				handle,
+				identity: {
+					dev: metadata.dev,
+					ino: metadata.ino
+				}
+			};
+		} catch (error) {
+			await handle?.close().catch(() => void 0);
+			if (!isAlreadyExists(error)) throw new Error("model management socket startup is already in progress", { cause: error });
+			const pid = parseLockOwner(await readPersistenceFile(path));
+			if (pid === void 0) throw new Error("model management socket startup lock owner could not be verified; manual recovery is required");
+			if (processIsAlive(pid)) throw new Error("model management socket startup is already in progress");
+			const reclaimed = `${path}.reclaim-${process.pid}-${randomUUID()}`;
+			try {
+				await rename(path, reclaimed);
+			} catch (reclaimError) {
+				if (isMissing$2(reclaimError)) continue;
+				throw new Error("model management socket startup lock could not be reclaimed safely", { cause: reclaimError });
+			}
+			await unlink(reclaimed).catch((reclaimError) => {
+				if (!isMissing$2(reclaimError)) throw reclaimError;
+			});
+		}
+	}
+	throw new Error("model management socket startup lock changed during stale-owner recovery; manual recovery is required");
+}
+async function releaseStartLock(lock, path) {
+	await lock.handle.close();
+	try {
+		const current = await stat(path);
+		if (current.dev !== lock.identity.dev || current.ino !== lock.identity.ino) return;
+		await unlink(path);
+	} catch (error) {
+		if (!isMissing$2(error)) throw error;
+	}
+}
+async function unlinkSocketIfPresent(socketPath) {
+	try {
+		if ((await stat(socketPath)).isSocket()) await unlink(socketPath);
+	} catch (error) {
+		if (!isMissing$2(error)) throw error;
+	}
+}
+async function unlinkOwnedSocket(socketPath, identity) {
+	try {
+		const current = await readSocketIdentity(socketPath);
+		if (current.dev !== identity.dev || current.ino !== identity.ino) return;
+		await unlink(socketPath);
+	} catch (error) {
+		if (!isMissing$2(error)) throw error;
+	}
+}
+async function readSocketIdentity(socketPath) {
+	const metadata = await stat(socketPath);
+	return {
+		dev: metadata.dev,
+		ino: metadata.ino
+	};
+}
+function listen(server, socketPath) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(socketPath);
+	});
+}
+function closeServer(server) {
+	return new Promise((resolve, reject) => {
+		server.close((error) => error ? reject(error) : resolve());
+	});
+}
+function assertAbsoluteSocketPath(socketPath) {
+	if (!isAbsolute(socketPath)) throw new Error("model socket path must be absolute");
+}
+function isMissing$2(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isAlreadyExists(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function processIsAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return typeof error === "object" && error !== null && "code" in error && error.code !== "ESRCH";
+	}
+}
+function parseLockOwner(value) {
+	const normalized = value?.trim();
+	if (!normalized || !/^\d+$/.test(normalized)) return void 0;
+	const pid = Number(normalized);
+	return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+//#endregion
+//#region src/platform/home/config/runtime/local-env-file.ts
+var LocalEnvFileError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LocalEnvFileError";
+	}
+};
+async function 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$1(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$1(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 = "main";
+const DEFAULT_CARD_STREAM_LEASE_MS = 51e4;
+const DEFAULT_FEISHU_BASE_URL = "https://open.feishu.cn";
+const DEFAULT_STREAM_MIN_INTERVAL_MS = 200;
+const THINKING_LEVELS = /* @__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);
+		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,
+			feishu: {
+				appId,
+				appSecret,
+				baseUrl: optional(env.FEISHU_BASE_URL) ?? DEFAULT_FEISHU_BASE_URL,
+				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.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/platform/project/setup/gateway-package-resources.ts
+const packageManifestUrl = import.meta.resolve("@rivus/gateway/package.json");
+const packageRootUrl = new URL("./", packageManifestUrl);
+const gatewayPackageDirectory = fileURLToPath(packageRootUrl);
+const gatewayPackageManifestPath = fileURLToPath(new URL("package.json", packageRootUrl));
+const gatewayTemplateDirectory = fileURLToPath(new URL("templates/", packageRootUrl));
+const gatewaySkillsDirectory = fileURLToPath(new URL("skills/", packageRootUrl));
+//#endregion
+//#region src/platform/project/setup/release-descriptor.ts
+const RIVUS_RELEASE_DESCRIPTOR = Object.freeze({
+	version: "0.16.2",
+	dependencies: Object.freeze({
+		"@earendil-works/pi-coding-agent": "0.84.4",
+		"@larksuiteoapi/node-sdk": "1.71.1",
+		effect: "^3.21.4"
+	})
+});
+//#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/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/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
+export { toProcessAgentRuntimeInput as A, parseRivusModelCliArguments as C, deepFreeze as D, runDeploymentProcessEffect as E, disposeRuntimeCacheEntries as M, invokeRuntimeControl as N, toEffectAgentRuntime as O, createRivusModelManagementWireRequest as S, renderRivusModelCliHelp as T, migrateRivusModelManagementConfig as _, InvalidRivusProjectSpace as a, createRivusModelManagementSocketServer as b, RIVUS_RELEASE_DESCRIPTOR as c, gatewaySkillsDirectory as d, gatewayTemplateDirectory as f, installRivusRuntimeManagementSkill as g, installRivusModelManagementCliLauncher as h, resolveFeishuEndpointCredentials as i, createRuntimeCache as j, toEffectAgentRuntimeInput as k, gatewayPackageDirectory as l, loadRivusDaemonConfig as m, loadRivusDeploymentManifest as n, validateRivusDeploymentManifest as o, RivusDaemonConfigError as p, FeishuEndpointCredentialError as r, validateRivusProjectSpaceDeployment as s, RivusDeploymentManifestError as t, gatewayPackageManifestPath as u, parseRivusModelManagementHomeConfig as v, renderRivusModelCliArgumentError as w, createRivusModelManagementFailure as x, loadMergedLocalEnvFile as y };