clawmini 0.0.3 → 0.0.5

package/dist/daemon/index.mjs

@@ -1,5 +1,5 @@
-import { C as CronJobSchema, S as pathIsInsideDir, _ as readSettings, a as getAgent, b as writeChatSettings, c as getSettingsPath, g as readPolicies, h as readEnvironment, i as getActiveEnvironmentInfo, l as getSocketPath, m as readChatSettings, o as getClawminiDir, p as readAgentSessionSettings, s as getEnvironmentPath, u as getWorkspaceRoot, v as writeAgentSessionSettings, w as SettingsSchema } from "../workspace-DjoNjhW0.mjs";
-import { d as getMessages$1, n as exportLiteToEnvironment, o as appendMessage$1, p as listChats, u as getDefaultChatId } from "../lite-oSYSvaOr.mjs";
+import { C as writeAgentSessionSettings, D as pathIsInsideDir, O as CronJobSchema, S as updateChatSettings, T as writeChatSettings, _ as readEnvironment, b as resolveAgentWorkDir, c as getClawminiDir, d as getSocketPath, f as getWorkspaceRoot, g as readChatSettings, h as readAgentSessionSettings, k as SettingsSchema, l as getEnvironmentPath, m as listAgents, o as getActiveEnvironmentInfo, s as getAgent, u as getSettingsPath, v as readPolicies, y as readSettings } from "../workspace-BJmJBfKi.mjs";
+import { c as createChat, f as getDefaultChatId, h as listChats, n as exportLiteToEnvironment, p as getMessages$1, s as appendMessage$1, u as findLastMessage } from "../lite-CBxOT1y5.mjs";
 import fs, { constants } from "node:fs";
 import path from "node:path";
 import { execSync, spawn } from "node:child_process";
@@ -10,11 +10,11 @@ import net from "node:net";
 import { createHTTPHandler } from "@trpc/server/adapters/standalone";
 import { TRPCError, initTRPC } from "@trpc/server";
 import schedule from "node-schedule";
-import { EventEmitter, on } from "node:events";
 import crypto$1, { randomBytes, randomUUID } from "node:crypto";
 import fs$2 from "fs/promises";
 import path$1 from "path";
 import { randomInt } from "crypto";
+import { EventEmitter, on } from "node:events";
 
 //#region src/daemon/api/trpc.ts
 const t = initTRPC.context().create();
@@ -34,107 +34,17 @@ const apiAuthMiddleware = t.middleware(({ ctx, next }) => {
 });
 const apiProcedure = t.procedure.use(apiAuthMiddleware);
 
-//#endregion
-//#region src/daemon/events.ts
-const daemonEvents = new EventEmitter();
-const DAEMON_EVENT_MESSAGE_APPENDED = "message-appended";
-const DAEMON_EVENT_TYPING = "typing";
-function emitMessageAppended(chatId, message) {
-	daemonEvents.emit(DAEMON_EVENT_MESSAGE_APPENDED, {
-		chatId,
-		message
-	});
-}
-function emitTyping(chatId) {
-	daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId });
-}
-
-//#endregion
-//#region src/daemon/chats.ts
-async function appendMessage(id, message, startDir = process.cwd()) {
-	await appendMessage$1(id, message, startDir);
-	emitMessageAppended(id, message);
-}
-
-//#endregion
-//#region src/daemon/queue.ts
-var Queue = class {
-	pending = [];
-	isRunning = false;
-	currentController = null;
-	currentPayload;
-	enqueue(task, payload) {
-		return new Promise((resolve, reject) => {
-			this.pending.push({
-				task,
-				payload,
-				resolve,
-				reject
-			});
-			this.processNext().catch(() => {});
-		});
-	}
-	async processNext() {
-		if (this.isRunning || this.pending.length === 0) return;
-		this.isRunning = true;
-		const entry = this.pending.shift();
-		this.currentController = new AbortController();
-		this.currentPayload = entry.payload;
-		try {
-			await entry.task(this.currentController.signal);
-			entry.resolve();
-		} catch (error) {
-			entry.reject(error);
-		} finally {
-			this.isRunning = false;
-			this.currentController = null;
-			this.currentPayload = void 0;
-			this.processNext().catch(() => {});
-		}
-	}
-	abortCurrent(predicate) {
-		if (this.currentController) {
-			if (!predicate || this.currentPayload !== void 0 && predicate(this.currentPayload)) {
-				const error = /* @__PURE__ */ new Error("Task aborted");
-				error.name = "AbortError";
-				this.currentController.abort(error);
-			}
-		}
-	}
-	getCurrentPayload() {
-		return this.currentPayload;
-	}
-	clear(reason = "Task cleared", predicate) {
-		const tasksToClear = predicate ? this.pending.filter((p) => p.payload !== void 0 && predicate(p.payload)) : [...this.pending];
-		if (predicate) this.pending = this.pending.filter((p) => !(p.payload !== void 0 && predicate(p.payload)));
-		else this.pending = [];
-		for (const { reject } of tasksToClear) {
-			const error = new Error(reason);
-			error.name = "AbortError";
-			reject(error);
-		}
-	}
-	extractPending(predicate) {
-		const extracted = this.pending.map((p) => p.payload).filter((p) => p !== void 0 && (!predicate || predicate(p)));
-		this.clear("Task extracted for batching", predicate);
-		return extracted;
-	}
-};
-const messageQueues = /* @__PURE__ */ new Map();
-function getMessageQueue(dir) {
-	if (!messageQueues.has(dir)) messageQueues.set(dir, new Queue());
-	return messageQueues.get(dir);
-}
-
 //#endregion
 //#region src/daemon/routers/slash-new.ts
 function slashNew(state) {
 	if (/^\/new(\s|$)/.test(state.message)) {
 		const newMessage = state.message.replace(/^\/new(\s+|$)/, "").trim();
+		const id = crypto.randomUUID();
 		return {
 			...state,
 			message: newMessage,
-			sessionId: crypto.randomUUID(),
+			sessionId: id,
+			nextSessionId: id,
 			reply: "[@clawmini/slash-new] Starting a new session..."
 		};
 	}
@@ -356,6 +266,16 @@ function executeSafe(command, args, options) {
 		});
 	});
 }
+async function executeRequest(request, policy, cwd) {
+	const interpolatedArgs = interpolateArgs([...policy.args || [], ...request.args], request.fileMappings);
+	const { stdout, stderr, exitCode } = await executeSafe(policy.command, interpolatedArgs, cwd ? { cwd } : void 0);
+	return {
+		stdout,
+		stderr,
+		exitCode,
+		commandStr: `${policy.command} ${interpolatedArgs.join(" ")}`
+	};
+}
 async function generateRequestPreview(request) {
 	let previewContent = `Sandbox Policy Request: ${request.commandName}\n`;
 	previewContent += `ID: ${request.id}\n`;
@@ -374,6 +294,28 @@ async function generateRequestPreview(request) {
 	return previewContent;
 }
 
+//#endregion
+//#region src/daemon/events.ts
+const daemonEvents = new EventEmitter();
+const DAEMON_EVENT_MESSAGE_APPENDED = "message-appended";
+const DAEMON_EVENT_TYPING = "typing";
+function emitMessageAppended(chatId, message) {
+	daemonEvents.emit(DAEMON_EVENT_MESSAGE_APPENDED, {
+		chatId,
+		message
+	});
+}
+function emitTyping(chatId) {
+	daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId });
+}
+
+//#endregion
+//#region src/daemon/chats.ts
+async function appendMessage(id, message, startDir = process.cwd()) {
+	await appendMessage$1(id, message, startDir);
+	emitMessageAppended(id, message);
+}
+
 //#endregion
 //#region src/daemon/routers/slash-policies.ts
 async function loadAndValidateRequest(id, state) {
@@ -425,29 +367,30 @@ async function slashPolicies(state) {
 			reply: `Policy not found: ${req.commandName}`
 		};
 		req.state = "Approved";
+		const { stdout, stderr, exitCode } = await executeRequest(req, policy, getWorkspaceRoot());
+		req.executionResult = {
+			stdout,
+			stderr,
+			exitCode
+		};
 		await store.save(req);
-		const interpolatedArgs = interpolateArgs([...policy.args || [], ...req.args], req.fileMappings);
-		const { stdout, stderr, exitCode } = await executeSafe(policy.command, interpolatedArgs, { cwd: getWorkspaceRoot() });
-		const commandStr = `${policy.command} ${interpolatedArgs.join(" ")}`;
+		const agentMessage = `Request ${id} approved.\n\n${wrapInHtml("stdout", stdout)}\n\n${wrapInHtml("stderr", stderr)}\n\nExit Code: ${exitCode}`;
 		const logMsg = {
 			id: randomUUID(),
 			messageId: state.messageId,
-			role: "log",
-			source: "router",
-			content: `Request ${id} approved and executed.`,
-			stderr,
-			stdout,
+			role: "system",
+			event: "policy_approved",
+			displayRole: "user",
+			content: agentMessage,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			command: commandStr,
-			cwd: getWorkspaceRoot(),
-			exitCode
+			...req.subagentId ? { subagentId: req.subagentId } : {}
 		};
 		await appendMessage(state.chatId, logMsg);
-		const agentMessage = `Request ${id} approved.\n\n${wrapInHtml("stdout", stdout)}\n\n${wrapInHtml("stderr", stderr)}\n\nExit Code: ${exitCode}`;
 		return {
 			...state,
 			message: agentMessage,
-			reply: `Approved request, running ${req.commandName}`
+			reply: `Approved request, running ${req.commandName}`,
+			...req.subagentId ? { subagentId: req.subagentId } : {}
 		};
 	}
 	const rejectMatch = message.match(/^\/reject\s+([^\s]+)(?:\s+(.*))?/);
@@ -461,23 +404,33 @@ async function slashPolicies(state) {
 		req.state = "Rejected";
 		req.rejectionReason = reason;
 		await store.save(req);
+		const agentMessage = `Request ${id} rejected. Reason: ${reason}`;
 		const logMsg = {
 			id: randomUUID(),
 			messageId: state.messageId,
-			role: "log",
-			source: "router",
-			content: `Request ${id} rejected. Reason: ${reason}`,
-			stderr: "",
+			role: "system",
+			event: "policy_rejected",
+			displayRole: "user",
+			content: agentMessage,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			command: `policy-request-reject ${id}`,
-			cwd: getWorkspaceRoot(),
-			exitCode: 1
+			...req.subagentId ? { subagentId: req.subagentId } : {}
+		};
+		const userNotificationMsg = {
+			id: randomUUID(),
+			messageId: state.messageId,
+			role: "system",
+			event: "policy_rejected",
+			displayRole: "agent",
+			content: agentMessage,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...req.subagentId ? { subagentId: req.subagentId } : {}
 		};
 		await appendMessage(state.chatId, logMsg);
-		const agentMessage = `Request ${id} rejected. Reason: ${reason}`;
+		await appendMessage(state.chatId, userNotificationMsg);
 		return {
 			...state,
-			message: agentMessage
+			message: agentMessage,
+			...req.subagentId ? { subagentId: req.subagentId } : {}
 		};
 	}
 	return state;
