agent-worker 0.10.0 → 0.12.0

package/dist/cli/index.mjs

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
-import { A as getDefaultModel, E as FRONTIER_MODELS, n as createBackend } from "../backends-BOAkfYyL.mjs";
-import { a as createSkillsTool, c as createFeedbackTool, l as AgentSession, o as SkillsProvider, s as FEEDBACK_PROMPT, t as SkillImporter } from "../skills-xNmQZf8e.mjs";
-import { jsonSchema, tool } from "ai";
+import { D as FRONTIER_MODELS, T as normalizeBackendType, j as getDefaultModel, n as createBackend } from "../backends-DLaP0rMW.mjs";
+import { t as AgentWorker } from "../worker-CJ5_b2_q.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { appendFile, mkdir, open, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { z } from "zod";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { Command, Option } from "commander";
-import { createConnection, createServer } from "node:net";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { randomUUID } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { nanoid } from "nanoid";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -30,509 +34,784 @@ var __exportAll = (all, symbols) => {
 //#endregion
 //#region src/daemon/registry.ts
 /**
-* Session Registry — Directory-per-session design.
+* Daemon Registry
 *
-* Each session is stored as its own file: sessions/{id}.json
-* Only the owning daemon process writes to its session file.
-* No shared mutable state → no locks needed.
+* Discovery: daemon.json = { pid, host, port, startedAt }
+* One daemon process on a fixed port. Clients read daemon.json to find it.
 *
-* Default session ID is stored in a separate file: default
+* Legacy: per-session files in sessions/{id}.json (deprecated, kept for transition)
 */
 const CONFIG_DIR = join(homedir(), ".agent-worker");
 const SESSIONS_DIR = join(CONFIG_DIR, "sessions");
+const DEFAULT_PORT = 5099;
+const DAEMON_FILE = join(CONFIG_DIR, "daemon.json");
 const DEFAULT_FILE = join(CONFIG_DIR, "default");
-const DURATION_RE = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/;
-/**
-* Parse a duration string like "30s", "5m", "2h" into milliseconds.
-* Returns null if not a valid duration format.
-*/
-function parseDuration(value) {
-	const match = value.match(DURATION_RE);
-	if (!match) return null;
-	return parseFloat(match[1]) * {
-		ms: 1,
-		s: 1e3,
-		m: 60 * 1e3,
-		h: 3600 * 1e3,
-		d: 1440 * 60 * 1e3
-	}[match[2]];
-}
-/**
-* Resolve a wakeup value into a typed schedule.
-* - number → interval (ms)
-* - "30s"/"5m"/"2h" → interval (converted to ms)
-* - cron expression → cron
-*/
-function resolveSchedule(config) {
-	const { wakeup, prompt } = config;
-	if (typeof wakeup === "number") {
-		if (wakeup <= 0) throw new Error("Wakeup interval must be positive");
-		return {
-			type: "interval",
-			ms: wakeup,
-			prompt
-		};
-	}
-	const ms = parseDuration(wakeup);
-	if (ms !== null) {
-		if (ms <= 0) throw new Error("Wakeup duration must be positive");
-		return {
-			type: "interval",
-			ms,
-			prompt
-		};
-	}
-	return {
-		type: "cron",
-		expr: wakeup,
-		prompt
-	};
-}
-function ensureDirs() {
-	mkdirSync(SESSIONS_DIR, { recursive: true });
-}
-/** Path to a session's metadata file */
-function sessionFile(id) {
-	return join(SESSIONS_DIR, `${id}.json`);
-}
-/** Read all session metadata files from the sessions directory */
-function readAllSessions() {
-	ensureDirs();
-	const entries = [];
-	for (const file of readdirSync(SESSIONS_DIR)) {
-		if (!file.endsWith(".json")) continue;
-		try {
-			entries.push(JSON.parse(readFileSync(join(SESSIONS_DIR, file), "utf-8")));
-		} catch {}
-	}
-	return entries;
+/** Write daemon.json for client discovery */
+function writeDaemonInfo(info) {
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(DAEMON_FILE, JSON.stringify(info, null, 2));
 }
-function readDefault() {
+/** Read daemon.json. Returns null if missing or malformed. */
+function readDaemonInfo() {
 	try {
-		return readFileSync(DEFAULT_FILE, "utf-8").trim() || void 0;
+		return JSON.parse(readFileSync(DAEMON_FILE, "utf-8"));
 	} catch {
-		return;
+		return null;
 	}
 }
-function registerSession(info) {
-	ensureDirs();
-	writeFileSync(sessionFile(info.id), JSON.stringify(info, null, 2));
-	if (!readDefault()) writeFileSync(DEFAULT_FILE, info.id);
-}
-function unregisterSession(idOrName) {
-	const info = getSessionInfo(idOrName);
-	if (!info) return;
+/** Remove daemon.json (on shutdown) */
+function removeDaemonInfo() {
 	try {
-		unlinkSync(sessionFile(info.id));
+		unlinkSync(DAEMON_FILE);
 	} catch {}
-	if (readDefault() === info.id) {
-		const remaining = readAllSessions();
-		if (remaining.length > 0) writeFileSync(DEFAULT_FILE, remaining[0].id);
-		else try {
-			unlinkSync(DEFAULT_FILE);
-		} catch {}
-	}
-}
-function getSessionInfo(idOrName) {
-	if (!idOrName) {
-		const defaultId = readDefault();
-		if (defaultId) return getSessionInfo(defaultId);
-		const sessions = readAllSessions();
-		if (sessions.length === 1) return sessions[0] ?? null;
-		return null;
-	}
-	const filePath = sessionFile(idOrName);
-	if (existsSync(filePath)) try {
-		return JSON.parse(readFileSync(filePath, "utf-8"));
-	} catch {
-		return null;
-	}
-	const sessions = readAllSessions();
-	const byName = sessions.find((s) => s.name === idOrName);
-	if (byName) return byName;
-	const prefixMatches = sessions.filter((s) => s.id.startsWith(idOrName));
-	if (prefixMatches.length === 1) return prefixMatches[0];
-	return null;
-}
-function listSessions() {
-	return readAllSessions();
-}
-function setDefaultSession(idOrName) {
-	const info = getSessionInfo(idOrName);
-	if (!info) return false;
-	ensureDirs();
-	writeFileSync(DEFAULT_FILE, info.id);
-	return true;
 }
-function isSessionRunning(idOrName) {
-	const info = getSessionInfo(idOrName);
-	if (!info) return false;
+/** Check if a daemon is already running (daemon.json exists + PID alive) */
+function isDaemonRunning() {
+	const info = readDaemonInfo();
+	if (!info) return null;
 	try {
 		process.kill(info.pid, 0);
-		return true;
+		return info;
 	} catch {
-		if (existsSync(info.socketPath)) unlinkSync(info.socketPath);
-		if (existsSync(info.pidFile)) unlinkSync(info.pidFile);
-		if (info.readyFile && existsSync(info.readyFile)) unlinkSync(info.readyFile);
-		unregisterSession(info.id);
-		return false;
+		removeDaemonInfo();
+		return null;
 	}
 }
+
+//#endregion
+//#region src/agent/handle.ts
 /**
-* Wait for a session to be ready (ready file exists)
-* Returns session info if ready, null if timeout
+* LocalWorker — In-process execution via AgentWorker.
+*
+* Wraps an AgentWorker instance. State lives in the AgentWorker's memory.
+* This is the default for single-machine deployments.
 */
-async function waitForReady(nameOrId, timeoutMs = 5e3) {
-	const start = Date.now();
-	const pollInterval = 50;
-	while (Date.now() - start < timeoutMs) {
-		const info = getSessionInfo(nameOrId);
-		if (info?.readyFile && existsSync(info.readyFile)) return info;
-		await new Promise((resolve) => setTimeout(resolve, pollInterval));
+var LocalWorker = class {
+	engine;
+	constructor(config, restore) {
+		const backend = config.backend !== "default" ? createBackend({
+			type: config.backend,
+			model: config.model
+		}) : void 0;
+		this.engine = new AgentWorker({
+			model: config.model,
+			system: config.system,
+			tools: {},
+			backend
+		}, restore);
+	}
+	send(input, options) {
+		return this.engine.send(input, options);
+	}
+	sendStream(input, options) {
+		return this.engine.sendStream(input, options);
+	}
+	getState() {
+		return this.engine.getState();
+	}
+};
+
+//#endregion
+//#region src/agent/store.ts
+/**
+* In-memory state store. State is lost when the daemon stops.
+* Suitable for development and single-machine deployments.
+*/
+var MemoryStateStore = class {
+	states = /* @__PURE__ */ new Map();
+	async load(agentId) {
+		return this.states.get(agentId) ?? null;
 	}
-	return null;
+	async save(agentId, state) {
+		this.states.set(agentId, state);
+	}
+	async delete(agentId) {
+		this.states.delete(agentId);
+	}
+};
+
+//#endregion
+//#region src/daemon/serve.ts
+/**
+* Start an HTTP server for a Hono app.
+* Auto-detects runtime: Bun.serve() when available, @hono/node-server otherwise.
+*/
+async function startHttpServer(app, options) {
+	if (typeof globalThis.Bun !== "undefined") return startBun(app, options);
+	return startNode(app, options);
+}
+function startBun(app, options) {
+	const server = Bun.serve({
+		fetch: app.fetch,
+		port: options.port,
+		hostname: options.hostname
+	});
+	return {
+		port: server.port ?? options.port,
+		close: async () => server.stop(true)
+	};
+}
+async function startNode(app, options) {
+	const mod = await import("@hono/node-server");
+	return new Promise((resolve, reject) => {
+		const server = mod.serve({
+			fetch: app.fetch,
+			port: options.port,
+			hostname: options.hostname
+		}, (info) => {
+			resolve({
+				port: info.port,
+				close: () => new Promise((r) => server.close(() => r()))
+			});
+		});
+		server.on("error", reject);
+	});
 }
+
+//#endregion
+//#region src/workflow/context/event-log.ts
+var EventLog = class {
+	constructor(provider) {
+		this.provider = provider;
+	}
+	/** Record a tool invocation (MCP, SDK, or backend native) */
+	toolCall(agent, name, args, source) {
+		this.provider.appendChannel(agent, `${name}(${args})`, {
+			kind: "tool_call",
+			toolCall: {
+				name,
+				args,
+				source
+			}
+		}).catch(() => {});
+	}
+	/** Record an operational log (workflow lifecycle, warnings, errors) */
+	system(from, message) {
+		this.provider.appendChannel(from, message, { kind: "system" }).catch(() => {});
+	}
+	/** Record backend streaming text output (not tool calls) */
+	output(agent, text) {
+		this.provider.appendChannel(agent, text, { kind: "output" }).catch(() => {});
+	}
+	/** Record debug-level detail (only shown with --debug) */
+	debug(from, message) {
+		this.provider.appendChannel(from, message, { kind: "debug" }).catch(() => {});
+	}
+};
+
+//#endregion
+//#region src/workflow/context/mcp/helpers.ts
 /**
-* Get all sessions belonging to an instance.
+* Extract agent ID from MCP extra context.
+* Session ID format: "agentName-uuid8chars" — extract agent name.
 */
-function getInstanceAgents(instance) {
-	return readAllSessions().filter((s) => s.instance === instance);
+function getAgentId(extra) {
+	if (!extra || typeof extra !== "object") return void 0;
+	if ("sessionId" in extra && typeof extra.sessionId === "string") {
+		const sid = extra.sessionId;
+		const match = sid.match(/^(.+)-[0-9a-f]{8}$/);
+		return match ? match[1] : sid;
+	}
+	if ("meta" in extra && extra.meta && typeof extra.meta === "object") {
+		const meta = extra.meta;
+		if ("agentId" in meta && typeof meta.agentId === "string") return meta.agentId;
+	}
 }
 /**
-* Get agent display names (before @) for all agents in an instance.
+* Format inbox messages for JSON display.
 */
-function getInstanceAgentNames(instance) {
-	return getInstanceAgents(instance).map((s) => {
-		if (!s.name) return null;
-		const atIndex = s.name.indexOf("@");
-		return atIndex === -1 ? s.name : s.name.slice(0, atIndex);
-	}).filter((n) => n !== null);
+function formatInbox(messages) {
+	if (messages.length === 0) return JSON.stringify({
+		messages: [],
+		count: 0
+	});
+	return JSON.stringify({
+		messages: messages.map((m) => ({
+			id: m.entry.id,
+			from: m.entry.from,
+			content: m.entry.content,
+			timestamp: m.entry.timestamp,
+			priority: m.priority
+		})),
+		count: messages.length
+	});
 }
 /**
-* Extract agent display name from session name (part before @).
+* Format tool call parameters as a concise string.
 */
-function getAgentDisplayName(sessionName) {
-	const atIndex = sessionName.indexOf("@");
-	return atIndex === -1 ? sessionName : sessionName.slice(0, atIndex);
+function formatToolParams(params) {
+	return Object.entries(params).filter(([_, v]) => v !== void 0).map(([k, v]) => {
+		const val = typeof v === "string" && v.length > 50 ? v.slice(0, 50) + "..." : v;
+		return `${k}=${JSON.stringify(val)}`;
+	}).join(", ");
 }
 /**
-* Generate next available agent name in sequence: a0, a1, ..., a9, b0, ..., z9.
-* Checks existing sessions to avoid collisions.
+* Create a logTool function that records tool calls via EventLog.
 */
-function generateAutoName() {
-	const sessions = readAllSessions();
-	const usedNames = /* @__PURE__ */ new Set();
-	for (const s of sessions) if (s.name) {
-		const atIndex = s.name.indexOf("@");
-		usedNames.add(atIndex === -1 ? s.name : s.name.slice(0, atIndex));
-	}
-	for (let letter = 0; letter < 26; letter++) for (let digit = 0; digit < 10; digit++) {
-		const name = String.fromCharCode(97 + letter) + digit;
-		if (!usedNames.has(name)) return name;
-	}
-	return `agent-${crypto.randomUUID().slice(0, 6)}`;
+function createLogTool(eventLog) {
+	return (tool, agent, params) => {
+		if (!agent) return;
+		const args = formatToolParams(params);
+		eventLog.toolCall(agent, tool, args, "mcp");
+	};
 }
 
 //#endregion
-//#region src/daemon/cron.ts
-/**
-* Minimal cron expression parser.
-* Supports standard 5-field cron: minute hour day-of-month month day-of-week
-*
-* Field syntax:
-*   *       every value
-*   N       exact value
-*   N-M     range (inclusive)
-*   N,M,O   list
-*   * /step  every step (e.g. * /15 = 0,15,30,45)  [no space — formatting only]
-*   N-M/step range with step
-*/
-function range(min, max) {
-	const r = [];
-	for (let i = min; i <= max; i++) r.push(i);
-	return r;
+//#region src/workflow/context/mcp/channel.ts
+const CHANNEL_MSG_LIMIT = 2e3;
+function registerChannelTools(server, ctx, options) {
+	const { provider, getAgentId, logTool } = ctx;
+	const { onMention } = options ?? {};
+	server.tool("channel_send", `Send a message to the shared channel. Use @agent to mention/notify. Use "to" for private DMs. Long messages (> ${CHANNEL_MSG_LIMIT} chars) are automatically converted to resources.`, {
+		message: z.string().describe("Message content, can include @mentions like @reviewer or @coder. Long messages are auto-converted to resources."),
+		to: z.string().optional().describe("Send as DM to a specific agent (private, only you and recipient see it)")
+	}, async ({ message, to }, extra) => {
+		const from = getAgentId(extra) || "anonymous";
+		logTool("channel_send", from, {
+			message,
+			to
+		});
+		const sendOpts = to ? { to } : void 0;
+		const msg = await provider.smartSend(from, message, sendOpts);
+		for (const target of msg.mentions) onMention?.(from, target, msg);
+		if (to && !msg.mentions.includes(to)) onMention?.(from, to, msg);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "sent",
+				timestamp: msg.timestamp,
+				mentions: msg.mentions,
+				to: msg.to
+			})
+		}] };
+	});
+	server.tool("channel_read", "Read messages from the shared channel. DMs and logs are automatically filtered based on your identity.", {
+		since: z.string().optional().describe("Read entries after this timestamp (ISO format)"),
+		limit: z.number().optional().describe("Maximum entries to return")
+	}, async ({ since, limit }, extra) => {
+		const agent = getAgentId(extra);
+		logTool("channel_read", agent, {
+			since,
+			limit
+		});
+		const entries = await provider.readChannel({
+			since,
+			limit,
+			agent
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(entries)
+		}] };
+	});
 }
-function parseIntStrict(s, context) {
-	const n = parseInt(s, 10);
-	if (isNaN(n)) throw new Error(`Invalid number "${s}" in ${context}`);
-	return n;
+
+//#endregion
+//#region src/workflow/context/mcp/resource.ts
+function registerResourceTools(server, ctx) {
+	const { provider, getAgentId, logTool } = ctx;
+	server.tool("resource_create", "Store large content as a resource. Returns a reference (resource:id) usable in channel messages or documents.", {
+		content: z.string().describe("Content to store as resource"),
+		type: z.enum([
+			"markdown",
+			"json",
+			"text",
+			"diff"
+		]).optional().describe("Content type hint (default: text)")
+	}, async ({ content, type }, extra) => {
+		const createdBy = getAgentId(extra) || "anonymous";
+		logTool("resource_create", createdBy, {
+			type,
+			contentLen: content.length
+		});
+		const result = await provider.createResource(content, createdBy, type);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				id: result.id,
+				ref: result.ref,
+				hint: `Use [description](${result.ref}) in messages or documents`
+			})
+		}] };
+	});
+	server.tool("resource_read", "Read resource content by ID. Use when you encounter resource:id references.", { id: z.string().describe("Resource ID (e.g., res_abc123)") }, async ({ id }) => {
+		const content = await provider.readResource(id);
+		if (content === null) return { content: [{
+			type: "text",
+			text: JSON.stringify({ error: `Resource not found: ${id}` })
+		}] };
+		return { content: [{
+			type: "text",
+			text: content
+		}] };
+	});
 }
-function parseCronField(field, min, max) {
-	const values = /* @__PURE__ */ new Set();
-	for (const part of field.split(",")) if (part === "*") for (const v of range(min, max)) values.add(v);
-	else if (part.includes("/")) {
-		const [rangeStr, stepStr] = part.split("/");
-		const step = parseIntStrict(stepStr, `step "${part}"`);
-		if (step <= 0) throw new Error(`Invalid step: ${part}`);
-		let lo = min;
-		let hi = max;
-		if (rangeStr !== "*") if (rangeStr.includes("-")) {
-			const parts = rangeStr.split("-");
-			lo = parseIntStrict(parts[0], `range "${part}"`);
-			hi = parseIntStrict(parts[1], `range "${part}"`);
-		} else {
-			lo = parseIntStrict(rangeStr, `field "${part}"`);
-			hi = max;
-		}
-		for (let v = lo; v <= hi; v += step) values.add(v);
-	} else if (part.includes("-")) {
-		const parts = part.split("-");
-		const lo = parseIntStrict(parts[0], `range "${part}"`);
-		const hi = parseIntStrict(parts[1], `range "${part}"`);
-		for (const v of range(lo, hi)) values.add(v);
-	} else values.add(parseIntStrict(part, `field "${field}"`));
-	return values;
+
+//#endregion
+//#region src/workflow/context/mcp/inbox.ts
+function registerInboxTools(server, ctx, options) {
+	const { provider, getAgentId, logTool } = ctx;
+	const { debugLog } = options ?? {};
+	server.tool("my_inbox", "Check your unread inbox messages. Does NOT acknowledge — use my_inbox_ack after processing.", {}, async (_args, extra) => {
+		const agent = getAgentId(extra) || "anonymous";
+		logTool("my_inbox", agent, {});
+		const messages = await provider.getInbox(agent);
+		if (debugLog && messages.length > 0) debugLog(`[mcp:${agent}] my_inbox → ${messages.length} unread`);
+		return { content: [{
+			type: "text",
+			text: formatInbox(messages)
+		}] };
+	});
+	server.tool("my_inbox_ack", "Acknowledge inbox messages up to a message ID. Call after processing messages.", { until: z.string().describe("Acknowledge messages up to and including this message ID") }, async ({ until }, extra) => {
+		const agent = getAgentId(extra) || "anonymous";
+		logTool("my_inbox_ack", agent, { until });
+		await provider.ackInbox(agent, until);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "acknowledged",
+				until
+			})
+		}] };
+	});
+	server.tool("my_status_set", "Update your status and current task. Call when starting or completing work.", {
+		task: z.string().optional().describe("Current task description (what you're working on)"),
+		state: z.enum(["idle", "running"]).optional().describe("Agent state (running = working, idle = available)"),
+		metadata: z.record(z.unknown()).optional().describe("Additional metadata (e.g., PR number, file path)")
+	}, async (args, extra) => {
+		const agent = getAgentId(extra) || "anonymous";
+		logTool("my_status_set", agent, args);
+		const status = {};
+		if (args.task !== void 0) status.task = args.task;
+		if (args.state !== void 0) status.state = args.state;
+		if (args.metadata !== void 0) status.metadata = args.metadata;
+		await provider.setAgentStatus(agent, status);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "updated",
+				agent,
+				...status
+			})
+		}] };
+	});
 }
