@rivus/agent 0.14.3 → 0.15.0

package/dist/cli.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-import { T as loadRivusDeploymentManifest, V as resolveFeishuEndpointCredentials, W as loadMergedLocalEnvFile, d as validateTrustedModulePath, f as isPathWithin, j as validateRivusDeploymentManifest, p as findTrustedPackageRoot, t as runRivusDaemonCli, u as resolveNodeRivusPluginModulePath } from "./chunks/rivus-daemon-cli.js";
+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 = {}) {
@@ -33,7 +35,7 @@ function checkManifest$1(home) {
 			manifest
 		};
 	}), Effect.catchAll((error) => Effect.succeed({ check: {
-		message: `deployment manifest is invalid: ${formatError$1(error)}`,
+		message: `deployment manifest is invalid: ${formatError(error)}`,
 		name: "manifest",
 		status: "fail"
 	} })));
@@ -49,7 +51,7 @@ function checkModules(home, manifest, resolveModule, resolvePluginModule) {
 		const missing = [];
 		for (const specifier of specifiers) {
 			const result = yield* toEffect(() => resolveModule(specifier)).pipe(Effect.either);
-			if (result._tag === "Left") missing.push(`${specifier} (${formatError$1(result.left)})`);
+			if (result._tag === "Left") missing.push(`${specifier} (${formatError(result.left)})`);
 		}
 		for (const plugin of manifest.plugins) {
 			const result = yield* toEffect(() => resolvePluginModule({
@@ -57,7 +59,7 @@ function checkModules(home, manifest, resolveModule, resolvePluginModule) {
 				module: plugin.module,
 				pluginId: plugin.id
 			})).pipe(Effect.either);
-			if (result._tag === "Left") missing.push(`${plugin.module} (${formatError$1(result.left)})`);
+			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",
@@ -102,7 +104,7 @@ function checkCredentials$1(home, manifest, env, envFilePath) {
 		},
 		catch: toError$1
 	}).pipe(Effect.catchAll((error) => Effect.succeed({
-		message: `enabled Endpoint credentials are incomplete: ${formatError$1(error)}`,
+		message: `enabled Endpoint credentials are incomplete: ${formatError(error)}`,
 		name: "credentials",
 		status: "fail"
 	})));
@@ -120,410 +122,340 @@ function defaultResolveModule(specifier, packageManifestPath) {
 function toError$1(error) {
 	return error instanceof Error ? error : new Error(String(error));
 }
-function formatError$1(error) {
+function formatError(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#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) {
+//#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 directory = resolve(options.directory);
-		const checks = [checkNode$1(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")
+		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);
-	if (major === 24 && Number.isInteger(minor) && minor >= 11) return {
+	return major === 24 && Number.isInteger(minor) && minor >= 11 ? {
 		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",
+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: `required project files are missing: ${missing.join(", ")}`,
-		name: "files",
+		message: `Workspace paths are missing: ${missing.join(", ")}`,
+		name: "workspace",
 		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",
+function blockedCheck(name, owner) {
+	return {
+		message: `${owner} cannot be checked until config.json is valid`,
+		name,
 		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"
+function report(directory, checks) {
+	return {
+		checks,
+		directory,
+		ready: checks.every(({ status }) => status === "pass")
 	};
-	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$1()],
-		[".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$1()]
-	]);
-	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;
-	}
+//#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 {
-		directory,
-		files: Object.freeze(paths)
+		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", ""]
+		])
 	};
 }
-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$1(error));
-	}
-	for (const path of directories.reverse()) try {
-		await rmdir(path);
-	} catch (error) {
-		if (!isMissingPath(error) && !isDirectoryNotEmpty(error)) errors.push(asError$1(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$1(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));
+function homeConfig() {
 	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
-		}
+		bootstrap: "@rivus/agent/bootstrap/pi-feishu",
+		envFile: ".env",
+		logs: "logs",
+		manifest: "rivus.config.json",
+		state: "state",
+		version: 1,
+		workspace: "workspace"
 	}, null, 2)}\n`;
 }
-function sanitizePackageName(value) {
-	return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "") || "rivus-app";
-}
 function deploymentManifest$1() {
 	return `${JSON.stringify({
-		plugins: [{
-			id: "rivus-starter",
-			module: "./rivus-agents.plugin.mjs",
-			required: true
-		}],
 		agents: [{
-			agentId: "agent-a",
-			endpointIds: ["feishu-agent-a"],
+			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: "agent-a",
-		defaultEndpointId: "feishu-agent-a",
+		defaultAgentId: "personal",
+		defaultEndpointId: "personal-feishu",
 		endpoints: [{
-			agentId: "agent-a",
+			agentId: "personal",
 			baseUrl: "https://open.feishu.cn",
 			cardStreamLeaseMs: 51e4,
 			credentialRef: "env:RIVUS_FEISHU",
 			enabled: true,
 			experimental: { cotMessages: false },
 			groupPolicy: "mention-only",
-			id: "feishu-agent-a",
+			id: "personal-feishu",
 			progressDisplay: "collapsed",
 			required: true,
-			sessionNamespace: "rivus-starter",
+			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.local and keep the real values untracked.",
+		"# 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=上海",
-		"# 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 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");
 }
-function xmlEscape(value) {
-	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+//#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/composition/rivus-cli.ts
-const USAGE = `Usage:
+//#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:
@@ -534,126 +466,48 @@ Commands:
             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 runRivusCli(options) {
-	const command = options.argv[0];
-	if (command === "setup") return runSetupCommand(options);
-	if (command === "start") return runHomeDaemonCommand(options, []);
-	if (command === "status") return runHomeDaemonCommand(options, ["--status"]);
-	if (command === "check-config") return runHomeDaemonCommand(options, ["--check-config"]);
-	if (command === "init") return runInitCommand(options);
-	if (command === "doctor") return runDoctorCommand(options);
-	if (command && !command.startsWith("-")) return Effect.sync(() => {
-		options.stderr.write(`Unknown command: ${command}\n\n${USAGE}`);
-		return 1;
-	});
-	return runRivusDaemonCli(options);
+function renderRivusCliError(error) {
+	return `${error instanceof Error ? error.message : String(error)}\n`;
 }
-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(`Initialized Rivus Home in ${directory}\n\nNext:\n  cp ${shellQuote(`${directory}/.env.example`)} ${shellQuote(`${directory}/.env`)}\n  rivus doctor\n  rivus start\n`))), Effect.as(0))), Effect.catchAll((error) => writeError(options, error))));
+function renderRivusCliUnknownCommand(command) {
+	return `Unknown command: ${command}\n\n${RIVUS_CLI_USAGE}`;
 }
-function runHomeDaemonCommand(options, daemonArgs) {
-	if (options.argv.length > 1) return Effect.sync(() => {
-		options.stderr.write(`Usage: rivus ${options.argv[0]}\n`);
-		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 renderRivusDirectoryCommandUsage(command) {
+	return `Usage: rivus ${command} [directory]\n`;
 }
-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(`Initialized Rivus project in ${result.directory}\n\nNext:\n  cd ${shellQuote(result.directory)}\n  npm install\n  cp .env.example .env.local\n  npm run doctor\n  npm start\n`))), Effect.as(0), Effect.catchAll((error) => writeError(options, error)));
-	});
+function renderRivusHomeCommandUsage(command) {
+	return `Usage: rivus ${command}\n`;
 }
-function withOptionalDirectoryArgument(options, command, run) {
-	const args = options.argv.slice(1);
-	const usage = `Usage: rivus ${command} [directory]\n`;
-	if (args.includes("--help") || args.includes("-h")) return Effect.sync(() => {
-		options.stdout.write(usage);
-		return 0;
-	});
-	if (args.length > 1 || args[0]?.startsWith("-")) return Effect.sync(() => {
-		options.stderr.write(usage);
-		return 1;
-	});
-	return run(args[0]);
+function renderRivusDoctorUsage() {
+	return "Usage: rivus doctor [directory] [--env-file <path>]\n";
 }
-function runDoctorCommand(options) {
-	const parsed = parseDoctorArguments(options.argv.slice(1));
-	if (parsed.help) return Effect.sync(() => {
-		options.stdout.write("Usage: rivus doctor [directory] [--env-file <path>]\n");
-		return 0;
-	});
-	if (parsed.error) return Effect.sync(() => {
-		options.stderr.write(`${parsed.error}\nUsage: rivus doctor [directory] [--env-file <path>]\n`);
-		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 renderRivusDoctorArgumentError(error) {
+	return `${error}\n${renderRivusDoctorUsage()}`;
 }
-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 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 writeError(options, error) {
-	return Effect.sync(() => {
-		options.stderr.write(`${formatError(error)}\n`);
-		return 1;
-	});
+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 writeDoctorReport(stdout, report, owner) {
-	stdout.write(`Rivus doctor: ${report.directory}\n`);
-	for (const check of report.checks) stdout.write(`${check.status === "pass" ? "PASS" : "FAIL"} ${check.name}: ${check.message}\n`);
-	stdout.write(report.ready ? `Rivus ${owner} is ready\n` : `Rivus ${owner} is not ready\n`);
-	return report.ready ? 0 : 1;
+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 parseDoctorArguments(argv) {
+function hasRivusHomeCommandArguments(argv) {
+	return argv.length > 0;
+}
+function parseRivusDoctorArguments(argv) {
 	let directory;
 	let envFilePath;
 	for (let index = 0; index < argv.length; index += 1) {
@@ -680,357 +534,706 @@ function parseDoctorArguments(argv) {
 		...envFilePath !== void 0 ? { envFilePath } : {}
 	};
 }
-function formatError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 function shellQuote(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
 //#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
+//#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 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 isResponse(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-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;
+//#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 nonEmptyString(value, owner) {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`Rivus Home ${owner} must be a non-empty string`);
-	return value;
+function isRivusModelManagementEnabled(env) {
+	const value = optional(env[RIVUS_MODEL_MANAGEMENT_ENABLED_ENV]);
+	return value === "1" || value === "true";
 }
-function record(value, owner) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${owner} must be an object`);
-	return value;
+function resolveAbsoluteHome(value) {
+	if (!isAbsolute(value)) throw new Error("RIVUS_HOME must be an absolute path");
+	return resolve(value);
 }
-function asError(error) {
-	return error instanceof Error ? error : new Error(String(error));
+function optional(value) {
+	return value?.trim() || void 0;
 }
 //#endregion
-//#region src/platform/home/doctor/rivus-home-doctor.ts
-function diagnoseRivusHome(input, options) {
+//#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 checks = [checkNode(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);
+		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);
-	return major === 24 && Number.isInteger(minor) && minor >= 11 ? {
+	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"
 	};
 }
-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",
+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: `Workspace paths are missing: ${missing.join(", ")}`,
-		name: "workspace",
+		message: `required project files are missing: ${missing.join(", ")}`,
+		name: "files",
 		status: "fail"
-	}));
+	};
 }