@@ -487,17 +440,130 @@ function wrapInHtml(tag, text) {
 	return `<${tag}>\n${text.trim()}\n</${tag}>`;
 }
 
+//#endregion
+//#region src/daemon/routers/session-timeout.ts
+/**
+* Router that automatically starts a new session after a period of inactivity.
+*
+* To register this router, add it to your `~/.gemini/settings.json`:
+* ```json
+* {
+*   "routers": [
+*     {
+*       "use": "session-timeout",
+*       "with": {
+*         "timeout": "60m",
+*         "prompt": "This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY."
+*       }
+*     }
+*   ]
+* }
+* ```
+*/
+function createSessionTimeoutRouter(config = {}) {
+	const timeStr = config.timeout ?? "60m";
+	const prompt = config.prompt ?? "This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY.";
+	return function(state) {
+		if (state.env?.__SESSION_TIMEOUT__ === "true") return state;
+		const sessionId = state.sessionId || crypto.randomUUID();
+		const jobId = `__session_timeout__${sessionId}`;
+		const jobs = {
+			...state.jobs,
+			remove: [
+				...state.jobs?.remove || [],
+				jobId,
+				"__session_timeout__"
+			]
+		};
+		return {
+			...state,
+			sessionId,
+			jobs: {
+				...jobs,
+				add: [...jobs.add || [], {
+					id: jobId,
+					schedule: { at: timeStr },
+					message: prompt,
+					reply: "[@clawmini/session-timeout] Starting a fresh session...",
+					nextSessionId: randomUUID(),
+					session: {
+						type: "existing",
+						id: sessionId
+					},
+					env: { __SESSION_TIMEOUT__: "true" },
+					jobs: { remove: [jobId] }
+				}]
+			}
+		};
+	};
+}
+
 //#endregion
 //#region src/daemon/routers.ts