-/**
-* Parse a 5-field cron expression into sets of matching values.
-*/
-function parseCron(expr) {
-	const parts = expr.trim().split(/\s+/);
-	if (parts.length !== 5) throw new Error(`Invalid cron expression (expected 5 fields): ${expr}`);
-	return {
-		minutes: parseCronField(parts[0], 0, 59),
-		hours: parseCronField(parts[1], 0, 23),
-		daysOfMonth: parseCronField(parts[2], 1, 31),
-		months: parseCronField(parts[3], 1, 12),
-		daysOfWeek: parseCronField(parts[4], 0, 6)
-	};
+
+//#endregion
+//#region src/workflow/context/mcp/team.ts
+function registerTeamTools(server, ctx) {
+	const { provider, validAgents, getAgentId, logTool } = ctx;
+	server.tool("team_members", "List all agents in this workflow. Use to discover who you can @mention. Optionally includes agent status (state, current task).", { includeStatus: z.boolean().optional().describe("Include agent status information") }, async (args, extra) => {
+		const currentAgent = getAgentId(extra) || "anonymous";
+		const includeStatus = args.includeStatus ?? false;
+		const agents = validAgents.map((name) => ({
+			name,
+			mention: `@${name}`,
+			isYou: name === currentAgent
+		}));
+		const result = {
+			agents,
+			count: agents.length,
+			hint: "Use @agent in channel_send to mention other agents"
+		};
+		if (includeStatus) result.status = await provider.listAgentStatus();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result)
+		}] };
+	});
+	server.tool("team_doc_read", "Read a shared team document.", { file: z.string().optional().describe("Document file path (default: notes.md)") }, async ({ file }, extra) => {
+		logTool("team_doc_read", getAgentId(extra), { file });
+		return { content: [{
+			type: "text",
+			text: await provider.readDocument(file) || "(empty document)"
+		}] };
+	});
+	server.tool("team_doc_write", "Write/replace a shared team document.", {
+		content: z.string().describe("New document content (replaces existing)"),
+		file: z.string().optional().describe("Document file path (default: notes.md)")
+	}, async ({ content, file }, extra) => {
+		logTool("team_doc_write", getAgentId(extra), {
+			file,
+			contentLen: content.length
+		});
+		await provider.writeDocument(content, file);
+		return { content: [{
+			type: "text",
+			text: `Document ${file || "notes.md"} written successfully`
+		}] };
+	});
+	server.tool("team_doc_append", "Append content to a shared team document.", {
+		content: z.string().describe("Content to append to the document"),
+		file: z.string().optional().describe("Document file path (default: notes.md)")
+	}, async ({ content, file }, extra) => {
+		logTool("team_doc_append", getAgentId(extra), {
+			file,
+			contentLen: content.length
+		});
+		await provider.appendDocument(content, file);
+		return { content: [{
+			type: "text",
+			text: `Content appended to ${file || "notes.md"}`
+		}] };
+	});
+	server.tool("team_doc_list", "List all shared team document files.", {}, async () => {
+		const files = await provider.listDocuments();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				files,
+				count: files.length
+			})
+		}] };
+	});
+	server.tool("team_doc_create", "Create a new shared team document file.", {
+		file: z.string().describe("Document file path (e.g., \"findings/auth.md\")"),
+		content: z.string().describe("Initial document content")
+	}, async ({ file, content }) => {
+		await provider.createDocument(file, content);
+		return { content: [{
+			type: "text",
+			text: `Document ${file} created successfully`
+		}] };
+	});
 }
+
+//#endregion
+//#region src/workflow/context/proposals.ts
 /**
-* Check if a Date matches a parsed cron expression.
+* Format a proposal for display
 */
-function matchesCron(date, fields) {
-	return fields.minutes.has(date.getMinutes()) && fields.hours.has(date.getHours()) && fields.daysOfMonth.has(date.getDate()) && fields.months.has(date.getMonth() + 1) && fields.daysOfWeek.has(date.getDay());
+function formatProposal(proposal) {
+	const lines = [];
+	lines.push(`📋 **${proposal.title}** (${proposal.id})`);
+	lines.push(`Type: ${proposal.type} | Status: ${proposal.status}`);
+	if (proposal.description) lines.push(`\n${proposal.description}`);
+	lines.push("\nOptions:");
+	for (const option of proposal.options) {
+		const count = proposal.result?.counts[option.id] || 0;
+		const marker = proposal.result?.winner === option.id ? "✓ " : "  ";
+		lines.push(`${marker}- ${option.label} (${option.id}): ${count} votes`);
+	}
+	if (proposal.result && Object.keys(proposal.result.votes).length > 0) {
+		lines.push("\nVotes:");
+		for (const [voter, choice] of Object.entries(proposal.result.votes)) lines.push(`  @${voter} → ${choice}`);
+	}
+	if (proposal.status === "active" && proposal.expiresAt) {
+		const remaining = new Date(proposal.expiresAt).getTime() - Date.now();
+		const minutes = Math.max(0, Math.floor(remaining / 6e4));
+		lines.push(`\nExpires in: ${minutes} minutes`);
+	}
+	if (proposal.status === "resolved" && proposal.result?.winner) {
+		const winningOption = proposal.options.find((o) => o.id === proposal.result?.winner);
+		lines.push(`\n🏆 Winner: ${winningOption?.label || proposal.result.winner}`);
+	}
+	return lines.join("\n");
 }
 /**
-* Calculate the next occurrence of a cron expression after `from`.
-* Searches forward minute-by-minute, up to 1 year.
-* Returns the Date of the next match.
+* Format multiple proposals as a summary
 */
-function nextCronTime(expr, from = /* @__PURE__ */ new Date()) {
-	const fields = parseCron(expr);
-	const next = new Date(from);
-	next.setSeconds(0, 0);
-	next.setMinutes(next.getMinutes() + 1);
-	const maxMinutes = 366 * 24 * 60;
-	for (let i = 0; i < maxMinutes; i++) {
-		if (matchesCron(next, fields)) return next;
-		next.setMinutes(next.getMinutes() + 1);
-	}
-	throw new Error(`No matching cron time found within 1 year: ${expr}`);
+function formatProposalList(proposals) {
+	if (proposals.length === 0) return "(no proposals)";
+	return proposals.map((p) => {
+		const votes = Object.keys(p.result?.votes || {}).length;
+		return `- ${p.id}: ${p.title} [${p.status}] (${votes} votes)`;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/workflow/context/mcp/proposal.ts
+function registerProposalTools(server, ctx, proposalManager) {
+	const { provider, validAgents, getAgentId } = ctx;
+	server.tool("team_proposal_create", "Create a new proposal for team voting. Use for decisions, elections, approvals, or assignments.", {
+		type: z.enum([
+			"election",
+			"decision",
+			"approval",
+			"assignment"
+		]).describe("Type of proposal"),
+		title: z.string().describe("Brief title for the proposal"),
+		description: z.string().optional().describe("Detailed description"),
+		options: z.array(z.object({
+			id: z.string().describe("Unique option identifier"),
+			label: z.string().describe("Display label for the option")
+		})).optional().describe("Voting options (required except for approval type)"),
+		resolution: z.object({
+			type: z.enum([
+				"plurality",
+				"majority",
+				"unanimous"
+			]).optional().describe("How to determine winner"),
+			quorum: z.number().optional().describe("Minimum votes required"),
+			tieBreaker: z.enum([
+				"first",
+				"random",
+				"creator-decides"
+			]).optional().describe("How to break ties")
+		}).optional().describe("Resolution rules"),
+		binding: z.boolean().optional().describe("Whether result is binding (default: true)"),
+		timeoutSeconds: z.number().optional().describe("Timeout in seconds (default: 3600)")
+	}, async (params, extra) => {
+		const createdBy = getAgentId(extra) || "anonymous";
+		try {
+			const proposal = proposalManager.create({
+				type: params.type,
+				title: params.title,
+				description: params.description,
+				options: params.options,
+				resolution: params.resolution,
+				binding: params.binding,
+				timeoutSeconds: params.timeoutSeconds,
+				createdBy
+			});
+			const optionsList = proposal.options.map((o) => `${o.id}: ${o.label}`).join(", ");
+			const otherAgents = validAgents.filter((a) => a !== createdBy).map((a) => `@${a}`).join(" ");
+			await provider.appendChannel(createdBy, `Created proposal "${proposal.title}" (${proposal.id})\nOptions: ${optionsList}\nUse team_vote tool to cast your vote. ${otherAgents}`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "created",
+					proposal: {
+						id: proposal.id,
+						title: proposal.title,
+						options: proposal.options,
+						expiresAt: proposal.expiresAt
+					}
+				})
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "error",
+					error: error instanceof Error ? error.message : String(error)
+				})
+			}] };
+		}
+	});
+	server.tool("team_vote", "Cast your vote on a team proposal.", {
+		proposal: z.string().describe("Proposal ID (e.g., prop-1)"),
+		choice: z.string().describe("Option ID to vote for"),
+		reason: z.string().optional().describe("Optional reason for your vote")
+	}, async ({ proposal: proposalId, choice, reason }, extra) => {
+		const voter = getAgentId(extra) || "anonymous";
+		const result = proposalManager.vote({
+			proposalId,
+			voter,
+			choice,
+			reason
+		});
+		if (!result.success) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "error",
+				error: result.error
+			})
+		}] };
+		const reasonText = reason ? ` (reason: ${reason})` : "";
+		await provider.appendChannel(voter, `Voted "${choice}" on ${proposalId}${reasonText}`);
+		if (result.resolved && result.proposal) {
+			const winnerOption = result.proposal.options.find((o) => o.id === result.proposal.result?.winner);
+			const mentions = Object.keys(result.proposal.result?.votes || {}).map((v) => `@${v}`).join(" ");
+			await provider.appendChannel("system", `Proposal ${proposalId} resolved! Winner: ${winnerOption?.label || result.proposal.result?.winner || "none"} ${mentions}`);
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "voted",
+				proposal: proposalId,
+				choice,
+				resolved: result.resolved,
+				winner: result.proposal?.result?.winner
+			})
+		}] };
+	});
+	server.tool("team_proposal_status", "Check status of team proposals. Omit proposal ID to see all active proposals.", { proposal: z.string().optional().describe("Proposal ID (omit for all active)") }, async ({ proposal: proposalId }) => {
+		if (proposalId) {
+			const proposal = proposalManager.get(proposalId);
+			if (!proposal) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "error",
+					error: `Proposal not found: ${proposalId}`
+				})
+			}] };
+			return { content: [{
+				type: "text",
+				text: formatProposal(proposal)
+			}] };
+		}
+		const activeProposals = proposalManager.list("active");
+		return { content: [{
+			type: "text",
+			text: activeProposals.length > 0 ? formatProposalList(activeProposals) : "(no active proposals)"
+		}] };
+	});
+	server.tool("team_proposal_cancel", "Cancel a proposal you created.", { proposal: z.string().describe("Proposal ID to cancel") }, async ({ proposal: proposalId }, extra) => {
+		const cancelledBy = getAgentId(extra) || "anonymous";
+		const result = proposalManager.cancel(proposalId, cancelledBy);
+		if (!result.success) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "error",
+				error: result.error
+			})
+		}] };
+		await provider.appendChannel(cancelledBy, `Cancelled proposal ${proposalId}`);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "cancelled",
+				proposal: proposalId
+			})
+		}] };
+	});
 }