-function blockedCheck(name, owner) {
-	return {
-		message: `${owner} cannot be checked until config.json is valid`,
-		name,
+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 report(directory, checks) {
-	return {
-		checks,
-		directory,
-		ready: checks.every(({ status }) => status === "pass")
+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/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() {
+//#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 {
-		directories: HOME_DIRECTORIES,
-		files: /* @__PURE__ */ new Map([
-			[".env.example", environmentTemplate()],
-			[".gitignore", ".DS_Store\n.env\nlogs/\nstate/\nworkspace/work/tmp/\n"],
-			["config.json", homeConfig()],
-			["rivus.config.json", deploymentManifest()],
-			["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", ""]
-		])
+		directory,
+		files: Object.freeze(paths)
 	};
 }
-function homeConfig() {
+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({
-		bootstrap: "@rivus/agent/bootstrap/pi-feishu",
-		envFile: ".env",
-		logs: "logs",
-		manifest: "rivus.config.json",
-		state: "state",
-		version: 1,
-		workspace: "workspace"
+		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: "personal",
-			endpointIds: ["personal-feishu"],
-			memory: {
-				scopes: ["agent-private"],
-				tool: true
-			},
+			agentId: "agent-a",
+			endpointIds: ["feishu-agent-a"],
 			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",
+		defaultAgentId: "agent-a",
+		defaultEndpointId: "feishu-agent-a",
 		endpoints: [{
-			agentId: "personal",
+			agentId: "agent-a",
 			baseUrl: "https://open.feishu.cn",
 			cardStreamLeaseMs: 51e4,
 			credentialRef: "env:RIVUS_FEISHU",
 			enabled: true,
 			experimental: { cotMessages: false },
 			groupPolicy: "mention-only",
-			id: "personal-feishu",
+			id: "feishu-agent-a",
 			progressDisplay: "collapsed",
 			required: true,
-			sessionNamespace: "rivus-home-v1",
+			sessionNamespace: "rivus-starter",
 			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() {
 	return [
-		"# Copy this file to .env and keep the real values untracked.",
+		"# 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 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");
+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/platform/home/setup/rivus-home-initializer.ts
-function initializeRivusHome(directoryPath) {
-	const directory = resolve(directoryPath);
-	const { directories, files } = createRivusHomeLayout();
-	const paths = [...files.keys()].sort();
+//#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: 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
-			};
+		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"
 		},
-		catch: (error) => error instanceof Error ? error : new Error(String(error))
+		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)));
 }
-//#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;
+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/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
-	};
+//#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
 //#region src/cli.ts
 const packageDirectory = fileURLToPath(new URL("..", import.meta.url));
-const exitCode = await Effect.runPromise(runRivusCli({
+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),
-	homeApi: createNodeRivusHome({ deploymentInspector: createRivusHomeDeploymentInspector({ packageManifestPath: join(packageDirectory, "package.json") }) }),
-	loadBootstrap: (specifier) => import(toImportSpecifier(specifier)),
-	homeDirectory: homedir(),
-	nodeExecutable: process.execPath,
-	nodeVersion: process.versions.node,
-	packageManifestPath: join(packageDirectory, "package.json"),
+	packageDirectory,
 	signalSource: process,
 	stderr: process.stderr,
-	stdout: process.stdout,
-	templateDirectory: join(packageDirectory, "examples")
+	stdout: process.stdout
 }));
 process.exitCode = exitCode;
-function toImportSpecifier(specifier) {
-	if (specifier.startsWith(".") || specifier.startsWith("/")) return pathToFileURL(resolve(specifier)).href;
-	return specifier;
-}
 //#endregion
 export {};