+const GLOBAL_ROUTERS = ["@clawmini/session-timeout"];
+const USER_ROUTERS = [
+	"@clawmini/slash-new",
+	"@clawmini/slash-command",
+	"@clawmini/slash-stop",
+	"@clawmini/slash-interrupt",
+	"@clawmini/slash-policies"
+];
+function resolveRouters(userRouters, isUserMessage) {
+	const resolvedGlobals = [];
+	const resolvedUsers = [];
+	const userConfigMap = /* @__PURE__ */ new Map();
+	for (const r of userRouters) {
+		const name = typeof r === "string" ? r : r.use;
+		const config = typeof r === "string" ? {} : r.with || {};
+		if (name.startsWith("@clawmini/")) userConfigMap.set(name, config);
+		else resolvedUsers.push(r);
+	}
+	for (const globalRouter of GLOBAL_ROUTERS) {
+		const name = typeof globalRouter === "string" ? globalRouter : globalRouter.use;
+		const baseConfig = typeof globalRouter === "string" ? {} : globalRouter.with || {};
+		const userConfig = userConfigMap.get(name) || {};
+		const mergedConfig = {
+			...baseConfig,
+			...userConfig
+		};
+		resolvedGlobals.push({
+			use: name,
+			with: mergedConfig
+		});
+	}
+	const defaultUserRouters = [];
+	for (const defaultUserRouter of USER_ROUTERS) {
+		const name = typeof defaultUserRouter === "string" ? defaultUserRouter : defaultUserRouter.use;
+		const baseConfig = typeof defaultUserRouter === "string" ? {} : defaultUserRouter.with || {};
+		const userConfig = userConfigMap.get(name) || {};
+		const mergedConfig = {
+			...baseConfig,
+			...userConfig
+		};
+		defaultUserRouters.push({
+			use: name,
+			with: mergedConfig
+		});
+	}
+	if (isUserMessage) return [
+		...resolvedGlobals,
+		...defaultUserRouters,
+		...resolvedUsers
+	];
+	else return resolvedGlobals;
+}
 async function executeRouterPipeline(initialState, routers) {
 	let state = { ...initialState };
-	for (const router of routers) {
+	for (const routerDef of routers) {
 		if (state.action === "stop") break;
+		const router = typeof routerDef === "string" ? routerDef : routerDef.use;
+		const config = typeof routerDef === "string" ? {} : routerDef.with || {};
 		if (router === "@clawmini/slash-new") state = slashNew(state);
 		else if (router === "@clawmini/slash-command") state = await slashCommand(state);
 		else if (router === "@clawmini/slash-stop") state = slashStop(state);
 		else if (router === "@clawmini/slash-interrupt") state = slashInterrupt(state);
 		else if (router === "@clawmini/slash-policies") state = await slashPolicies(state);
+		else if (router === "@clawmini/session-timeout") state = createSessionTimeoutRouter(config)(state);
 		else try {
 			state = await executeCustomRouter(router, state);
 		} catch (err) {
@@ -563,6 +629,387 @@ async function executeCustomRouter(command, state) {
 	});
 }
 
+//#endregion
+//#region src/daemon/agent/agent-context.ts
+function formatEnvironmentPrefix(prefix, replacements) {
+	const map = {
+		"{WORKSPACE_DIR}": replacements.targetPath,
+		"{AGENT_DIR}": replacements.executionCwd,
+		"{ENV_DIR}": replacements.envDir,
+		"{HOME_DIR}": process.env.HOME || "",
+		"{ENV_ARGS}": replacements.envArgs
+	};
+	return prefix.replace(/{(WORKSPACE_DIR|AGENT_DIR|ENV_DIR|HOME_DIR|ENV_ARGS)}/g, (match) => map[match] || match);
+}
+async function sandboxExecutionContext(initialCommand, env, agentSpecificEnvKeys, executionCwd, cwd) {
+	let command = initialCommand;
+	const activeEnvInfo = await getActiveEnvironmentInfo(executionCwd, cwd);
+	if (!activeEnvInfo) return command;
+	const activeEnvName = activeEnvInfo.name;
+	const activeEnv = await readEnvironment(activeEnvName, cwd);
+	if (activeEnv?.env) for (const [key, value] of Object.entries(activeEnv.env)) if (value === false) {
+		delete env[key];
+		agentSpecificEnvKeys.delete(key);
+	} else {
+		let interpolatedValue = String(value);
+		interpolatedValue = interpolatedValue.replace(/\{PATH\}/g, process.env.PATH || "");
+		interpolatedValue = interpolatedValue.replace(/\{ENV_DIR\}/g, getEnvironmentPath(activeEnvName, cwd));
+		interpolatedValue = interpolatedValue.replace(/\{WORKSPACE_DIR\}/g, activeEnvInfo.targetPath);
+		env[key] = interpolatedValue;
+		agentSpecificEnvKeys.add(key);
+	}
+	if (activeEnv?.prefix) {
+		const envArgs = Array.from(agentSpecificEnvKeys).map((key) => {
+			if (activeEnv.envFormat) return activeEnv.envFormat.replace("{key}", key);
+			return key;
+		}).join(" ");
+		const prefixReplaced = formatEnvironmentPrefix(activeEnv.prefix, {
+			targetPath: activeEnvInfo.targetPath,
+			executionCwd,
+			envDir: getEnvironmentPath(activeEnvName, cwd),
+			envArgs
+		});
+		if (prefixReplaced.includes("{COMMAND}")) command = prefixReplaced.replace("{COMMAND}", command);
+		else command = `${prefixReplaced} ${command}`;
+	}
+	return command;
+}
+
+//#endregion
+//#region src/daemon/agent/agent-extractors.ts
+async function runExtractionCommand(name, command, runCommand, cwd, env, mainResult, signal) {
+	try {
+		console.log(`Executing extraction command (${name}): ${command}`);
+		const res = await runCommand({
+			command,
+			cwd,
+			env,
+			stdin: mainResult.stdout,
+			signal
+		});
+		if (res.exitCode === 0) return { result: res.stdout.trim() };
+		else return { error: `${name} failed: ${res.stderr}` };
+	} catch (e) {
+		return { error: `${name} error: ${e.message}` };
+	}
+}
+async function extractMessageContent(context, mainResult, runCommand, executionCwd, signal) {
+	if (!context.currentAgent.commands?.getMessageContent) return {};
+	return runExtractionCommand("getMessageContent", context.currentAgent.commands.getMessageContent, runCommand, executionCwd, context.env, mainResult, signal);
+}
+async function extractSessionId(context, mainResult, runCommand, executionCwd, signal) {
+	if (!context.currentAgent.commands?.getSessionId) return {};
+	return runExtractionCommand("getSessionId", context.currentAgent.commands.getSessionId, runCommand, executionCwd, context.env, mainResult, signal);
+}
+
+//#endregion
+//#region src/daemon/agent/utils.ts
+function formatPendingMessages(payloads) {
+	return payloads.map((text) => `<message>\n${text}\n</message>`).join("\n\n");
+}
+function isNewSession(env) {
+	return env["SESSION_ID"] === void 0;
+}
+
+//#endregion
+//#region src/daemon/agent/agent-runner.ts
+function calculateDelay(attempt, baseDelayMs, isFallback = false) {
+	const effectiveAttempt = isFallback ? attempt + 1 : attempt;
+	if (effectiveAttempt <= 0) return 0;
+	const delay = baseDelayMs * Math.pow(2, effectiveAttempt - 1);
+	return Math.min(delay, 15e3);
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var AgentRunner = class {
+	constructor(session, runCommand) {
+		this.session = session;
+		this.runCommand = runCommand;
+	}
+	async withTypingIndicator(fn) {
+		const interval = setInterval(() => emitTyping(this.session.chatId), 5e3);
+		try {
+			return await fn();
+		} finally {
+			clearInterval(interval);
+		}
+	}
+	*getExecutionAttempts() {
+		const executionConfigs = [{
+			fallback: void 0,
+			retries: 0,
+			delayMs: 1e3
+		}, ...(this.session.settings.fallbacks || []).map((f) => ({
+			fallback: f,
+			retries: f.retries,
+			delayMs: f.delayMs
+		}))];
+		for (let configIdx = 0; configIdx < executionConfigs.length; configIdx++) {
+			const config = executionConfigs[configIdx];
+			const isFallbackConfig = configIdx > 0;
+			for (let attempt = 0; attempt <= config.retries; attempt++) yield {
+				fallback: config.fallback,
+				delay: calculateDelay(attempt, config.delayMs, isFallbackConfig)
+			};
+		}
+	}
+	async executeSingleAttempt(message, fallback, signal) {
+		const context = await this.session.buildExecutionContext(message.content, message.env, fallback);
+		if (!context) return { success: false };
+		const mainResult = await this.withTypingIndicator(() => this.runCommand({
+			command: context.command,
+			cwd: this.session.workDirectory,
+			env: context.env,
+			signal
+		}));
+		let success = mainResult.exitCode === 0;
+		let finalContent = mainResult.stdout.trim();
+		const additonalErrors = [];
+		if (success && context.currentAgent.commands?.getMessageContent) {
+			const extraction = await extractMessageContent(context, mainResult, this.runCommand, this.session.workDirectory, signal);
+			if (extraction.error) additonalErrors.push(extraction.error);
+			if (extraction.result !== void 0) finalContent = extraction.result.trim();
+			if (!finalContent) success = false;
+		}
+		let extractedSessionId;
+		if (success && isNewSession(message.env) && context.currentAgent.commands?.getSessionId) {
+			const extraction = await extractSessionId(context, mainResult, this.runCommand, this.session.workDirectory, signal);
+			if (extraction.error) additonalErrors.push(extraction.error);
+			if (extraction.result) extractedSessionId = extraction.result;
+		}
+		return {
+			success,
+			response: {
+				messageId: message.id,
+				content: finalContent,
+				command: context.command,
+				cwd: this.session.workDirectory,
+				extractedSessionId,
+				result: {
+					...mainResult,
+					stderr: [mainResult.stderr, ...additonalErrors].join("\n\n")
+				}
+			}
+		};
+	}
+	async executeWithFallbacks(message, signal) {
+		let lastResponse;
+		for (const attempt of this.getExecutionAttempts()) {
+			if (attempt.delay > 0) {
+				await this.session.logger.logCommandRetry({
+					messageId: message.id,
+					content: `Error running agent, retrying in ${Math.round(attempt.delay / 1e3)} seconds...`,
+					cwd: this.session.workDirectory
+				});
+				await sleep(attempt.delay);
+			}
+			const attemptResult = await this.executeSingleAttempt(message, attempt.fallback, signal);
+			lastResponse = attemptResult.response || lastResponse;
+			if (attemptResult.success) return lastResponse;
+		}
+		return lastResponse;
+	}
+};
+
+//#endregion
+//#region src/daemon/utils/spawn.ts
+const runCommand = async ({ command, cwd, env, stdin, signal }) => {
+	return new Promise((resolve, reject) => {
+		const p = spawn(command, {
+			shell: true,
+			cwd,
+			env,
+			signal
+		});
+		if (stdin && p.stdin) {
+			p.stdin.on("error", (err) => {
+				if (err.code !== "EPIPE") console.error("stdin error:", err);
+			});
+			p.stdin.write(stdin);
+			p.stdin.end();
+		}
+		let stdout = "";
+		let stderr = "";
+		if (p.stdout) p.stdout.on("data", (data) => {
+			stdout += data.toString();
+			if (!stdin) process.stdout.write(data);
+		});
+		if (p.stderr) p.stderr.on("data", (data) => {
+			stderr += data.toString();
+			if (!stdin) process.stderr.write(data);
+		});
+		p.on("close", (code) => {
+			resolve({
+				stdout,
+				stderr,
+				exitCode: code ?? 1
+			});
+		});
+		p.on("error", (err) => {
+			if (err.name === "AbortError") {
+				reject(err);
+				return;
+			}
+			resolve({
+				stdout: "",
+				stderr: err.toString(),
+				exitCode: 1
+			});
+		});
+	});
+};
+
+//#endregion
+//#region src/daemon/agent/chat-logger.ts
+function createChatLogger(chatId, subagentId) {
+	async function append(msg) {
+		const finalMsg = subagentId ? {
+			...msg,
+			subagentId
+		} : msg;
+		await appendMessage(chatId, finalMsg);
+		return finalMsg;
+	}
+	return {
+		append,
+		getMessages: async (limit) => {
+			let filtered = (await getMessages$1(chatId)).filter((m) => m.subagentId === subagentId);
+			if (limit !== void 0 && limit > 0) filtered = filtered.slice(-limit);
+			return filtered;
+		},
+		findLastMessage: async (predicate) => {
+			return findLastMessage(chatId, (msg) => {
+				if (msg.subagentId !== subagentId) return false;
+				return predicate(msg);
+			});
+		},
+		logUserMessage: async (msg) => append({
+			id: crypto.randomUUID(),
+			role: "user",
+			content: msg,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		}),
+		logCommandResult: async ({ messageId, content, command, cwd, result }) => append({
+			id: crypto.randomUUID(),
+			role: "command",
+			content,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			messageId,
+			command,
+			cwd,
+			stdout: result.stdout,
+			stderr: result.stderr,
+			exitCode: result.exitCode
+		}),
+		logSystemEvent: async ({ content }) => append({
+			id: crypto.randomUUID(),
+			role: "command",
+			content,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			messageId: crypto.randomUUID(),
+			stderr: "",
+			command: "",
+			cwd: "",
+			stdout: "",
+			exitCode: 0
+		}),
+		logAutomaticReply: async ({ messageId, content }) => append({
+			id: crypto.randomUUID(),
+			role: "system",
+			content,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			messageId,
+			event: "router",
+			displayRole: "agent"
+		}),
+		logCommandRetry: async ({ messageId, content, cwd }) => append({
+			id: crypto.randomUUID(),
+			role: "command",
+			content,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			messageId,
+			command: "retry-delay",
+			stderr: "",
+			stdout: "",
+			cwd,
+			exitCode: 0
+		}),
+		logSystemMessage: async ({ content, event, messageId, displayRole }) => {
+			const msg = {
+				id: crypto.randomUUID(),
+				role: "system",
+				content,
+				event,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			if (messageId !== void 0) msg.messageId = messageId;
+			if (displayRole !== void 0) msg.displayRole = displayRole;
+			return append(msg);
+		},
+		logSubagentStatus: async ({ subagentId: targetSubagentId, status }) => {
+			return append({
+				id: crypto.randomUUID(),
+				role: "subagent_status",
+				content: `Subagent ${status}`,
+				subagentId: targetSubagentId,
+				status,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		},
+		logAgentReply: async ({ content, files }) => {
+			const msg = {
+				id: crypto.randomUUID(),
+				role: "agent",
+				content,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			if (files !== void 0) msg.files = files;
+			return append(msg);
+		},
+		logToolMessage: async ({ content, messageId, name, payload }) => {
+			return append({
+				id: crypto.randomUUID(),
+				role: "tool",
+				content,
+				messageId,
+				name,
+				payload,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		},
+		logPolicyRequestMessage: async ({ content, messageId, requestId, commandName, args, status }) => {
+			return append({
+				id: crypto.randomUUID(),
+				role: "policy",
+				content,
+				messageId,
+				requestId,
+				commandName,
+				args,
+				status,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/utils/env.ts
+function applyEnvOverrides(targetEnv, overrides) {
+	if (!overrides) return;
+	for (const [key, val] of Object.entries(overrides)) if (val === true && process.env[key] !== void 0) targetEnv[key] = process.env[key];
+	else if (typeof val === "string") targetEnv[key] = val;
+}
+function getActiveEnvKeys(...envs) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const env of envs) {
+		if (!env) continue;
+		Object.entries(env).forEach(([key, val]) => {
+			if (val === true || typeof val === "string") keys.add(key);
+		});
+	}
+	return keys;
+}
+
 //#endregion
 //#region src/daemon/auth.ts
 const DAEMON_SECRET = crypto$1.randomBytes(32);
@@ -608,315 +1055,387 @@ function getApiContext(settings) {
 }
 
 //#endregion
-//#region src/shared/utils/env.ts
-function applyEnvOverrides(targetEnv, overrides) {
-	if (!overrides) return;
-	for (const [key, val] of Object.entries(overrides)) if (val === true && process.env[key] !== void 0) targetEnv[key] = process.env[key];
-	else if (typeof val === "string") targetEnv[key] = val;
-}
-function getActiveEnvKeys(...envs) {
-	const keys = /* @__PURE__ */ new Set();
-	for (const env of envs) {
-		if (!env) continue;
-		Object.entries(env).forEach(([key, val]) => {
-			if (val === true || typeof val === "string") keys.add(key);
+//#region src/daemon/agent/task-scheduler.ts
+var ResourceLock = class {
+	resources = /* @__PURE__ */ new Map();
+	async acquire(resourceId, workspaceId, signal) {
+		if (signal?.aborted) {
+			const error = /* @__PURE__ */ new Error("Task aborted");
+			error.name = "AbortError";
+			throw error;
+		}
+		const res = this.resources.get(resourceId);
+		if (!res) {
+			this.resources.set(resourceId, {
+				activeWorkspace: workspaceId,
+				count: 1,
+				waiters: []
+			});
+			return;
+		}
+		if (res.activeWorkspace === workspaceId) {
+			res.count++;
+			return;
+		}
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				workspaceId,
+				resolve,
+				reject
+			};
+			res.waiters.push(waiter);
+			if (signal) {
+				const onAbort = () => {
+					const idx = res.waiters.indexOf(waiter);
+					if (idx !== -1) {
+						res.waiters.splice(idx, 1);
+						const error = /* @__PURE__ */ new Error("Task aborted");
+						error.name = "AbortError";
+						reject(error);
+					}
+				};
+				signal.addEventListener("abort", onAbort);
+				waiter.resolve = () => {
+					signal.removeEventListener("abort", onAbort);
+					resolve();
+				};
+				waiter.reject = (err) => {
+					signal.removeEventListener("abort", onAbort);
+					reject(err);
+				};
+			}
 		});
 	}
-	return keys;
-}
+	release(resourceId, _workspaceId) {
+		const res = this.resources.get(resourceId);
+		if (!res) return;
+		res.count--;
+		if (res.count === 0) if (res.waiters.length > 0) {
+			const nextWorkspace = res.waiters[0].workspaceId;
+			res.activeWorkspace = nextWorkspace;
+			const remainingWaiters = [];
+			for (const waiter of res.waiters) if (waiter.workspaceId === nextWorkspace) {
+				res.count++;
+				waiter.resolve();
+			} else remainingWaiters.push(waiter);
+			res.waiters = remainingWaiters;
+		} else this.resources.delete(resourceId);
+	}
+};
+var TaskQueue = class {
+	queue = [];
+	activeTask = null;
+	isProcessing = false;
+	constructor(sessionId, resourceLock, onEmpty) {
+		this.sessionId = sessionId;
+		this.resourceLock = resourceLock;
+		this.onEmpty = onEmpty;
+	}
+	enqueue(task) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				task,
+				resolve,
+				reject
+			});
+			this.process();
+		});
+	}
+	async process() {
+		if (this.isProcessing || this.activeTask || this.queue.length === 0) return;
+		this.isProcessing = true;
+		while (this.queue.length > 0) {
+			const next = this.queue.shift();
+			const controller = new AbortController();
+			this.activeTask = {
+				task: next.task,
+				controller
+			};
+			let acquired = false;
+			try {
+				await this.resourceLock.acquire(next.task.dirPath, next.task.rootChatId, controller.signal);
+				acquired = true;
+				if (!controller.signal.aborted) await next.task.execute(controller.signal);
+				next.resolve();
+			} catch (err) {
+				next.reject(err);
+			} finally {
+				if (acquired) this.resourceLock.release(next.task.dirPath, next.task.rootChatId);
+				this.activeTask = null;
+			}
+		}
+		this.isProcessing = false;
+		this.onEmpty(this.sessionId);
+	}
+	abortAll() {
+		const error = /* @__PURE__ */ new Error("Task aborted");
+		error.name = "AbortError";
+		if (this.activeTask) this.activeTask.controller.abort(error);
+		for (const qTask of this.queue) qTask.reject(error);
+		this.queue = [];
+	}
+	interruptAndExtract() {
+		const payloads = [];
+		const error = /* @__PURE__ */ new Error("Task aborted");
+		error.name = "AbortError";
+		if (this.activeTask) {
+			if (this.activeTask.task.text !== void 0) payloads.push(this.activeTask.task.text);
+			this.activeTask.controller.abort(error);
+		}
+		for (const qTask of this.queue) {
+			if (qTask.task.text !== void 0) payloads.push(qTask.task.text);
+			qTask.reject(error);
+		}
+		this.queue = [];
+		return payloads;
+	}
+	extractPending() {
+		const payloads = [];
+		const error = /* @__PURE__ */ new Error("Task extracted for batching");
+		error.name = "AbortError";
+		for (const qTask of this.queue) {
+			if (qTask.task.text !== void 0) payloads.push(qTask.task.text);
+			qTask.reject(error);
+		}
+		this.queue = [];
+		return payloads;
+	}
+	hasTasks() {
+		return this.activeTask !== null || this.queue.length > 0;
+	}
+};
+var TaskScheduler = class {
+	queues = /* @__PURE__ */ new Map();
+	resourceLock = new ResourceLock();
+	getQueueKey(sessionId, rootChatId) {
+		return `${rootChatId}:${sessionId}`;
+	}
+	schedule(task) {
+		const key = this.getQueueKey(task.sessionId, task.rootChatId);
+		let queue = this.queues.get(key);
+		if (!queue) {
+			queue = new TaskQueue(task.sessionId, this.resourceLock, () => {
+				this.queues.delete(key);
+			});
+			this.queues.set(key, queue);
+		}
+		return queue.enqueue(task);
+	}
+	hasTasks(sessionId) {
+		for (const queue of this.queues.values()) if (queue.sessionId === sessionId && queue.hasTasks()) return true;
+		return false;
+	}
+	extractPending(sessionId) {
+		const payloads = [];
+		for (const queue of this.queues.values()) if (queue.sessionId === sessionId) payloads.push(...queue.extractPending());
+		return payloads;
+	}
+	abortTasks(sessionId) {
+		for (const queue of this.queues.values()) if (queue.sessionId === sessionId) queue.abortAll();
+	}
+	interruptTasks(sessionId) {
+		const payloads = [];
+		for (const queue of this.queues.values()) if (queue.sessionId === sessionId) payloads.push(...queue.interruptAndExtract());
+		return payloads;
+	}
+};
+const taskScheduler = new TaskScheduler();
 
 //#endregion
-//#region src/daemon/message.ts
-function calculateDelay(attempt, baseDelayMs, isFallback = false) {
-	const effectiveAttempt = isFallback ? attempt + 1 : attempt;
-	if (effectiveAttempt <= 0) return 0;
-	const delay = baseDelayMs * Math.pow(2, effectiveAttempt - 1);
-	return Math.min(delay, 15e3);
-}
-function formatPendingMessages(payloads) {
-	return payloads.map((text) => `<message>\n${text}\n</message>`).join("\n\n");
-}
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function resolveSessionState(chatId, cwd, sessionId, overrideAgentId) {
-	const chatSettings = await readChatSettings(chatId, cwd);
-	const agentId = overrideAgentId ?? (typeof chatSettings?.defaultAgent === "string" ? chatSettings.defaultAgent : "default");
-	let targetSessionId = sessionId;
-	if (!targetSessionId) targetSessionId = (chatSettings?.sessions || {})[agentId] || "default";
-	const agentSessionSettings = await readAgentSessionSettings(agentId, targetSessionId, cwd);
-	return {
-		chatSettings,
-		agentId,
-		targetSessionId,
-		agentSessionSettings,
-		isNewSession: !agentSessionSettings
-	};
-}
-function prepareCommandAndEnv(agent, message, isNewSession, agentSessionSettings, fallback) {
-	const currentAgent = {
-		...agent,
-		commands: {
-			...agent.commands,
-			...fallback?.commands || {}
-		},
-		env: {
-			...agent.env,
-			...fallback?.env || {}
-		}
-	};
-	let command = currentAgent.commands?.new ?? "";
-	const env = {
-		...process.env,
-		CLAW_CLI_MESSAGE: message
-	};
-	applyEnvOverrides(env, currentAgent.env);
-	if (!isNewSession && currentAgent.commands?.append) {
-		command = currentAgent.commands.append;
-		applyEnvOverrides(env, agentSessionSettings?.env);
+//#region src/daemon/agent/agent-session.ts
+var AgentSession = class {
+	agentId;
+	sessionId;
+	chatId;
+	subagentId;
+	settings;
+	workspaceRoot;
+	globalSettings;
+	logger;
+	constructor(config) {
+		this.agentId = config.agentId;
+		this.sessionId = config.sessionId;
+		this.chatId = config.chatId;
+		this.subagentId = config.subagentId;
+		this.settings = config.settings;
+		this.workspaceRoot = config.workspaceRoot;
+		this.globalSettings = config.globalSettings;
+		this.logger = config.logger ?? createChatLogger(this.chatId, this.subagentId);
 	}
-	return {
-		command,
-		env,
-		currentAgent
-	};
-}
-async function runExtractionCommand(name, command, runCommand, cwd, env, mainResult, signal) {
-	try {
-		console.log(`Executing extraction command (${name}): ${command}`);
-		const res = await runCommand({
+	async buildExecutionContext(messageContent, routerEnv, fallback) {
+		const currentAgent = {
+			...this.settings,
+			commands: {
+				...this.settings.commands,
+				...fallback?.commands || {}
+			},
+			env: {
+				...this.settings.env,
+				...this.subagentId && this.settings.subagentEnv ? this.settings.subagentEnv : {},
+				...fallback?.env || {}
+			}
+		};
+		let initialCommand = currentAgent.commands?.new ?? "";
+		const env = {
+			...process.env,
+			CLAW_CLI_MESSAGE: messageContent
+		};
+		applyEnvOverrides(env, currentAgent.env);
+		if (!isNewSession(routerEnv) && currentAgent.commands?.append) initialCommand = currentAgent.commands.append;
+		if (!initialCommand) return null;
+		const agentSpecificEnvKeys = getActiveEnvKeys(currentAgent.env);
+		agentSpecificEnvKeys.add("CLAW_CLI_MESSAGE");
+		Object.assign(env, routerEnv);
+		Object.keys(routerEnv).forEach((k) => agentSpecificEnvKeys.add(k));
+		const apiCtx = getApiContext(this.globalSettings);
+		if (apiCtx) {
+			const proxyUrl = apiCtx.proxy_host ? `${apiCtx.proxy_host}:${apiCtx.port}` : `http://${apiCtx.host}:${apiCtx.port}`;
+			if (currentAgent.apiUrlEnvVar) {
+				env[currentAgent.apiUrlEnvVar] = proxyUrl;
+				agentSpecificEnvKeys.add(currentAgent.apiUrlEnvVar);
+				env["CLAW_LITE_URL_VAR"] = currentAgent.apiUrlEnvVar;
+				agentSpecificEnvKeys.add("CLAW_LITE_URL_VAR");
+			} else {
+				env["CLAW_API_URL"] = proxyUrl;
+				agentSpecificEnvKeys.add("CLAW_API_URL");
+			}
+			const token = generateToken({
+				chatId: this.chatId,
+				agentId: this.agentId,
+				sessionId: this.sessionId,
+				...this.subagentId ? { subagentId: this.subagentId } : {},
+				timestamp: Date.now()
+			});
+			if (currentAgent.apiTokenEnvVar) {
+				env[currentAgent.apiTokenEnvVar] = token;
+				agentSpecificEnvKeys.add(currentAgent.apiTokenEnvVar);
+				env["CLAW_LITE_API_VAR"] = currentAgent.apiTokenEnvVar;
+				agentSpecificEnvKeys.add("CLAW_LITE_API_VAR");
+			} else {
+				env["CLAW_API_TOKEN"] = token;
+				agentSpecificEnvKeys.add("CLAW_API_TOKEN");
+			}
+		}
+		let command = initialCommand;
+		command = await sandboxExecutionContext(command, env, agentSpecificEnvKeys, this.workDirectory, this.workspaceRoot);
+		return {
 			command,
-			cwd,
 			env,
-			stdin: mainResult.stdout,
-			signal
-		});
-		if (res.exitCode === 0) return { result: res.stdout.trim() };
-		else return { error: `${name} failed: ${res.stderr}` };
-	} catch (e) {
-		return { error: `${name} error: ${e.message}` };
+			currentAgent
+		};
 	}
-}
-/**
-* Formats the environment prefix string by replacing placeholders with actual values.
-* Available placeholders:
-* - {WORKSPACE_DIR}: The root directory of the workspace.
-* - {AGENT_DIR}: The directory where the agent is executing.
-* - {ENV_DIR}: The directory of the active environment.
-* - {HOME_DIR}: The home directory of the current user.
-* - {ENV_ARGS}: The formatted environment arguments based on envFormat.
-*/
-function formatEnvironmentPrefix(prefix, replacements) {
-	const map = {
-		"{WORKSPACE_DIR}": replacements.targetPath,
-		"{AGENT_DIR}": replacements.executionCwd,
-		"{ENV_DIR}": replacements.envDir,
-		"{HOME_DIR}": process.env.HOME || "",
-		"{ENV_ARGS}": replacements.envArgs
-	};
-	return prefix.replace(/{(WORKSPACE_DIR|AGENT_DIR|ENV_DIR|HOME_DIR|ENV_ARGS)}/g, (match) => map[match] || match);
-}
-async function executeDirectMessage(chatId, state, settings, cwd, runCommand, noWait = false, userMessageContent) {
-	const userMsg = {
-		id: state.messageId ?? crypto.randomUUID(),
-		role: "user",
-		content: userMessageContent ?? state.message,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	await appendMessage(chatId, userMsg);
-	if (state.reply) await appendMessage(chatId, {
-		id: crypto.randomUUID(),
-		messageId: userMsg.id,
-		role: "log",
-		source: "router",
-		content: state.reply,
-		stderr: "",
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		command: "router",
-		cwd,
-		exitCode: 0,
-		...state.reply.includes("NO_REPLY_NECESSARY") ? { level: "verbose" } : {}
-	});
-	if (!state.message.trim() && state.action !== "stop" && state.action !== "interrupt") return;
-	const queue = getMessageQueue(cwd);
-	if (state.action === "stop") {
-		queue.abortCurrent();
-		queue.clear();
-		return;
+	createRunner() {
+		return new AgentRunner(this, runCommand);
 	}
-	if (state.action === "interrupt") {
-		const targetSessionId = state.sessionId || "default";
-		const isMatchingSession = (p) => p.sessionId === targetSessionId;
-		const currentPayload = queue.getCurrentPayload();
-		const currentMatches = currentPayload ? isMatchingSession(currentPayload) : false;
-		const extracted = queue.extractPending(isMatchingSession);
-		queue.abortCurrent(isMatchingSession);
-		const payloads = currentMatches && currentPayload ? [currentPayload, ...extracted] : extracted;
-		if (payloads.length > 0) state.message = `${formatPendingMessages(payloads.map((p) => p.text))}\n\n<message>\n${state.message}\n</message>`.trim();
-	}
-	if (!state.message.trim()) return;
-	const routerEnv = state.env ?? {};
-	const taskPromise = queue.enqueue(async (signal) => {
-		const { agentId, agentSessionSettings, isNewSession, targetSessionId: finalSessionId } = await resolveSessionState(chatId, cwd, state.sessionId, state.agentId);
-		let mergedAgent = settings?.defaultAgent || {};
-		if (agentId !== "default") try {
-			const customAgent = await getAgent(agentId, cwd);
-			if (customAgent) mergedAgent = {
-				...mergedAgent,
-				...customAgent,
-				commands: {
-					...mergedAgent.commands,
-					...customAgent.commands
-				},
-				env: {
-					...mergedAgent.env,
-					...customAgent.env
-				}
+	get workDirectory() {
+		return resolveAgentWorkDir(this.agentId, this.settings.directory, this.workspaceRoot);
+	}
+	stop() {
+		taskScheduler.abortTasks(this.sessionId);
+	}
+	interrupt(message) {
+		const payloads = taskScheduler.interruptTasks(this.sessionId);
+		if (payloads.length > 0) {
+			const pendingText = formatPendingMessages(payloads);
+			return {
+				...message,
+				content: `${pendingText}\n\n<message>\n${message.content}\n</message>`.trim()
 			};
-		} catch {}
-		const executionConfigs = [{
-			retries: 0,
-			delayMs: 1e3
-		}, ...(mergedAgent.fallbacks || []).map((f) => ({
-			fallback: f,
-			retries: f.retries,
-			delayMs: f.delayMs
-		}))];
-		const workspaceRoot = getWorkspaceRoot(cwd);
-		let executionCwd = cwd;
-		if (mergedAgent.directory) executionCwd = path.resolve(workspaceRoot, mergedAgent.directory);
-		else if (agentId !== "default") executionCwd = path.resolve(workspaceRoot, agentId);
-		let lastLogMsg;
-		let success = false;
-		for (let configIdx = 0; configIdx < executionConfigs.length; configIdx++) {
-			const config = executionConfigs[configIdx];
-			const isFallbackConfig = configIdx > 0;
-			for (let attempt = 0; attempt <= config.retries; attempt++) {
-				const delay = calculateDelay(attempt, config.delayMs, isFallbackConfig);
-				if (delay > 0) {
-					await appendMessage(chatId, {
-						id: crypto.randomUUID(),
-						messageId: userMsg.id,
-						role: "log",
-						content: `Error running agent, retrying in ${Math.round(delay / 1e3)} seconds...`,
-						stderr: "",
-						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-						command: "retry-delay",
-						cwd: executionCwd,
-						exitCode: 0
-					});
-					await sleep(delay);
-				}
-				const { env, currentAgent, command: initialCommand } = prepareCommandAndEnv(mergedAgent, state.message, isNewSession, agentSessionSettings, config.fallback);
-				let command = initialCommand;
-				if (!command) continue;
-				const agentSpecificEnv = getActiveEnvKeys(currentAgent.env, !isNewSession ? agentSessionSettings?.env : void 0);
-				agentSpecificEnv.add("CLAW_CLI_MESSAGE");
-				Object.assign(env, routerEnv);
-				Object.keys(routerEnv).forEach((k) => agentSpecificEnv.add(k));
-				const apiCtx = getApiContext(settings);
-				if (apiCtx) {
-					env["CLAW_API_URL"] = apiCtx.proxy_host ? `${apiCtx.proxy_host}:${apiCtx.port}` : `http://${apiCtx.host}:${apiCtx.port}`;
-					agentSpecificEnv.add("CLAW_API_URL");
-					env["CLAW_API_TOKEN"] = generateToken({
-						chatId,
-						agentId,
-						sessionId: finalSessionId,
-						timestamp: Date.now()
-					});
-					agentSpecificEnv.add("CLAW_API_TOKEN");
-				}
-				const activeEnvInfo = await getActiveEnvironmentInfo(executionCwd, cwd);
-				if (activeEnvInfo) {
-					const activeEnvName = activeEnvInfo.name;
-					const activeEnv = await readEnvironment(activeEnvName, cwd);
-					if (activeEnv?.env) for (const [key, value] of Object.entries(activeEnv.env)) if (value === false) {
-						delete env[key];
-						agentSpecificEnv.delete(key);
-					} else {
-						let interpolatedValue = String(value);
-						interpolatedValue = interpolatedValue.replace(/\{PATH\}/g, process.env.PATH || "");
-						interpolatedValue = interpolatedValue.replace(/\{ENV_DIR\}/g, getEnvironmentPath(activeEnvName, cwd));
-						interpolatedValue = interpolatedValue.replace(/\{WORKSPACE_DIR\}/g, activeEnvInfo.targetPath);
-						env[key] = interpolatedValue;
-						agentSpecificEnv.add(key);
-					}
-					if (activeEnv?.prefix) {
-						const envArgs = Array.from(agentSpecificEnv).map((key) => {
-							if (activeEnv.envFormat) return activeEnv.envFormat.replace("{key}", key);
-							return key;
-						}).join(" ");
-						const prefixReplaced = formatEnvironmentPrefix(activeEnv.prefix, {
-							targetPath: activeEnvInfo.targetPath,
-							executionCwd,
-							envDir: getEnvironmentPath(activeEnvName, cwd),
-							envArgs
-						});
-						if (prefixReplaced.includes("{COMMAND}")) command = prefixReplaced.replace("{COMMAND}", command);
-						else command = `${prefixReplaced} ${command}`;
-					}
-				}
-				console.log(`Executing command: ${command}`);
-				let mainResult;
-				const typingInterval = setInterval(() => {
-					emitTyping(chatId);
-				}, 5e3);
-				try {
-					mainResult = await runCommand({
-						command,
-						cwd: executionCwd,
-						env,
-						signal
-					});
-				} finally {
-					clearInterval(typingInterval);
-				}
-				const logMsg = {
-					id: crypto.randomUUID(),
-					messageId: userMsg.id,
-					role: "log",
-					content: mainResult.stdout,
-					stdout: mainResult.stdout,
-					stderr: "",
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					command,
-					cwd: executionCwd,
-					exitCode: mainResult.exitCode,
-					...mainResult.stdout.includes("NO_REPLY_NECESSARY") ? { level: "verbose" } : {}
-				};
-				const errors = [];
-				if (mainResult.stderr) errors.push(mainResult.stderr);
-				let currentSuccess = mainResult.exitCode === 0;
-				if (currentSuccess) {
-					if (currentAgent.commands?.getMessageContent) {
-						const { result, error } = await runExtractionCommand("getMessageContent", currentAgent.commands.getMessageContent, runCommand, executionCwd, env, mainResult, signal);
-						if (result !== void 0) {
-							logMsg.content = result;
-							logMsg.stdout = mainResult.stdout;
-							if (result.includes("NO_REPLY_NECESSARY")) logMsg.level = "verbose";
-							else delete logMsg.level;
-							if (result.trim() === "") currentSuccess = false;
-						}
-						if (error) errors.push(error);
-					}
-				}
-				logMsg.stderr = errors.join("\n\n");
-				lastLogMsg = logMsg;
-				if (currentSuccess) {
-					success = true;
-					if (isNewSession && currentAgent.commands?.getSessionId) {
-						const { result, error } = await runExtractionCommand("getSessionId", currentAgent.commands.getSessionId, runCommand, executionCwd, env, mainResult, signal);
-						if (result) await writeAgentSessionSettings(agentId, finalSessionId, { env: { SESSION_ID: result } }, cwd);
-						if (error) logMsg.stderr = [logMsg.stderr, error].filter(Boolean).join("\n\n");
-					}
-					break;
-				}
+		}
+		return message;
+	}
+	async handleMessage(message) {
+		if (!message.content.trim()) return;
+		await taskScheduler.schedule({
+			id: `task-${this.agentId}-${randomUUID()}`,
+			rootChatId: this.chatId,
+			dirPath: this.workDirectory,
+			sessionId: this.sessionId,
+			text: message.content,
+			execute: async (signal) => {
+				const sessionSettings = await readAgentSessionSettings(this.agentId, this.sessionId, this.workspaceRoot);
+				applyEnvOverrides(message.env, sessionSettings?.env);
+				const result = await this.createRunner().executeWithFallbacks(message, signal);
+				if (!result) return;
+				if (result.extractedSessionId) await writeAgentSessionSettings(this.agentId, this.sessionId, { env: { SESSION_ID: result.extractedSessionId } }, this.workspaceRoot);
+				await this.logger.logCommandResult(result);
+				if (!result.content.includes("NO_REPLY_NECESSARY")) await this.logger.logAgentReply({ content: result.content });
+			}
+		});
+	}
+};
+async function createAgentSession(options) {
+	const settings = options.settings ?? await readSettings(options.cwd) ?? void 0;
+	const mergedAgent = await resolveMergedAgent(options.agentId, settings, options.cwd);
+	const workspaceRoot = getWorkspaceRoot(options.cwd);
+	return new AgentSession({
+		agentId: options.agentId,
+		sessionId: options.sessionId,
+		chatId: options.chatId,
+		...options.subagentId ? { subagentId: options.subagentId } : {},
+		settings: mergedAgent,
+		workspaceRoot,
+		globalSettings: settings,
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+async function resolveMergedAgent(agentId, settings, cwd) {
+	let mergedAgent = settings?.defaultAgent || {};
+	if (agentId !== "default") try {
+		const customAgent = await getAgent(agentId, cwd);
+		if (customAgent) mergedAgent = {
+			...mergedAgent,
+			...customAgent,
+			commands: {
+				...mergedAgent.commands,
+				...customAgent.commands
+			},
+			env: {
+				...mergedAgent.env,
+				...customAgent.env
 			}
-			if (success) break;
-		}
-		if (lastLogMsg) await appendMessage(chatId, lastLogMsg);
-	}, {
-		text: state.message,
-		sessionId: state.sessionId || "default"
+		};
+	} catch {}
+	return mergedAgent;
+}
+
+//#endregion
+//#region src/daemon/message.ts
+async function executeDirectMessage(chatId, state, settings, cwd, noWait = false, userMessageContent, subagentId, systemEvent, displayRole) {
+	const logger = createChatLogger(chatId, subagentId);
+	let msgId;
+	if (systemEvent) msgId = (await logger.logSystemMessage({
+		content: userMessageContent ?? state.message,
+		event: systemEvent,
+		messageId: state.messageId,
+		...displayRole ? { displayRole } : {}
+	})).id;
+	else msgId = (await logger.logUserMessage(userMessageContent ?? state.message)).id;
+	if (state.reply) await logger.logAutomaticReply({
+		messageId: msgId,
+		content: state.reply
+	});
+	if (!state.message.trim() && state.action !== "stop" && state.action !== "interrupt") return;
+	const agentSession = await createAgentSession({
+		chatId,
+		agentId: state.agentId || "default",
+		sessionId: state.sessionId || "default",
+		...subagentId ? { subagentId } : {},
+		cwd,
+		settings,
+		logger
 	});
+	let finalMessage = {
+		id: state.messageId,
+		content: state.message,
+		env: state.env ?? {}
+	};
+	if (state.action === "stop") {
+		agentSession.stop();
+		return;
+	}
+	if (state.action === "interrupt") finalMessage = agentSession.interrupt(finalMessage);
+	const taskPromise = agentSession.handleMessage(finalMessage);
 	if (!noWait) try {
 		await taskPromise;
 	} catch (err) {
@@ -926,12 +1445,11 @@ async function executeDirectMessage(chatId, state, settings, cwd, runCommand, no
 		if (err.name !== "AbortError") console.error("Task execution error:", err);
 	});
 }
-async function getInitialRouterState(chatId, message, cwd = process.cwd(), overrideAgentId, overrideSessionId, overrideMessageId) {
-	const chatSettings = await readChatSettings(chatId, cwd) ?? {};
+async function getInitialRouterState(chatId, message, chatSettings, overrideAgentId, overrideSessionId) {
 	const agentId = overrideAgentId ?? chatSettings.defaultAgent ?? "default";
 	const sessionId = overrideSessionId ?? chatSettings.sessions?.[agentId] ?? "default";
 	return {
-		messageId: overrideMessageId ?? crypto.randomUUID(),
+		messageId: crypto.randomUUID(),
 		message,
 		chatId,
 		agentId,
@@ -939,92 +1457,52 @@ async function getInitialRouterState(chatId, message, cwd = process.cwd(), overr
 		env: {}
 	};
 }
-async function handleUserMessage(chatId, message, settings, cwd = process.cwd(), noWait = false, runCommand, sessionId, overrideAgentId) {
+async function handleUserMessage(chatId, message, settings, cwd = process.cwd(), noWait = false, sessionId, overrideAgentId) {
 	const chatSettings = await readChatSettings(chatId, cwd) ?? {};
 	if (overrideAgentId && chatSettings.defaultAgent !== overrideAgentId) {
 		chatSettings.defaultAgent = overrideAgentId;
 		await writeChatSettings(chatId, chatSettings, cwd);
 	}
-	const initialState = await getInitialRouterState(chatId, message, cwd, overrideAgentId, sessionId);
-	const initialAgent = initialState.agentId;
-	const finalState = await executeRouterPipeline(initialState, chatSettings.routers ?? settings?.routers ?? []);
-	const finalMessage = finalState.message;
+	const initialState = await getInitialRouterState(chatId, message, chatSettings, overrideAgentId, sessionId);
+	const finalState = await executeRouterPipeline(initialState, resolveRouters(chatSettings.routers ?? settings?.routers ?? [], true));
+	await applyRouterStateUpdates(chatId, cwd, finalState, chatSettings, initialState.agentId);
+	await executeDirectMessage(chatId, finalState, settings, cwd, noWait, message);
+}
+async function applyRouterStateUpdates(chatId, cwd, finalState, chatSettings, initialAgent) {
 	const finalAgentId = finalState.agentId;
 	const finalSessionId = finalState.sessionId ?? crypto.randomUUID();
-	const routerEnv = finalState.env ?? {};
 	const currentAgentId = finalAgentId ?? chatSettings.defaultAgent ?? "default";
 	let settingsChanged = false;
 	if (finalAgentId && finalAgentId !== initialAgent) {
 		chatSettings.defaultAgent = finalAgentId;
 		settingsChanged = true;
 	}
-	if (finalSessionId && chatSettings.sessions?.[currentAgentId] !== finalSessionId) {
+	if (finalState.nextSessionId) {
 		chatSettings.sessions = chatSettings.sessions || {};
-		chatSettings.sessions[currentAgentId] = finalSessionId;
+		chatSettings.sessions[currentAgentId] = finalState.nextSessionId;
 		settingsChanged = true;
 	}
+	if (finalState.jobs) {
+		chatSettings.jobs = chatSettings.jobs || [];
+		if (finalState.jobs.remove?.length) {
+			const removeSet = new Set(finalState.jobs.remove);
+			for (const jobId of finalState.jobs.remove) cronManager.unscheduleJob(chatId, jobId);
+			chatSettings.jobs = chatSettings.jobs.filter((job) => !removeSet.has(job.id));
+			settingsChanged = true;
+		}
+		if (finalState.jobs.add?.length) {
+			const addMap = new Map(finalState.jobs.add.map((job) => [job.id, job]));
+			for (const job of finalState.jobs.add) cronManager.scheduleJob(chatId, job);
+			chatSettings.jobs = chatSettings.jobs.filter((job) => !addMap.has(job.id));
+			chatSettings.jobs.push(...finalState.jobs.add);
+			settingsChanged = true;
+		}
+	}
 	if (settingsChanged) await writeChatSettings(chatId, chatSettings, cwd);
-	const directState = {
-		messageId: finalState.messageId,
-		message: finalMessage,
-		chatId,
-		env: routerEnv
-	};
-	if (finalAgentId !== void 0) directState.agentId = finalAgentId;
-	if (finalSessionId !== void 0) directState.sessionId = finalSessionId;
-	if (finalState.reply !== void 0) directState.reply = finalState.reply;
-	if (finalState.action !== void 0) directState.action = finalState.action;
-	await executeDirectMessage(chatId, directState, settings, cwd, runCommand, noWait, message);
+	if (finalState.sessionId === void 0) finalState.sessionId = finalSessionId;
+	if (finalState.agentId === void 0) finalState.agentId = currentAgentId;
 }
 
-//#endregion
-//#region src/daemon/utils/spawn.ts
-const runCommand = async ({ command, cwd, env, stdin, signal, logToTerminal }) => {
-	return new Promise((resolve, reject) => {
-		const p = spawn(command, {
-			shell: true,
-			cwd,
-			env,
-			signal
-		});
-		if (stdin && p.stdin) {
-			p.stdin.on("error", (err) => {
-				if (err.code !== "EPIPE") console.error("stdin error:", err);
-			});
-			p.stdin.write(stdin);
-			p.stdin.end();
-		}
-		let stdout = "";
-		let stderr = "";
-		if (p.stdout) p.stdout.on("data", (data) => {
-			stdout += data.toString();
-			if (logToTerminal && !stdin) process.stdout.write(data);
-		});
-		if (p.stderr) p.stderr.on("data", (data) => {
-			stderr += data.toString();
-			if (logToTerminal && !stdin) process.stderr.write(data);
-		});
-		p.on("close", (code) => {
-			resolve({
-				stdout,
-				stderr,
-				exitCode: code ?? 1
-			});
-		});
-		p.on("error", (err) => {
-			if (err.name === "AbortError") {
-				reject(err);
-				return;
-			}
-			resolve({
-				stdout: "",
-				stderr: err.toString(),
-				exitCode: 1
-			});
-		});
-	});
-};
-
 //#endregion
 //#region src/daemon/cron.ts
 var CronManager = class {
@@ -1107,14 +1585,25 @@ var CronManager = class {
 			} catch {
 				globalSettings = void 0;
 			}
-			const overrideSessionId = job.session?.type === "new" ? crypto.randomUUID() : void 0;
-			const routerState = await getInitialRouterState(chatId, job.message, process.cwd(), job.agentId, overrideSessionId);
+			const overrideSessionId = job.session?.type === "new" ? crypto.randomUUID() : job.session?.id;
+			const chatSettings = await readChatSettings(chatId, process.cwd()) ?? {};
+			let routerState = await getInitialRouterState(chatId, job.message, chatSettings, job.agentId, overrideSessionId);
 			if (job.env !== void 0) {
 				routerState.env = routerState.env || {};
 				applyEnvOverrides(routerState.env, job.env);
 			}
-			if (job.reply !== void 0) routerState.reply = job.reply;
-			await executeDirectMessage(chatId, routerState, globalSettings, process.cwd(), runCommand, false, job.message);
+			const currentAgentId = job.agentId ?? chatSettings.defaultAgent ?? "default";
+			const currentActiveSession = chatSettings.sessions?.[currentAgentId];
+			const isOutdatedSession = job.session?.type === "existing" && currentActiveSession !== void 0 && currentActiveSession !== job.session.id;
+			if (job.reply !== void 0 && !isOutdatedSession) routerState.reply = job.reply;
+			if (job.nextSessionId !== void 0 && !isOutdatedSession) routerState.nextSessionId = job.nextSessionId;
+			if (job.action !== void 0) routerState.action = job.action;
+			if (job.jobs !== void 0) routerState.jobs = job.jobs;
+			const resolvedRouters = resolveRouters(chatSettings.routers ?? globalSettings?.routers ?? [], false);
+			const initialState = { ...routerState };
+			routerState = await executeRouterPipeline(routerState, resolvedRouters);
+			await applyRouterStateUpdates(chatId, process.cwd(), routerState, chatSettings, initialState.agentId);
+			await executeDirectMessage(chatId, routerState, globalSettings, process.cwd(), false, job.message, void 0, "cron");
 			if (isOneOff) {
 				const chatSettings = await readChatSettings(chatId);
 				if (chatSettings && chatSettings.jobs) {
@@ -1297,10 +1786,7 @@ const sendMessage = apiProcedure.input(z.object({
 		const fileList = `Attached files:\n${finalPaths.map((p) => `- ${p}`).join("\n")}`;
 		message = message ? `${message}\n\n${fileList}` : fileList;
 	}
-	await handleUserMessage(chatId, message, settings, void 0, noWait, (args) => runCommand({
-		...args,
-		logToTerminal: true
-	}), sessionId, agentId);
+	await handleUserMessage(chatId, message, settings, void 0, noWait, sessionId, agentId);
 	return { success: true };
 });
 const getMessages = apiProcedure.input(z.object({
@@ -1348,6 +1834,23 @@ const shutdown = publicProcedure.mutation(() => {
 const userListCronJobs = apiProcedure.input(z.object({ chatId: z.string().optional() })).query(async ({ input }) => {
 	return listCronJobsShared(input.chatId ?? await getDefaultChatId());
 });
+const getChats = apiProcedure.query(async () => {
+	return listChats();
+});
+const getAgents = apiProcedure.query(async () => {
+	return listAgents();
+});
+const userCreateChat = apiProcedure.input(z.object({
+	chatId: z.string(),
+	agent: z.string().optional()
+})).mutation(async ({ input }) => {
+	await createChat(input.chatId);
+	if (input.agent) await writeChatSettings(input.chatId, { defaultAgent: input.agent });
+	return {
+		success: true,
+		chatId: input.chatId
+	};
+});
 const userAddCronJob = apiProcedure.input(z.object({
 	chatId: z.string().optional(),
 	job: CronJobSchema
@@ -1369,7 +1872,10 @@ const userRouter = router({
 	shutdown,
 	listCronJobs: userListCronJobs,
 	addCronJob: userAddCronJob,
-	deleteCronJob: userDeleteCronJob
+	deleteCronJob: userDeleteCronJob,
+	getChats,
+	getAgents,
+	createChat: userCreateChat
 });
 
 //#endregion
@@ -1385,7 +1891,7 @@ var PolicyRequestService = class {
 		this.snapshotDir = snapshotDir;
 		this.maxPending = maxPending;
 	}
-	async createRequest(commandName, args, fileMappings, chatId, agentId) {
+	async createRequest(commandName, args, fileMappings, chatId, agentId, skipSave = false, subagentId) {
 		const allRequests = await this.store.list();
 		if (allRequests.filter((r) => r.state === "Pending").length >= this.maxPending) throw new Error(`Maximum number of pending requests (${this.maxPending}) reached.`);
 		const snapshotMappings = {};
@@ -1399,12 +1905,13 @@ var PolicyRequestService = class {
 			commandName,
 			args,
 			fileMappings: snapshotMappings,
-			state: "Pending",
+			state: skipSave ? "Approved" : "Pending",
 			createdAt: Date.now(),
 			chatId,
-			agentId
+			agentId,
+			...subagentId ? { subagentId } : {}
 		};
-		await this.store.save(request);
+		if (!skipSave) await this.store.save(request);
 		return request;
 	}
 	getInterpolatedArgs(request) {
@@ -1412,6 +1919,295 @@ var PolicyRequestService = class {
 	}
 };
 
+//#endregion
+//#region src/daemon/api/subagent-utils.ts
+function getSubagentDepth(settings, parentId) {
+	let depth = 0;
+	let currentParentId = parentId;
+	while (currentParentId && settings.subagents?.[currentParentId]) {
+		depth++;
+		currentParentId = settings.subagents[currentParentId]?.parentId;
+	}
+	return depth;
+}
+async function executeSubagent(chatId, subagentId, agentId, sessionId, prompt, isAsync, parentTokenPayload, workspaceRoot) {
+	try {
+		const settings = await readChatSettings(chatId) || {};
+		const resolvedRouters = resolveRouters(settings.routers ?? [], false);
+		let routerState = {
+			messageId: randomUUID(),
+			message: prompt,
+			chatId,
+			agentId,
+			sessionId,
+			env: {}
+		};
+		const initialState = { ...routerState };
+		routerState = await executeRouterPipeline(routerState, resolvedRouters);
+		await applyRouterStateUpdates(chatId, workspaceRoot, routerState, settings, initialState.agentId);
+		await executeDirectMessage(chatId, routerState, void 0, workspaceRoot, false, void 0, subagentId);
+		if (taskScheduler.hasTasks(sessionId)) return;
+		await updateChatSettings(chatId, (finalSettings) => {
+			if (finalSettings.subagents?.[subagentId]) finalSettings.subagents[subagentId].status = "completed";
+			return finalSettings;
+		});
+		const logger = createChatLogger(chatId, subagentId);
+		await logger.logSubagentStatus({
+			subagentId,
+			status: "completed"
+		});
+		if (isAsync) {
+			const lastLogMessage = await logger.findLastMessage((m) => m.role === "agent" || m.displayRole === "agent");
+			let outputContent = "";
+			if (lastLogMessage && "content" in lastLogMessage) outputContent = `\n\n<subagent_output>\n${lastLogMessage.content}\n</subagent_output>`;
+			console.log("Notifying parent", chatId, parentTokenPayload?.agentId, parentTokenPayload?.subagentId);
+			await executeDirectMessage(chatId, {
+				messageId: randomUUID(),
+				message: `<notification>Subagent ${subagentId} completed.</notification>${outputContent}`,
+				chatId,
+				agentId: parentTokenPayload?.agentId || "default",
+				...parentTokenPayload?.subagentId ? { subagentId: parentTokenPayload.subagentId } : {},
+				sessionId: parentTokenPayload?.sessionId || "default",
+				env: {}
+			}, void 0, workspaceRoot, true, void 0, parentTokenPayload?.subagentId, "subagent_update");
+		}
+	} catch {
+		await updateChatSettings(chatId, (errSettings) => {
+			if (errSettings.subagents?.[subagentId]) errSettings.subagents[subagentId].status = "failed";
+			return errSettings;
+		});
+		await createChatLogger(chatId, subagentId).logSubagentStatus({
+			subagentId,
+			status: "failed"
+		});
+	}
+}
+
+//#endregion
+//#region src/daemon/api/subagent-router.ts
+const MAX_SUBAGENT_DEPTH = 2;
+const subagentSpawn = apiProcedure.input(z.object({
+	subagentId: z.string().optional(),
+	targetAgentId: z.string().optional(),
+	prompt: z.string(),
+	async: z.boolean().optional()
+})).mutation(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	const parentAgentId = ctx.tokenPayload.agentId;
+	const parentId = ctx.tokenPayload.subagentId;
+	const id = input.subagentId || randomUUID();
+	const sessionId = randomUUID();
+	const agentId = input.targetAgentId || parentAgentId;
+	let depth = 0;
+	await updateChatSettings(chatId, (settings) => {
+		settings.subagents = settings.subagents || {};
+		depth = getSubagentDepth(settings, parentId);
+		if (depth >= MAX_SUBAGENT_DEPTH) throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Max subagent depth reached"
+		});
+		if (settings.subagents[id]) throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Subagent ID already exists"
+		});
+		settings.subagents[id] = {
+			id,
+			agentId,
+			sessionId,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			status: "active",
+			parentId
+		};
+		return settings;
+	});
+	const workspaceRoot = getWorkspaceRoot(process.cwd());
+	const isAsync = input.async ?? depth === 0;
+	executeSubagent(chatId, id, agentId, sessionId, input.prompt, isAsync, ctx.tokenPayload, workspaceRoot);
+	return {
+		id,
+		depth,
+		isAsync
+	};
+});
+const subagentSend = apiProcedure.input(z.object({
+	subagentId: z.string(),
+	prompt: z.string(),
+	async: z.boolean().optional()
+})).mutation(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	let sub;
+	await updateChatSettings(chatId, (settings) => {
+		if (!settings.subagents?.[input.subagentId]) throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Subagent not found"
+		});
+		sub = settings.subagents[input.subagentId];
+		sub.status = "active";
+		return settings;
+	});
+	const workspaceRoot = getWorkspaceRoot(process.cwd());
+	executeSubagent(chatId, sub.id, sub.agentId || "default", sub.sessionId || "default", input.prompt, input.async, ctx.tokenPayload, workspaceRoot);
+	return { success: true };
+});
+async function checkSubagentStatus(chatId, subagentId) {
+	const sub = (await readChatSettings(chatId))?.subagents?.[subagentId];
+	if (!sub) throw new TRPCError({
+		code: "NOT_FOUND",
+		message: "Subagent not found"
+	});
+	if (sub.status === "completed" || sub.status === "failed") {
+		let outputContent;
+		if (sub.status === "completed") {
+			const lastLogMessage = await createChatLogger(chatId, subagentId).findLastMessage((m) => m.role === "agent");
+			if (lastLogMessage && "content" in lastLogMessage) outputContent = lastLogMessage.content;
+		}
+		return {
+			status: sub.status,
+			output: outputContent
+		};
+	}
+	return null;
+}
+const subagentWait = apiProcedure.input(z.object({ subagentId: z.string() })).mutation(async ({ input, ctx, signal }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	const ac = new AbortController();
+	const timeout = setTimeout(() => ac.abort(), 6e4);
+	const onAbort = () => {
+		clearTimeout(timeout);
+		ac.abort();
+	};
+	if (signal) signal.addEventListener("abort", onAbort);
+	const eventIterator = on(daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, { signal: ac.signal });
+	try {
+		const initialStatus = await checkSubagentStatus(chatId, input.subagentId);
+		if (initialStatus) {
+			clearTimeout(timeout);
+			if (signal) signal.removeEventListener("abort", onAbort);
+			return initialStatus;
+		}
+		for await (const [event] of eventIterator) if (event.chatId === chatId && event.message?.subagentId === input.subagentId) {
+			if (event.message.role === "subagent_status") {
+				const status = await checkSubagentStatus(chatId, input.subagentId);
+				if (status) {
+					clearTimeout(timeout);
+					if (signal) signal.removeEventListener("abort", onAbort);
+					return status;
+				}
+			}
+		}
+	} catch (err) {
+		if (err && typeof err === "object" && "name" in err && err.name === "AbortError") return {
+			status: "active",
+			output: void 0
+		};
+		throw err;
+	} finally {
+		clearTimeout(timeout);
+		if (signal) signal.removeEventListener("abort", onAbort);
+		ac.abort();
+	}
+	return {
+		status: "active",
+		output: void 0
+	};
+});
+const subagentStop = apiProcedure.input(z.object({ subagentId: z.string() })).mutation(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	let subToStop;
+	await updateChatSettings(chatId, (settings) => {
+		if (settings.subagents) {
+			const sub = settings.subagents[input.subagentId];
+			if (sub) {
+				sub.status = "failed";
+				subToStop = sub;
+			}
+		}
+		return settings;
+	});
+	if (subToStop) (await createAgentSession({
+		chatId,
+		agentId: subToStop.agentId || "default",
+		sessionId: subToStop.sessionId || "default",
+		subagentId: input.subagentId,
+		cwd: process.cwd()
+	})).stop();
+	return { success: true };
+});
+const subagentDelete = apiProcedure.input(z.object({ subagentId: z.string() })).mutation(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	let subToDelete;
+	await updateChatSettings(chatId, (settings) => {
+		if (settings.subagents && settings.subagents[input.subagentId]) {
+			subToDelete = settings.subagents[input.subagentId];
+			delete settings.subagents[input.subagentId];
+		}
+		return settings;
+	});
+	if (subToDelete) {
+		(await createAgentSession({
+			chatId,
+			agentId: subToDelete.agentId || "default",
+			sessionId: subToDelete.sessionId || "default",
+			subagentId: input.subagentId,
+			cwd: process.cwd()
+		})).stop();
+		return {
+			success: true,
+			deleted: true
+		};
+	}
+	return {
+		success: true,
+		deleted: false
+	};
+});
+const subagentList = apiProcedure.input(z.object({ blocking: z.boolean().optional() }).optional()).query(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	const settings = await readChatSettings(chatId);
+	let subagents = Object.values(settings?.subagents || {});
+	const isSubagent = !!ctx.tokenPayload.subagentId;
+	const myId = ctx.tokenPayload.subagentId;
+	subagents = subagents.filter((s) => s.parentId === myId);
+	if (input?.blocking) if (!isSubagent) subagents = [];
+	else subagents = subagents.filter((s) => s.status === "active");
+	return { subagents };
+});
+const subagentTail = apiProcedure.input(z.object({
+	subagentId: z.string(),
+	limit: z.number().optional()
+})).query(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	return { messages: await createChatLogger(chatId, input.subagentId).getMessages(input.limit) };
+});
+
 //#endregion
 //#region src/daemon/api/agent-router.ts
 const logMessage = apiProcedure.input(z.object({
@@ -1438,18 +2234,81 @@ const logMessage = apiProcedure.input(z.object({
 	await appendMessage(chatId, {
 		id,
 		messageId: id,
-		role: "log",
-		source: "router",
+		role: "command",
 		content: input.message || "",
+		stdout: "",
 		stderr: "",
 		timestamp,
 		command: `clawmini-lite log${filesArgStr}`,
 		cwd: process.cwd(),
 		exitCode: 0,
+		...ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {},
+		...filePaths.length > 0 ? { files: filePaths } : {}
+	});
+	return { success: true };
+});
+const logReplyMessage = apiProcedure.input(z.object({
+	message: z.string(),
+	files: z.array(z.string()).optional()
+})).mutation(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+	const filePaths = [];
+	if (input.files && input.files.length > 0) {
+		const workspaceRoot = getWorkspaceRoot(process.cwd());
+		const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+		for (const file of input.files) {
+			const validPath = await validateLogFile(file, agentDir, workspaceRoot);
+			filePaths.push(validPath);
+		}
+	}
+	await appendMessage(chatId, {
+		id,
+		role: "agent",
+		content: input.message,
+		timestamp,
+		...ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {},
 		...filePaths.length > 0 ? { files: filePaths } : {}
 	});
 	return { success: true };
 });
+const logToolMessage = apiProcedure.input(z.object({
+	name: z.string(),
+	payload: z.any().optional()
+})).mutation(async ({ input, ctx }) => {
+	if (!ctx.tokenPayload) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing token"
+	});
+	const chatId = ctx.tokenPayload.chatId;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+	const messageId = randomUUID();
+	const payloadObj = input.payload !== void 0 ? input.payload : {};
+	let contentStr;
+	if (typeof payloadObj === "string") contentStr = payloadObj;
+	else try {
+		contentStr = JSON.stringify(payloadObj, null, 2);
+	} catch {
+		contentStr = String(payloadObj);
+	}
+	await appendMessage(chatId, {
+		id,
+		messageId,
+		role: "tool",
+		name: input.name,
+		payload: payloadObj,
+		content: contentStr,
+		timestamp,
+		...ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}
+	});
+	return { success: true };
+});
 const agentListCronJobs = apiProcedure.query(async ({ ctx }) => {
 	if (!ctx.tokenPayload) throw new TRPCError({
 		code: "UNAUTHORIZED",
@@ -1510,34 +2369,68 @@ const createPolicyRequest = apiProcedure.input(z.object({
 	});
 	const workspaceRoot = getWorkspaceRoot(process.cwd());
 	const snapshotDir = path.join(getClawminiDir(process.cwd()), "tmp", "snapshots");
-	const service = new PolicyRequestService(new RequestStore(process.cwd()), await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot), snapshotDir);
+	const store = new RequestStore(process.cwd());
+	const service = new PolicyRequestService(store, await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot), snapshotDir);
 	const chatId = ctx.tokenPayload.chatId;
 	const agentId = ctx.tokenPayload.agentId;
-	const request = await service.createRequest(input.commandName, input.args, input.fileMappings, chatId, agentId);
+	const policy = (await readPolicies())?.policies?.[input.commandName];
+	if (!policy) throw new TRPCError({
+		code: "NOT_FOUND",
+		message: `Policy not found: ${input.commandName}`
+	});
+	const isAutoApprove = !!policy.autoApprove;
+	const request = await service.createRequest(input.commandName, input.args, input.fileMappings, chatId, agentId, isAutoApprove, ctx.tokenPayload.subagentId);
+	if (isAutoApprove) {
+		const { stdout, stderr, exitCode, commandStr } = await executeRequest(request, policy, getWorkspaceRoot());
+		request.executionResult = {
+			stdout,
+			stderr,
+			exitCode
+		};
+		await store.save(request);
+		await appendMessage(chatId, {
+			id: randomUUID(),
+			messageId: randomUUID(),
+			role: "policy",
+			requestId: request.id,
+			commandName: input.commandName,
+			args: input.args,
+			status: "approved",
+			content: `[Auto-approved] Policy ${input.commandName} was executed.\n\nCommand: ${commandStr}\nExit Code: ${exitCode}\n\nStdout:\n${stdout}\n\nStderr:\n${stderr}`,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}
+		});
+		return request;
+	}
 	const previewContent = await generateRequestPreview(request);
 	await appendMessage(chatId, {
 		id: randomUUID(),
 		messageId: randomUUID(),
-		role: "log",
-		source: "router",
+		role: "policy",
+		requestId: request.id,
+		commandName: input.commandName,
+		args: input.args,
+		status: "pending",
 		content: previewContent,
-		stderr: "",
 		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		command: "policy-request",
-		cwd: process.cwd(),
-		exitCode: 0
+		displayRole: "agent"
 	});
 	return request;
 });
 const fetchPendingMessages = apiProcedure.mutation(async ({ ctx }) => {
-	const queue = getMessageQueue(process.cwd());
+	if (!ctx.tokenPayload?.agentId) throw new TRPCError({
+		code: "UNAUTHORIZED",
+		message: "Missing agent ID"
+	});
 	const targetSessionId = ctx.tokenPayload?.sessionId || "default";
-	const extracted = queue.extractPending((p) => p.sessionId === targetSessionId);
+	const extracted = taskScheduler.extractPending(targetSessionId);
 	if (extracted.length === 0) return { messages: "" };
-	return { messages: formatPendingMessages(extracted.map((p) => p.text)) };
+	return { messages: formatPendingMessages(extracted) };
 });
 const agentRouter = router({
 	logMessage,
+	logReplyMessage,
+	logToolMessage,
 	listCronJobs: agentListCronJobs,
 	addCronJob: agentAddCronJob,
 	deleteCronJob: agentDeleteCronJob,
@@ -1545,7 +2438,14 @@ const agentRouter = router({
 	executePolicyHelp,
 	createPolicyRequest,
 	fetchPendingMessages,
-	ping
+	ping,
+	subagentSpawn,
+	subagentSend,
+	subagentWait,
+	subagentStop,
+	subagentDelete,
+	subagentList,
+	subagentTail
 });
 
 //#endregion
@@ -1644,6 +2544,20 @@ async function initDaemon() {
 			resolve();
 		});
 	});
+	const cleanOrphanedSubagents = async () => {
+		try {
+			const chats = await listChats();
+			for (const chatId of chats) await updateChatSettings(chatId, (settings) => {
+				if (settings.subagents) {
+					for (const subagent of Object.values(settings.subagents)) if (subagent.status === "active") subagent.status = "failed";
+				}
+				return settings;
+			});
+		} catch (err) {
+			console.warn("Failed to clean orphaned subagents:", err);
+		}
+	};
+	await cleanOrphanedSubagents();
 	await runHooks("up");
 	isReady = true;
 	readyPromiseResolve();