+
+//#endregion
+//#region src/workflow/context/mcp/feedback.ts
 /**
-* Calculate ms until the next cron occurrence.
+* Register the feedback_submit tool and return a getter for collected entries.
 */
-function msUntilNextCron(expr, from = /* @__PURE__ */ new Date()) {
-	return nextCronTime(expr, from).getTime() - from.getTime();
+function registerFeedbackTool(server, ctx) {
+	const { getAgentId, logTool } = ctx;
+	const entries = [];
+	server.tool("feedback_submit", "Report a workflow improvement need. Use when you hit something inconvenient — a missing tool, an awkward step, or a capability you wished you had.", {
+		target: z.string().describe("The area this is about — a tool name, a workflow step, or a general area (e.g. file search, code review)."),
+		type: z.enum([
+			"missing",
+			"friction",
+			"suggestion"
+		]).describe("missing: a tool or capability you needed but didn't have. friction: something that works but is awkward or slow. suggestion: a concrete improvement idea."),
+		description: z.string().describe("What you needed or what could be improved. Be specific."),
+		context: z.string().optional().describe("Optional: what you were trying to do when you hit this.")
+	}, async ({ target, type, description, context: ctx }, extra) => {
+		logTool("feedback_submit", getAgentId(extra) || "anonymous", {
+			target,
+			type
+		});
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			target,
+			type,
+			description,
+			...ctx ? { context: ctx } : {}
+		};
+		if (entries.length >= 50) entries.shift();
+		entries.push(entry);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ status: "recorded" })
+		}] };
+	});
+	return { getFeedback: () => [...entries] };
 }
 
 //#endregion
