@rivus/agent 0.16.1 → 0.16.6

package/dist/cli.js

@@ -1,1239 +1,17 @@
 #!/usr/bin/env node
-import { A as validateRivusDeploymentManifest, I as resolveFeishuEndpointCredentials, O as loadRivusDeploymentManifest, X as loadMergedLocalEnvFile, g as findTrustedPackageRoot, h as isPathWithin, m as validateTrustedModulePath, p as resolveNodeRivusPluginModulePath, t as runRivusDaemonCli } from "./chunks/rivus-daemon-cli.js";
-import { c as renderRivusModelCliHelp, n as createRivusModelManagementWireRequest, o as parseRivusModelCliArguments, s as renderRivusModelCliArgumentError } from "./chunks/rivus-model-management-wire.js";
-import { Effect, Either } from "effect";
-import { lstat, mkdir, readFile, realpath, rmdir, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { homedir } from "node:os";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createConnection } from "node:net";
-//#region src/adapters/deployment/inspection/rivus-home-deployment-inspector.ts
-const DEFAULT_BOOTSTRAP_PEERS = Object.freeze(["@earendil-works/pi-coding-agent", "@larksuiteoapi/node-sdk"]);
-function createRivusHomeDeploymentInspector(options = {}) {
-	const resolveModule = options.resolveModule ?? ((specifier) => defaultResolveModule(specifier, options.packageManifestPath));
-	const resolvePluginModule = options.resolvePluginModule ?? ((request) => resolveNodeRivusPluginModulePath(request, options.packageManifestPath ? { packageManifestPath: options.packageManifestPath } : {}));
-	return { inspect: (input) => Effect.gen(function* () {
-		const manifestResult = yield* checkManifest$1(input.home);
-		const credentials = yield* checkCredentials$1(input.home, manifestResult.manifest, input.env, input.envFilePath);
-		const modules = yield* checkModules(input.home, manifestResult.manifest, resolveModule, resolvePluginModule);
-		return {
-			credentials,
-			manifest: manifestResult.check,
-			modules
-		};
-	}) };
-}
-function checkManifest$1(home) {
-	return loadRivusDeploymentManifest(home.manifestPath).pipe(Effect.map((manifest) => {
-		validateRivusDeploymentManifest(manifest);
-		return {
-			check: {
-				message: "deployment manifest is valid",
-				name: "manifest",
-				status: "pass"
-			},
-			manifest
-		};
-	}), Effect.catchAll((error) => Effect.succeed({ check: {
-		message: `deployment manifest is invalid: ${formatError(error)}`,
-		name: "manifest",
-		status: "fail"
-	} })));
-}
-function checkModules(home, manifest, resolveModule, resolvePluginModule) {
-	if (!manifest) return Effect.succeed({
-		message: "modules cannot be checked until manifest is valid",
-		name: "modules",
-		status: "fail"
-	});
-	const specifiers = [home.bootstrap, ...home.bootstrap === "@rivus/agent/bootstrap/pi-feishu" ? DEFAULT_BOOTSTRAP_PEERS : []];
-	return Effect.gen(function* () {
-		const missing = [];
-		for (const specifier of specifiers) {
-			const result = yield* toEffect(() => resolveModule(specifier)).pipe(Effect.either);
-			if (result._tag === "Left") missing.push(`${specifier} (${formatError(result.left)})`);
-		}
-		for (const plugin of manifest.plugins) {
-			const result = yield* toEffect(() => resolvePluginModule({
-				deploymentRoot: home.directory,
-				module: plugin.module,
-				pluginId: plugin.id
-			})).pipe(Effect.either);
-			if (result._tag === "Left") missing.push(`${plugin.module} (${formatError(result.left)})`);
-		}
-		return missing.length === 0 ? {
-			message: "Bootstrap, Plugin, Pi, and Feishu modules resolve from the global installation",
-			name: "modules",
-			status: "pass"
-		} : {
-			message: `global npm modules are unavailable: ${missing.join(", ")}`,
-			name: "modules",
-			status: "fail"
-		};
-	});
-}
-function toEffect(read) {
-	return Effect.suspend(() => {
-		try {
-			const value = read();
-			if (Effect.isEffect(value)) return value;
-			return Effect.tryPromise({
-				try: () => Promise.resolve(value),
-				catch: toError$1
-			});
-		} catch (error) {
-			return Effect.fail(toError$1(error));
-		}
-	});
-}
-function checkCredentials$1(home, manifest, env, envFilePath) {
-	if (!manifest) return Effect.succeed({
-		message: "credentials cannot be checked until manifest is valid",
-		name: "credentials",
-		status: "fail"
-	});
-	return Effect.tryPromise({
-		try: async () => {
-			const merged = await loadMergedLocalEnvFile(envFilePath ? resolve(home.directory, envFilePath) : home.envFilePath, env);
-			for (const endpoint of manifest.endpoints.filter(({ enabled }) => enabled)) resolveFeishuEndpointCredentials(endpoint.credentialRef, merged);
-			return {
-				message: "enabled Endpoint credential references resolve",
-				name: "credentials",
-				status: "pass"
-			};
-		},
-		catch: toError$1
-	}).pipe(Effect.catchAll((error) => Effect.succeed({
-		message: `enabled Endpoint credentials are incomplete: ${formatError(error)}`,
-		name: "credentials",
-		status: "fail"
-	})));
-}
-function defaultResolveModule(specifier, packageManifestPath) {
-	if (!packageManifestPath) return Effect.fail(/* @__PURE__ */ new Error("Rivus package manifest path is required for trusted module resolution"));
-	return Effect.gen(function* () {
-		const resolvedRealpath = yield* Effect.tryPromise({
-			try: () => realpath(fileURLToPath(import.meta.resolve(specifier))),
-			catch: toError$1
-		});
-		return yield* validateTrustedModulePath(yield* findTrustedPackageRoot(packageManifestPath), resolvedRealpath, `module ${specifier}`);
-	});
-}
-function toError$1(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-function formatError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-//#endregion
-//#region src/platform/home/config/rivus-home-config.ts
-/** Loads and validates the operator-owned Home config file. */
-function loadRivusHome(directoryPath) {
-	const directory = resolve(directoryPath);
-	const configPath = resolve(directory, "config.json");
-	return Effect.tryPromise({
-		try: async () => {
-			const config = parseRivusHomeConfig(JSON.parse(await readFile(configPath, "utf8")));
-			return {
-				bootstrap: resolveBootstrap(directory, config.bootstrap),
-				config,
-				configPath,
-				directory,
-				envFilePath: resolveHomePath(directory, config.envFile, "envFile"),
-				logsDirectory: resolveHomePath(directory, config.logs, "logs"),
-				manifestPath: resolveHomePath(directory, config.manifest, "manifest"),
-				stateDirectory: resolveHomePath(directory, config.state, "state"),
-				workspaceDirectory: resolveHomePath(directory, config.workspace, "workspace")
-			};
-		},
-		catch: asError$1
-	});
-}
-function parseRivusHomeConfig(value) {
-	const config = record(value, "Rivus Home config");
-	if (config.version !== 1) throw new Error("Rivus Home config version must be 1");
-	return {
-		bootstrap: nonEmptyString(config.bootstrap, "bootstrap"),
-		envFile: relativePath(config.envFile, "envFile"),
-		logs: relativePath(config.logs, "logs"),
-		manifest: relativePath(config.manifest, "manifest"),
-		state: relativePath(config.state, "state"),
-		version: 1,
-		workspace: relativePath(config.workspace, "workspace")
-	};
-}
-function resolveBootstrap(directory, value) {
-	if (value.startsWith("./") || value.startsWith("../")) return resolveHomePath(directory, value, "bootstrap");
-	if (isAbsolute(value)) throw new Error("Rivus Home bootstrap must be a package specifier or a relative path inside Rivus Home");
-	return value;
-}
-function resolveHomePath(directory, value, owner) {
-	const candidate = resolve(directory, value);
-	const relation = relative(directory, candidate);
-	if (relation === "" || !relation.startsWith(`..${sep}`) && relation !== ".." && !isAbsolute(relation)) return candidate;
-	throw new Error(`Rivus Home ${owner} escapes the Home directory`);
-}
-function relativePath(value, owner) {
-	const path = nonEmptyString(value, owner);
-	if (isAbsolute(path)) throw new Error(`Rivus Home ${owner} must be a relative path`);
-	return path;
-}
-function nonEmptyString(value, owner) {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`Rivus Home ${owner} must be a non-empty string`);
-	return value;
-}
-function record(value, owner) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${owner} must be an object`);
-	return value;
-}
-function asError$1(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-//#endregion
-//#region src/platform/home/doctor/rivus-home-doctor.ts
-function diagnoseRivusHome(input, options) {
-	return Effect.gen(function* () {
-		const checks = [checkNode$1(input.nodeVersion)];
-		const loaded = yield* options.load(input.directory).pipe(Effect.either);
-		if (Either.isLeft(loaded)) {
-			checks.push({
-				message: `Rivus Home is invalid: ${loaded.left.message}`,
-				name: "home",
-				status: "fail"
-			}, blockedCheck("workspace", "Workspace"), blockedCheck("manifest", "manifest"), blockedCheck("modules", "modules"), blockedCheck("credentials", "credentials"));
-			return report(input.directory, checks);
-		}
-		const home = loaded.right;
-		checks.push({
-			message: "config.json is valid and contained in Rivus Home",
-			name: "home",
-			status: "pass"
-		});
-		checks.push(yield* checkWorkspace(home, options.findMissingWorkspacePaths));
-		const deployment = yield* options.deploymentInspector.inspect({
-			env: input.env,
-			...input.envFilePath ? { envFilePath: input.envFilePath } : {},
-			home
-		});
-		checks.push(deployment.manifest, deployment.modules, deployment.credentials);
-		return report(input.directory, checks);
-	});
-}
-function checkNode$1(version) {
-	const [major, minor] = version.split(".").map(Number);
-	return major === 24 && Number.isInteger(minor) && minor >= 11 ? {
-		message: `Node.js ${version} satisfies the supported ^24.11 runtime`,
-		name: "node",
-		status: "pass"
-	} : {
-		message: `Node.js 24.11 or newer on major 24 is required; current version is ${version}`,
-		name: "node",
-		status: "fail"
-	};
-}
-function checkWorkspace(home, findMissingWorkspacePaths) {
-	return findMissingWorkspacePaths(home).pipe(Effect.map((missing) => missing.length === 0 ? {
-		message: "Workspace instructions, Memory, Skills, and work directories are present",
-		name: "workspace",
-		status: "pass"
-	} : {
-		message: `Workspace paths are missing: ${missing.join(", ")}`,
-		name: "workspace",
-		status: "fail"
-	}));
-}
-function blockedCheck(name, owner) {
-	return {
-		message: `${owner} cannot be checked until config.json is valid`,
-		name,
-		status: "fail"
-	};
-}
-function report(directory, checks) {
-	return {
-		checks,
-		directory,
-		ready: checks.every(({ status }) => status === "pass")
-	};
-}
-//#endregion
-//#region src/platform/home/setup/rivus-home-layout.ts
-const HOME_DIRECTORIES = Object.freeze([
-	"logs",
-	"plugins",
-	"state",
-	"workspace/memory",
-	"workspace/skills",
-	"workspace/work/artifacts",
-	"workspace/work/drafts",
-	"workspace/work/inbox",
-	"workspace/work/tmp"
-]);
-function createRivusHomeLayout() {
-	return {
-		directories: HOME_DIRECTORIES,
-		files: /* @__PURE__ */ new Map([
-			[".env.example", environmentTemplate$1()],
-			[".gitignore", ".DS_Store\n.env\nlogs/\nstate/\nworkspace/work/tmp/\n"],
-			["config.json", homeConfig()],
-			["rivus.config.json", deploymentManifest$1()],
-			["workspace/AGENTS.md", agentsTemplate()],
-			["workspace/IDENTITY.md", "# Identity\n\nName: Rivus\n\nRole: Personal agent\n"],
-			["workspace/MEMORY.md", "# Curated Memory\n\nStore confirmed, durable facts and decisions here.\n"],
-			["workspace/SOUL.md", "# Character\n\nBe direct, thoughtful, and evidence-led.\n"],
-			["workspace/USER.md", "# User\n\nRecord stable user preferences here.\n"],
-			["plugins/.gitkeep", ""],
-			["workspace/memory/.gitkeep", ""],
-			["workspace/skills/.gitkeep", ""],
-			["workspace/work/artifacts/.gitkeep", ""],
-			["workspace/work/drafts/.gitkeep", ""],
-			["workspace/work/inbox/.gitkeep", ""]
-		])
-	};
-}
-function homeConfig() {
-	return `${JSON.stringify({
-		bootstrap: "@rivus/agent/bootstrap/pi-feishu",
-		envFile: ".env",
-		logs: "logs",
-		manifest: "rivus.config.json",
-		state: "state",
-		version: 1,
-		workspace: "workspace"
-	}, null, 2)}\n`;
-}
-function deploymentManifest$1() {
-	return `${JSON.stringify({
-		agents: [{
-			agentId: "personal",
-			endpointIds: ["personal-feishu"],
-			memory: {
-				scopes: ["agent-private"],
-				tool: true
-			},
-			pluginId: "rivus-starter",
-			profileId: "agent-a",
-			projectSpaceId: "personal-home",
-			runtimeTools: { allow: [
-				"read",
-				"bash",
-				"edit",
-				"write",
-				"grep",
-				"find",
-				"ls"
-			] },
-			skills: { allow: [] },
-			tools: { allow: ["rivus-starter/current-weather"] }
-		}],
-		defaultAgentId: "personal",
-		defaultEndpointId: "personal-feishu",
-		endpoints: [{
-			agentId: "personal",
-			baseUrl: "https://open.feishu.cn",
-			cardStreamLeaseMs: 51e4,
-			credentialRef: "env:RIVUS_FEISHU",
-			enabled: true,
-			experimental: { cotMessages: false },
-			groupPolicy: "mention-only",
-			id: "personal-feishu",
-			progressDisplay: "collapsed",
-			required: true,
-			sessionNamespace: "rivus-home-v1",
-			streamMinIntervalMs: 200
-		}],
-		plugins: [{
-			id: "rivus-starter",
-			module: "@rivus/agent/plugin/starter",
-			required: true
-		}],
-		projectSpaces: [{
-			id: "personal-home",
-			root: "workspace",
-			skills: { sources: ["skills"] },
-			workingDirectory: "."
-		}]
-	}, null, 2)}\n`;
-}
-function environmentTemplate$1() {
-	return [
-		"# Copy this file to .env and keep the real values untracked.",
-		"RIVUS_FEISHU_APP_ID=",
-		"RIVUS_FEISHU_APP_SECRET=",
-		"PI_MODEL=",
-		"PI_API_KEY=",
-		"# PI_BASE_URL=",
-		"RIVUS_WEATHER_DEFAULT_LOCATION=上海",
-		""
-	].join("\n");
-}
-function agentsTemplate() {
-	return [
-		"# Personal Workspace",
-		"",
-		"Use this directory as the default home for personal work.",
-		"",
-		"- Read `SOUL.md` and `IDENTITY.md` when identity or tone matters.",
-		"- Read `USER.md` when stable user preferences affect the task.",
-		"- Search `MEMORY.md` and dated files under `memory/` when prior facts or decisions matter.",
-		"- Read the selected `skills/<name>/SKILL.md` before following a Workspace Skill.",
-		"- Put incoming material in `work/inbox/`, drafts in `work/drafts/`, and durable general outputs in `work/artifacts/`.",
-		"- Put disposable files in `work/tmp/`.",
-		"- Store only confirmed durable facts in Memory; keep credentials and raw private transcripts out of tracked files.",
-		""
-	].join("\n");
-}
-//#endregion
-//#region src/platform/home/setup/rivus-home-initializer.ts
-function initializeRivusHome(directoryPath) {
-	const directory = resolve(directoryPath);
-	const { directories, files } = createRivusHomeLayout();
-	const paths = [...files.keys()].sort();
-	return Effect.tryPromise({
-		try: async () => {
-			for (const path of [...directories].sort()) await mkdir(join(directory, path), { recursive: true });
-			for (const path of paths) {
-				const destination = join(directory, path);
-				await mkdir(dirname(destination), { recursive: true });
-				await writeFile(destination, files.get(path), {
-					encoding: "utf8",
-					flag: "wx"
-				});
-			}
-			return {
-				directory,
-				files: paths
-			};
-		},
-		catch: (error) => error instanceof Error ? error : new Error(String(error))
-	});
-}
-//#endregion
-//#region src/platform/home/workspace/rivus-home-workspace.ts
-function findMissingRivusHomeWorkspacePaths(home) {
-	const required = [
-		home.workspaceDirectory,
-		resolve(home.workspaceDirectory, "AGENTS.md"),
-		resolve(home.workspaceDirectory, "MEMORY.md"),
-		resolve(home.workspaceDirectory, "memory"),
-		resolve(home.workspaceDirectory, "skills"),
-		resolve(home.workspaceDirectory, "work")
-	];
-	return Effect.tryPromise({
-		try: async () => {
-			const missing = [];
-			for (const path of required) try {
-				await stat(path);
-			} catch (error) {
-				if (error instanceof Error && "code" in error && error.code === "ENOENT") missing.push(path);
-				else throw error;
-			}
-			return missing;
-		},
-		catch: (error) => error instanceof Error ? error : new Error(String(error))
-	});
-}
-//#endregion
-//#region src/platform/home/node/node-rivus-home.ts
-function createNodeRivusHome(options) {
-	return {
-		diagnose: (input) => diagnoseRivusHome(input, {
-			deploymentInspector: options.deploymentInspector,
-			findMissingWorkspacePaths: findMissingRivusHomeWorkspacePaths,
-			load: loadRivusHome
-		}),
-		load: loadRivusHome,
-		setup: initializeRivusHome
-	};
-}
-//#endregion
-//#region src/adapters/cli/command/rivus-cli-protocol.ts
-const RIVUS_CLI_USAGE = `Usage:
-  rivus setup [directory]
-  rivus start
-  rivus status
-  rivus check-config
-  rivus init [directory]
-  rivus doctor [directory] [--env-file <path>]
-  rivus model <status|set|rollback> ...
-  rivus --bootstrap <module> [--manifest <rivus.config.json>] [options]
-
-Commands:
-  setup     Create Rivus Home (default ~/.rivus-agent) without overwriting files
-  start     Start the Rivus Home deployment in the foreground
-  status    Print Rivus Home deployment status without activating Endpoints
-  check-config
-            Validate and print the redacted Rivus Home manifest
-  init      Create a standalone local Rivus project without overwriting files
-  doctor    Check Rivus Home by default, or an explicit standalone project directory
-  model     Query or change the managed default model through the current Home
-
-Run rivus --help for the complete daemon option list.
-`;
-function renderRivusCliError(error) {
-	return `${error instanceof Error ? error.message : String(error)}\n`;
-}
-function renderRivusCliUnknownCommand(command) {
-	return `Unknown command: ${command}\n\n${RIVUS_CLI_USAGE}`;
-}
-function renderRivusDirectoryCommandUsage(command) {
-	return `Usage: rivus ${command} [directory]\n`;
-}
-function renderRivusHomeCommandUsage(command) {
-	return `Usage: rivus ${command}\n`;
-}
-function renderRivusDoctorUsage() {
-	return "Usage: rivus doctor [directory] [--env-file <path>]\n";
-}
-function renderRivusDoctorArgumentError(error) {
-	return `${error}\n${renderRivusDoctorUsage()}`;
-}
-function renderRivusSetupSuccess(directory) {
-	return `Initialized Rivus Home in ${directory}\n\nNext:\n  cp ${shellQuote(`${directory}/.env.example`)} ${shellQuote(`${directory}/.env`)}\n  rivus doctor\n  rivus start\n`;
-}
-function renderRivusProjectInitializationSuccess(directory) {
-	return `Initialized Rivus project in ${directory}\n\nNext:\n  cd ${shellQuote(directory)}\n  npm install\n  cp .env.example .env.local\n  npm run doctor\n  npm start\n`;
-}
-function* renderRivusDoctorReport(report, owner) {
-	yield `Rivus doctor: ${report.directory}\n`;
-	for (const check of report.checks) yield `${check.status === "pass" ? "PASS" : "FAIL"} ${check.name}: ${check.message}\n`;
-	yield report.ready ? `Rivus ${owner} is ready\n` : `Rivus ${owner} is not ready\n`;
-}
-function parseRivusDirectoryArguments(argv) {
-	if (argv.includes("--help") || argv.includes("-h")) return { help: true };
-	if (argv.length > 1 || argv[0]?.startsWith("-")) return { error: "invalid directory arguments" };
-	return argv[0] === void 0 ? {} : { directory: argv[0] };
-}
-function hasRivusHomeCommandArguments(argv) {
-	return argv.length > 0;
-}
-function parseRivusDoctorArguments(argv) {
-	let directory;
-	let envFilePath;
-	for (let index = 0; index < argv.length; index += 1) {
-		const argument = argv[index];
-		if (argument === "--help" || argument === "-h") return { help: true };
-		if (argument === "--env-file") {
-			const value = argv[index + 1];
-			if (!value) return { error: "--env-file requires a path" };
-			envFilePath = value;
-			index += 1;
-			continue;
-		}
-		if (argument.startsWith("--env-file=")) {
-			envFilePath = argument.slice(11);
-			if (!envFilePath) return { error: "--env-file requires a path" };
-			continue;
-		}
-		if (argument.startsWith("-")) return { error: `Unknown doctor option: ${argument}` };
-		if (directory !== void 0) return { error: "doctor accepts at most one directory" };
-		directory = argument;
-	}
-	return {
-		...directory !== void 0 ? { directory } : {},
-		...envFilePath !== void 0 ? { envFilePath } : {}
-	};
-}
-function shellQuote(value) {
-	return `'${value.replaceAll("'", "'\\''")}'`;
-}
-//#endregion
-//#region src/adapters/cli/model/rivus-model-management-socket-client.ts
-const MAX_FRAME_BYTES = 64 * 1024;
-const DEFAULT_TIMEOUT_MS = 1e4;
-var RivusModelManagementTransportError = class extends Error {
-	code;
-	constructor(code, message, options) {
-		super(message, options);
-		this.name = "RivusModelManagementTransportError";
-		this.code = code;
-	}
-};
-function createRivusModelManagementSocketClient(options) {
-	if (!isAbsolute(options.socketPath)) throw new Error("model socket path must be absolute");
-	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	return { execute: (command) => request(options.socketPath, options.env, command, timeoutMs) };
-}
-async function request(socketPath, env, command, timeoutMs) {
-	const payload = createRivusModelManagementWireRequest(command, env);
-	return new Promise((resolve, reject) => {
-		const socket = createConnection(socketPath);
-		let response = "";
-		let settled = false;
-		const finish = (callback) => {
-			if (settled) return;
-			settled = true;
-			callback();
-		};
-		socket.setEncoding("utf8");
-		socket.setTimeout(timeoutMs, () => {
-			finish(() => reject(new RivusModelManagementTransportError("timeout", "model management socket timed out")));
-			socket.destroy();
-		});
-		socket.on("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
-		socket.on("data", (chunk) => {
-			response += chunk;
-			if (Buffer.byteLength(response, "utf8") > MAX_FRAME_BYTES) {
-				finish(() => reject(new RivusModelManagementTransportError("invalid_response", "model response is too large")));
-				socket.destroy();
-			}
-		});
-		socket.on("error", (error) => {
-			finish(() => reject(new RivusModelManagementTransportError("socket_error", "model management socket is unavailable", { cause: error })));
-		});
-		socket.on("end", () => {
-			const line = response.split("\n", 1)[0]?.trim();
-			if (!line) {
-				finish(() => reject(new RivusModelManagementTransportError("invalid_response", "model response was empty")));
-				return;
-			}
-			try {
-				const parsed = JSON.parse(line);
-				if (!isResponse(parsed)) throw new Error("model response must be a JSON object");
-				finish(() => resolve(parsed));
-			} catch (error) {
-				finish(() => reject(new RivusModelManagementTransportError("invalid_response", "model response was not valid JSON", { cause: error })));
-			}
-		});
-	});
-}
-function isResponse(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
-//#region src/adapters/cli/model/rivus-model-socket.ts
-const RIVUS_MODEL_SOCKET_ENV = "RIVUS_MODEL_SOCKET";
-const RIVUS_MODEL_MANAGEMENT_ENABLED_ENV = "RIVUS_MODEL_MANAGEMENT_ENABLED";
-const RIVUS_MODEL_SOCKET_RELATIVE_PATH = "state/model-management/control.sock";
-function resolveRivusModelSocketPath(options) {
-	const configured = optional(options.env[RIVUS_MODEL_SOCKET_ENV]);
-	if (configured) {
-		if (!isAbsolute(configured)) throw new Error(`${RIVUS_MODEL_SOCKET_ENV} must be an absolute path`);
-		return resolve(configured);
-	}
-	const configuredHome = optional(options.env.RIVUS_HOME);
-	return join(configuredHome ? resolveAbsoluteHome(configuredHome) : resolve(options.homeDirectory, ".rivus-agent"), RIVUS_MODEL_SOCKET_RELATIVE_PATH);
-}
-function isRivusModelManagementEnabled(env) {
-	const value = optional(env[RIVUS_MODEL_MANAGEMENT_ENABLED_ENV]);
-	return value === "1" || value === "true";
-}
-function resolveAbsoluteHome(value) {
-	if (!isAbsolute(value)) throw new Error("RIVUS_HOME must be an absolute path");
-	return resolve(value);
-}
-function optional(value) {
-	return value?.trim() || void 0;
-}
-//#endregion
-//#region src/adapters/deployment/inspection/rivus-project-doctor.ts
-const REQUIRED_FILES = Object.freeze([
-	"package.json",
-	"rivus.bootstrap.ts",
-	"rivus.config.json"
-]);
-const REQUIRED_DEPENDENCIES = Object.freeze([
-	"@rivus/agent",
-	"@earendil-works/pi-coding-agent",
-	"@larksuiteoapi/node-sdk"
-]);
-function diagnoseRivusProject(options) {
-	return Effect.gen(function* () {
-		const directory = resolve(options.directory);
-		const checks = [checkNode(options.nodeVersion)];
-		checks.push(yield* Effect.tryPromise({
-			try: () => checkFiles(directory),
-			catch: toError
-		}));
-		checks.push(yield* Effect.tryPromise({
-			try: () => checkDependencies(directory),
-			catch: toError
-		}));
-		const manifestResult = yield* checkManifest(directory);
-		checks.push(manifestResult.check);
-		const envFilePath = resolve(directory, options.envFilePath ?? ".env.local");
-		checks.push(yield* Effect.tryPromise({
-			try: () => checkCredentials(manifestResult.manifest, envFilePath, options.env),
-			catch: toError
-		}));
-		return Object.freeze({
-			checks: Object.freeze(checks),
-			directory,
-			ready: checks.every(({ status }) => status === "pass")
-		});
-	});
-}
-function checkNode(version) {
-	const [major, minor] = version.split(".").map(Number);
-	if (major === 24 && Number.isInteger(minor) && minor >= 11) return {
-		message: `Node.js ${version} satisfies the supported ^24.11 runtime`,
-		name: "node",
-		status: "pass"
-	};
-	return {
-		message: `Node.js 24.11 or newer on major 24 is required; current version is ${version}`,
-		name: "node",
-		status: "fail"
-	};
-}
-async function checkFiles(directory) {
-	const missing = await missingRegularFiles(directory, REQUIRED_FILES);
-	return missing.length === 0 ? {
-		message: "required project files are present",
-		name: "files",
-		status: "pass"
-	} : {
-		message: `required project files are missing: ${missing.join(", ")}`,
-		name: "files",
-		status: "fail"
-	};
-}
-async function checkDependencies(directory) {
-	const packageFiles = REQUIRED_DEPENDENCIES.map((name) => join("node_modules", ...name.split("/"), "package.json"));
-	const missingIndexes = new Set((await missingRegularFiles(directory, packageFiles)).map((path) => packageFiles.indexOf(path)));
-	const missing = REQUIRED_DEPENDENCIES.filter((_, index) => missingIndexes.has(index));
-	return missing.length === 0 ? {
-		message: "Rivus, Pi, and Feishu dependencies are installed",
-		name: "dependencies",
-		status: "pass"
-	} : {
-		message: `run npm install; missing local dependencies: ${missing.join(", ")}`,
-		name: "dependencies",
-		status: "fail"
-	};
-}
-function checkManifest(directory) {
-	return loadRivusDeploymentManifest(join(directory, "rivus.config.json")).pipe(Effect.flatMap((manifest) => Effect.gen(function* () {
-		validateRivusDeploymentManifest(manifest);
-		const missingModules = [];
-		for (const plugin of manifest.plugins) {
-			const result = yield* resolveNodeRivusPluginModulePath({
-				deploymentRoot: directory,
-				module: plugin.module,
-				pluginId: plugin.id
-			}).pipe(Effect.either);
-			if (Either.isLeft(result)) missingModules.push(plugin.module);
-		}
-		if (missingModules.length > 0) return { check: {
-			message: `manifest Plugin modules are missing: ${missingModules.join(", ")}`,
-			name: "manifest",
-			status: "fail"
-		} };
-		return {
-			check: {
-				message: "deployment manifest is valid",
-				name: "manifest",
-				status: "pass"
-			},
-			manifest
-		};
-	})), Effect.catchAll((error) => Effect.succeed({ check: {
-		message: `deployment manifest is invalid: ${error.message}`,
-		name: "manifest",
-		status: "fail"
-	} })));
-}
-async function checkCredentials(manifest, envFilePath, env) {
-	let mergedEnv;
-	try {
-		mergedEnv = await loadMergedLocalEnvFile(envFilePath, env);
-	} catch (error) {
-		return {
-			message: `required env file is unavailable at ${envFilePath}: ${error instanceof Error ? error.message : String(error)}`,
-			name: "credentials",
-			status: "fail"
-		};
-	}
-	if (!manifest) return {
-		message: "enabled Endpoint credentials cannot be checked until the deployment manifest is valid",
-		name: "credentials",
-		status: "fail"
-	};
-	try {
-		for (const endpoint of manifest.endpoints.filter(({ enabled }) => enabled)) resolveFeishuEndpointCredentials(endpoint.credentialRef, mergedEnv);
-		return {
-			message: "enabled Endpoint credential references resolve",
-			name: "credentials",
-			status: "pass"
-		};
-	} catch (error) {
-		return {
-			message: `enabled Endpoint credentials are incomplete: ${error instanceof Error ? error.message : String(error)}`,
-			name: "credentials",
-			status: "fail"
-		};
-	}
-}
-async function missingRegularFiles(directory, paths) {
-	const missing = [];
-	for (const path of paths) try {
-		if (!(await stat(resolve(directory, path))).isFile()) missing.push(path);
-	} catch (error) {
-		if (!isMissingPath$1(error)) throw error;
-		missing.push(path);
-	}
-	return missing;
-}
-function isMissingPath$1(error) {
-	return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function toError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-//#endregion
-//#region src/platform/project/setup/rivus-project-initializer.ts
-const TEMPLATE_FILES = Object.freeze({
-	"current-weather.mjs": "current-weather.mjs",
-	"https-response-reader.mjs": "https-response-reader.mjs",
-	"rivus-agents.plugin.mjs": "rivus-starter.plugin.mjs",
-	"rivus.bootstrap.ts": "pi-feishu-deployment.bootstrap.ts"
-});
-async function initializeRivusProject(options) {
-	const directory = resolve(options.directory);
-	const manifest = await readPackageManifest(options.packageManifestPath);
-	const files = /* @__PURE__ */ new Map([
-		[".env.example", environmentTemplate()],
-		[".gitignore", ".env.local\n.rivus/\nnode_modules/\n"],
-		["deploy/launchd/com.rivus.agent.plist", launchdService(directory, options.nodeExecutable)],
-		["deploy/systemd/rivus.service", systemdService(directory, options.nodeExecutable)],
-		["package.json", projectPackageJson(directory, manifest)],
-		["rivus.config.json", deploymentManifest()]
-	]);
-	for (const [target, source] of Object.entries(TEMPLATE_FILES)) files.set(target, await readFile(join(options.templateDirectory, source), "utf8"));
-	const paths = [...files.keys()].sort();
-	await assertSafeProjectAncestors(directory, paths);
-	const conflicts = await findConflicts(directory, paths);
-	if (conflicts.length > 0) throw new Error(`Rivus project initialization refused; refusing to overwrite: ${conflicts.join(", ")}`);
-	const createdDirectories = [];
-	const createdFiles = [];
-	const writeProjectFile = options.writeProjectFile ?? writeExclusiveProjectFile;
-	try {
-		for (const path of paths) {
-			const destination = join(directory, path);
-			await ensureDirectory(dirname(destination), directory, createdDirectories);
-			await assertSafeProjectAncestors(directory, [path]);
-			await writeProjectFile(destination, files.get(path));
-			createdFiles.push(destination);
-		}
-	} catch (error) {
-		const rollbackErrors = await rollbackCreatedPaths(createdFiles, createdDirectories);
-		if (rollbackErrors.length > 0) throw new AggregateError([error, ...rollbackErrors], "Rivus project initialization failed and rollback was incomplete");
-		throw error;
-	}
-	return {
-		directory,
-		files: Object.freeze(paths)
-	};
-}
-async function writeExclusiveProjectFile(path, contents) {
-	await writeFile(path, contents, {
-		encoding: "utf8",
-		flag: "wx"
-	});
-}
-async function assertSafeProjectAncestors(directory, paths) {
-	const rootState = await lstatOrUndefined(directory);
-	if (rootState?.isSymbolicLink()) throw new Error("Rivus project initialization refused; symbolic link ancestor: .");
-	if (rootState && !rootState.isDirectory()) throw new Error("Rivus project initialization refused; project path is not a directory");
-	if (!rootState) return;
-	for (const path of paths) {
-		let current = directory;
-		for (const segment of path.split("/").slice(0, -1)) {
-			current = join(current, segment);
-			const state = await lstatOrUndefined(current);
-			if (!state) break;
-			if (state.isSymbolicLink()) throw new Error(`Rivus project initialization refused; symbolic link ancestor: ${relative(directory, current)}`);
-			if (!state.isDirectory()) throw new Error(`Rivus project initialization refused; non-directory ancestor: ${relative(directory, current)}`);
-		}
-	}
-}
-async function ensureDirectory(path, projectRoot, createdDirectories) {
-	try {
-		await mkdir(path);
-		createdDirectories.push(path);
-	} catch (error) {
-		if (isMissingPath(error)) {
-			const parent = dirname(path);
-			if (parent === path) throw error;
-			await ensureDirectory(parent, projectRoot, createdDirectories);
-			await ensureDirectory(path, projectRoot, createdDirectories);
-			return;
-		}
-		if (!isAlreadyExists(error)) throw error;
-		const state = await lstat(path);
-		if (state.isSymbolicLink()) {
-			if (isPathWithin(projectRoot, path)) throw new Error(`Rivus project initialization refused; symbolic link ancestor: ${relative(projectRoot, path) || "."}`);
-			if ((await stat(path)).isDirectory()) return;
-		}
-		if (!state.isDirectory()) throw new Error(`Rivus project initialization refused; non-directory ancestor: ${path}`);
-	}
-}
-async function rollbackCreatedPaths(files, directories) {
-	const errors = [];
-	for (const path of files.reverse()) try {
-		await unlink(path);
-	} catch (error) {
-		if (!isMissingPath(error)) errors.push(asError(error));
-	}
-	for (const path of directories.reverse()) try {
-		await rmdir(path);
-	} catch (error) {
-		if (!isMissingPath(error) && !isDirectoryNotEmpty(error)) errors.push(asError(error));
-	}
-	return errors;
-}
-async function lstatOrUndefined(path) {
-	try {
-		return await lstat(path);
-	} catch (error) {
-		if (isMissingPath(error)) return void 0;
-		throw error;
-	}
-}
-function isAlreadyExists(error) {
-	return error instanceof Error && "code" in error && error.code === "EEXIST";
-}
-function isDirectoryNotEmpty(error) {
-	return error instanceof Error && "code" in error && error.code === "ENOTEMPTY";
-}
-function asError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-async function readPackageManifest(path) {
-	const manifest = JSON.parse(await readFile(path, "utf8"));
-	if (manifest.name !== "@rivus/agent" || typeof manifest.version !== "string") throw new Error("Rivus package manifest is missing its release identity");
-	return manifest;
-}
-async function findConflicts(directory, paths) {
-	const conflicts = [];
-	for (const path of paths) try {
-		await lstat(join(directory, path));
-		conflicts.push(path);
-	} catch (error) {
-		if (!isMissingPath(error)) throw error;
-	}
-	return conflicts;
-}
-function isMissingPath(error) {
-	return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function projectPackageJson(directory, manifest) {
-	const pi = manifest.dependencies?.["@earendil-works/pi-coding-agent"];
-	const lark = manifest.dependencies?.["@larksuiteoapi/node-sdk"];
-	const effect = manifest.dependencies?.effect;
-	if (!pi || !lark || !effect) throw new Error("Rivus package manifest is missing its Effect, Pi, or Feishu dependency range");
-	const projectName = sanitizePackageName(basename(directory));
-	return `${JSON.stringify({
-		name: projectName,
-		private: true,
-		type: "module",
-		scripts: {
-			"check-config": "rivus --manifest ./rivus.config.json --check-config",
-			doctor: "rivus doctor .",
-			start: "rivus --env-file .env.local --bootstrap ./rivus.bootstrap.ts --manifest ./rivus.config.json"
-		},
-		dependencies: {
-			"@earendil-works/pi-coding-agent": pi,
-			"@larksuiteoapi/node-sdk": lark,
-			"@rivus/agent": `^${manifest.version}`,
-			effect
-		}
-	}, null, 2)}\n`;
-}
-function sanitizePackageName(value) {
-	return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "") || "rivus-app";
-}
-function deploymentManifest() {
-	return `${JSON.stringify({
-		plugins: [{
-			id: "rivus-starter",
-			module: "./rivus-agents.plugin.mjs",
-			required: true
-		}],
-		agents: [{
-			agentId: "agent-a",
-			endpointIds: ["feishu-agent-a"],
-			pluginId: "rivus-starter",
-			profileId: "agent-a",
-			skills: { allow: [] },
-			tools: { allow: ["rivus-starter/current-weather"] }
-		}],
-		defaultAgentId: "agent-a",
-		defaultEndpointId: "feishu-agent-a",
-		endpoints: [{
-			agentId: "agent-a",
-			baseUrl: "https://open.feishu.cn",
-			cardStreamLeaseMs: 51e4,
-			credentialRef: "env:RIVUS_FEISHU",
-			enabled: true,
-			experimental: { cotMessages: false },
-			groupPolicy: "mention-only",
-			id: "feishu-agent-a",
-			progressDisplay: "collapsed",
-			required: true,
-			sessionNamespace: "rivus-starter",
-			streamMinIntervalMs: 200
-		}]
-	}, null, 2)}\n`;
-}
-function environmentTemplate() {
-	return [
-		"# Copy this file to .env.local and keep the real values untracked.",
-		"RIVUS_FEISHU_APP_ID=",
-		"RIVUS_FEISHU_APP_SECRET=",
-		"PI_MODEL=",
-		"PI_API_KEY=",
-		"# PI_BASE_URL=",
-		"RIVUS_WEATHER_DEFAULT_LOCATION=上海",
-		"# LANGFUSE_BASE_URL=https://jp.cloud.langfuse.com",
-		"# LANGFUSE_PUBLIC_KEY=",
-		"# LANGFUSE_SECRET_KEY=",
-		"# RIVUS_TELEMETRY_CONTENT=redacted",
-		""
-	].join("\n");
-}
-function systemdService(directory, nodeExecutable) {
-	const cli = join(directory, "node_modules", "@rivus", "agent", "dist", "cli.js");
-	return `[Unit]\nDescription=Rivus Agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nWorkingDirectory=${systemdPath(directory)}\nExecStart=${systemdQuote(nodeExecutable)} ${systemdQuote(cli)} --env-file .env.local --bootstrap ./rivus.bootstrap.ts --manifest ./rivus.config.json\nRestart=on-failure\nRestartSec=5\nEnvironment=NODE_ENV=production\n\n[Install]\nWantedBy=default.target\n`;
-}
-function systemdPath(value) {
-	return value.replaceAll("%", "%%");
-}
-function systemdQuote(value) {
-	return `"${value.replace(/%/g, "%%").replace(/\$/g, () => "$$").replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
-}
-function launchdService(directory, nodeExecutable) {
-	return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>Label</key>\n  <string>com.rivus.agent</string>\n  <key>ProgramArguments</key>\n  <array>\n${[
-		nodeExecutable,
-		join(directory, "node_modules", "@rivus", "agent", "dist", "cli.js"),
-		"--env-file",
-		".env.local",
-		"--bootstrap",
-		"./rivus.bootstrap.ts",
-		"--manifest",
-		"./rivus.config.json"
-	].map((value) => `    <string>${xmlEscape(value)}</string>`).join("\n")}\n  </array>\n  <key>WorkingDirectory</key>\n  <string>${xmlEscape(directory)}</string>\n  <key>RunAtLoad</key>\n  <true/>\n  <key>KeepAlive</key>\n  <dict>\n    <key>SuccessfulExit</key>\n    <false/>\n  </dict>\n  <key>ThrottleInterval</key>\n  <integer>5</integer>\n</dict>\n</plist>\n`;
-}
-function xmlEscape(value) {
-	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-//#endregion
-//#region src/bootstrap/cli/rivus-cli.ts
-function runRivusCli(options) {
-	const command = options.argv[0];
-	if (command === "setup") return runSetupCommand(options);
-	if (command === "start") return runHomeDaemonCommand(options, "start", []);
-	if (command === "status") return runHomeDaemonCommand(options, "status", ["--status"]);
-	if (command === "check-config") return runHomeDaemonCommand(options, "check-config", ["--check-config"]);
-	if (command === "init") return runInitCommand(options);
-	if (command === "doctor") return runDoctorCommand(options);
-	if (command === "model") return runModelCommand(options);
-	if (command && !command.startsWith("-")) return Effect.sync(() => {
-		options.stderr.write(renderRivusCliUnknownCommand(command));
-		return 1;
-	});
-	return runRivusDaemonCli(options);
-}
-function runModelCommand(options) {
-	const parsed = parseRivusModelCliArguments(options.argv.slice(1));
-	if ("help" in parsed) return Effect.sync(() => {
-		options.stdout.write(renderRivusModelCliHelp());
-		return 0;
-	});
-	if ("error" in parsed) return Effect.sync(() => {
-		options.stderr.write(renderRivusModelCliArgumentError(parsed.error));
-		return 1;
-	});
-	if (parsed.operation !== "status" && !isRivusModelManagementEnabled(options.env)) return Effect.sync(() => {
-		writeModelResponse(options.stdout, {
-			error: {
-				code: "management_disabled",
-				message: "model management is not enabled for this Home"
-			},
-			schemaVersion: 1,
-			status: "failed"
-		});
-		return 1;
-	});
-	const client = options.modelManagementClient ?? createRivusModelManagementSocketClient({
-		env: options.env,
-		socketPath: resolveRivusModelSocketPath({
-			env: options.env,
-			homeDirectory: options.homeDirectory
-		})
-	});
-	return Effect.tryPromise({
-		try: () => client.execute(parsed),
-		catch: (error) => error
-	}).pipe(Effect.tap((response) => Effect.sync(() => writeModelResponse(options.stdout, response))), Effect.map((response) => modelManagementExitCode(response)), Effect.catchAll((error) => Effect.sync(() => {
-		writeModelResponse(options.stdout, modelTransportFailure(error));
-		return 1;
-	})));
-}
-function modelManagementExitCode(response) {
-	if (response.status !== "failed") return 0;
-	if (typeof response.requestId === "string" && response.requestId.trim()) return 0;
-	const request = response.request;
-	if (typeof request !== "object" || request === null || Array.isArray(request)) return 1;
-	const requestId = request.requestId;
-	return typeof requestId === "string" && requestId.trim() ? 0 : 1;
-}
-function writeModelResponse(stdout, response) {
-	stdout.write(`${JSON.stringify(response)}\n`);
-}
-function modelTransportFailure(error) {
-	const code = error instanceof RivusModelManagementTransportError ? error.code : "socket_error";
-	return {
-		error: {
-			code,
-			message: code === "timeout" ? "model management service timed out" : code === "invalid_response" ? "model management returned an invalid response" : "model management service is unavailable"
-		},
-		schemaVersion: 1,
-		status: "failed"
-	};
-}
-function runSetupCommand(options) {
-	return withOptionalDirectoryArgument(options, "setup", (argument) => resolveHomeDirectoryEffect(options, argument).pipe(Effect.flatMap((directory) => options.homeApi.setup(directory).pipe(Effect.tap(() => Effect.sync(() => options.stdout.write(renderRivusSetupSuccess(directory)))), Effect.as(0))), Effect.catchAll((error) => writeError(options, error))));
-}
-function runHomeDaemonCommand(options, command, daemonArgs) {
-	if (hasRivusHomeCommandArguments(options.argv.slice(1))) return Effect.sync(() => {
-		options.stderr.write(renderRivusHomeCommandUsage(command));
-		return 1;
-	});
-	return resolveHomeDirectoryEffect(options).pipe(Effect.flatMap((directory) => options.homeApi.load(directory)), Effect.tap((home) => Effect.sync(() => options.changeWorkingDirectory(home.workspaceDirectory))), Effect.flatMap((home) => runRivusDaemonCli({
-		...options,
-		argv: [
-			"--env-file",
-			home.envFilePath,
-			"--bootstrap",
-			home.bootstrap,
-			"--manifest",
-			home.manifestPath,
-			...daemonArgs
-		],
-		env: {
-			...options.env,
-			RIVUS_DEPLOYMENT_STATE_DIR: home.stateDirectory,
-			RIVUS_HOME: home.directory
-		},
-		pluginPackageManifestPath: options.packageManifestPath
-	})), Effect.catchAll((error) => writeError(options, error)));
-}
-function runInitCommand(options) {
-	return withOptionalDirectoryArgument(options, "init", (argument) => {
-		const directory = resolve(options.cwd, argument ?? ".");
-		return Effect.tryPromise({
-			try: () => initializeRivusProject({
-				directory,
-				nodeExecutable: options.nodeExecutable,
-				packageManifestPath: options.packageManifestPath,
-				templateDirectory: options.templateDirectory
-			}),
-			catch: (error) => error
-		}).pipe(Effect.tap((result) => Effect.sync(() => options.stdout.write(renderRivusProjectInitializationSuccess(result.directory)))), Effect.as(0), Effect.catchAll((error) => writeError(options, error)));
-	});
-}
-function withOptionalDirectoryArgument(options, command, run) {
-	const parsed = parseRivusDirectoryArguments(options.argv.slice(1));
-	if (parsed.help) return Effect.sync(() => {
-		options.stdout.write(renderRivusDirectoryCommandUsage(command));
-		return 0;
-	});
-	if (parsed.error) return Effect.sync(() => {
-		options.stderr.write(renderRivusDirectoryCommandUsage(command));
-		return 1;
-	});
-	return run(parsed.directory);
-}
-function runDoctorCommand(options) {
-	const parsed = parseRivusDoctorArguments(options.argv.slice(1));
-	if (parsed.help) return Effect.sync(() => {
-		options.stdout.write(renderRivusDoctorUsage());
-		return 0;
-	});
-	if (parsed.error) {
-		const error = parsed.error;
-		return Effect.sync(() => {
-			options.stderr.write(renderRivusDoctorArgumentError(error));
-			return 1;
-		});
-	}
-	if (parsed.directory === void 0) return resolveHomeDirectoryEffect(options).pipe(Effect.flatMap((directory) => options.homeApi.diagnose({
-		directory,
-		env: options.env,
-		...parsed.envFilePath ? { envFilePath: parsed.envFilePath } : {},
-		nodeVersion: options.nodeVersion
-	})), Effect.map((report) => writeDoctorReport(options.stdout, report, "Home")), Effect.catchAll((error) => writeError(options, error)));
-	const projectDirectory = parsed.directory;
-	return diagnoseRivusProject({
-		directory: resolve(options.cwd, projectDirectory),
-		env: options.env,
-		...parsed.envFilePath ? { envFilePath: parsed.envFilePath } : {},
-		nodeVersion: options.nodeVersion
-	}).pipe(Effect.map((report) => writeDoctorReport(options.stdout, report, "project")), Effect.catchAll((error) => writeError(options, error)));
-}
-function resolveHomeDirectoryEffect(options, argument) {
-	return Effect.try({
-		try: () => {
-			if (argument) return resolve(options.cwd, argument);
-			const configured = options.env.RIVUS_HOME?.trim();
-			if (!configured) return resolve(options.homeDirectory, ".rivus-agent");
-			if (!isAbsolute(configured)) throw new Error("RIVUS_HOME must be an absolute path");
-			return resolve(configured);
-		},
-		catch: (error) => error instanceof Error ? error : new Error(String(error))
-	});
-}
-function writeDoctorReport(stdout, report, owner) {
-	for (const chunk of renderRivusDoctorReport(report, owner)) stdout.write(chunk);
-	return report.ready ? 0 : 1;
-}
-function writeError(options, error) {
-	return Effect.sync(() => {
-		options.stderr.write(renderRivusCliError(error));
-		return 1;
-	});
-}
-//#endregion
-//#region src/bootstrap/cli/rivus-node-entrypoint.ts
-function runRivusNodeEntrypoint(options) {
-	const packageManifestPath = join(options.packageDirectory, "package.json");
-	return runRivusCli({
-		argv: options.argv,
-		changeWorkingDirectory: options.changeWorkingDirectory,
-		cwd: options.cwd,
-		env: options.env,
-		...options.exitAfterSignal !== void 0 ? { exitAfterSignal: options.exitAfterSignal } : {},
-		homeApi: createNodeRivusHome({ deploymentInspector: createRivusHomeDeploymentInspector({ packageManifestPath }) }),
-		homeDirectory: homedir(),
-		loadBootstrap: (specifier) => import(toImportSpecifier(specifier)),
-		nodeExecutable: process.execPath,
-		nodeVersion: process.versions.node,
-		packageManifestPath,
-		signalSource: options.signalSource,
-		stderr: options.stderr,
-		stdout: options.stdout,
-		templateDirectory: join(options.packageDirectory, "examples")
-	});
-}
-function toImportSpecifier(specifier) {
-	if (specifier.startsWith(".") || specifier.startsWith("/")) return pathToFileURL(resolve(specifier)).href;
-	return specifier;
-}
-//#endregion
+import { runRivusNodeEntrypoint } from "@rivus/gateway";
+import { Effect } from "effect";
 //#region src/cli.ts
-const packageDirectory = fileURLToPath(new URL("..", import.meta.url));
-const exitCode = await Effect.runPromise(runRivusNodeEntrypoint({
-	argv: process.argv.slice(2),
-	changeWorkingDirectory: (directory) => process.chdir(directory),
-	cwd: process.cwd(),
-	env: process.env,
-	exitAfterSignal: (code) => process.exit(code),
-	packageDirectory,
-	signalSource: process,
+const processResult = runRivusNodeEntrypoint({
+	stdout: process.stdout,
 	stderr: process.stderr,
-	stdout: process.stdout
-}));
-process.exitCode = exitCode;
+	signalSource: process,
+	exitAfterSignal: (code) => process.exit(code),
+	env: process.env,
+	cwd: process.cwd(),
+	changeWorkingDirectory: (directory) => process.chdir(directory),
+	argv: process.argv.slice(2)
+});
+process.exitCode = await Effect.runPromise(processResult);
 //#endregion
 export {};