clawmini 0.0.8 → 0.0.9

package/dist/cli/index.mjs

@@ -1,25 +1,35 @@
 #!/usr/bin/env node
-import { D as pathIsInsideDir, E as writeSettings, T as writeChatSettings, a as enableEnvironment, c as getClawminiDir, d as getSocketPath, g as readChatSettings, i as deleteAgent, m as listAgents, n as copyAgentSkill, p as isValidAgentId, r as copyAgentSkills, s as getAgent, t as applyTemplateToAgent, w as writeAgentSettings, x as resolveSkillsTemplatePath, y as readSettings } from "../workspace-BJmJBfKi.mjs";
-import { a as writeLiteScript, c as createChat, d as getChatsDir, f as getDefaultChatId, g as setDefaultChatId, h as listChats, i as resolveCompiledScript, l as deleteChat, m as isValidChatId, o as DEFAULT_CHAT_ID, p as getMessages, r as getLiteScriptContent, t as exportLiteToAllEnvironments } from "../lite-CBxOT1y5.mjs";
+import { C as readSettings, D as resolveSkillsTemplatePath, F as pathIsInsideDir, M as writeAgentSettings, N as writeChatSettings, P as writeSettings, R as BUILTIN_POLICIES, T as refreshAgentTemplate, _ as isValidAgentId, a as enableEnvironment, b as readChatSettings, c as getAgent, h as getSocketPath, i as deleteAgent, l as getAgentOverlay, n as copyAgentSkill, o as formatPlanActions, p as getPoliciesPath, r as copyAgentSkills, t as applyTemplateToAgent, u as getClawminiDir, v as listAgents, w as refreshAgentSkills } from "../workspace-oWmVh5mi.mjs";
+import { A as getMessages, C as writeLiteScript, E as deleteChat, M as listChats, N as setDefaultChatId, O as getChatsDir, S as resolveCompiledScript, T as createChat, _ as removeSupervisorPid, f as getControlSocketPath, g as readSupervisorPid, h as getSupervisorPidPath, j as isValidChatId, k as getDefaultChatId, n as startSupervisorControl, v as writeSupervisorPid, w as DEFAULT_CHAT_ID, x as getLiteScriptContent, y as exportLiteToAllEnvironments } from "../supervisor-actions-CiW56eLi.mjs";
 import { t as createUnixSocketFetch } from "../fetch-Cn1XNyiO.mjs";
+import { t as getDiscordConfigPath } from "../config-CPFQIGdG.mjs";
+import { t as getGoogleChatConfigPath } from "../config-Dvl-Pov4.mjs";
 import { Command } from "commander";
 import fs from "node:fs";
 import path from "node:path";
-import { spawn } from "node:child_process";
-import * as fs$2 from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs$1 from "node:fs/promises";
+import fsPromises from "node:fs/promises";
 import { z } from "zod";
 import { createTRPCClient, httpLink } from "@trpc/client";
 import http from "node:http";
+import net from "node:net";
+import readline from "node:readline";
 import { promises } from "fs";
 
 //#region src/shared/agent-utils.ts