-//#region src/daemon/handler.ts
-async function handleRequest(getState, req, resetIdleTimer, gracefulShutdown, resetAllTimers) {
-	const state = getState();
-	if (!state) return {
-		success: false,
-		error: "No active session"
+//#region src/workflow/context/mcp/skills.ts
+function registerSkillsTools(server, provider) {
+	server.tool("skills_list", "List all available agent skills with their descriptions.", {}, async () => {
+		const skills = provider.list();
+		if (skills.length === 0) return { content: [{
+			type: "text",
+			text: JSON.stringify({ message: "No skills available" })
+		}] };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ skills: skills.map((s) => ({
+				name: s.name,
+				description: s.description
+			})) })
+		}] };
+	});
+	server.tool("skills_view", "Read the complete SKILL.md file for a skill.", { skillName: z.string().describe("Skill name to view") }, async ({ skillName }) => {
+		return { content: [{
+			type: "text",
+			text: await provider.view(skillName)
+		}] };
+	});
+	server.tool("skills_read", "Read a file within a skill directory (e.g., references/, scripts/, assets/).", {
+		skillName: z.string().describe("Skill name"),
+		filePath: z.string().describe("Relative file path within the skill (e.g., \"references/search-strategies.md\")")
+	}, async ({ skillName, filePath }) => {
+		return { content: [{
+			type: "text",
+			text: await provider.readFile(skillName, filePath)
+		}] };
+	});
+}
+
+//#endregion
+//#region src/workflow/context/mcp/server.ts
+/**
+* Context MCP Server — thin orchestrator.
+*
+* Creates an McpServer and registers tools from each category.
+* The actual tool implementations live in their own files:
+*   channel.ts, resource.ts, inbox.ts, team.ts, proposal.ts,
+*   feedback.ts, skills.ts
+*/
+function createContextMCPServer(options) {
+	const { provider, validAgents, name = "workflow-context", version = "1.0.0", onMention, proposalManager, feedback: feedbackEnabled, skills, debugLog } = options;
+	const server = new McpServer({
+		name,
+		version
+	});
+	const eventLog = new EventLog(provider);
+	const ctx = {
+		provider,
+		eventLog,
+		validAgents,
+		getAgentId,
+		logTool: createLogTool(eventLog)
 	};
-	state.pendingRequests++;
-	resetIdleTimer();
-	const { session, info } = state;
-	try {
-		switch (req.action) {
-			case "ping": return {
-				success: true,
-				data: {
-					id: info.id,
-					model: info.model,
-					backend: info.backend,
-					name: info.name
-				}
-			};
-			case "send": {
-				const { message, options, async: isAsync } = req.payload;
-				if (isAsync) {
-					session.send(message, options).catch((error) => {
-						console.error("Background send error:", error);
-					});
-					return {
-						success: true,
-						data: {
-							async: true,
-							message: "Processing in background. Use `peek` to check the response."
-						}
-					};
-				}
-				return {
-					success: true,
-					data: await session.send(message, options)
-				};
-			}
-			case "tool_add": {
-				const { name, description, parameters, needsApproval } = req.payload;
-				const t = tool({
-					description,
-					inputSchema: jsonSchema(parameters),
-					execute: async () => ({ error: "No implementation - use tool mock to set response" })
-				});
-				session.addTool(name, t);
-				if (needsApproval) session.setApproval(name, true);
-				return {
-					success: true,
-					data: { name }
-				};
-			}
-			case "tool_mock": {
-				const { name, response } = req.payload;
-				session.setMockResponse(name, response);
-				return {
-					success: true,
-					data: { name }
-				};
-			}
-			case "tool_list": return {
-				success: true,
-				data: session.getTools()
-			};
-			case "tool_import": {
-				if (!session.supportsTools) return {
-					success: false,
-					error: "Tool import not supported for CLI backends"
-				};
-				const { filePath } = req.payload;
-				if (!filePath || typeof filePath !== "string") return {
-					success: false,
-					error: "File path is required"
-				};
-				let module;
-				try {
-					module = await import(filePath);
-				} catch (importError) {
-					return {
-						success: false,
-						error: `Failed to import file: ${(importError instanceof Error ? importError.message : String(importError)).replace(filePath, "<file>")}`
-					};
-				}
-				let toolsRecord = {};
-				if (module.default && typeof module.default === "object" && !Array.isArray(module.default)) toolsRecord = module.default;
-				else if (typeof module.default === "function") try {
-					const result = await module.default();
-					if (result && typeof result === "object" && !Array.isArray(result)) toolsRecord = result;
-				} catch (factoryError) {
-					return {
-						success: false,
-						error: `Factory function failed: ${factoryError instanceof Error ? factoryError.message : String(factoryError)}`
-					};
-				}
-				else if (module.tools && typeof module.tools === "object" && !Array.isArray(module.tools)) toolsRecord = module.tools;
-				else return {
-					success: false,
-					error: "No tools found. Export default Record<name, tool()> or named \"tools\" Record."
-				};
-				const imported = [];
-				for (const [name, t] of Object.entries(toolsRecord)) if (t && typeof t === "object") {
-					session.addTool(name, t);
-					imported.push(name);
-				}
-				return {
-					success: true,
-					data: { imported }
-				};
-			}
-			case "history": return {
-				success: true,
-				data: session.history()
-			};
-			case "stats": return {
-				success: true,
-				data: session.stats()
-			};
-			case "export": return {
-				success: true,
-				data: session.export()
-			};
-			case "clear":
-				session.clear();
-				return { success: true };
-			case "pending": return {
-				success: true,
-				data: session.getPendingApprovals()
-			};
-			case "approve": {
-				const { id } = req.payload;
-				return {
-					success: true,
-					data: await session.approve(id)
-				};
-			}
-			case "deny": {
-				const { id, reason } = req.payload;
-				session.deny(id, reason);
-				return { success: true };
-			}
-			case "feedback_list":
-				if (!state.getFeedback) return {
-					success: false,
-					error: "Feedback not enabled. Start agent with --feedback"
-				};
-				return {
-					success: true,
-					data: state.getFeedback()
-				};
-			case "schedule_get": return {
-				success: true,
-				data: info.schedule ?? null
-			};
-			case "schedule_set": {
-				const payload = req.payload;
-				if (!payload?.wakeup && payload?.wakeup !== 0) return {
-					success: false,
-					error: "Invalid schedule: provide wakeup (number ms, duration string, or cron expression)"
-				};
-				const schedule = {
-					wakeup: payload.wakeup,
-					prompt: payload.prompt
-				};
-				try {
-					const resolved = resolveSchedule(schedule);
-					if (resolved.type === "cron") parseCron(resolved.expr);
-				} catch (error) {
-					return {
-						success: false,
-						error: error instanceof Error ? error.message : String(error)
-					};
-				}
-				info.schedule = schedule;
-				if (resetAllTimers) resetAllTimers();
-				return {
-					success: true,
-					data: info.schedule
-				};
-			}
-			case "schedule_clear":
-				info.schedule = void 0;
-				if (resetAllTimers) resetAllTimers();
-				return { success: true };
-			case "shutdown":
-				state.pendingRequests--;
-				setTimeout(() => gracefulShutdown(), 100);
-				return {
-					success: true,
-					data: "Shutting down"
-				};
-			default: return {
-				success: false,
-				error: `Unknown action: ${req.action}`
-			};
-		}
-	} catch (error) {
-		return {
-			success: false,
-			error: error instanceof Error ? error.message : String(error)
-		};
-	} finally {
-		if (getState() && req.action !== "shutdown") state.pendingRequests--;
+	const agentConnections = /* @__PURE__ */ new Map();
+	const mcpToolNames = new Set([
+		"channel_send",
+		"channel_read",
+		"resource_create",
+		"resource_read",
+		"my_inbox",
+		"my_inbox_ack",
+		"my_status_set",
+		"team_members",
+		"team_doc_read",
+		"team_doc_write",
+		"team_doc_append",
+		"team_doc_list",
+		"team_doc_create"
+	]);
+	registerChannelTools(server, ctx, { onMention });
+	registerResourceTools(server, ctx);
+	registerInboxTools(server, ctx, { debugLog });
+	registerTeamTools(server, ctx);
+	if (proposalManager) {
+		registerProposalTools(server, ctx, proposalManager);
+		mcpToolNames.add("team_proposal_create");
+		mcpToolNames.add("team_vote");
+		mcpToolNames.add("team_proposal_status");
+		mcpToolNames.add("team_proposal_cancel");
+	}
+	let getFeedback = () => [];
+	if (feedbackEnabled) {
+		getFeedback = registerFeedbackTool(server, ctx).getFeedback;
+		mcpToolNames.add("feedback_submit");
+	}
+	if (skills) {
+		registerSkillsTools(server, skills);
+		mcpToolNames.add("skills_list");
+		mcpToolNames.add("skills_view");
+		mcpToolNames.add("skills_read");
 	}
+	return {
+		server,
+		agentConnections,
+		validAgents,
+		proposalManager,
+		getFeedback,
+		mcpToolNames,
+		eventLog
+	};
 }
 
 //#endregion
@@ -673,7 +952,7 @@ var ContextProviderImpl = class {
 		if (options?.agent) {
 			const agent = options.agent;
 			entries = entries.filter((e) => {
-				if (e.kind === "log" || e.kind === "debug" || e.kind === "stream") return false;
+				if (e.kind === "system" || e.kind === "debug" || e.kind === "output") return false;
 				if (e.to) return e.to === agent || e.from === agent;
 				return true;
 			});
@@ -719,7 +998,7 @@ var ContextProviderImpl = class {
 		let seenIdx = -1;
 		if (lastSeenId) seenIdx = entries.findIndex((e) => e.id === lastSeenId);
 		return entries.filter((e) => {
-			if (e.kind === "log" || e.kind === "debug" || e.kind === "stream") return false;
+			if (e.kind === "system" || e.kind === "debug" || e.kind === "output" || e.kind === "tool_call") return false;
 			if (e.from === agent) return false;
 			return e.mentions.includes(agent) || e.to === agent;
 		}).map((entry) => {
@@ -1142,610 +1421,597 @@ function createFileContextProvider(contextDir, validAgents) {
 }
 
 //#endregion
-//#region src/cli/target.ts
-var target_exports = /* @__PURE__ */ __exportAll({
-	DEFAULT_INSTANCE: () => DEFAULT_INSTANCE,
-	DEFAULT_TAG: () => DEFAULT_TAG,
-	DEFAULT_WORKFLOW: () => DEFAULT_WORKFLOW,
-	buildTarget: () => buildTarget,
-	buildTargetDisplay: () => buildTargetDisplay,
-	parseTarget: () => parseTarget
-});
+//#region src/daemon/daemon.ts
 /**
-* Target identifier utilities
+* Daemon — Centralized agent coordinator.
 *
-* Format: agent@workflow:tag (inspired by Docker image:tag)
-* - agent: agent name (optional for @workflow references)
-* - workflow: workflow name (optional, defaults to 'global')
-* - tag: workflow instance tag (optional, defaults to 'main')
+* Data ownership:
+*   Registry (configs)  — what agents exist and their configuration
+*   StateStore (store)  — conversation history and usage (pluggable)
+*   WorkerHandle (workers) — execution, local or remote
+*   Workflows (workflows) — running workflow instances with controllers
 *
-* Examples:
-* - "alice"              → { agent: "alice", workflow: "global", tag: "main", display: "alice" }
-* - "alice@review"       → { agent: "alice", workflow: "review", tag: "main", display: "alice@review" }
-* - "alice@review:pr-123"→ { agent: "alice", workflow: "review", tag: "pr-123", display: "alice@review:pr-123" }
-* - "@review"            → { agent: undefined, workflow: "review", tag: "main", display: "@review" }
-* - "@review:pr-123"     → { agent: undefined, workflow: "review", tag: "pr-123", display: "@review:pr-123" }
+* The daemon is pure glue: receive request → lookup config →
+* dispatch to worker → persist state → return response.
 *
-* Display rules:
-* - Omit @global (standalone agents): "alice" not "alice@global"
-* - Omit :main (default tag): "alice@review" not "alice@review:main"
-*/
-const DEFAULT_WORKFLOW = "global";
-const DEFAULT_TAG = "main";
-/**
-* Parse target identifier from string
-* Supports: "agent", "agent@workflow", "agent@workflow:tag", "@workflow", "@workflow:tag"
+* HTTP endpoints:
+*   GET  /health, POST /shutdown
+*   GET/POST /agents, GET/DELETE /agents/:name
+*   POST /run (SSE), POST /serve
+*   GET/POST /workflows, DELETE /workflows/:name/:tag
+*   ALL  /mcp
 */
-function parseTarget(input) {
-	if (input.startsWith("@")) {
-		const workflowPart = input.slice(1);
-		const colonIndex = workflowPart.indexOf(":");
-		if (colonIndex === -1) {
-			const workflow = workflowPart || DEFAULT_WORKFLOW;
+var daemon_exports = /* @__PURE__ */ __exportAll({
+	createDaemonApp: () => createDaemonApp,
+	startDaemon: () => startDaemon
+});
+let state = null;
+let shuttingDown = false;
+const mcpSessions = /* @__PURE__ */ new Map();
+async function gracefulShutdown() {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	if (state) {
+		for (const [, wf] of state.workflows) try {
+			await wf.shutdown();
+		} catch {}
+		state.workflows.clear();
+		for (const [name, handle] of state.workers) try {
+			await state.store.save(name, handle.getState());
+		} catch {}
+		if (state.server) await state.server.close();
+	}
+	for (const [, session] of mcpSessions) try {
+		await session.transport.close();
+	} catch {}
+	mcpSessions.clear();
+	removeDaemonInfo();
+	process.exit(0);
+}
+/** Safe JSON body parsing — returns null on malformed input */
+async function parseJsonBody(c) {
+	try {
+		return await c.req.json();
+	} catch {
+		return null;
+	}
+}
+function createDaemonApp(optionsOrGetState) {
+	const { getState, token } = typeof optionsOrGetState === "function" ? {
+		getState: optionsOrGetState,
+		token: void 0
+	} : optionsOrGetState;
+	const app = new Hono();
+	if (token) app.use("*", async (c, next) => {
+		if (c.req.header("authorization") !== `Bearer ${token}`) return c.json({ error: "Unauthorized" }, 401);
+		await next();
+	});
+	function getWorkflowAgentNames(workflow, tag) {
+		const s = getState();
+		if (!s) return [];
+		return [...s.configs.values()].filter((c) => c.workflow === workflow && c.tag === tag).map((c) => c.name);
+	}
+	app.get("/health", (c) => {
+		const s = getState();
+		if (!s) return c.json({ status: "unavailable" }, 503);
+		const standaloneAgents = [...s.configs.keys()];
+		const workflowList = [...s.workflows.values()].map((wf) => ({
+			name: wf.name,
+			tag: wf.tag,
+			agents: wf.agents
+		}));
+		return c.json({
+			status: "ok",
+			pid: process.pid,
+			port: s.port,
+			uptime: Date.now() - new Date(s.startedAt).getTime(),
+			agents: standaloneAgents,
+			workflows: workflowList
+		});
+	});
+	app.post("/shutdown", (c) => {
+		setImmediate(() => gracefulShutdown());
+		return c.json({ success: true });
+	});
+	app.get("/agents", (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const standaloneAgents = [...s.configs.values()].map((cfg) => ({
+			name: cfg.name,
+			model: cfg.model,
+			backend: cfg.backend,
+			workflow: cfg.workflow,
+			tag: cfg.tag,
+			createdAt: cfg.createdAt,
+			source: "standalone"
+		}));
+		const workflowAgents = [...s.workflows.values()].flatMap((wf) => wf.agents.map((agentName) => {
+			const controller = wf.controllers.get(agentName);
 			return {
-				agent: void 0,
-				workflow,
-				tag: DEFAULT_TAG,
-				full: `@${workflow}:${DEFAULT_TAG}`,
-				display: workflow === DEFAULT_WORKFLOW ? `@${workflow}` : `@${workflow}`
-			};
-		} else {
-			const workflow = workflowPart.slice(0, colonIndex) || DEFAULT_WORKFLOW;
-			const tag = workflowPart.slice(colonIndex + 1) || DEFAULT_TAG;
-			return {
-				agent: void 0,
-				workflow,
-				tag,
-				full: `@${workflow}:${tag}`,
-				display: buildDisplay(void 0, workflow, tag)
+				name: agentName,
+				model: "",
+				backend: "",
+				workflow: wf.name,
+				tag: wf.tag,
+				createdAt: wf.startedAt,
+				source: "workflow",
+				state: controller?.state ?? "unknown"
 			};
-		}
-	}
-	const atIndex = input.indexOf("@");
-	if (atIndex === -1) return {
-		agent: input,
-		workflow: DEFAULT_WORKFLOW,
-		tag: DEFAULT_TAG,
-		full: `${input}@${DEFAULT_WORKFLOW}:${DEFAULT_TAG}`,
-		display: input
-	};
-	const agent = input.slice(0, atIndex);
-	const workflowPart = input.slice(atIndex + 1);
-	const colonIndex = workflowPart.indexOf(":");
-	if (colonIndex === -1) {
-		const workflow = workflowPart || DEFAULT_WORKFLOW;
-		return {
-			agent,
-			workflow,
-			tag: DEFAULT_TAG,
-			full: `${agent}@${workflow}:${DEFAULT_TAG}`,
-			display: buildDisplay(agent, workflow, DEFAULT_TAG)
-		};
-	} else {
-		const workflow = workflowPart.slice(0, colonIndex) || DEFAULT_WORKFLOW;
-		const tag = workflowPart.slice(colonIndex + 1) || DEFAULT_TAG;
-		return {
-			agent,
+		}));
+		return c.json({ agents: [...standaloneAgents, ...workflowAgents] });
+	});
+	app.post("/agents", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { name, model, system, backend = "default", workflow = "global", tag = "main" } = body;
+		if (!name || !model || !system) return c.json({ error: "name, model, system required" }, 400);
+		if (s.configs.has(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
+		const agentConfig = {
+			name,
+			model,
+			system,
+			backend,
 			workflow,
 			tag,
-			full: `${agent}@${workflow}:${tag}`,
-			display: buildDisplay(agent, workflow, tag)
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
-	}
-}
-/**
-* Build display string following display rules:
-* - Omit @global for standalone agents
-* - Omit :main for default tag
-*/
-function buildDisplay(agent, workflow, tag) {
-	const isGlobal = workflow === DEFAULT_WORKFLOW;
-	const isMainTag = tag === DEFAULT_TAG;
-	if (agent === void 0) {
-		if (isMainTag) return `@${workflow}`;
-		return `@${workflow}:${tag}`;
-	}
-	if (isGlobal && isMainTag) return agent;
-	if (isGlobal && !isMainTag) return `${agent}@${workflow}:${tag}`;
-	if (!isGlobal && isMainTag) return `${agent}@${workflow}`;
-	return `${agent}@${workflow}:${tag}`;
-}
-/**
-* Build full target identifier from parts
-*/
-function buildTarget(agent, workflow, tag) {
-	const wf = workflow || DEFAULT_WORKFLOW;
-	const t = tag || DEFAULT_TAG;
-	if (agent === void 0) return `@${wf}:${t}`;
-	return `${agent}@${wf}:${t}`;
-}
-/**
-* Build display string from parts (following display rules)
-*/
-function buildTargetDisplay(agent, workflow, tag) {
-	return buildDisplay(agent, workflow || DEFAULT_WORKFLOW, tag || DEFAULT_TAG);
-}
-/**
-* @deprecated Use DEFAULT_WORKFLOW and DEFAULT_TAG instead
-*/
-const DEFAULT_INSTANCE = DEFAULT_WORKFLOW;
-
-//#endregion
-//#region src/daemon/daemon.ts
-const DEFAULT_SKILL_DIRS = [
-	".agents/skills",
-	".claude/skills",
-	".cursor/skills",
-	join(homedir(), ".agents/skills"),
-	join(homedir(), ".claude/skills")
-];
-/**
-* Setup skills provider and return Skills tool
-* Supports both local and imported skills
-* Skills are always loaded and provided as tools, regardless of backend
-*/
-async function setupSkills(sessionId, skillPaths, skillDirs, importSkills) {
-	const provider = new SkillsProvider();
-	for (const dir of DEFAULT_SKILL_DIRS) try {
-		provider.scanDirectorySync(dir);
-	} catch {}
-	if (skillDirs) for (const dir of skillDirs) try {
-		provider.scanDirectorySync(dir);
-	} catch (error) {
-		console.error(`Failed to scan skill directory ${dir}:`, error);
-	}
-	if (skillPaths) for (const skillPath of skillPaths) try {
-		provider.addSkillSync(skillPath);
-	} catch (error) {
-		console.error(`Failed to add skill ${skillPath}:`, error);
-	}
-	let importer;
-	if (importSkills && importSkills.length > 0) {
-		importer = new SkillImporter(sessionId);
+		const handle = new LocalWorker(agentConfig, await s.store.load(name) ?? void 0);
+		s.configs.set(name, agentConfig);
+		s.workers.set(name, handle);
+		return c.json({
+			name,
+			model,
+			backend,
+			workflow,
+			tag
+		}, 201);
+	});
+	app.get("/agents/:name", (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const cfg = s.configs.get(c.req.param("name"));
+		if (!cfg) return c.json({ error: "Agent not found" }, 404);
+		return c.json({
+			name: cfg.name,
+			model: cfg.model,
+			backend: cfg.backend,
+			system: cfg.system,
+			workflow: cfg.workflow,
+			tag: cfg.tag,
+			createdAt: cfg.createdAt
+		});
+	});
+	app.delete("/agents/:name", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const name = c.req.param("name");
+		if (!s.configs.delete(name)) return c.json({ error: "Agent not found" }, 404);
+		const handle = s.workers.get(name);
+		if (handle) try {
+			await s.store.save(name, handle.getState());
+		} catch {}
+		s.workers.delete(name);
+		return c.json({ success: true });
+	});
+	app.post("/run", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { agent: agentName, message } = body;
+		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
+		const handle = s.workers.get(agentName);
+		if (!handle) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		return streamSSE(c, async (stream) => {
+			try {
+				const gen = handle.sendStream(message);
+				while (true) {
+					const { value, done } = await gen.next();
+					if (done) {
+						const currentState = getState();
+						if (currentState) await currentState.store.save(agentName, handle.getState());
+						await stream.writeSSE({
+							event: "done",
+							data: JSON.stringify(value)
+						});
+						break;
+					}
+					await stream.writeSSE({
+						event: "chunk",
+						data: JSON.stringify({
+							agent: agentName,
+							text: value
+						})
+					});
+				}
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				await stream.writeSSE({
+					event: "error",
+					data: JSON.stringify({ error: msg })
+				});
+			}
+		});
+	});
+	app.post("/serve", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { agent: agentName, message } = body;
+		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
+		const handle = s.workers.get(agentName);
+		if (!handle) return c.json({ error: `Agent not found: ${agentName}` }, 404);
 		try {
-			await importer.importMultiple(importSkills);
-			await provider.addImportedSkills(importer);
+			const response = await handle.send(message);
+			await s.store.save(agentName, handle.getState());
+			return c.json(response);
 		} catch (error) {
-			console.error("Failed to import skills:", error);
-		}
-	}
-	const skills = provider.list();
-	if (skills.length > 0) {
-		console.log(`Loaded ${skills.length} skill(s):`);
-		for (const skill of skills) console.log(`  - ${skill.name}: ${skill.description}`);
-	}
-	const tools = {};
-	if (skills.length > 0) tools.Skills = createSkillsTool(provider);
-	return {
-		tools,
-		importer
-	};
-}
-let state = null;
-const DEFAULT_IDLE_TIMEOUT = 1800 * 1e3;
-const DEFAULT_SCHEDULE_PROMPT = "[Scheduled wakeup] You have been idle. Check if there are any pending tasks or updates to process.";
-function resetIdleTimer() {
-	if (!state) return;
-	state.lastActivity = Date.now();
-	if (state.idleTimer) {
-		clearTimeout(state.idleTimer);
-		state.idleTimer = void 0;
-	}
-	const timeout = state.info.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
-	if (timeout > 0) state.idleTimer = setTimeout(() => {
-		if (state && state.pendingRequests === 0) {
-			console.log(`\nSession idle for ${timeout / 1e3}s, shutting down...`);
-			gracefulShutdown();
-		} else resetIdleTimer();
-	}, timeout);
-}
-/**
-* Interval-based wakeup: fires when agent has been idle for resolved.ms.
-* Resets on any activity (external send, @mention, etc).
-* After the wakeup send completes, the timer restarts.
-*/
-function resetIntervalSchedule() {
-	if (!state) return;
-	if (state.scheduleTimer) {
-		clearTimeout(state.scheduleTimer);
-		state.scheduleTimer = void 0;
-	}
-	const schedule = state.info.schedule;
-	if (!schedule) return;
-	let resolved;
-	try {
-		resolved = resolveSchedule(schedule);
-	} catch {
-		return;
-	}
-	if (resolved.type !== "interval" || !resolved.ms) return;
-	const ms = resolved.ms;
-	const prompt = resolved.prompt || DEFAULT_SCHEDULE_PROMPT;
-	state.scheduleTimer = setTimeout(async () => {
-		if (!state || state.pendingRequests > 0) {
-			resetIntervalSchedule();
-			return;
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: msg }, 500);
 		}
-		console.log(`\n[wakeup:interval] Waking agent after ${ms / 1e3}s idle`);
-		try {
-			state.pendingRequests++;
-			resetIdleTimer();
-			await state.session.send(prompt);
-		} catch (error) {
-			console.error("[wakeup:interval] Send error:", error);
-		} finally {
-			if (state) {
-				state.pendingRequests--;
-				resetIdleTimer();
-				resetIntervalSchedule();
+	});
+	app.all("/mcp", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const req = c.req.raw;
+		const sessionId = req.headers.get("mcp-session-id");
+		if (sessionId && mcpSessions.has(sessionId)) {
+			const session = mcpSessions.get(sessionId);
+			if (req.method === "DELETE") {
+				await session.transport.close();
+				mcpSessions.delete(sessionId);
+				return new Response(null, { status: 200 });
 			}
-		}
-	}, ms);
-}
-/**
-* Cron-based wakeup: fires at fixed cron times, regardless of activity.
-* NOT reset by external activity — the agent is woken at the scheduled time.
-* After the wakeup completes, schedules the next occurrence.
-*/
-function startCronSchedule() {
-	if (!state) return;
-	if (state.cronTimer) {
-		clearTimeout(state.cronTimer);
-		state.cronTimer = void 0;
-	}
-	const schedule = state.info.schedule;
-	if (!schedule) return;
-	let resolved;
-	try {
-		resolved = resolveSchedule(schedule);
-	} catch {
-		return;
-	}
-	if (resolved.type !== "cron" || !resolved.expr) return;
-	const expr = resolved.expr;
-	const prompt = resolved.prompt || DEFAULT_SCHEDULE_PROMPT;
-	let delay;
-	try {
-		delay = msUntilNextCron(expr);
-	} catch (error) {
-		console.error("[wakeup:cron] Invalid cron expression:", error);
-		return;
-	}
-	const nextTime = new Date(Date.now() + delay);
-	console.log(`[wakeup:cron] Next at ${nextTime.toISOString()} (in ${Math.round(delay / 1e3)}s)`);
-	state.cronTimer = setTimeout(async () => {
-		if (!state) return;
-		console.log(`\n[wakeup:cron] Waking agent (${expr})`);
+			return session.transport.handleRequest(req);
+		}
+		if (req.method === "POST") {
+			const body = await req.json();
+			if (!(Array.isArray(body) ? body.some((m) => m?.method === "initialize") : body?.method === "initialize")) return c.json({ error: "Bad request: session required" }, 400);
+			const agentName = new URL(req.url).searchParams.get("agent") || "user";
+			const agentCfg = s.configs.get(agentName);
+			const workflow = agentCfg?.workflow ?? "global";
+			const tag = agentCfg?.tag ?? "main";
+			const workflowAgents = getWorkflowAgentNames(workflow, tag);
+			const allNames = [...new Set([
+				...workflowAgents,
+				agentName,
+				"user"
+			])];
+			const contextDir = getDefaultContextDir(workflow, tag);
+			mkdirSync(contextDir, { recursive: true });
+			const provider = createFileContextProvider(contextDir, allNames);
+			const transport = new WebStandardStreamableHTTPServerTransport({
+				sessionIdGenerator: () => `${agentName}-${randomUUID().slice(0, 8)}`,
+				onsessioninitialized: (sid) => {
+					mcpSessions.set(sid, {
+						transport,
+						agentId: agentName
+					});
+				},
+				onsessionclosed: (sid) => {
+					mcpSessions.delete(sid);
+				},
+				enableJsonResponse: true
+			});
+			await createContextMCPServer({
+				provider,
+				validAgents: allNames,
+				name: `${workflow}-context`,
+				version: "1.0.0"
+			}).server.connect(transport);
+			return transport.handleRequest(req, { parsedBody: body });
+		}
+		if (req.method === "GET") return c.json({ error: "Session ID required for GET requests" }, 400);
+		return c.json({ error: "Method not allowed" }, 405);
+	});
+	app.post("/workflows", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { workflow, tag = "main", feedback, pollInterval } = body;
+		if (!workflow || !workflow.agents) return c.json({ error: "workflow (parsed YAML) required" }, 400);
+		const workflowName = workflow.name || "global";
+		const key = `${workflowName}:${tag}`;
+		if (s.workflows.has(key)) return c.json({ error: `Workflow already running: ${key}` }, 409);
 		try {
-			state.pendingRequests++;
-			resetIdleTimer();
-			await state.session.send(prompt);
+			const { runWorkflowWithControllers } = await import("../runner-CQJYnM7D.mjs");
+			const result = await runWorkflowWithControllers({
+				workflow,
+				workflowName,
+				tag,
+				mode: "start",
+				headless: true,
+				feedback,
+				pollInterval,
+				log: () => {}
+			});
+			if (!result.success) return c.json({ error: result.error || "Workflow failed to start" }, 500);
+			const handle = {
+				name: workflowName,
+				tag,
+				key,
+				agents: Object.keys(workflow.agents),
+				controllers: result.controllers,
+				contextProvider: result.contextProvider,
+				shutdown: result.shutdown,
+				workflowPath: workflow.filePath,
+				startedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			s.workflows.set(key, handle);
+			return c.json({
+				key,
+				name: workflowName,
+				tag,
+				agents: handle.agents
+			}, 201);
 		} catch (error) {
-			console.error("[wakeup:cron] Send error:", error);
-		} finally {
-			if (state) {
-				state.pendingRequests--;
-				resetIdleTimer();
-				startCronSchedule();
-			}
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to start workflow: ${msg}` }, 500);
 		}
-	}, delay);
-}
-/**
-* Reset schedule timers on external activity.
-* - Interval: resets (idle-based)
-* - Cron: NOT reset (fixed schedule)
-*/
-function resetScheduleTimers() {
-	resetIntervalSchedule();
-}
-const INBOX_POLL_MS = 2e3;
-/**
-* Start inbox polling — checks channel for @mentions and processes them via the LLM.
-* This is how agents receive messages from `send` (which posts to the channel).
-*/
-function startInboxPolling() {
-	if (!state?.contextProvider || !state?.agentDisplayName) return;
-	const provider = state.contextProvider;
-	const agentName = state.agentDisplayName;
-	state.inboxPollTimer = setInterval(async () => {
-		if (!state || state.pendingRequests > 0) return;
+	});
+	app.get("/workflows", (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const workflows = [...s.workflows.values()].map((wf) => {
+			const agentStates = {};
+			for (const [name, controller] of wf.controllers) agentStates[name] = controller.state;
+			return {
+				name: wf.name,
+				tag: wf.tag,
+				key: wf.key,
+				agents: wf.agents,
+				agentStates,
+				workflowPath: wf.workflowPath,
+				startedAt: wf.startedAt
+			};
+		});
+		return c.json({ workflows });
+	});
+	async function deleteWorkflow(c, name, tag) {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const key = `${name}:${tag}`;
+		const handle = s.workflows.get(key);
+		if (!handle) return c.json({ error: `Workflow not found: ${key}` }, 404);
 		try {
-			const inbox = await provider.getInbox(agentName);
-			if (inbox.length === 0) return;
-			const latestId = inbox[inbox.length - 1].entry.id;
-			const prompt = inbox.map((m) => `[${m.entry.from}]: ${m.entry.content}`).join("\n\n");
-			state.pendingRequests++;
-			resetIdleTimer();
-			resetScheduleTimers();
-			const senders = [...new Set(inbox.map((m) => m.entry.from))];
-			await provider.appendChannel(agentName, `read ${inbox.length} message(s) from ${senders.join(", ")}`, { kind: "log" });
-			try {
-				const response = await state.session.send(prompt);
-				await provider.appendChannel(agentName, response.content);
-				await provider.ackInbox(agentName, latestId);
-			} finally {
-				if (state) {
-					state.pendingRequests--;
-					resetIdleTimer();
-				}
-			}
+			await handle.shutdown();
+			s.workflows.delete(key);
+			return c.json({
+				success: true,
+				key
+			});
 		} catch (error) {
-			console.error("[inbox] Poll error:", error instanceof Error ? error.message : error);
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to stop workflow: ${msg}` }, 500);
 		}
-	}, INBOX_POLL_MS);
-}
-async function gracefulShutdown() {
-	if (!state) {
-		process.exit(0);
-		return;
 	}
-	state.server.close();
-	const maxWait = 1e4;
-	const start = Date.now();
-	while (state.pendingRequests > 0 && Date.now() - start < maxWait) await new Promise((resolve) => setTimeout(resolve, 100));
-	if (state.importer) await state.importer.cleanup();
-	cleanup();
-	process.exit(0);
+	app.delete("/workflows/:name/:tag", (c) => deleteWorkflow(c, c.req.param("name"), c.req.param("tag")));
+	app.delete("/workflows/:name", (c) => deleteWorkflow(c, c.req.param("name"), "main"));
+	return app;
 }
-function cleanup() {
-	if (state) {
-		if (state.idleTimer) clearTimeout(state.idleTimer);
-		if (state.scheduleTimer) clearTimeout(state.scheduleTimer);
-		if (state.cronTimer) clearTimeout(state.cronTimer);
-		if (state.inboxPollTimer) clearInterval(state.inboxPollTimer);
-		if (existsSync(state.info.socketPath)) unlinkSync(state.info.socketPath);
-		if (existsSync(state.info.pidFile)) unlinkSync(state.info.pidFile);
-		if (existsSync(state.info.readyFile)) unlinkSync(state.info.readyFile);
-		unregisterSession(state.info.id);
-	}
-}
-async function startDaemon(config) {
-	ensureDirs();
-	const backendType = config.backend || "sdk";
-	const sessionId = crypto.randomUUID();
-	const workflow = config.workflow ?? config.instance ?? "global";
-	const tag = config.tag ?? "main";
-	const instance = config.instance ?? workflow;
-	const { tools, importer } = await setupSkills(sessionId, config.skills, config.skillDirs, config.importSkills);
-	if (config.tool) {
-		const toolPath = config.tool.startsWith("/") ? config.tool : join(process.cwd(), config.tool);
-		try {
-			const module = await import(toolPath);
-			const toolsList = Array.isArray(module.default) ? module.default : module.default?.tools || [];
-			for (const toolDef of toolsList) if (toolDef && toolDef.name) tools[toolDef.name] = toolDef;
-		} catch (error) {
-			console.error(`Failed to import tools from ${config.tool}:`, error);
-		}
+async function startDaemon(config = {}) {
+	const existing = isDaemonRunning();
+	if (existing) {
+		console.error(`Daemon already running: pid=${existing.pid} port=${existing.port}`);
+		process.exit(1);
 	}
-	let getFeedback;
-	if (config.feedback) {
-		const fb = createFeedbackTool();
-		tools.feedback = fb.tool;
-		getFeedback = fb.getFeedback;
-	}
-	const system = config.feedback ? `${config.system}\n\n${FEEDBACK_PROMPT}` : config.system;
-	const cliBackend = backendType !== "sdk" ? createBackend({
-		type: backendType,
-		model: config.model
-	}) : void 0;
-	const session = new AgentSession({
-		model: config.model,
-		system,
-		tools,
-		backend: cliBackend
+	const host = config.host ?? "127.0.0.1";
+	const store = config.store ?? new MemoryStateStore();
+	const token = randomUUID();
+	const server = await startHttpServer(createDaemonApp({
+		getState: () => state,
+		token
+	}), {
+		port: config.port ?? DEFAULT_PORT,
+		hostname: host
 	});
-	const effectiveId = session.id;
-	const socketPath = join(SESSIONS_DIR, `${effectiveId}.sock`);
-	const pidFile = join(SESSIONS_DIR, `${effectiveId}.pid`);
-	const readyFile = join(SESSIONS_DIR, `${effectiveId}.ready`);
-	if (existsSync(socketPath)) unlinkSync(socketPath);
-	const contextDir = getDefaultContextDir(workflow, tag);
-	mkdirSync(contextDir, { recursive: true });
-	const agentDisplayName = config.name ? getAgentDisplayName(config.name) : effectiveId.slice(0, 8);
-	const existingAgentNames = getInstanceAgentNames(instance);
-	const contextProvider = createFileContextProvider(contextDir, [...new Set([
-		...existingAgentNames,
-		agentDisplayName,
-		"user"
-	])]);
-	const info = {
-		id: effectiveId,
-		name: config.name,
-		workflow,
-		tag,
-		instance,
-		contextDir,
-		model: config.model,
-		system: config.system,
-		backend: backendType,
-		socketPath,
-		pidFile,
-		readyFile,
+	const actualPort = server.port;
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	writeDaemonInfo({
 		pid: process.pid,
-		createdAt: session.createdAt,
-		idleTimeout: config.idleTimeout,
-		schedule: config.schedule
-	};
-	const server = createServer((socket) => {
-		let buffer = "";
-		socket.on("data", async (data) => {
-			buffer += data.toString();
-			const lines = buffer.split("\n");
-			buffer = lines.pop() || "";
-			for (const line of lines) {
-				if (!line.trim()) continue;
-				try {
-					const req = JSON.parse(line);
-					const resetActivity = () => {
-						resetIdleTimer();
-						resetScheduleTimers();
-					};
-					const resetAll = () => {
-						resetIdleTimer();
-						resetIntervalSchedule();
-						startCronSchedule();
-					};
-					const res = await handleRequest(() => state, req, resetActivity, gracefulShutdown, resetAll);
-					socket.write(JSON.stringify(res) + "\n");
-				} catch (error) {
-					socket.write(JSON.stringify({
-						success: false,
-						error: error instanceof Error ? error.message : "Parse error"
-					}) + "\n");
-				}
-			}
-		});
-		socket.on("error", () => {});
-	});
-	server.listen(socketPath, () => {
-		writeFileSync(pidFile, process.pid.toString());
-		registerSession(info);
-		state = {
-			session,
-			server,
-			info,
-			lastActivity: Date.now(),
-			pendingRequests: 0,
-			importer,
-			getFeedback,
-			contextProvider,
-			agentDisplayName
-		};
-		writeFileSync(readyFile, effectiveId);
-		resetIdleTimer();
-		resetIntervalSchedule();
-		startCronSchedule();
-		startInboxPolling();
-		const nameStr = config.name ? ` (${config.name})` : "";
-		const workflowDisplay = buildTargetDisplay(void 0, workflow, tag);
-		console.log(`Session started: ${effectiveId}${nameStr}`);
-		console.log(`Model: ${config.model}`);
-		console.log(`Backend: ${backendType}`);
-		console.log(`Workflow: ${workflowDisplay}`);
-		if (config.schedule) try {
-			const resolved = resolveSchedule(config.schedule);
-			if (resolved.type === "interval") {
-				console.log(`Wakeup: every ${resolved.ms / 1e3}s when idle`);
-				const idleMs = config.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
-				if (idleMs > 0 && resolved.ms > idleMs) console.warn(`Warning: idle timeout (${idleMs / 1e3}s) is shorter than wakeup interval (${resolved.ms / 1e3}s). Session will shut down before wakeup fires. Use --idle-timeout 0 to disable.`);
-			} else console.log(`Wakeup: cron ${resolved.expr}`);
-		} catch (error) {
-			console.error("Invalid wakeup schedule:", error);
-		}
-	});
-	server.on("error", (error) => {
-		console.error("Server error:", error);
-		cleanup();
-		process.exit(1);
+		host,
+		port: actualPort,
+		startedAt,
+		token
 	});
+	state = {
+		configs: /* @__PURE__ */ new Map(),
+		workers: /* @__PURE__ */ new Map(),
+		workflows: /* @__PURE__ */ new Map(),
+		store,
+		server,
+		port: actualPort,
+		host,
+		startedAt
+	};
+	console.log(`Daemon started: pid=${process.pid}`);
+	console.log(`Listening: http://${host}:${actualPort}`);
+	console.log(`MCP: http://${host}:${actualPort}/mcp`);
 	process.on("SIGINT", () => {
 		console.log("\nShutting down...");
-		cleanup();
-		process.exit(0);
+		gracefulShutdown();
 	});
 	process.on("SIGTERM", () => {
-		cleanup();
-		process.exit(0);
+		gracefulShutdown();
 	});
 }
 
 //#endregion
 //#region src/cli/client.ts
-function sendRequest(req, targetOrOptions, options) {
-	let target;
-	let opts = {};
-	if (typeof targetOrOptions === "string") {
-		target = targetOrOptions;
-		opts = options || {};
-	} else if (targetOrOptions) {
-		opts = targetOrOptions;
-		target = opts.target;
-	}
-	const debug = opts.debug || false;
-	return new Promise((resolve, reject) => {
-		if (debug) console.error(`[DEBUG] Looking up session: ${target || "(default)"}`);
-		const info = getSessionInfo(target);
-		if (!info) {
-			if (target) resolve({
-				success: false,
-				error: `Session not found: ${target}`
-			});
-			else resolve({
-				success: false,
-				error: "No active session. Start one with: agent-worker session start -m <model>"
-			});
-			return;
-		}
-		if (debug) {
-			console.error(`[DEBUG] Found session: ${info.id} (${info.backend})`);
-			console.error(`[DEBUG] Socket path: ${info.socketPath}`);
-		}
-		if (!isSessionRunning(target)) {
-			resolve({
-				success: false,
-				error: `Session not running: ${target || info.id}`
-			});
-			return;
-		}
-		if (debug) console.error(`[DEBUG] Connecting to socket...`);
-		const socket = createConnection(info.socketPath);
-		let buffer = "";
-		const startTime = Date.now();
-		socket.on("connect", () => {
-			if (debug) {
-				console.error(`[DEBUG] Connected. Sending request:`);
-				console.error(`[DEBUG] ${JSON.stringify(req, null, 2)}`);
-			}
-			socket.write(JSON.stringify(req) + "\n");
+/**
+* CLI client — HTTP client for daemon REST API.
+*
+* Talks to the 9-endpoint daemon:
+*   GET  /health, POST /shutdown
+*   GET/POST /agents, GET/DELETE /agents/:name
+*   POST /run (SSE), POST /serve
+*   ALL  /mcp
+*/
+var client_exports = /* @__PURE__ */ __exportAll({
+	createAgent: () => createAgent,
+	deleteAgent: () => deleteAgent,
+	health: () => health,
+	isDaemonActive: () => isDaemonActive,
+	listAgents: () => listAgents,
+	run: () => run,
+	serve: () => serve,
+	shutdown: () => shutdown,
+	startWorkflow: () => startWorkflow,
+	stopWorkflow: () => stopWorkflow
+});
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 200;
+function isRetryableError(error) {
+	if (error instanceof TypeError) return true;
+	if (error instanceof Error) {
+		const code = error.code;
+		return code === "ECONNREFUSED" || code === "ECONNRESET";
+	}
+	return false;
+}
+function getDaemonConnection() {
+	const daemon = isDaemonRunning();
+	if (!daemon) return null;
+	return {
+		url: `http://${daemon.host}:${daemon.port}`,
+		token: daemon.token
+	};
+}
+function requireDaemon() {
+	const conn = getDaemonConnection();
+	if (!conn) throw new Error("No daemon running. Start one with: agent-worker daemon");
+	return conn;
+}
+/** Build headers with auth token */
+function authHeaders(token, extra) {
+	const headers = { ...extra };
+	if (token) headers["Authorization"] = `Bearer ${token}`;
+	return headers;
+}
+async function request(method, path, body) {
+	const { url: baseUrl, token } = requireDaemon();
+	let lastError;
+	for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) try {
+		const init = {
+			method,
+			headers: authHeaders(token, body !== void 0 ? { "Content-Type": "application/json" } : void 0),
+			body: body !== void 0 ? JSON.stringify(body) : void 0,
+			signal: AbortSignal.timeout(6e4)
+		};
+		return await (await fetch(`${baseUrl}${path}`, init)).json();
+	} catch (error) {
+		lastError = error;
+		if (attempt < MAX_RETRIES && isRetryableError(error)) {
+			const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		} else break;
+	}
+	return {
+		success: false,
+		error: `Connection failed: ${lastError instanceof Error ? lastError.message : String(lastError)}`
+	};
+}
+/** GET /health */
+function health() {
+	return request("GET", "/health");
+}
+/** POST /shutdown */
+function shutdown() {
+	return request("POST", "/shutdown");
+}
+/** GET /agents */
+function listAgents() {
+	return request("GET", "/agents");
+}
+/** POST /agents */
+function createAgent(body) {
+	return request("POST", "/agents", body);
+}
+/** DELETE /agents/:name */
+function deleteAgent(name) {
+	return request("DELETE", `/agents/${encodeURIComponent(name)}`);
+}
+/** POST /serve (sync JSON response) */
+function serve(body) {
+	return request("POST", "/serve", body);
+}
+/**
+* POST /run (SSE stream).
+* Calls onChunk for each chunk, returns final response.
+*/
+async function run(body, onChunk) {
+	let baseUrl;
+	let token;
+	try {
+		const conn = requireDaemon();
+		baseUrl = conn.url;
+		token = conn.token;
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+	try {
+		const res = await fetch(`${baseUrl}/run`, {
+			method: "POST",
+			headers: authHeaders(token, { "Content-Type": "application/json" }),
+			body: JSON.stringify(body)
 		});
-		socket.on("data", (data) => {
-			if (debug) {
-				const elapsed = ((Date.now() - startTime) / 1e3).toFixed(2);
-				console.error(`[DEBUG] Received data after ${elapsed}s: ${data.toString().substring(0, 100)}...`);
-			}
-			buffer += data.toString();
+		if (!res.ok || !res.body) return await res.json();
+		const reader = res.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let finalResponse = { success: true };
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
 			const lines = buffer.split("\n");
-			buffer = lines.pop() || "";
-			for (const line of lines) {
-				if (!line.trim()) continue;
+			buffer = lines.pop() ?? "";
+			let currentEvent = "";
+			for (const line of lines) if (line.startsWith("event: ")) currentEvent = line.slice(7);
+			else if (line.startsWith("data: ")) {
+				const data = line.slice(6);
 				try {
-					const res = JSON.parse(line);
-					if (debug) {
-						const elapsed = ((Date.now() - startTime) / 1e3).toFixed(2);
-						console.error(`[DEBUG] Received response after ${elapsed}s`);
-					}
-					socket.end();
-					resolve(res);
-				} catch (error) {
-					if (debug) console.error(`[DEBUG] Parse error:`, error);
-					socket.end();
-					reject(error);
-				}
+					const parsed = JSON.parse(data);
+					if (currentEvent === "chunk" && onChunk) onChunk(parsed);
+					else if (currentEvent === "done") finalResponse = parsed;
+					else if (currentEvent === "error") return {
+						success: false,
+						error: parsed.error
+					};
+				} catch {}
 			}
-		});
-		socket.on("error", (error) => {
-			if (debug) console.error(`[DEBUG] Socket error:`, error);
-			reject(error);
-		});
-		socket.on("timeout", () => {
-			if (debug) console.error(`[DEBUG] Socket timeout after 60s`);
-			socket.end();
-			reject(/* @__PURE__ */ new Error("Connection timeout"));
-		});
-		socket.setTimeout(6e4);
-		if (debug) console.error(`[DEBUG] Waiting for response (60s timeout)...`);
-	});
+		}
+		return finalResponse;
+	} catch (error) {
+		return {
+			success: false,
+			error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
 }
-/**
-* Check if any session is active, or a specific session
-*/
-function isSessionActive(target) {
-	return isSessionRunning(target);
+/** POST /workflows — start a workflow via daemon */
+function startWorkflow(body) {
+	return request("POST", "/workflows", body);
+}
+/** DELETE /workflows/:name/:tag — stop a workflow */
+function stopWorkflow(name, tag = "main") {
+	return request("DELETE", `/workflows/${encodeURIComponent(name)}/${encodeURIComponent(tag)}`);
+}
+/** Check if daemon is running */
+function isDaemonActive() {
+	return getDaemonConnection() !== null;
 }
 
 //#endregion
 //#region src/cli/output.ts
+var output_exports = /* @__PURE__ */ __exportAll({ outputJson: () => outputJson });
 /**
 * CLI Output Utilities
 *
@@ -1764,388 +2030,304 @@ function outputJson(data) {
 
 //#endregion
 //#region src/cli/commands/agent.ts
-async function createAgentAction(name, options) {
-	let system = options.system ?? "You are a helpful assistant.";
-	if (options.systemFile) system = readFileSync(options.systemFile, "utf-8");
-	const backend = options.backend ?? "sdk";
-	const model = options.model || getDefaultModel();
-	const idleTimeout = parseInt(options.idleTimeout ?? "1800000", 10);
-	const workflow = DEFAULT_WORKFLOW;
-	const tag = DEFAULT_TAG;
-	const instance = DEFAULT_INSTANCE;
-	const agentName = name || generateAutoName();
-	let fullName;
-	if (agentName.includes("@")) fullName = agentName;
-	else fullName = buildTarget(agentName, workflow, tag);
-	const schedule = options.wakeup ? {
-		wakeup: /^\d+$/.test(options.wakeup) ? parseInt(options.wakeup, 10) : options.wakeup,
-		prompt: options.wakeupPrompt
-	} : void 0;
-	if (options.foreground) startDaemon({
-		model,
-		system,
-		name: fullName,
-		workflow,
-		tag,
-		instance,
-		idleTimeout,
-		backend,
-		skills: options.skill,
-		skillDirs: options.skillDir,
-		importSkills: options.importSkill,
-		tool: options.tool,
-		feedback: options.feedback,
-		schedule
-	});
-	else {
-		const args = [
-			process.argv[1] ?? "",
-			"new",
-			agentName,
-			"-m",
-			model,
-			"-b",
-			backend,
-			"-s",
-			system,
-			"--foreground"
-		];
-		args.push("--idle-timeout", String(idleTimeout));
-		if (options.feedback) args.push("--feedback");
-		if (options.skill) for (const skillPath of options.skill) args.push("--skill", skillPath);
-		if (options.skillDir) for (const dir of options.skillDir) args.push("--skill-dir", dir);
-		if (options.importSkill) for (const spec of options.importSkill) args.push("--import-skill", spec);
-		if (options.tool) args.push("--tool", options.tool);
-		if (options.wakeup) args.push("--wakeup", options.wakeup);
-		if (options.wakeupPrompt) args.push("--wakeup-prompt", options.wakeupPrompt);
-		spawn(process.execPath, args, {
-			detached: true,
-			stdio: "ignore"
-		}).unref();
-		const info = await waitForReady(fullName, 5e3);
-		if (info) {
-			const targetDisplay = buildTargetDisplay(agentName, workflow, tag);
-			if (options.json) outputJson({
-				name: agentName,
-				workflow,
-				tag,
-				instance,
-				model: info.model,
-				backend
-			});
-			else console.log(targetDisplay);
-		} else {
-			console.error("Failed to start agent");
-			process.exit(1);
-		}
+var agent_exports = /* @__PURE__ */ __exportAll({
+	ensureDaemon: () => ensureDaemon,
+	registerAgentCommands: () => registerAgentCommands
+});
+/**
+* Ensure daemon is running. If not, spawn it in background and wait.
+*/
+async function ensureDaemon(port, host) {
+	if (isDaemonRunning()) return;
+	const args = [process.argv[1] ?? "", "daemon"];
+	if (port) args.push("--port", String(port));
+	if (host) args.push("--host", host);
+	spawn(process.execPath, args, {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+	const maxWait = 5e3;
+	const start = Date.now();
+	while (Date.now() - start < maxWait) {
+		if (isDaemonRunning()) return;
+		await new Promise((r) => setTimeout(r, 100));
 	}
+	console.error("Failed to start daemon");
+	process.exit(1);
 }
-function listAgentsAction(targetInput, options) {
-	let sessions = listSessions();
-	if (!options?.all && targetInput) {
-		const target = parseTarget(targetInput);
-		sessions = sessions.filter((s) => {
-			const sessionWorkflow = s.workflow || s.instance || DEFAULT_WORKFLOW;
-			const sessionTag = s.tag || DEFAULT_TAG;
-			return sessionWorkflow === target.workflow && sessionTag === target.tag;
+function registerAgentCommands(program) {
+	program.command("daemon").description("Start daemon in foreground").option("--port <port>", `HTTP port (default: ${DEFAULT_PORT})`).option("--host <host>", "Host to bind to (default: 127.0.0.1)").action(async (options) => {
+		const { startDaemon } = await Promise.resolve().then(() => daemon_exports);
+		await startDaemon({
+			port: options.port ? parseInt(options.port, 10) : void 0,
+			host: options.host
 		});
-	} else if (!options?.all && !targetInput) sessions = sessions.filter((s) => {
-		return (s.workflow || s.instance || DEFAULT_WORKFLOW) === DEFAULT_WORKFLOW;
 	});
-	if (options?.json) {
-		outputJson(sessions.map((s) => {
-			const parsed = s.name ? parseTarget(s.name) : null;
-			return {
-				id: s.id,
-				name: parsed?.agent ?? null,
-				workflow: s.workflow,
-				tag: s.tag,
-				instance: s.instance,
-				model: s.model,
-				backend: s.backend,
-				running: isSessionRunning(s.id)
-			};
-		}));
-		return;
-	}
-	if (sessions.length === 0) {
-		console.log("No active agents");
-		return;
-	}
-	const byWorkflow = /* @__PURE__ */ new Map();
-	for (const s of sessions) {
-		const key = buildTargetDisplay(void 0, s.workflow || s.instance || DEFAULT_WORKFLOW, s.tag || DEFAULT_TAG);
-		if (!byWorkflow.has(key)) byWorkflow.set(key, []);
-		byWorkflow.get(key).push(s);
-	}
-	for (const [workflowDisplay, agents] of byWorkflow) {
-		if (byWorkflow.size > 1) console.log(`[${workflowDisplay}]`);
-		for (const s of agents) {
-			const status = isSessionRunning(s.id) ? "running" : "stopped";
-			const displayName = s.name ? getAgentDisplayName(s.name) : s.id.slice(0, 8);
-			const prefix = byWorkflow.size > 1 ? "  " : "";
-			console.log(`${prefix}${displayName.padEnd(12)} ${s.model.padEnd(30)} [${status}]`);
-		}
-	}
-}
-async function stopAgentAction(targetInput, options) {
-	if (options?.all) {
-		const sessions = listSessions();
-		for (const s of sessions) if (isSessionRunning(s.id)) {
-			await sendRequest({ action: "shutdown" }, s.id);
-			const displayName = s.name ? getAgentDisplayName(s.name) : s.id.slice(0, 8);
-			console.log(`Stopped: ${displayName}`);
-		}
-		return;
-	}
-	if (!targetInput) {
-		console.error("Specify target agent or use --all");
-		process.exit(1);
-	}
-	const target = parseTarget(targetInput);
-	if (!target.agent) {
-		let sessions = listSessions();
-		sessions = sessions.filter((s) => {
-			const sessionWorkflow = s.workflow || s.instance || DEFAULT_WORKFLOW;
-			const sessionTag = s.tag || DEFAULT_TAG;
-			return sessionWorkflow === target.workflow && sessionTag === target.tag;
-		});
-		if (sessions.length === 0) {
-			console.error(`No agents found in ${buildTargetDisplay(void 0, target.workflow, target.tag)}`);
-			process.exit(1);
-		}
-		for (const s of sessions) if (isSessionRunning(s.id)) {
-			await sendRequest({ action: "shutdown" }, s.id);
-			const displayName = s.name ? getAgentDisplayName(s.name) : s.id.slice(0, 8);
-			console.log(`Stopped: ${displayName}`);
-		}
-		return;
-	}
-	const fullTarget = buildTarget(target.agent, target.workflow, target.tag);
-	if (!isSessionRunning(fullTarget)) {
-		console.error(`Agent not found: ${targetInput}`);
-		process.exit(1);
-	}
-	const res = await sendRequest({ action: "shutdown" }, fullTarget);
-	if (res.success) console.log("Agent stopped");
-	else console.error("Error:", res.error);
-}
-function addNewCommandOptions(cmd) {
-	return cmd.option("-m, --model <model>", `Model identifier (default: ${getDefaultModel()})`).addOption(new Option("-b, --backend <type>", "Backend type").choices([
+	program.command("new <name>").description("Create a new agent").option("-m, --model <model>", `Model identifier (default: ${getDefaultModel()})`).addOption(new Option("-b, --backend <type>", "Backend type").choices([
+		"default",
 		"sdk",
 		"claude",
 		"codex",
 		"cursor",
 		"mock"
-	]).default("sdk")).option("-s, --system <prompt>", "System prompt", "You are a helpful assistant.").option("-f, --system-file <file>", "Read system prompt from file").option("--idle-timeout <ms>", "Idle timeout in ms (0 = no timeout)", "1800000").option("--skill <path...>", "Add individual skill directories").option("--skill-dir <path...>", "Scan directories for skills").option("--import-skill <spec...>", "Import skills from Git (owner/repo:{skill1,skill2})").option("--tool <file>", "Import MCP tools from file (SDK backend only)").option("--feedback", "Enable feedback tool (agent can report tool/workflow observations)").option("--wakeup <value>", "Scheduled wakeup: ms number, duration (30s/5m/2h), or cron expr").option("--wakeup-prompt <prompt>", "Custom prompt for scheduled wakeup").option("--foreground", "Run in foreground").option("--json", "Output as JSON");
-}
-function registerAgentCommands(program) {
-	addNewCommandOptions(program.command("new [name]").description("Create a new standalone agent (auto-names if omitted: a0, a1, ...)").addHelpText("after", `
-Examples:
-  $ agent-worker new alice -m anthropic/claude-sonnet-4-5    # Create standalone agent
-  $ agent-worker new -b mock                                 # Quick testing without API key
-  $ agent-worker new monitor --wakeup 30s                    # Agent with scheduled wakeup
-
-Note: Agent Mode creates standalone agents in the global workflow.
-      For coordinated multi-agent workflows, use Workflow Mode (YAML files).
-      `)).action(createAgentAction);
-	program.command("ls [target]").description("List agents (default: global workflow)").option("--json", "Output as JSON").option("--all", "Show agents from all workflows").addHelpText("after", `
+	]).default("default")).option("-s, --system <prompt>", "System prompt", "You are a helpful assistant.").option("-f, --system-file <file>", "Read system prompt from file").option("--workflow <name>", "Workflow name (default: global)").option("--tag <tag>", "Workflow instance tag (default: main)").option("--port <port>", `Daemon port if starting new daemon (default: ${DEFAULT_PORT})`).option("--host <host>", "Daemon host (default: 127.0.0.1)").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
-  $ agent-worker ls                # List global workflow agents (default)
-  $ agent-worker ls @review        # List review workflow agents
-  $ agent-worker ls @review:pr-123 # List specific workflow:tag agents
-  $ agent-worker ls --all          # List all agents from all workflows
-    `).action(listAgentsAction);
-	program.command("stop [target]").description("Stop agent(s)").option("--all", "Stop all agents").addHelpText("after", `
-Examples:
-  $ agent-worker stop alice           # Stop alice in global workflow
-  $ agent-worker stop alice@review    # Stop alice in review workflow
-  $ agent-worker stop @review:pr-123  # Stop all agents in review:pr-123
-  $ agent-worker stop --all           # Stop all agents
-    `).action(stopAgentAction);
-	program.command("status [target]").description("Check agent status").option("--json", "Output as JSON").action(async (target, options) => {
-		if (!isSessionRunning(target)) {
-			if (options.json) outputJson({
-				running: false,
-				error: target ? `Not found: ${target}` : "No active agent"
-			});
-			else console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
-		}
-		const res = await sendRequest({ action: "ping" }, target);
-		if (res.success && res.data) {
-			const data = res.data;
-			if (options.json) outputJson({
-				...data,
-				running: true
-			});
-			else {
-				const nameStr = data.name ? ` (${data.name})` : "";
-				console.log(`Agent: ${data.id}${nameStr}`);
-				console.log(`Model: ${data.model}`);
-			}
-		}
-	});
-	program.command("use <target>").description("Set default agent").option("--json", "Output as JSON").action((target, options) => {
-		if (setDefaultSession(target)) if (options.json) outputJson({ target });
-		else console.log(`Default agent set to: ${target}`);
-		else {
-			console.error(`Agent not found: ${target}`);
-			process.exit(1);
-		}
-	});
-	const scheduleCmd = program.command("schedule").description("Manage scheduled wakeup for agents").addHelpText("after", `
-Examples:
-  $ agent-worker schedule alice set 30s                    # Wake alice every 30 seconds
-  $ agent-worker schedule alice set 5m --prompt "Status?"  # With custom prompt
-  $ agent-worker schedule alice get                        # View current schedule
-  $ agent-worker schedule alice clear                      # Remove schedule
-    `);
-	scheduleCmd.command("get [target]").description("Show current wakeup schedule").option("--json", "Output as JSON").action(async (target, options) => {
-		const res = await sendRequest({ action: "schedule_get" }, target);
-		if (!res.success) {
-			console.error("Error:", res.error);
-			process.exit(1);
-		}
-		if (options.json) outputJson(res.data);
-		else if (res.data) {
-			const s = res.data;
-			console.log(`Wakeup: ${s.wakeup}`);
-			if (s.prompt) console.log(`Prompt: ${s.prompt}`);
-			else console.log("Prompt: (default)");
-		} else console.log("No wakeup schedule configured");
-	});
-	scheduleCmd.command("set <wakeup>").description("Set wakeup schedule (ms number, duration 30s/5m/2h, or cron expression)").option("-p, --prompt <prompt>", "Custom wakeup prompt").option("--to <target>", "Target agent").option("--json", "Output as JSON").action(async (wakeup, options) => {
-		const wakeupValue = /^\d+$/.test(wakeup) ? parseInt(wakeup, 10) : wakeup;
-		const payload = { wakeup: wakeupValue };
-		if (options.prompt) payload.prompt = options.prompt;
-		const res = await sendRequest({
-			action: "schedule_set",
-			payload
-		}, options.to);
-		if (res.success) if (options.json) outputJson({
-			wakeup: wakeupValue,
-			prompt: options.prompt || null
+  $ agent-worker new alice -m anthropic/claude-sonnet-4-5
+  $ agent-worker new bot -b mock
+  $ agent-worker new reviewer --workflow review --tag pr-123
+      `).action(async (name, options) => {
+		let system = options.system;
+		if (options.systemFile) system = readFileSync(options.systemFile, "utf-8");
+		const backend = normalizeBackendType(options.backend ?? "default");
+		const model = options.model || getDefaultModel();
+		await ensureDaemon(options.port ? parseInt(options.port, 10) : void 0, options.host);
+		const res = await createAgent({
+			name,
+			model,
+			system,
+			backend,
+			workflow: options.workflow,
+			tag: options.tag
 		});
-		else {
-			console.log(`Wakeup set: ${wakeup}`);
-			if (options.prompt) console.log(`Prompt: ${options.prompt}`);
-		}
-		else {
-			console.error("Error:", res.error);
-			process.exit(1);
-		}
-	});
-	scheduleCmd.command("clear [target]").description("Remove scheduled wakeup").option("--json", "Output as JSON").action(async (target, options) => {
-		const res = await sendRequest({ action: "schedule_clear" }, target);
-		if (res.success) if (options.json) outputJson({ success: true });
-		else console.log("Schedule cleared");
-		else {
+		if (res.error) {
 			console.error("Error:", res.error);
 			process.exit(1);
 		}
+		if (options.json) outputJson(res);
+		else console.log(`${name} (${model})`);
 	});
-}
-
-//#endregion
-//#region src/cli/commands/send.ts
-/**
-* Get a context provider for the given workflow:tag.
-* Auto-provisions the context directory if it doesn't exist.
-*/
-function getContextProvider(workflow, tag, instanceFallback) {
-	const dir = getDefaultContextDir(workflow, tag);
-	mkdirSync(dir, { recursive: true });
-	return createFileContextProvider(dir, [...getInstanceAgentNames(instanceFallback || workflow), "user"]);
-}
-function registerSendCommands(program) {
-	program.command("send <target> <message>").description("Send message to agent or workflow. Use @workflow for broadcast or @mentions within workflow.").option("--json", "Output as JSON").addHelpText("after", `
+	program.command("ls").description("List agents").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
-  $ agent-worker send alice "analyze this code"              # Send to alice@global:main
-  $ agent-worker send alice@review "hello"                   # Send to alice@review:main
-  $ agent-worker send alice@review:pr-123 "check this"       # Send to specific workflow:tag
-  $ agent-worker send @review "team update"                  # Broadcast to review workflow
-  $ agent-worker send @review "@alice @bob discuss this"     # @mention within workflow
-    `).action(async (targetInput, message, options) => {
-		const target = parseTarget(targetInput);
-		const entry = await getContextProvider(target.workflow, target.tag, target.workflow).appendChannel("user", message);
-		if (options.json) outputJson({
-			id: entry.id,
-			timestamp: entry.timestamp,
-			mentions: entry.mentions,
-			target: target.display
-		});
-		else if (entry.mentions.length > 0) console.log(`→ @${entry.mentions.join(" @")}`);
-		else console.log("→ (broadcast)");
-	});
-	program.command("peek [target]").description("View channel messages (default: @global)").option("--json", "Output as JSON").option("--all", "Show all messages").option("-n, --last <count>", "Show last N messages", parseInt).option("--find <text>", "Filter messages containing text (case-insensitive)").addHelpText("after", `
-Examples:
-  $ agent-worker peek                    # View @global:main
-  $ agent-worker peek @review            # View @review:main
-  $ agent-worker peek @review:pr-123     # View specific workflow:tag
-    `).action(async (targetInput, options) => {
-		const target = parseTarget(targetInput || `@${DEFAULT_WORKFLOW}`);
-		const provider = getContextProvider(target.workflow, target.tag, target.workflow);
-		const limit = options.all ? void 0 : options.last ?? 10;
-		let messages = await provider.readChannel({ limit });
-		if (options.find) {
-			const searchText = options.find.toLowerCase();
-			messages = messages.filter((msg) => msg.content.toLowerCase().includes(searchText));
+  $ agent-worker ls
+  $ agent-worker ls --json
+      `).action(async (options) => {
+		if (!isDaemonActive()) {
+			if (options.json) outputJson({ agents: [] });
+			else console.log("No daemon running");
+			return;
+		}
+		const res = await listAgents();
+		if (res.error) {
+			console.error("Error:", res.error);
+			process.exit(1);
 		}
+		const agents = res.agents ?? [];
 		if (options.json) {
-			outputJson(messages);
+			outputJson({ agents });
 			return;
 		}
-		if (messages.length === 0) {
-			console.log(options.find ? "No messages found" : "No messages");
+		if (agents.length === 0) {
+			console.log("No agents");
 			return;
 		}
-		for (const msg of messages) if (msg.kind === "log" || msg.kind === "debug") console.log(`  ~ ${msg.from}: ${msg.content}`);
-		else {
-			const mentions = msg.mentions.length > 0 ? ` → @${msg.mentions.join(" @")}` : "";
-			console.log(`[${msg.from}]${mentions} ${msg.content}`);
+		for (const a of agents) {
+			const wf = a.tag === "main" ? `@${a.workflow}` : `@${a.workflow}:${a.tag}`;
+			const info = a.model || a.state || "";
+			console.log(`${a.name.padEnd(12)} ${info.padEnd(30)} ${wf}`);
 		}
 	});
-	program.command("stats [target]").description("Show agent statistics").option("--json", "Output as JSON").action(async (target, options) => {
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
+	program.command("stop [name]").description("Stop agent, workflow, or daemon").option("--all", "Stop daemon (all agents and workflows)").addHelpText("after", `
+Examples:
+  $ agent-worker stop alice           # Stop specific agent
+  $ agent-worker stop @review:pr-123  # Stop workflow
+  $ agent-worker stop @review         # Stop workflow (tag defaults to main)
+  $ agent-worker stop --all           # Stop daemon (everything)
+      `).action(async (name, options) => {
+		if (!isDaemonActive()) {
+			console.error("No daemon running");
 			process.exit(1);
 		}
-		const res = await sendRequest({ action: "stats" }, target);
-		if (!res.success) {
-			console.error("Error:", res.error);
+		if (options.all) {
+			const res = await shutdown();
+			if (res.success) console.log("Daemon stopped");
+			else console.error("Error:", res.error);
+			return;
+		}
+		if (!name) {
+			console.error("Specify agent name, @workflow[:tag], or use --all");
 			process.exit(1);
 		}
-		const stats = res.data;
-		if (options.json) outputJson(stats);
+		const { parseTarget } = await Promise.resolve().then(() => target_exports);
+		const target = parseTarget(name);
+		let res;
+		if (target.agent === void 0) {
+			const { stopWorkflow: stopWf } = await Promise.resolve().then(() => client_exports);
+			res = await stopWf(target.workflow, target.tag);
+		} else res = await deleteAgent(target.agent);
+		if (res.success) console.log(`Stopped: ${target.display}`);
 		else {
-			console.log(`Messages: ${stats.messageCount}`);
-			console.log(`Tokens: ${stats.usage.total} (in: ${stats.usage.input}, out: ${stats.usage.output})`);
+			console.error("Error:", res.error);
+			process.exit(1);
 		}
 	});
-	program.command("export [target]").description("Export agent transcript").action(async (target) => {
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
+	program.command("status").description("Show daemon status").option("--json", "Output as JSON").action(async (options) => {
+		if (!isDaemonActive()) {
+			if (options.json) outputJson({ running: false });
+			else console.log("Daemon not running");
+			return;
 		}
-		const res = await sendRequest({ action: "export" }, target);
-		if (!res.success) {
-			console.error("Error:", res.error);
+		const res = await health();
+		if (options.json) outputJson(res);
+		else {
+			console.log(`Daemon: pid=${res.pid} port=${res.port}`);
+			const agents = res.agents ?? [];
+			console.log(`Agents: ${agents.length > 0 ? agents.join(", ") : "(none)"}`);
+			const workflows = res.workflows ?? [];
+			if (workflows.length > 0) {
+				console.log(`Workflows:`);
+				for (const wf of workflows) {
+					const display = wf.tag === "main" ? `@${wf.name}` : `@${wf.name}:${wf.tag}`;
+					console.log(`  ${display} → ${wf.agents.join(", ")}`);
+				}
+			}
+			if (res.uptime) {
+				const secs = Math.round(res.uptime / 1e3);
+				console.log(`Uptime: ${secs}s`);
+			}
+		}
+	});
+	program.command("ask <agent> <message>").description("Send message to agent (SSE streaming)").option("--json", "Output final response as JSON").addHelpText("after", `
+Examples:
+  $ agent-worker ask alice "analyze this code"
+  $ agent-worker ask alice "hello" --json
+      `).action(async (agent, message, options) => {
+		if (!isDaemonActive()) {
+			console.error("No daemon running");
 			process.exit(1);
 		}
-		console.log(JSON.stringify(res.data, null, 2));
+		const res = await run({
+			agent,
+			message
+		}, (chunk) => {
+			if (!options.json) process.stdout.write(chunk.text);
+		});
+		if (options.json) outputJson(res);
+		else console.log();
 	});
-	program.command("clear [target]").description("Clear agent conversation history").action(async (target) => {
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
+	program.command("serve <agent> <message>").description("Send message to agent (sync response)").option("--json", "Output as JSON").action(async (agent, message, options) => {
+		if (!isDaemonActive()) {
+			console.error("No daemon running");
 			process.exit(1);
 		}
-		const res = await sendRequest({ action: "clear" }, target);
-		if (res.success) console.log("History cleared");
-		else console.error("Error:", res.error);
+		const res = await serve({
+			agent,
+			message
+		});
+		if (options.json) outputJson(res);
+		else if (res.error) {
+			console.error("Error:", res.error);
+			process.exit(1);
+		} else console.log(res.content ?? JSON.stringify(res));
 	});
 }
 
+//#endregion
+//#region src/cli/target.ts
+var target_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_TAG: () => DEFAULT_TAG,
+	DEFAULT_WORKFLOW: () => DEFAULT_WORKFLOW,
+	parseTarget: () => parseTarget
+});
+/**
+* Target identifier utilities
+*
+* Format: agent@workflow:tag (inspired by Docker image:tag)
+* - agent: agent name (optional for @workflow references)
+* - workflow: workflow name (optional, defaults to 'global')
+* - tag: workflow instance tag (optional, defaults to 'main')
+*
+* Examples:
+* - "alice"              → { agent: "alice", workflow: "global", tag: "main", display: "alice" }
+* - "alice@review"       → { agent: "alice", workflow: "review", tag: "main", display: "alice@review" }
+* - "alice@review:pr-123"→ { agent: "alice", workflow: "review", tag: "pr-123", display: "alice@review:pr-123" }
+* - "@review"            → { agent: undefined, workflow: "review", tag: "main", display: "@review" }
+* - "@review:pr-123"     → { agent: undefined, workflow: "review", tag: "pr-123", display: "@review:pr-123" }
+*
+* Display rules:
+* - Omit @global (standalone agents): "alice" not "alice@global"
+* - Omit :main (default tag): "alice@review" not "alice@review:main"
+*/
+const DEFAULT_WORKFLOW = "global";
+const DEFAULT_TAG = "main";
+/**
+* Parse target identifier from string
+* Supports: "agent", "agent@workflow", "agent@workflow:tag", "@workflow", "@workflow:tag"
+*/
+function parseTarget(input) {
+	if (input.startsWith("@")) {
+		const workflowPart = input.slice(1);
+		const colonIndex = workflowPart.indexOf(":");
+		if (colonIndex === -1) {
+			const workflow = workflowPart || DEFAULT_WORKFLOW;
+			return {
+				agent: void 0,
+				workflow,
+				tag: DEFAULT_TAG,
+				full: `@${workflow}:${DEFAULT_TAG}`,
+				display: workflow === DEFAULT_WORKFLOW ? `@${workflow}` : `@${workflow}`
+			};
+		} else {
+			const workflow = workflowPart.slice(0, colonIndex) || DEFAULT_WORKFLOW;
+			const tag = workflowPart.slice(colonIndex + 1) || DEFAULT_TAG;
+			return {
+				agent: void 0,
+				workflow,
+				tag,
+				full: `@${workflow}:${tag}`,
+				display: buildDisplay(void 0, workflow, tag)
+			};
+		}
+	}
+	const atIndex = input.indexOf("@");
+	if (atIndex === -1) return {
+		agent: input,
+		workflow: DEFAULT_WORKFLOW,
+		tag: DEFAULT_TAG,
+		full: `${input}@${DEFAULT_WORKFLOW}:${DEFAULT_TAG}`,
+		display: input
+	};
+	const agent = input.slice(0, atIndex);
+	const workflowPart = input.slice(atIndex + 1);
+	const colonIndex = workflowPart.indexOf(":");
+	if (colonIndex === -1) {
+		const workflow = workflowPart || DEFAULT_WORKFLOW;
+		return {
+			agent,
+			workflow,
+			tag: DEFAULT_TAG,
+			full: `${agent}@${workflow}:${DEFAULT_TAG}`,
+			display: buildDisplay(agent, workflow, DEFAULT_TAG)
+		};
+	} else {
+		const workflow = workflowPart.slice(0, colonIndex) || DEFAULT_WORKFLOW;
+		const tag = workflowPart.slice(colonIndex + 1) || DEFAULT_TAG;
+		return {
+			agent,
+			workflow,
+			tag,
+			full: `${agent}@${workflow}:${tag}`,
+			display: buildDisplay(agent, workflow, tag)
+		};
+	}
+}
+/**
+* Build display string following display rules:
+* - Omit @global for standalone agents
+* - Omit :main for default tag
+*/
+function buildDisplay(agent, workflow, tag) {
+	const isGlobal = workflow === DEFAULT_WORKFLOW;
+	const isMainTag = tag === DEFAULT_TAG;
+	if (agent === void 0) {
+		if (isMainTag) return `@${workflow}`;
+		return `@${workflow}:${tag}`;
+	}
+	if (isGlobal && isMainTag) return agent;
+	if (isGlobal && !isMainTag) return `${agent}@${workflow}:${tag}`;
+	if (!isGlobal && isMainTag) return `${agent}@${workflow}`;
+	return `${agent}@${workflow}:${tag}`;
+}
+
 //#endregion
 //#region src/cli/commands/workflow.ts
 function registerWorkflowCommands(program) {
@@ -2157,7 +2339,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-BGpkJlFb.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CNlUyGit.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2168,8 +2350,8 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 			isCleaningUp = true;
 			console.log("\nInterrupted, cleaning up...");
 			if (controllers) {
-				const { shutdownControllers } = await import("../workflow-BGpkJlFb.mjs");
-				const { createSilentLogger } = await import("../logger-C3ekEOzi.mjs");
+				const { shutdownControllers } = await import("../workflow-CNlUyGit.mjs");
+				const { createSilentLogger } = await import("../logger-Bfdo83xL.mjs");
 				await shutdownControllers(controllers, createSilentLogger());
 			}
 			process.exit(130);
@@ -2206,7 +2388,7 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 					feedback: result.feedback
 				}, null, 2));
 				else if (!options.debug) {
-					const { showWorkflowSummary } = await import("../display-pretty-CWoRE9FY.mjs");
+					const { showWorkflowSummary } = await import("../display-pretty-BCJq5v9d.mjs");
 					showWorkflowSummary({
 						duration: result.duration,
 						document: finalDoc,
@@ -2230,144 +2412,130 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 			process.exit(1);
 		}
 	});
-	program.command("start <file>").description("Start workflow and keep agents running").option("--tag <tag>", "Workflow instance tag (default: main)", DEFAULT_TAG).option("-d, --debug", "Show debug details (internal logs, MCP traces, idle checks)").option("--feedback", "Enable feedback tool (agents can report tool/workflow observations)").option("--background", "Run in background (daemonize)").addHelpText("after", `
+	program.command("start <file>").description("Start workflow via daemon and keep agents running").option("--tag <tag>", "Workflow instance tag (default: main)", DEFAULT_TAG).option("--feedback", "Enable feedback tool (agents can report tool/workflow observations)").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
-  $ agent-worker start review.yaml                    # Foreground (Ctrl+C to stop)
-  $ agent-worker start review.yaml --background       # Background daemon
+  $ agent-worker start review.yaml                    # Start review:main (Ctrl+C to stop)
   $ agent-worker start review.yaml --tag pr-123       # Start review:pr-123
 
+Workflow runs inside the daemon. Use ls/stop to manage:
+  $ agent-worker ls                                   # List all agents
+  $ agent-worker stop @review:pr-123                  # Stop workflow
+
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-BGpkJlFb.mjs");
+		const { parseWorkflowFile } = await import("../workflow-CNlUyGit.mjs");
+		const { ensureDaemon } = await Promise.resolve().then(() => agent_exports);
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
-		if (options.background) {
-			const { getDefaultContextDir } = await Promise.resolve().then(() => file_provider_exports);
-			const contextDir = getDefaultContextDir(workflowName, tag);
-			const args = [
-				process.argv[1] ?? "",
-				"start",
-				file
-			];
-			if (tag !== DEFAULT_TAG) args.push("--tag", tag);
-			if (options.feedback) args.push("--feedback");
-			const child = spawn(process.execPath, args, {
-				detached: true,
-				stdio: "ignore"
+		await ensureDaemon();
+		const res = await startWorkflow({
+			workflow: parsedWorkflow,
+			tag,
+			feedback: options.feedback
+		});
+		if (res.error) {
+			console.error("Error:", res.error);
+			process.exit(1);
+		}
+		const agents = res.agents ?? [];
+		if (options.json) {
+			const { outputJson } = await Promise.resolve().then(() => output_exports);
+			outputJson({
+				name: workflowName,
+				tag,
+				agents
 			});
-			child.unref();
-			console.log(`Workflow: ${workflowName}:${tag}`);
-			console.log(`PID: ${child.pid}`);
-			console.log(`Context: ${contextDir}`);
-			console.log(`\nTo monitor:`);
-			console.log(`  agent-worker ls @${workflowName}:${tag}`);
-			console.log(`  agent-worker peek @${workflowName}:${tag}`);
-			console.log(`\nTo stop:`);
-			console.log(`  agent-worker stop @${workflowName}:${tag}`);
 			return;
 		}
-		let shutdownFn;
+		console.log(`Workflow: @${workflowName}${tag !== "main" ? ":" + tag : ""}`);
+		console.log(`Agents:   ${agents.join(", ")}`);
+		console.log(`\nTo monitor:`);
+		console.log(`  agent-worker ls`);
+		console.log(`  agent-worker peek @${workflowName}${tag !== "main" ? ":" + tag : ""}`);
+		console.log(`\nTo stop:`);
+		console.log(`  agent-worker stop @${workflowName}${tag !== "main" ? ":" + tag : ""}`);
+		let isCleaningUp = false;
 		const cleanup = async () => {
-			console.log("\nShutting down...");
-			if (shutdownFn) await shutdownFn();
+			if (isCleaningUp) return;
+			isCleaningUp = true;
+			console.log("\nStopping workflow...");
+			await stopWorkflow(workflowName, tag);
 			process.exit(0);
 		};
 		process.on("SIGINT", cleanup);
 		process.on("SIGTERM", cleanup);
-		try {
-			const result = await runWorkflowWithControllers({
-				workflow: parsedWorkflow,
-				workflowName,
-				tag,
-				instance: `${workflowName}:${tag}`,
-				debug: options.debug,
-				log: console.log,
-				mode: "start",
-				feedback: options.feedback
-			});
-			if (!result.success) {
-				console.error("Workflow failed:", result.error);
-				process.exit(1);
-			}
-			shutdownFn = result.shutdown;
-			await new Promise(() => {});
-		} catch (error) {
-			console.error("Error:", error instanceof Error ? error.message : String(error));
-			await cleanup();
-			process.exit(1);
-		}
+		await new Promise(() => {});
 	});
 }
 
 //#endregion
-//#region src/cli/commands/approval.ts
-function registerApprovalCommands(program) {
-	program.command("pending").description("List pending tool approvals").option("--to <target>", "Target agent").option("--json", "Output as JSON").action(async (options) => {
-		const target = options.to;
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
-		}
-		const res = await sendRequest({ action: "pending" }, target);
-		if (!res.success) {
-			console.error("Error:", res.error);
-			process.exit(1);
+//#region src/cli/commands/send.ts
+/**
+* Get agent names for a workflow from the daemon.
+* Falls back to ["user"] if daemon is not running.
+*/
+async function getWorkflowAgentNames(workflow, tag) {
+	if (!isDaemonActive()) return ["user"];
+	try {
+		const names = ((await listAgents()).agents ?? []).filter((a) => a.workflow === workflow && a.tag === tag).map((a) => a.name);
+		return [...new Set([...names, "user"])];
+	} catch {
+		return ["user"];
+	}
+}
+/**
+* Get a context provider for the given workflow:tag.
+*/
+async function getContextProvider(workflow, tag) {
+	const dir = getDefaultContextDir(workflow, tag);
+	mkdirSync(dir, { recursive: true });
+	return createFileContextProvider(dir, await getWorkflowAgentNames(workflow, tag));
+}
+function registerSendCommands(program) {
+	program.command("send <target> <message>").description("Send message to agent or workflow channel").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ agent-worker send alice "analyze this code"
+  $ agent-worker send @review "team update"
+  $ agent-worker send @review "@alice @bob discuss this"
+    `).action(async (targetInput, message, options) => {
+		const target = parseTarget(targetInput);
+		const entry = await (await getContextProvider(target.workflow, target.tag)).appendChannel("user", message);
+		if (options.json) outputJson({
+			id: entry.id,
+			timestamp: entry.timestamp,
+			mentions: entry.mentions,
+			target: target.display
+		});
+		else if (entry.mentions.length > 0) console.log(`→ @${entry.mentions.join(" @")}`);
+		else console.log("→ (broadcast)");
+	});
+	program.command("peek [target]").description("View channel messages (default: @global)").option("--json", "Output as JSON").option("--all", "Show all messages").option("-n, --last <count>", "Show last N messages", parseInt).option("--find <text>", "Filter messages containing text").addHelpText("after", `
+Examples:
+  $ agent-worker peek
+  $ agent-worker peek @review
+  $ agent-worker peek @review:pr-123
+    `).action(async (targetInput, options) => {
+		const target = parseTarget(targetInput || `@${DEFAULT_WORKFLOW}`);
+		const provider = await getContextProvider(target.workflow, target.tag);
+		const limit = options.all ? void 0 : options.last ?? 10;
+		let messages = await provider.readChannel({ limit });
+		if (options.find) {
+			const searchText = options.find.toLowerCase();
+			messages = messages.filter((msg) => msg.content.toLowerCase().includes(searchText));
 		}
-		const pending = res.data;
 		if (options.json) {
-			console.log(JSON.stringify(pending, null, 2));
+			outputJson(messages);
 			return;
 		}
-		if (pending.length === 0) {
-			console.log("No pending approvals");
+		if (messages.length === 0) {
+			console.log(options.find ? "No messages found" : "No messages");
 			return;
 		}
-		for (const p of pending) {
-			console.log(`[${p.id.slice(0, 8)}] ${p.toolName}`);
-			console.log(`  Arguments: ${JSON.stringify(p.arguments)}`);
-		}
-	});
-	program.command("approve <id>").description("Approve a pending tool call").option("--to <target>", "Target agent").option("--json", "Output as JSON").action(async (id, options) => {
-		const target = options.to;
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
-		}
-		const res = await sendRequest({
-			action: "approve",
-			payload: { id }
-		}, target);
-		if (!res.success) {
-			console.error("Error:", res.error);
-			process.exit(1);
-		}
-		if (options.json) console.log(JSON.stringify({
-			approved: true,
-			result: res.data
-		}, null, 2));
-		else {
-			console.log("Approved");
-			console.log(`Result: ${JSON.stringify(res.data, null, 2)}`);
-		}
-	});
-	program.command("deny <id>").description("Deny a pending tool call").option("--to <target>", "Target agent").option("-r, --reason <reason>", "Reason for denial").action(async (id, options) => {
-		const target = options.to;
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
-		}
-		const res = await sendRequest({
-			action: "deny",
-			payload: {
-				id,
-				reason: options.reason
-			}
-		}, target);
-		if (res.success) console.log("Denied");
+		for (const msg of messages) if (msg.kind === "system" || msg.kind === "debug") console.log(`  ~ ${msg.from}: ${msg.content}`);
 		else {
-			console.error("Error:", res.error);
-			process.exit(1);
+			const mentions = msg.mentions.length > 0 ? ` → @${msg.mentions.join(" @")}` : "";
+			console.log(`[${msg.from}]${mentions} ${msg.content}`);
 		}
 	});
 }
@@ -2433,7 +2601,7 @@ function registerInfoCommands(program) {
 		console.log(`\nDefault: ${defaultModel} (when no model specified)`);
 	});
 	program.command("backends").description("Check available backends (SDK, CLI tools)").action(async () => {
-		const { listBackends } = await import("../backends-e6gCxRZ9.mjs");
+		const { listBackends } = await import("../backends-DG5igQii.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2463,7 +2631,7 @@ Examples:
   $ agent-worker doc read @review:pr-123     # Read specific workflow:tag document
     `).action(async (targetInput) => {
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-dgI2YCGG.mjs");
+		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
@@ -2481,7 +2649,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-dgI2YCGG.mjs");
+		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
@@ -2499,7 +2667,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-dgI2YCGG.mjs");
+		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
@@ -2511,77 +2679,9 @@ async function resolveDir(targetInput) {
 	return getDefaultContextDir(target.workflow, target.tag);
 }
 
-//#endregion
-//#region src/cli/commands/mock.ts
-function registerMockCommands(program) {
-	program.command("mock").description("Mock responses for testing").command("tool <name> <response>").description("Set mock response for a tool").option("--to <target>", "Target agent").addHelpText("after", `
-Examples:
-  $ agent-worker mock tool get_weather '{"temp": 72, "condition": "sunny"}'
-  $ agent-worker mock tool read_file '{"content": "Hello World"}' --to alice
-    `).action(async (name, response, options) => {
-		const target = options.to;
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
-		}
-		try {
-			const res = await sendRequest({
-				action: "tool_mock",
-				payload: {
-					name,
-					response: JSON.parse(response)
-				}
-			}, target);
-			if (res.success) console.log(`Mock set for: ${name}`);
-			else {
-				console.error("Error:", res.error);
-				process.exit(1);
-			}
-		} catch {
-			console.error("Invalid JSON response. The response parameter must be valid JSON.");
-			console.error("Example: agent-worker mock tool my-tool '{\"result\": \"success\"}'");
-			process.exit(1);
-		}
-	});
-}
-
-//#endregion
-//#region src/cli/commands/feedback.ts
-function registerFeedbackCommand(program) {
-	program.command("feedback [target]").description("View agent feedback and observations").option("--json", "Output as JSON").addHelpText("after", `
-Examples:
-  $ agent-worker feedback                # View default agent feedback
-  $ agent-worker feedback alice          # View alice's feedback
-  $ agent-worker feedback --json         # JSON output
-
-Note: Requires agent to be created with --feedback flag
-    `).action(async (target, options) => {
-		if (!isSessionActive(target)) {
-			console.error(target ? `Agent not found: ${target}` : "No active agent");
-			process.exit(1);
-		}
-		const res = await sendRequest({ action: "feedback_list" }, target);
-		if (!res.success) {
-			console.error("Error:", res.error);
-			process.exit(1);
-		}
-		const entries = res.data;
-		if (options.json) {
-			outputJson(entries);
-			return;
-		}
-		if (entries.length === 0) console.log("No feedback yet");
-		else for (const entry of entries) {
-			const icon = entry.type === "missing" ? "[missing]" : entry.type === "friction" ? "[friction]" : "[suggestion]";
-			console.log(`  ${icon} ${entry.target}: ${entry.description}`);
-			if (entry.context) console.log(`         context: ${entry.context}`);
-		}
-	});
-}
-
 //#endregion
 //#region package.json
-var version = "0.10.0";
+var version = "0.12.0";
 
 //#endregion
 //#region src/cli/index.ts
@@ -2596,15 +2696,12 @@ process.stderr.write = function(chunk, ...rest) {
 };
 const program = new Command();
 program.name("agent-worker").description("CLI for creating and managing AI agents").version(version);
+registerWorkflowCommands(program);
 registerAgentCommands(program);
 registerSendCommands(program);
-registerMockCommands(program);
-registerFeedbackCommand(program);
-registerWorkflowCommands(program);
-registerApprovalCommands(program);
 registerInfoCommands(program);
 registerDocCommands(program);
 program.parse();
 
 //#endregion
-export { shouldUseResource as _, FileStorage as a, CONTEXT_DEFAULTS as c, RESOURCE_PREFIX as d, RESOURCE_SCHEME as f, generateResourceId as g, extractMentions as h, resolveContextDir as i, MENTION_PATTERN as l, createResourceRef as m, createFileContextProvider as n, MemoryStorage as o, calculatePriority as p, getDefaultContextDir as r, ContextProviderImpl as s, FileContextProvider as t, MESSAGE_LENGTH_THRESHOLD as u };
+export { formatToolParams as C, formatInbox as S, EventLog as T, shouldUseResource as _, FileStorage as a, formatProposalList as b, CONTEXT_DEFAULTS as c, RESOURCE_PREFIX as d, RESOURCE_SCHEME as f, generateResourceId as g, extractMentions as h, resolveContextDir as i, MENTION_PATTERN as l, createResourceRef as m, createFileContextProvider as n, MemoryStorage as o, calculatePriority as p, getDefaultContextDir as r, ContextProviderImpl as s, FileContextProvider as t, MESSAGE_LENGTH_THRESHOLD as u, createContextMCPServer as v, getAgentId as w, createLogTool as x, formatProposal as y };