-async function createAgentWithChat(agentId, agentData, template, startDir = process.cwd()) {
+async function createAgentWithChat(agentId, agentData, template, startDir = process.cwd(), opts = {}) {
 	await writeAgentSettings(agentId, agentData, startDir);
-	if (template) await applyTemplateToAgent(agentId, template, agentData, startDir);
+	if (template) await applyTemplateToAgent(agentId, template, agentData, startDir, opts);
 	try {
-		await copyAgentSkills(agentId, startDir);
-		console.log(`Copied skills to agent ${agentId}.`);
+		const resolved = await getAgent(agentId, startDir);
+		if (resolved?.skillsDir === null) console.log(`Skipping skills for agent ${agentId} (skillsDir is null).`);
+		else if (resolved) {
+			await refreshAgentSkills(agentId, resolved, startDir, { firstInstall: true });
+			console.log(`Installed skills for agent ${agentId}.`);
+		}
 	} catch (err) {
 		console.warn(`Warning: Failed to copy skills to agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`);
 	}
@@ -40,8 +50,43 @@ function handleError$1(action, err) {
 	process.exit(1);
 }
 
+//#endregion
+//#region src/cli/builtin-policies.ts
+const HASHBANG = "#!/usr/bin/env node\n";
+function sha256(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+async function installBuiltinPolicies(dirPath = getClawminiDir()) {
+	const policyScriptsDir = path.join(dirPath, "policy-scripts");
+	await fsPromises.mkdir(policyScriptsDir, { recursive: true });
+	for (const name of Object.keys(BUILTIN_POLICIES)) try {
+		const sourcePath = await resolveCompiledScript(name, import.meta.url);
+		let scriptContent = await fsPromises.readFile(sourcePath, "utf8");
+		if (!scriptContent.startsWith("#!")) scriptContent = HASHBANG + scriptContent;
+		const destPath = path.join(policyScriptsDir, `${name}.js`);
+		let existing = null;
+		try {
+			existing = await fsPromises.readFile(destPath, "utf8");
+		} catch {}
+		if (existing !== null && sha256(existing) === sha256(scriptContent)) continue;
+		await fsPromises.writeFile(destPath, scriptContent, { mode: 493 });
+	} catch (err) {
+		console.warn(`Warning: Could not install built-in policy ${name}:`, err instanceof Error ? err.message : String(err));
+	}
+}
+
 //#endregion
 //#region src/cli/commands/init.ts
+function readBackupGitignoreTemplate() {
+	let currentDir = path.dirname(fileURLToPath(import.meta.url));
+	while (currentDir !== path.parse(currentDir).root && !fs.existsSync(path.join(currentDir, "package.json"))) currentDir = path.dirname(currentDir);
+	const templatePath = path.join(currentDir, "docs", "backups", "clawmini.gitignore");
+	try {
+		return fs.readFileSync(templatePath, "utf8");
+	} catch {
+		return null;
+	}
+}
 const initCmd = new Command("init").description("Initialize a new .clawmini settings folder").option("--agent <name>", "Initialize with a specific agent").option("--agent-template <name>", "Template to use for the agent").option("--environment <name>", "Enable a specific environment").action(async (options) => {
 	if (options.agentTemplate && !options.agent) handleError$1("initialize", /* @__PURE__ */ new Error("--agent-template cannot be used without --agent"));
 	if (options.agent && !isValidAgentId(options.agent)) handleError$1("initialize", /* @__PURE__ */ new Error(`Invalid agent ID: ${options.agent}`));
@@ -62,6 +107,15 @@ const initCmd = new Command("init").description("Initialize a new .clawmini sett
 	if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
 	fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2));
 	console.log("Initialized .clawmini/settings.json");
+	const gitignoreTemplate = readBackupGitignoreTemplate();
+	if (gitignoreTemplate) {
+		const gitignorePath = path.join(dirPath, ".gitignore");
+		if (!fs.existsSync(gitignorePath)) {
+			fs.writeFileSync(gitignorePath, gitignoreTemplate);
+			console.log("Initialized .clawmini/.gitignore");
+		}
+	} else console.warn("Warning: backup .gitignore template not found; skipping .clawmini/.gitignore");
+	await installBuiltinPolicies(dirPath);
 	if (options.agent) try {
 		const agentId = options.agent;
 		await createAgentWithChat(agentId, {}, options.agentTemplate);
@@ -129,10 +183,10 @@ messagesCmd.command("send <message>").description("Send a new message").option("
 		if (options.file && options.file.length > 0) {
 			finalFiles = [];
 			const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp");
-			await fs$2.mkdir(tmpDir, { recursive: true });
+			await fs$1.mkdir(tmpDir, { recursive: true });
 			for (const f of options.file) {
 				const dest = path.join(tmpDir, `cli-${Date.now()}-${Math.random().toString(36).substring(2, 7)}-${path.basename(f)}`);
-				await fs$2.copyFile(path.resolve(process.cwd(), f), dest);
+				await fs$1.copyFile(path.resolve(process.cwd(), f), dest);
 				finalFiles.push(dest);
 			}
 		}
@@ -256,10 +310,10 @@ agentsCmd.command("list").description("Display existing agents").action(async ()
 		handleError$1("list agents", err);
 	}
 });
-agentsCmd.command("add <id>").description("Create a new agent").option("-d, --directory <dir>", "Working directory for the agent").option("-t, --template <name>", "Template to use for the agent").option("-e, --env <env...>", "Environment variables in KEY=VALUE format (can be specified multiple times)").action(async (id, options) => {
+agentsCmd.command("add <id>").description("Create a new agent").option("-d, --directory <dir>", "Working directory for the agent").option("-t, --template <name>", "Template to use for the agent").option("-e, --env <env...>", "Environment variables in KEY=VALUE format (can be specified multiple times)").option("--fork", "Copy the template settings into the agent fully (legacy, no auto-update)").option("--force", "Overwrite existing files in the target directory on first install").action(async (id, options) => {
 	try {
 		assertValidAgentId(id);
-		if (await getAgent(id)) throw new Error(`Agent ${id} already exists.`);
+		if (await getAgentOverlay(id)) throw new Error(`Agent ${id} already exists.`);
 		const agentData = {};
 		if (options.directory) agentData.directory = options.directory;
 		const env = parseEnv(options.env);
@@ -267,7 +321,11 @@ agentsCmd.command("add <id>").description("Create a new agent").option("-d, --di
 			...agentData.env || {},
 			...env
 		};
-		await createAgentWithChat(id, agentData, options.template);
+		const applyOpts = {
+			...options.fork ? { fork: true } : {},
+			...options.force ? { force: true } : {}
+		};
+		await createAgentWithChat(id, agentData, options.template, process.cwd(), applyOpts);
 		console.log(`Agent ${id} created successfully.`);
 	} catch (err) {
 		handleError$1("create agent", err);
@@ -276,7 +334,7 @@ agentsCmd.command("add <id>").description("Create a new agent").option("-d, --di
 agentsCmd.command("update <id>").description("Update an existing agent").option("-d, --directory <dir>", "Working directory for the agent").option("-e, --env <env...>", "Environment variables in KEY=VALUE format (can be specified multiple times)").action(async (id, options) => {
 	try {
 		assertValidAgentId(id);
-		const existing = await getAgent(id);
+		const existing = await getAgentOverlay(id);
 		if (!existing) throw new Error(`Agent ${id} does not exist.`);
 		const agentData = { ...existing };
 		if (options.directory !== void 0) agentData.directory = options.directory;
@@ -294,17 +352,76 @@ agentsCmd.command("update <id>").description("Update an existing agent").option(
 agentsCmd.command("delete <id>").description("Remove an agent").action(async (id) => {
 	try {
 		assertValidAgentId(id);
-		if (!await getAgent(id)) throw new Error(`Agent ${id} does not exist.`);
+		if (!await getAgentOverlay(id)) throw new Error(`Agent ${id} does not exist.`);
 		await deleteAgent(id);
 		console.log(`Agent ${id} deleted successfully.`);
 	} catch (err) {
 		handleError$1("delete agent", err);
 	}
 });
+agentsCmd.command("refresh <id>").description("Refresh the agent's tracked template files against the installed clawmini").option("--accept", "Overwrite files that have diverged from the recorded SHA").option("--dry-run", "Print the per-file plan without writing anything").action(async (id, options) => {
+	try {
+		assertValidAgentId(id);
+		const overlay = await getAgentOverlay(id);
+		if (!overlay) throw new Error(`Agent ${id} does not exist.`);
+		const refreshOpts = {
+			...options.accept === void 0 ? {} : { accept: options.accept },
+			...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }
+		};
+		if (overlay.extends) {
+			const plan = await refreshAgentTemplate(id, overlay, process.cwd(), refreshOpts);
+			if (plan) for (const line of formatPlanActions(plan)) console.log(line);
+		}
+		const resolved = await getAgent(id);
+		if (resolved) {
+			const skillsPlan = await refreshAgentSkills(id, resolved, process.cwd(), refreshOpts);
+			if (skillsPlan) for (const line of formatPlanActions(skillsPlan)) console.log(line);
+		}
+	} catch (err) {
+		handleError$1("refresh agent", err);
+	}
+});
 
 //#endregion
 //#region src/cli/commands/down.ts
-const downCmd = new Command("down").description("Stop the local clawmini daemon server").action(async () => {
+function isErrnoCode(err, code) {
+	return err instanceof Error && err.code === code;
+}
+async function stopSupervisor(pid) {
+	process.stdout.write(`Stopping clawmini supervisor (pid ${pid})`);
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch (err) {
+		if (isErrnoCode(err, "ESRCH")) {
+			process.stdout.write("\nSupervisor already exited.\n");
+			return;
+		}
+		throw new Error(`Failed to signal supervisor: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+	}
+	const TIMEOUT_MS = 9e4;
+	const deadline = Date.now() + TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, 200));
+		process.stdout.write(".");
+		try {
+			process.kill(pid, 0);
+		} catch {
+			process.stdout.write("\nSuccessfully shut down clawmini supervisor.\n");
+			return;
+		}
+	}
+	throw new Error(`Supervisor did not exit within ${TIMEOUT_MS / 1e3} seconds.`);
+}
+const downCmd = new Command("down").description("Stop the local clawmini supervisor or daemon").action(async () => {
+	const supPid = readSupervisorPid();
+	if (supPid) try {
+		await stopSupervisor(supPid);
+		return;
+	} catch (err) {
+		console.error("\n", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	removeSupervisorPid();
 	try {
 		const client = await getDaemonClient({ autoStart: false });
 		process.stdout.write("Shutting down clawmini daemon...");
@@ -326,10 +443,69 @@ const downCmd = new Command("down").description("Stop the local clawmini daemon
 
 //#endregion
 //#region src/cli/commands/up.ts
-const upCmd = new Command("up").description("Start the local clawmini daemon server").action(async () => {
+function ensureDefaultPoliciesFile() {
+	const policiesPath = getPoliciesPath();
+	if (fs.existsSync(policiesPath)) return;
+	fs.mkdirSync(path.dirname(policiesPath), { recursive: true });
+	fs.writeFileSync(policiesPath, JSON.stringify({ policies: {} }, null, 2));
+}
+function logPlanWarnings(agentId, directory, actions) {
+	const workdir = directory ?? agentId;
+	for (const rawAction of actions) {
+		if (rawAction.action !== "skip-diverged") continue;
+		const action = rawAction;
+		if (action.reason === "edited") console.warn(`./${path.join(workdir, action.relPath)} differs from template; skipping refresh. Run 'clawmini agents refresh ${agentId} --accept' to overwrite.`);
+		else if (action.reason === "no-recorded-sha") console.warn(`./${path.join(workdir, action.relPath)} has no recorded SHA; skipping. Run 'clawmini agents refresh ${agentId} --accept' to adopt the current file.`);
+	}
+}
+async function refreshAllAgents(opts = {}) {
+	const output = [];
+	const agentIds = await listAgents();
+	for (const agentId of agentIds) {
+		let overlay;
+		try {
+			overlay = await getAgentOverlay(agentId);
+		} catch (err) {
+			console.warn(`Skipping refresh for agent '${agentId}': ${err instanceof Error ? err.message : String(err)}`);
+			continue;
+		}
+		if (!overlay) continue;
+		try {
+			if (overlay.extends) {
+				const plan = await refreshAgentTemplate(agentId, overlay, process.cwd(), opts.dryRun ? { dryRun: true } : {});
+				if (plan) {
+					logPlanWarnings(agentId, overlay.directory, plan.actions);
+					output.push(...formatPlanActions(plan, { agentId }));
+				}
+			}
+			const resolved = await getAgent(agentId);
+			if (resolved) {
+				const skillsPlan = await refreshAgentSkills(agentId, resolved, process.cwd(), opts.dryRun ? { dryRun: true } : {});
+				if (skillsPlan) {
+					logPlanWarnings(agentId, overlay.directory, skillsPlan.actions);
+					output.push(...formatPlanActions(skillsPlan, { agentId }));
+				}
+			}
+		} catch (err) {
+			console.warn(`Failed to refresh agent '${agentId}': ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	return output;
+}
+const upCmd = new Command("up").description("Start the local clawmini daemon server").option("--dry-run", "Print the per-file refresh plan without writing anything").action(async (options) => {
 	try {
 		const socketPath = getSocketPath();
 		const wasRunning = fs.existsSync(socketPath);
+		if (options.dryRun) {
+			const lines = await refreshAllAgents({ dryRun: true });
+			if (lines.length === 0) console.log("Dry run: no agents to refresh.");
+			else for (const line of lines) console.log(line);
+			return;
+		}
+		await installBuiltinPolicies();
+		ensureDefaultPoliciesFile();
+		await exportLiteToAllEnvironments();
+		await refreshAllAgents();
 		await (await getDaemonClient({ autoStart: true })).ping.query();
 		if (wasRunning) console.log("Daemon is already running.");
 		else console.log("Successfully started clawmini daemon.");
@@ -339,6 +515,486 @@ const upCmd = new Command("up").description("Start the local clawmini daemon ser
 	}
 });
 
+//#endregion
+//#region src/cli/supervisor.ts
+const DISPLAY_NAMES = {
+	daemon: "daemon",
+	web: "web",
+	"adapter-discord": "discord",
+	"adapter-google-chat": "google-chat"
+};
+const ADAPTER_TERMINATE_TIMEOUT_MS = 1e4;
+const DAEMON_TERMINATE_TIMEOUT_MS = 6e4;
+function resolveServiceCommand(service) {
+	const cliPath = fileURLToPath(import.meta.url);
+	switch (service) {
+		case "daemon": return {
+			command: process.execPath,
+			args: [new URL("../daemon/index.mjs", import.meta.url).pathname]
+		};
+		case "web": return {
+			command: process.execPath,
+			args: [cliPath, "web"]
+		};
+		case "adapter-discord": return {
+			command: process.execPath,
+			args: [new URL("../adapter-discord/index.mjs", import.meta.url).pathname]
+		};
+		case "adapter-google-chat": return {
+			command: process.execPath,
+			args: [new URL("../adapter-google-chat/index.mjs", import.meta.url).pathname]
+		};
+	}
+}
+var Supervisor = class Supervisor {
+	children = /* @__PURE__ */ new Map();
+	logFds = /* @__PURE__ */ new Map();
+	shuttingDown = false;
+	restarting = /* @__PURE__ */ new Set();
+	enabledServices = /* @__PURE__ */ new Set();
+	logDir;
+	constructor(logDir) {
+		this.logDir = logDir;
+		if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+	}
+	async startService(service) {
+		this.enabledServices.add(service);
+		const { command, args } = resolveServiceCommand(service);
+		const logPath = path.join(this.logDir, `${service}.log`);
+		const logFd = fs.openSync(logPath, "a");
+		this.logFds.set(service, logFd);
+		fs.writeSync(logFd, `\n--- clawmini serve: ${service} starting at ${(/* @__PURE__ */ new Date()).toISOString()} ---\n`);
+		const child = spawn(command, args, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: process.env,
+			cwd: process.cwd()
+		});
+		this.children.set(service, child);
+		this.attachPipe(service, child.stdout, logFd, "stdout");
+		this.attachPipe(service, child.stderr, logFd, "stderr");
+		child.on("exit", (code, signal) => {
+			const msg = `exited code=${code} signal=${signal}`;
+			process.stderr.write(`[${DISPLAY_NAMES[service]}] ${msg}\n`);
+			try {
+				fs.writeSync(logFd, `--- ${msg} at ${(/* @__PURE__ */ new Date()).toISOString()} ---\n`);
+				fs.closeSync(logFd);
+			} catch {}
+			this.logFds.delete(service);
+			this.children.delete(service);
+			if (service === "daemon" && !this.shuttingDown && !this.restarting.has("daemon")) {
+				process.stderr.write("[supervisor] daemon exited unexpectedly — shutting down\n");
+				this.shutdown(1);
+			}
+		});
+	}
+	attachPipe(service, stream, logFd, kind) {
+		const prefix = `[${DISPLAY_NAMES[service]}] `;
+		const target = kind === "stderr" ? process.stderr : process.stdout;
+		readline.createInterface({ input: stream }).on("line", (line) => {
+			try {
+				fs.writeSync(logFd, line + "\n");
+			} catch {}
+			target.write(prefix + line + "\n");
+		});
+	}
+	async waitForDaemonSocket(timeoutMs = 1e4) {
+		const socketPath = getSocketPath();
+		const start = Date.now();
+		while (Date.now() - start < timeoutMs) {
+			if (fs.existsSync(socketPath)) return;
+			if (!this.children.has("daemon")) throw new Error("Daemon exited before socket became available.");
+			await new Promise((r) => setTimeout(r, 100));
+		}
+		throw new Error(`Daemon did not start within ${timeoutMs}ms`);
+	}
+	async shutdown(exitCode = 0) {
+		if (this.shuttingDown) return;
+		this.shuttingDown = true;
+		process.stderr.write("\n[supervisor] shutting down...\n");
+		await this.stopAllChildren();
+		process.exit(exitCode);
+	}
+	/**
+	* Stop all children and close log fds without exiting the process. Used by
+	* `/upgrade`, which needs to tear down everything, run an install, then
+	* launch a fresh supervisor.
+	*/
+	async stopAllChildren() {
+		const adapterStops = [];
+		for (const [name, child] of this.children) {
+			if (name === "daemon") continue;
+			adapterStops.push(Supervisor.terminateChild(name, child, ADAPTER_TERMINATE_TIMEOUT_MS));
+		}
+		await Promise.allSettled(adapterStops);
+		const daemonChild = this.children.get("daemon");
+		if (daemonChild) await Supervisor.terminateChild("daemon", daemonChild, DAEMON_TERMINATE_TIMEOUT_MS);
+		for (const fd of this.logFds.values()) try {
+			fs.closeSync(fd);
+		} catch {}
+		this.logFds.clear();
+	}
+	/**
+	* Bounce every service that has ever been started under this supervisor.
+	* Daemon goes down with the adapters, then comes back first so the
+	* adapters can re-establish their tRPC subscriptions to the new daemon.
+	*
+	* This is what `/restart` and the `/upgrade` failure recovery paths call:
+	* just bouncing the daemon would leave adapter-discord (and any other
+	* adapter) holding a dead subscription, so outbound messages would never
+	* reach the chat. The user-visible symptom was "I send /restart and then
+	* the daemon's reply never shows up in Discord."
+	*/
+	async restartAll() {
+		if (this.shuttingDown) return;
+		this.restarting.add("daemon");
+		try {
+			await this.stopAllChildren();
+			await new Promise((r) => setImmediate(r));
+			if (this.enabledServices.has("daemon")) {
+				await this.startService("daemon");
+				await this.waitForDaemonSocket();
+			}
+			for (const name of this.enabledServices) {
+				if (name === "daemon") continue;
+				await this.startService(name);
+			}
+		} finally {
+			this.restarting.delete("daemon");
+		}
+	}
+	/**
+	* Stop and re-spawn a single service. The exit handler is suppressed so a
+	* restarted daemon doesn't trigger a full shutdown.
+	*/
+	async restartService(service) {
+		if (this.shuttingDown) return;
+		this.restarting.add(service);
+		try {
+			const child = this.children.get(service);
+			if (child) {
+				const timeoutMs = service === "daemon" ? DAEMON_TERMINATE_TIMEOUT_MS : ADAPTER_TERMINATE_TIMEOUT_MS;
+				await Supervisor.terminateChild(service, child, timeoutMs);
+			}
+			await new Promise((r) => setImmediate(r));
+			await this.startService(service);
+			if (service === "daemon") await this.waitForDaemonSocket();
+		} finally {
+			this.restarting.delete(service);
+		}
+	}
+	static terminateChild(name, child, timeoutMs) {
+		return new Promise((resolve) => {
+			if (child.exitCode !== null || child.signalCode !== null) {
+				resolve();
+				return;
+			}
+			const timer = setTimeout(() => {
+				process.stderr.write(`[supervisor] ${name} did not exit in ${Math.round(timeoutMs / 1e3)}s, sending SIGKILL\n`);
+				try {
+					child.kill("SIGKILL");
+				} catch {}
+			}, timeoutMs);
+			child.once("exit", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+			try {
+				child.kill("SIGTERM");
+			} catch {
+				clearTimeout(timer);
+				resolve();
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/cli/commands/serve.ts
+const ALL_SERVICES = [
+	"daemon",
+	"web",
+	"adapter-discord",
+	"adapter-google-chat"
+];
+const SERVICE_ALIASES$1 = {
+	daemon: "daemon",
+	web: "web",
+	discord: "adapter-discord",
+	"adapter-discord": "adapter-discord",
+	"google-chat": "adapter-google-chat",
+	"adapter-google-chat": "adapter-google-chat"
+};
+function resolveEnabledServices(opts) {
+	const parseList = (csv) => {
+		if (!csv) return [];
+		return csv.split(",").map((s) => s.trim()).filter(Boolean).map((name) => {
+			const resolved = SERVICE_ALIASES$1[name];
+			if (!resolved) throw new Error(`Unknown service: '${name}'. Valid: ${Object.keys(SERVICE_ALIASES$1).join(", ")}`);
+			return resolved;
+		});
+	};
+	const configPresent = {
+		daemon: true,
+		web: true,
+		"adapter-discord": false,
+		"adapter-google-chat": false,
+		...opts.adapterConfigPresent ?? {}
+	};
+	const excluded = new Set(parseList(opts.exclude));
+	const only = parseList(opts.only);
+	if (only.length > 0) return only.filter((n) => !excluded.has(n));
+	return ALL_SERVICES.filter((n) => configPresent[n] && !excluded.has(n));
+}
+async function runPreStart() {
+	await installBuiltinPolicies();
+	ensureDefaultPoliciesFile();
+	await exportLiteToAllEnvironments();
+	await refreshAllAgents();
+}
+async function runForeground(enabled) {
+	const supervisor = new Supervisor(path.join(getClawminiDir(), "logs"));
+	writeSupervisorPid(process.pid);
+	process.on("exit", () => {
+		removeSupervisorPid();
+		try {
+			fs.unlinkSync(getControlSocketPath());
+		} catch {}
+	});
+	const onSignal = () => {
+		supervisor.shutdown(0);
+	};
+	process.on("SIGINT", onSignal);
+	process.on("SIGTERM", onSignal);
+	if (enabled.includes("daemon")) {
+		process.stderr.write("[supervisor] starting daemon...\n");
+		await supervisor.startService("daemon");
+		await supervisor.waitForDaemonSocket();
+		process.stderr.write("[supervisor] daemon ready\n");
+	}
+	for (const name of enabled) {
+		if (name === "daemon") continue;
+		await supervisor.startService(name);
+	}
+	startSupervisorControl(supervisor);
+	process.stderr.write(`[supervisor] running: ${enabled.join(", ")}\n`);
+	process.stderr.write("[supervisor] press Ctrl-C to stop (or run 'clawmini down' elsewhere)\n");
+}
+function isSocketLive(socketPath) {
+	return new Promise((resolve) => {
+		const client = net.createConnection({ path: socketPath });
+		client.on("connect", () => {
+			client.destroy();
+			resolve(true);
+		});
+		client.on("error", () => resolve(false));
+	});
+}
+function printSupervisorLogTail(supLog, fromOffset) {
+	if (!fs.existsSync(supLog)) return;
+	const size = fs.statSync(supLog).size;
+	if (size <= fromOffset) return;
+	const fd = fs.openSync(supLog, "r");
+	try {
+		const len = size - fromOffset;
+		const buf = Buffer.alloc(len);
+		fs.readSync(fd, buf, 0, len, fromOffset);
+		const text = buf.toString("utf-8");
+		process.stderr.write("--- supervisor.log ---\n");
+		process.stderr.write(text);
+		if (!text.endsWith("\n")) process.stderr.write("\n");
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+async function runDetached(args) {
+	const clawDir = getClawminiDir();
+	const logDir = path.join(clawDir, "logs");
+	if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+	const supLog = path.join(logDir, "supervisor.log");
+	const supLogOffset = fs.existsSync(supLog) ? fs.statSync(supLog).size : 0;
+	const outFd = fs.openSync(supLog, "a");
+	removeSupervisorPid();
+	const childArgs = args.filter((a) => a !== "--detach" && a !== "-d");
+	const child = spawn(process.execPath, childArgs, {
+		detached: true,
+		stdio: [
+			"ignore",
+			outFd,
+			outFd
+		],
+		cwd: process.cwd(),
+		env: process.env
+	});
+	child.unref();
+	fs.closeSync(outFd);
+	const pidPath = getSupervisorPidPath();
+	const socketPath = getSocketPath();
+	const STARTUP_TIMEOUT_MS = 3e4;
+	const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		if (child.exitCode !== null || child.signalCode !== null) {
+			console.error(`clawmini serve exited during startup (code=${child.exitCode}, signal=${child.signalCode}).`);
+			printSupervisorLogTail(supLog, supLogOffset);
+			process.exit(1);
+		}
+		if (fs.existsSync(pidPath) && fs.existsSync(socketPath)) {
+			console.log(`Started clawmini supervisor in background (pid ${child.pid}).`);
+			console.log(`  Logs:   clawmini logs -f`);
+			console.log(`  Stop:   clawmini down`);
+			process.exit(0);
+		}
+		await new Promise((r) => setTimeout(r, 100));
+	}
+	console.error(`clawmini serve did not become ready within ${STARTUP_TIMEOUT_MS / 1e3}s.`);
+	printSupervisorLogTail(supLog, supLogOffset);
+	process.exit(1);
+}
+const serveCmd = new Command("serve").description("Run daemon, web UI, and configured adapters under one supervisor").option("-d, --detach", "Run in the background; logs go to .clawmini/logs/").option("--only <services>", "Comma-separated subset to run (daemon,web,discord,google-chat)").option("--exclude <services>", "Comma-separated services to skip").action(async (options) => {
+	const clawDir = getClawminiDir();
+	if (!fs.existsSync(clawDir)) {
+		console.error(`Not a clawmini workspace (no ${clawDir}). Run 'clawmini init' first.`);
+		process.exit(1);
+	}
+	const existingSupervisorPid = readSupervisorPid();
+	if (existingSupervisorPid) {
+		console.error(`clawmini serve is already running (pid ${existingSupervisorPid}). Run 'clawmini down' to stop it.`);
+		process.exit(1);
+	}
+	const socketPath = getSocketPath();
+	if (fs.existsSync(socketPath)) {
+		if (await isSocketLive(socketPath)) {
+			console.error("A clawmini daemon is already running (socket present). Run 'clawmini down' before 'clawmini serve'.");
+			process.exit(1);
+		}
+		try {
+			fs.unlinkSync(socketPath);
+			process.stderr.write(`[supervisor] removed stale socket at ${socketPath}\n`);
+		} catch (err) {
+			console.error(`Failed to remove stale socket at ${socketPath}: ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+	}
+	let enabled;
+	try {
+		enabled = resolveEnabledServices({
+			only: options.only,
+			exclude: options.exclude,
+			adapterConfigPresent: {
+				"adapter-discord": fs.existsSync(getDiscordConfigPath()),
+				"adapter-google-chat": fs.existsSync(getGoogleChatConfigPath())
+			}
+		});
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	if (enabled.length === 0) {
+		console.error("No services selected. Check --only/--exclude.");
+		process.exit(1);
+	}
+	if (options.detach) {
+		await runDetached(process.argv.slice(1));
+		return;
+	}
+	try {
+		await runPreStart();
+	} catch (err) {
+		console.error("Pre-start setup failed:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	try {
+		await runForeground(enabled);
+	} catch (err) {
+		console.error("Failed to start services:", err instanceof Error ? err.message : String(err));
+		removeSupervisorPid();
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/logs.ts
+const SERVICE_ALIASES = {
+	daemon: "daemon",
+	web: "web",
+	discord: "adapter-discord",
+	"adapter-discord": "adapter-discord",
+	"google-chat": "adapter-google-chat",
+	"adapter-google-chat": "adapter-google-chat",
+	supervisor: "supervisor"
+};
+function displayNameFor(logBase) {
+	if (logBase.startsWith("adapter-")) return logBase.slice(8);
+	return logBase;
+}
+function tailString(content, n) {
+	const lines = content.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines.slice(-n);
+}
+const logsCmd = new Command("logs").description("View logs from clawmini services (daemon, web, adapters)").option("-f, --follow", "Follow the logs as new lines are written").option("-s, --service <name>", "Restrict to one service: daemon, web, discord, google-chat, supervisor").option("-n, --lines <count>", "Number of lines to show from the tail of each file", "50").action(async (options) => {
+	const logDir = path.join(getClawminiDir(), "logs");
+	if (!fs.existsSync(logDir)) {
+		console.error(`No log directory at ${logDir}. Start the supervisor with 'clawmini serve'.`);
+		process.exit(1);
+	}
+	let targets;
+	if (options.service) {
+		const resolved = SERVICE_ALIASES[options.service];
+		if (!resolved) {
+			console.error(`Unknown service '${options.service}'. Valid: ${Object.keys(SERVICE_ALIASES).join(", ")}`);
+			process.exit(1);
+		}
+		targets = [`${resolved}.log`];
+	} else targets = fs.readdirSync(logDir).filter((f) => f.endsWith(".log"));
+	const linesCount = Math.max(0, parseInt(options.lines ?? "50", 10) || 50);
+	for (const file of targets) {
+		const full = path.join(logDir, file);
+		if (!fs.existsSync(full)) continue;
+		const prefix = `[${displayNameFor(file.replace(/\.log$/, ""))}] `;
+		const content = fs.readFileSync(full, "utf-8");
+		for (const line of tailString(content, linesCount)) process.stdout.write(prefix + line + "\n");
+	}
+	if (!options.follow) return;
+	const watched = [];
+	for (const file of targets) {
+		const full = path.join(logDir, file);
+		const prefix = `[${displayNameFor(file.replace(/\.log$/, ""))}] `;
+		const position = fs.existsSync(full) ? fs.statSync(full).size : 0;
+		watched.push({
+			file,
+			full,
+			prefix,
+			position
+		});
+		fs.watchFile(full, { interval: 500 }, (curr) => {
+			const entry = watched.find((w) => w.full === full);
+			if (!entry) return;
+			if (curr.size < entry.position) entry.position = 0;
+			if (curr.size > entry.position) {
+				const fd = fs.openSync(full, "r");
+				const buf = Buffer.alloc(curr.size - entry.position);
+				fs.readSync(fd, buf, 0, buf.length, entry.position);
+				fs.closeSync(fd);
+				entry.position = curr.size;
+				const lines = buf.toString().split("\n");
+				if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+				for (const line of lines) process.stdout.write(entry.prefix + line + "\n");
+			}
+		});
+	}
+	const stop = () => {
+		for (const entry of watched) fs.unwatchFile(entry.full);
+		process.exit(0);
+	};
+	process.on("SIGINT", stop);
+	process.on("SIGTERM", stop);
+	await new Promise(() => {});
+});
+
 //#endregion
 //#region src/cli/commands/web-api/utils.ts
 async function parseJsonBody(req, schema) {
@@ -385,7 +1041,7 @@ async function handleApiAgents(req, res, urlPath) {
 				env: z.record(z.string(), z.string()).optional(),
 				commands: z.record(z.string(), z.string()).optional()
 			}));
-			if (await getAgent(body.id)) {
+			if (await getAgentOverlay(body.id)) {
 				sendJsonResponse(res, 409, { error: "Agent already exists" });
 				return true;
 			}
@@ -439,7 +1095,7 @@ async function handleApiAgents(req, res, urlPath) {
 					env: z.record(z.string(), z.string()).optional(),
 					commands: z.record(z.string(), z.string()).optional()
 				}));
-				const agent = await getAgent(agentId) || {};
+				const agent = await getAgentOverlay(agentId) || {};
 				if (body.directory !== void 0) agent.directory = body.directory;
 				if (body.env !== void 0) agent.env = body.env;
 				if (body.commands !== void 0) agent.commands = body.commands;
@@ -817,9 +1473,9 @@ const exportLiteCmd = new Command("export-lite").description("Export the standal
 //#endregion
 //#region src/cli/commands/environments.ts
 const environmentsCmd = new Command("environments").description("Manage environments");
-environmentsCmd.command("enable <name>").description("Enable an environment for a path in the workspace").option("-p, --path <subpath>", "Path to apply the environment to", "./").action(async (name, options) => {
+environmentsCmd.command("enable <name>").description("Enable an environment for a path in the workspace").option("-p, --path <subpath>", "Path to apply the environment to", "./").option("--fork", "Clone the built-in template directory instead of writing a thin overlay").action(async (name, options) => {
 	try {
-		await enableEnvironment(name, options.path);
+		await enableEnvironment(name, options.path, process.cwd(), options.fork ? { fork: true } : {});
 	} catch (err) {
 		handleError$1("enable environment", err);
 	}
@@ -842,7 +1498,7 @@ environmentsCmd.command("disable").description("Disable an environment mapping")
 
 //#endregion
 //#region src/cli/commands/policies.ts
-const SUPPORTED_POLICIES = ["propose-policy"];
+const SUPPORTED_POLICIES = ["manage-policies"];
 const policiesCmd = new Command("policies").description("Manage sandbox policies");
 policiesCmd.command("add <name>").description("Add a new policy").action(async (name) => {
 	if (!SUPPORTED_POLICIES.includes(name)) handleError$1("add policy", /* @__PURE__ */ new Error(`Unsupported policy: "${name}". Supported policies: ${SUPPORTED_POLICIES.join(", ")}`));
@@ -853,10 +1509,12 @@ policiesCmd.command("add <name>").description("Add a new policy").action(async (
 	if (!fs.existsSync(policyScriptsDir)) fs.mkdirSync(policyScriptsDir, { recursive: true });
 	let policies = { policies: {} };
 	if (fs.existsSync(policiesPath)) policies = JSON.parse(fs.readFileSync(policiesPath, "utf8"));
+	const builtin = BUILTIN_POLICIES[name];
 	policies.policies[name] = {
-		description: "Propose a new policy to create",
+		description: builtin?.description ?? `Built-in policy ${name}`,
 		command: `./.clawmini/policy-scripts/${name}.js`,
-		allowHelp: true
+		allowHelp: builtin?.allowHelp ?? true,
+		...builtin?.autoApprove !== void 0 ? { autoApprove: builtin.autoApprove } : {}
 	};
 	fs.writeFileSync(policiesPath, JSON.stringify(policies, null, 2));
 	console.log(`Registered ${name} in .clawmini/policies.json`);
@@ -934,6 +1592,8 @@ program.addCommand(environmentsCmd);
 program.addCommand(skillsCmd);
 program.addCommand(downCmd);
 program.addCommand(upCmd);
+program.addCommand(serveCmd);
+program.addCommand(logsCmd);
 program.addCommand(webCmd);
 program.addCommand(jobsCmd);
 program.addCommand(exportLiteCmd);