agent-worker 0.12.0 → 0.14.0

package/dist/cli/index.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-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 { A as parseModel, I as getDefaultModel, P as createModelAsync, a as createMockBackend, j as FRONTIER_MODELS, k as normalizeBackendType, n as createBackend } from "../backends-C6WBIn9H.mjs";
+import { generateText, jsonSchema, stepCountIs, tool } from "ai";
 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 { execSync, spawn } from "node:child_process";
 import { Command, Option } from "commander";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -14,6 +14,11 @@ 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";
+import { createServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { MockLanguageModelV3, mockValues } from "ai/test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -77,39 +82,53 @@ function isDaemonRunning() {
 		return null;
 	}
 }
-
-//#endregion
-//#region src/agent/handle.ts
+const DURATION_RE = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/;
 /**
-* 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.
-*/
-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();
+* 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
+	};
+}
 
 //#endregion
 //#region src/agent/store.ts
@@ -220,7 +239,7 @@ function getAgentId(extra) {
 /**
 * Format inbox messages for JSON display.
 */
-function formatInbox(messages) {
+function formatInbox$1(messages) {
 	if (messages.length === 0) return JSON.stringify({
 		messages: [],
 		count: 0
@@ -359,7 +378,7 @@ function registerInboxTools(server, ctx, options) {
 		if (debugLog && messages.length > 0) debugLog(`[mcp:${agent}] my_inbox → ${messages.length} unread`);
 		return { content: [{
 			type: "text",
-			text: formatInbox(messages)
+			text: formatInbox$1(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) => {
@@ -1420,19 +1439,1200 @@ function createFileContextProvider(contextDir, validAgents) {
 	return new FileContextProvider(new FileStorage(contextDir), validAgents, contextDir);
 }
 
+//#endregion
+//#region src/workflow/context/http-transport.ts
+/**
+* HTTP-based MCP Transport
+*
+* Hosts MCP server over HTTP using StreamableHTTPServerTransport.
+* CLI agents (cursor, claude, codex) connect directly via URL — no subprocess bridge needed.
+*
+* Each agent gets a unique URL: http://localhost:<port>/mcp?agent=<name>
+* The agent name is used as the MCP session ID, so tool handlers
+* receive it via extra.sessionId → getAgentId().
+*/
+/**
+* Parse request body as JSON
+*/
+function parseRequestBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => {
+			try {
+				const body = Buffer.concat(chunks).toString();
+				resolve(body ? JSON.parse(body) : void 0);
+			} catch (err) {
+				reject(err);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+/**
+* Check if a JSON-RPC message is an initialize request
+*/
+function isInitializeRequest(body) {
+	if (Array.isArray(body)) return body.some((msg) => msg?.method === "initialize");
+	return body?.method === "initialize";
+}
+/**
+* Start an HTTP MCP server
+*
+* Agents connect via: http://localhost:<port>/mcp?agent=<name>
+* The server creates a per-session StreamableHTTPServerTransport and McpServer.
+*/
+async function runWithHttp(options) {
+	const { createServerInstance, port = 0, onConnect, onDisconnect } = options;
+	const sessions = /* @__PURE__ */ new Map();
+	const httpServer = createServer(async (req, res) => {
+		const reqUrl = new URL(req.url || "/", `http://localhost`);
+		if (!reqUrl.pathname.startsWith("/mcp")) {
+			res.writeHead(404, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Not found" }));
+			return;
+		}
+		const agentName = reqUrl.searchParams.get("agent") || "anonymous";
+		const sessionId = req.headers["mcp-session-id"];
+		if (sessionId && sessions.has(sessionId)) {
+			const session = sessions.get(sessionId);
+			if (req.method === "DELETE") {
+				await session.transport.close();
+				sessions.delete(sessionId);
+				if (onDisconnect) onDisconnect(session.agentId, sessionId);
+				res.writeHead(200);
+				res.end();
+				return;
+			}
+			const body = req.method === "POST" ? await parseRequestBody(req) : void 0;
+			await session.transport.handleRequest(req, res, body);
+			return;
+		}
+		if (req.method === "POST") {
+			const body = await parseRequestBody(req);
+			if (!isInitializeRequest(body)) {
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: "Bad request: session required" }));
+				return;
+			}
+			const transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => `${agentName}-${randomUUID().slice(0, 8)}`,
+				onsessioninitialized: (sid) => {
+					sessions.set(sid, {
+						transport,
+						agentId: agentName
+					});
+					if (onConnect) onConnect(agentName, sid);
+				}
+			});
+			Object.defineProperty(transport, "_agentId", {
+				value: agentName,
+				writable: true
+			});
+			await createServerInstance().connect(transport);
+			await transport.handleRequest(req, res, body);
+			return;
+		}
+		if (req.method === "GET") {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Session ID required for GET requests" }));
+			return;
+		}
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Method not allowed" }));
+	});
+	const actualPort = await new Promise((resolve, reject) => {
+		httpServer.on("error", reject);
+		httpServer.listen(port, "127.0.0.1", () => {
+			httpServer.removeListener("error", reject);
+			const addr = httpServer.address();
+			if (typeof addr === "object" && addr) resolve(addr.port);
+			else reject(/* @__PURE__ */ new Error("Failed to get server address"));
+		});
+	});
+	return {
+		httpServer,
+		url: `http://127.0.0.1:${actualPort}/mcp`,
+		port: actualPort,
+		sessions,
+		async close() {
+			for (const [sid, session] of sessions) {
+				await session.transport.close();
+				if (onDisconnect) onDisconnect(session.agentId, sid);
+			}
+			sessions.clear();
+			await new Promise((resolve) => {
+				httpServer.close(() => resolve());
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/workflow/controller/types.ts
+/** Default controller configuration values */
+const CONTROLLER_DEFAULTS = {
+	pollInterval: 5e3,
+	retry: {
+		maxAttempts: 3,
+		backoffMs: 1e3,
+		backoffMultiplier: 2
+	},
+	recentChannelLimit: 50,
+	idleDebounceMs: 2e3
+};
+
+//#endregion
+//#region src/workflow/controller/prompt.ts
+/**
+* Format inbox messages for display
+*/
+function formatInbox(inbox) {
+	if (inbox.length === 0) return "(no messages)";
+	return inbox.map((m) => {
+		const priority = m.priority === "high" ? " [HIGH]" : "";
+		const time = m.entry.timestamp.slice(11, 19);
+		const dm = m.entry.to ? " [DM]" : "";
+		return `- [${time}] From @${m.entry.from}${priority}${dm}: ${m.entry.content}`;
+	}).join("\n");
+}
+/**
+* Build the complete agent prompt from run context
+*/
+function buildAgentPrompt(ctx) {
+	const sections = [];
+	sections.push("## Project");
+	sections.push(`Working on: ${ctx.projectDir}`);
+	sections.push("");
+	sections.push(`## Inbox (${ctx.inbox.length} message${ctx.inbox.length === 1 ? "" : "s"} for you)`);
+	sections.push(formatInbox(ctx.inbox));
+	sections.push("");
+	sections.push("## Recent Activity");
+	sections.push("Use channel_read tool to view recent channel messages and conversation context if needed.");
+	if (ctx.documentContent) {
+		sections.push("");
+		sections.push("## Shared Document");
+		sections.push(ctx.documentContent);
+	}
+	if (ctx.retryAttempt > 1) {
+		sections.push("");
+		sections.push(`## Note`);
+		sections.push(`This is retry attempt ${ctx.retryAttempt}. Previous attempt failed.`);
+	}
+	sections.push("");
+	sections.push("## Instructions");
+	sections.push("You are an agent in a multi-agent workflow. Communicate ONLY through the MCP tools below.");
+	sections.push("Your text output is NOT seen by other agents — you MUST use channel_send to communicate.");
+	sections.push("");
+	sections.push("### Channel Tools");
+	sections.push("- **channel_send**: Send a message to the shared channel. Use @agentname to mention/notify.");
+	sections.push("  Use the \"to\" parameter for private DMs: channel_send({ message: \"...\", to: \"bob\" })");
+	sections.push("- **channel_read**: Read recent channel messages (DMs and logs are auto-filtered).");
+	sections.push("");
+	sections.push("### Team Tools");
+	sections.push("- **team_members**: List all agents you can @mention. Pass includeStatus=true to see their current state and tasks.");
+	sections.push("- **team_doc_read/write/append/list/create**: Shared team documents.");
+	sections.push("");
+	sections.push("### Personal Tools");
+	sections.push("- **my_inbox**: Check your unread messages.");
+	sections.push("- **my_inbox_ack**: Acknowledge messages after processing (pass the latest message ID).");
+	sections.push("- **my_status_set**: Update your status. Call when starting work (state='running', task='...') or when done (state='idle').");
+	sections.push("");
+	sections.push("### Proposal & Voting Tools");
+	sections.push("- **team_proposal_create**: Create a proposal for team voting (types: election, decision, approval, assignment).");
+	sections.push("- **team_vote**: Cast your vote on an active proposal. You can change your vote by voting again.");
+	sections.push("- **team_proposal_status**: Check status of a proposal, or list all active proposals.");
+	sections.push("- **team_proposal_cancel**: Cancel a proposal you created.");
+	sections.push("");
+	sections.push("### Resource Tools");
+	sections.push("- **resource_create**: Store large content, get a reference (resource:id) for use anywhere.");
+	sections.push("- **resource_read**: Read resource content by ID.");
+	if (ctx.feedback) {
+		sections.push("");
+		sections.push("### Feedback Tool");
+		sections.push("- **feedback_submit**: Report workflow improvement needs — a missing tool, an awkward step, or a capability gap.");
+		sections.push("  Only use when you genuinely hit a pain point during your work.");
+	}
+	sections.push("");
+	sections.push("### Workflow");
+	sections.push("1. Read your inbox messages above");
+	sections.push("2. Do your assigned work using channel_send with @mentions");
+	sections.push("3. Acknowledge your inbox with my_inbox_ack");
+	sections.push("4. Exit when your task is complete");
+	sections.push("");
+	sections.push("### IMPORTANT: When to stop");
+	sections.push("- Once your assigned task is complete, acknowledge your inbox and exit. Do NOT keep chatting.");
+	sections.push("- Do NOT send pleasantries (\"you're welcome\", \"glad to help\", \"thanks again\") — they trigger unnecessary cycles.");
+	sections.push("- Do NOT @mention another agent in your final message unless you need them to do more work.");
+	sections.push("- If you receive a thank-you or acknowledgment, just call my_inbox_ack and exit. Do not reply.");
+	return sections.join("\n");
+}
+
+//#endregion
+//#region src/workflow/controller/mcp-config.ts
+/**
+* Generate MCP config for workflow context server.
+*
+* Uses HTTP transport — CLI agents connect directly via URL:
+*   { type: "http", url: "http://127.0.0.1:<port>/mcp?agent=<name>" }
+*/
+function generateWorkflowMCPConfig(mcpUrl, agentName) {
+	const url = `${mcpUrl}?agent=${encodeURIComponent(agentName)}`;
+	return { mcpServers: { "workflow-context": {
+		type: "http",
+		url
+	} } };
+}
+
+//#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;
+}
+function parseIntStrict(s, context) {
+	const n = parseInt(s, 10);
+	if (isNaN(n)) throw new Error(`Invalid number "${s}" in ${context}`);
+	return n;
+}
+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;
+}
+/**
+* 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)
+	};
+}
+/**
+* Check if a Date matches a parsed cron expression.
+*/
+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());
+}
+/**
+* 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.
+*/
+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}`);
+}
+/**
+* Calculate ms until the next cron occurrence.
+*/
+function msUntilNextCron(expr, from = /* @__PURE__ */ new Date()) {
+	return nextCronTime(expr, from).getTime() - from.getTime();
+}
+
+//#endregion
+//#region src/workflow/controller/mock-runner.ts
+/**
+* Mock Agent Runner
+*
+* Orchestrates mock agent execution for workflow integration testing.
+* Uses AI SDK generateText with MockLanguageModelV3 and real MCP tool calls.
+*
+* This lives in the controller layer (not backends) because it does orchestration:
+* connecting to MCP, building prompts, managing tool loops.
+* The mock backend itself is just a simple send() adapter.
+*/
+/**
+* Connect to workflow MCP server via HTTP and create AI SDK tool wrappers
+*/
+async function createMCPToolBridge$1(mcpUrl, agentName) {
+	const transport = new StreamableHTTPClientTransport(new URL(`${mcpUrl}?agent=${encodeURIComponent(agentName)}`));
+	const client = new Client({
+		name: agentName,
+		version: "1.0.0"
+	});
+	await client.connect(transport);
+	const { tools: mcpTools } = await client.listTools();
+	const aiTools = {};
+	for (const mcpTool of mcpTools) {
+		const toolName = mcpTool.name;
+		aiTools[toolName] = tool({
+			description: mcpTool.description || toolName,
+			inputSchema: jsonSchema(mcpTool.inputSchema),
+			execute: async (args) => {
+				return (await client.callTool({
+					name: toolName,
+					arguments: args
+				})).content;
+			}
+		});
+	}
+	return {
+		tools: aiTools,
+		close: () => client.close()
+	};
+}
+/**
+* Run a mock agent with AI SDK and real MCP tools.
+*
+* Used by the controller when backend.type === 'mock'.
+* Unlike real backends that just send(), the mock runner needs to:
+* 1. Connect to MCP server for real tool execution
+* 2. Generate scripted tool calls via MockLanguageModelV3
+* 3. Execute the full tool loop to test channel/document flow
+*/
+async function runMockAgent(ctx, debugLog) {
+	const startTime = Date.now();
+	const log = debugLog || (() => {});
+	try {
+		if (!ctx.mcpUrl) return {
+			success: false,
+			error: "Mock runner requires mcpUrl (HTTP MCP server)",
+			duration: 0
+		};
+		const mcp = await createMCPToolBridge$1(ctx.mcpUrl, ctx.name);
+		log(`MCP connected, ${Object.keys(mcp.tools).length} tools`);
+		const inboxSummary = ctx.inbox.map((m) => `${m.entry.from}: ${m.entry.content.slice(0, 80).replace(/@/g, "")}`).join("; ");
+		const mockModel = new MockLanguageModelV3({ doGenerate: mockValues({
+			content: [{
+				type: "tool-call",
+				toolCallId: `call-${ctx.name}-${Date.now()}`,
+				toolName: "channel_send",
+				input: JSON.stringify({ message: `[${ctx.name}] Processed: ${inboxSummary.slice(0, 200)}` })
+			}],
+			finishReason: {
+				unified: "tool-calls",
+				raw: "tool_use"
+			},
+			usage: {
+				inputTokens: {
+					total: 100,
+					noCache: 100,
+					cacheRead: 0,
+					cacheWrite: 0
+				},
+				outputTokens: {
+					total: 50,
+					text: 50,
+					reasoning: 0
+				}
+			}
+		}, {
+			content: [{
+				type: "text",
+				text: `${ctx.name} done.`
+			}],
+			finishReason: {
+				unified: "stop",
+				raw: "end_turn"
+			},
+			usage: {
+				inputTokens: {
+					total: 50,
+					noCache: 50,
+					cacheRead: 0,
+					cacheWrite: 0
+				},
+				outputTokens: {
+					total: 10,
+					text: 10,
+					reasoning: 0
+				}
+			}
+		}) });
+		const prompt = buildAgentPrompt(ctx);
+		log(`Prompt (${prompt.length} chars)`);
+		const result = await generateText({
+			model: mockModel,
+			tools: mcp.tools,
+			prompt,
+			system: ctx.agent.resolvedSystemPrompt,
+			stopWhen: stepCountIs(3)
+		});
+		const totalToolCalls = result.steps.reduce((n, s) => n + s.toolCalls.length, 0);
+		await mcp.close();
+		return {
+			success: true,
+			duration: Date.now() - startTime,
+			steps: result.steps.length,
+			toolCalls: totalToolCalls
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error),
+			duration: Date.now() - startTime
+		};
+	}
+}
+
+//#endregion
+//#region src/workflow/controller/sdk-runner.ts
+/**
+* SDK Agent Runner
+*
+* Runs SDK agents with full tool access in workflows:
+* - MCP context tools (channel_send, document_write, etc.)
+* - Bash tool for shell commands
+*
+* Same pattern as mock-runner.ts but with real models via createModelAsync.
+* This is the standard execution path for SDK backends in workflows —
+* all agents get MCP + bash regardless of backend type.
+*/
+/** Extract useful details from AI SDK errors (statusCode, url, responseBody) */
+function formatError(error) {
+	if (!(error instanceof Error)) return String(error);
+	const e = error;
+	const parts = [error.message];
+	if (e.statusCode) parts[0] = `HTTP ${e.statusCode}: ${error.message}`;
+	if (e.url) parts.push(`url=${e.url}`);
+	if (e.responseBody && typeof e.responseBody === "string") {
+		const body = e.responseBody.length > 200 ? e.responseBody.slice(0, 200) + "…" : e.responseBody;
+		parts.push(`body=${body}`);
+	}
+	return parts.join(" ");
+}
+/** Truncate string, flatten newlines */
+function truncate(s, max) {
+	const flat = s.replace(/\s+/g, " ").trim();
+	return flat.length > max ? flat.slice(0, max) + "…" : flat;
+}
+/** Format a tool call for concise single-line debug output (function call syntax) */
+function formatToolCall(tc) {
+	const input = tc.input ?? tc.args ?? {};
+	const pairs = Object.entries(input).map(([k, v]) => {
+		return `${k}=${truncate(typeof v === "string" ? v : JSON.stringify(v), 60)}`;
+	});
+	return `${tc.toolName}(${pairs.join(", ")})`;
+}
+/**
+* Connect to workflow MCP server and create AI SDK tool wrappers.
+* Same bridge as mock-runner — extracted here for SDK agents.
+*/
+async function createMCPToolBridge(mcpUrl, agentName) {
+	const transport = new StreamableHTTPClientTransport(new URL(`${mcpUrl}?agent=${encodeURIComponent(agentName)}`));
+	const client = new Client({
+		name: agentName,
+		version: "1.0.0"
+	});
+	await client.connect(transport);
+	const { tools: mcpTools } = await client.listTools();
+	const aiTools = {};
+	for (const mcpTool of mcpTools) {
+		const toolName = mcpTool.name;
+		aiTools[toolName] = tool({
+			description: mcpTool.description || toolName,
+			inputSchema: jsonSchema(mcpTool.inputSchema),
+			execute: async (args) => {
+				return (await client.callTool({
+					name: toolName,
+					arguments: args
+				})).content;
+			}
+		});
+	}
+	return {
+		tools: aiTools,
+		close: () => client.close()
+	};
+}
+function createBashTool() {
+	return tool({
+		description: "Execute a shell command and return stdout/stderr.",
+		inputSchema: jsonSchema({
+			type: "object",
+			properties: { command: {
+				type: "string",
+				description: "The shell command to execute"
+			} },
+			required: ["command"]
+		}),
+		execute: async ({ command }) => {
+			try {
+				return execSync(command, {
+					encoding: "utf-8",
+					timeout: 12e4
+				}).trim() || "(no output)";
+			} catch (error) {
+				return `Error (exit ${error.status}): ${error.stderr || error.message}`;
+			}
+		}
+	});
+}
+/**
+* Run an SDK agent with real model + MCP tools + bash.
+*
+* Used by the controller when backend.type === 'default'.
+* Unlike the simple SdkBackend.send() (text-only), this runner:
+* 1. Connects to MCP server for context tools (channel, document)
+* 2. Adds bash tool for shell access
+* 3. Runs generateText with full tool loop
+*/
+async function runSdkAgent(ctx, debugLog) {
+	const startTime = Date.now();
+	const log = debugLog || (() => {});
+	try {
+		if (!ctx.mcpUrl) return {
+			success: false,
+			error: "SDK runner requires mcpUrl",
+			duration: 0
+		};
+		const mcp = await createMCPToolBridge(ctx.mcpUrl, ctx.name);
+		log(`MCP connected, ${Object.keys(mcp.tools).length} context tools`);
+		const model = await createModelAsync(ctx.agent.model);
+		const tools = {
+			...mcp.tools,
+			bash: createBashTool()
+		};
+		const prompt = buildAgentPrompt(ctx);
+		log(`Prompt (${prompt.length} chars) → sdk with ${Object.keys(tools).length} tools`);
+		let _stepNum = 0;
+		const result = await generateText({
+			model,
+			tools,
+			system: ctx.agent.resolvedSystemPrompt,
+			prompt,
+			maxOutputTokens: ctx.agent.max_tokens ?? 8192,
+			stopWhen: stepCountIs(ctx.agent.max_steps ?? 200),
+			onStepFinish: (step) => {
+				_stepNum++;
+				if (step.toolCalls?.length && ctx.eventLog) {
+					for (const tc of step.toolCalls) if (tc.toolName === "bash") ctx.eventLog.toolCall(ctx.name, tc.toolName, formatToolCall(tc), "sdk");
+				}
+			}
+		});
+		const totalToolCalls = result.steps.reduce((n, s) => n + s.toolCalls.length, 0);
+		const lastStep = result.steps[result.steps.length - 1];
+		if (ctx.agent.max_steps && result.steps.length >= ctx.agent.max_steps && (lastStep?.toolCalls?.length ?? 0) > 0) {
+			const warning = `⚠️  Agent reached max_steps limit (${ctx.agent.max_steps}) but wanted to continue. Consider increasing max_steps or removing the limit.`;
+			log(warning);
+			await ctx.provider.appendChannel(ctx.name, warning, { kind: "system" }).catch(() => {});
+		}
+		await mcp.close();
+		return {
+			success: true,
+			duration: Date.now() - startTime,
+			content: result.text,
+			steps: result.steps.length,
+			toolCalls: totalToolCalls
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: formatError(error),
+			duration: Date.now() - startTime
+		};
+	}
+}
+
+//#endregion
+//#region src/workflow/controller/controller.ts
+/** Check if controller should continue running */
+function shouldContinue(state) {
+	return state !== "stopped";
+}
+/**
+* Create an agent controller
+*
+* The controller:
+* 1. Polls for inbox messages on an interval
+* 2. Runs the agent when messages are found
+* 3. Acknowledges inbox only on successful run
+* 4. Retries with exponential backoff on failure
+* 5. Can be woken early via wake()
+*/
+function createAgentController(config) {
+	const { name, agent, contextProvider, eventLog, mcpUrl, workspaceDir, projectDir, backend, onRunComplete, log = () => {}, feedback } = config;
+	const infoLog = config.infoLog ?? log;
+	const errorLog = config.errorLog ?? log;
+	const pollInterval = config.pollInterval ?? CONTROLLER_DEFAULTS.pollInterval;
+	const retryConfig = {
+		maxAttempts: config.retry?.maxAttempts ?? CONTROLLER_DEFAULTS.retry.maxAttempts,
+		backoffMs: config.retry?.backoffMs ?? CONTROLLER_DEFAULTS.retry.backoffMs,
+		backoffMultiplier: config.retry?.backoffMultiplier ?? CONTROLLER_DEFAULTS.retry.backoffMultiplier
+	};
+	let state = "stopped";
+	let wakeResolver = null;
+	let pollTimeout = null;
+	let directRunning = false;
+	const scheduleConfig = agent.schedule;
+	let resolvedSchedule;
+	if (scheduleConfig) try {
+		resolvedSchedule = resolveSchedule(scheduleConfig);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new Error(`Agent "${name}" has invalid schedule config: ${msg}`);
+	}
+	let lastActivityTime = Date.now();
+	/**
+	* Wait for either poll interval or wake() call
+	*/
+	async function waitForWakeOrPoll() {
+		return new Promise((resolve) => {
+			wakeResolver = resolve;
+			pollTimeout = setTimeout(() => {
+				wakeResolver = null;
+				resolve();
+			}, pollInterval);
+		});
+	}
+	/**
+	* Main controller loop
+	*/
+	async function runLoop() {
+		while (shouldContinue(state)) {
+			await waitForWakeOrPoll();
+			if (!shouldContinue(state)) break;
+			if (directRunning) continue;
+			const inbox = await contextProvider.getInbox(name);
+			if (inbox.length === 0) {
+				if (resolvedSchedule) {
+					const now = Date.now();
+					let wakeupDue = false;
+					if (resolvedSchedule.type === "interval") {
+						if (now - lastActivityTime >= resolvedSchedule.ms) wakeupDue = true;
+					} else if (resolvedSchedule.type === "cron") {
+						const msTillNext = msUntilNextCron(resolvedSchedule.expr, new Date(lastActivityTime));
+						if (now >= lastActivityTime + msTillNext) wakeupDue = true;
+					}
+					if (wakeupDue) {
+						const wakeupPrompt = resolvedSchedule.prompt ?? "Scheduled wakeup. Check for any pending work or updates.";
+						log(`Schedule wakeup triggered for ${name}`);
+						await contextProvider.appendChannel("system", `@${name} ${wakeupPrompt}`);
+						lastActivityTime = now;
+						continue;
+					}
+				}
+				state = "idle";
+				await contextProvider.setAgentStatus(name, { state: "idle" });
+				continue;
+			}
+			const senders = inbox.map((m) => m.entry.from);
+			infoLog(`Inbox: ${inbox.length} message(s) from [${senders.join(", ")}]`);
+			for (const msg of inbox) {
+				const preview = msg.entry.content.length > 120 ? msg.entry.content.slice(0, 120) + "..." : msg.entry.content;
+				log(`  from @${msg.entry.from}: ${preview}`);
+			}
+			const latestId = inbox[inbox.length - 1].entry.id;
+			await contextProvider.markInboxSeen(name, latestId);
+			let attempt = 0;
+			let lastResult = null;
+			while (attempt < retryConfig.maxAttempts && shouldContinue(state)) {
+				attempt++;
+				state = "running";
+				await contextProvider.setAgentStatus(name, { state: "running" });
+				infoLog(`Running (attempt ${attempt}/${retryConfig.maxAttempts})`);
+				lastResult = await runAgent(backend, {
+					name,
+					agent,
+					inbox,
+					recentChannel: await contextProvider.readChannel({
+						limit: CONTROLLER_DEFAULTS.recentChannelLimit,
+						agent: name
+					}),
+					documentContent: await contextProvider.readDocument(),
+					mcpUrl,
+					workspaceDir,
+					projectDir,
+					retryAttempt: attempt,
+					provider: contextProvider,
+					eventLog,
+					feedback
+				}, log, infoLog);
+				if (lastResult.success) {
+					infoLog(`DONE ${lastResult.steps ? `${lastResult.steps} steps, ${lastResult.toolCalls} tool calls, ${lastResult.duration}ms` : `${lastResult.duration}ms`}`);
+					if (lastResult.content) await contextProvider.appendChannel(name, lastResult.content);
+					await contextProvider.ackInbox(name, latestId);
+					lastActivityTime = Date.now();
+					await contextProvider.setAgentStatus(name, { state: "idle" });
+					break;
+				}
+				errorLog(`ERROR ${lastResult.error}`);
+				if (attempt < retryConfig.maxAttempts && shouldContinue(state)) {
+					const delay = retryConfig.backoffMs * Math.pow(retryConfig.backoffMultiplier, attempt - 1);
+					log(`Retrying in ${delay}ms...`);
+					await sleep(delay);
+				}
+			}
+			if (lastResult && !lastResult.success) {
+				errorLog(`ERROR max retries exhausted, acknowledging to prevent loop`);
+				await contextProvider.ackInbox(name, latestId);
+			}
+			if (lastResult && onRunComplete) onRunComplete(lastResult);
+			state = "idle";
+			await contextProvider.setAgentStatus(name, { state: "idle" });
+		}
+	}
+	return {
+		get name() {
+			return name;
+		},
+		get state() {
+			return state;
+		},
+		async start() {
+			if (state !== "stopped") throw new Error(`Controller ${name} is already running`);
+			state = "idle";
+			lastActivityTime = Date.now();
+			await contextProvider.setAgentStatus(name, { state: "idle" });
+			if (resolvedSchedule) infoLog(`Starting (schedule: ${resolvedSchedule.type === "interval" ? `${resolvedSchedule.ms}ms interval` : `cron "${resolvedSchedule.expr}"`})`);
+			else infoLog(`Starting`);
+			runLoop().catch((error) => {
+				errorLog(`ERROR ${error instanceof Error ? error.message : String(error)}`);
+				state = "stopped";
+				contextProvider.setAgentStatus(name, { state: "stopped" }).catch(() => {});
+			});
+		},
+		async stop() {
+			log(`Stopping`);
+			state = "stopped";
+			await contextProvider.setAgentStatus(name, { state: "stopped" });
+			if (backend.abort) backend.abort();
+			if (pollTimeout) {
+				clearTimeout(pollTimeout);
+				pollTimeout = null;
+			}
+			if (wakeResolver) {
+				wakeResolver();
+				wakeResolver = null;
+			}
+		},
+		wake() {
+			if (state === "idle" && wakeResolver) {
+				log(`Waking`);
+				if (pollTimeout) {
+					clearTimeout(pollTimeout);
+					pollTimeout = null;
+				}
+				wakeResolver();
+				wakeResolver = null;
+			}
+		},
+		async sendDirect(message) {
+			if (directRunning) return {
+				success: false,
+				error: "Agent is already processing a direct request",
+				duration: 0
+			};
+			if (state === "running") return {
+				success: false,
+				error: "Agent is currently running (poll loop)",
+				duration: 0
+			};
+			directRunning = true;
+			const prevState = state;
+			state = "running";
+			await contextProvider.setAgentStatus(name, { state: "running" });
+			try {
+				await contextProvider.appendChannel("user", `@${name} ${message}`);
+				const inbox = await contextProvider.getInbox(name);
+				const latestId = inbox.length > 0 ? inbox[inbox.length - 1].entry.id : void 0;
+				if (latestId) await contextProvider.markInboxSeen(name, latestId);
+				const runContext = {
+					name,
+					agent,
+					inbox,
+					recentChannel: await contextProvider.readChannel({
+						limit: CONTROLLER_DEFAULTS.recentChannelLimit,
+						agent: name
+					}),
+					documentContent: await contextProvider.readDocument(),
+					mcpUrl,
+					workspaceDir,
+					projectDir,
+					retryAttempt: 1,
+					provider: contextProvider,
+					eventLog,
+					feedback
+				};
+				infoLog(`Direct send (${message.length} chars)`);
+				const result = await runAgent(backend, runContext, log, infoLog);
+				if (result.success) {
+					if (result.content) await contextProvider.appendChannel(name, result.content);
+					if (latestId) await contextProvider.ackInbox(name, latestId);
+					lastActivityTime = Date.now();
+				}
+				return result;
+			} finally {
+				directRunning = false;
+				state = prevState === "stopped" ? "stopped" : "idle";
+				await contextProvider.setAgentStatus(name, { state }).catch(() => {});
+			}
+		}
+	};
+}
+/**
+* Run an agent: build prompt, configure workspace, call backend.send()
+*
+* This is the single orchestration function that the controller calls.
+* All the "how to run an agent" logic lives here — backends just send().
+*
+* SDK and mock backends get special runners with MCP tool bridge + bash,
+* because they can't manage tools on their own (unlike CLI backends).
+*/
+async function runAgent(backend, ctx, log, infoLog) {
+	const info = infoLog ?? log;
+	if (backend.type === "mock") return runMockAgent(ctx, (msg) => log(msg));
+	if (backend.type === "default") return runSdkAgent(ctx, (msg) => log(msg));
+	const startTime = Date.now();
+	try {
+		if (backend.setWorkspace) {
+			const mcpConfig = generateWorkflowMCPConfig(ctx.mcpUrl, ctx.name);
+			backend.setWorkspace(ctx.workspaceDir, mcpConfig);
+		}
+		const prompt = buildAgentPrompt(ctx);
+		info(`Prompt (${prompt.length} chars) → ${backend.type} backend`);
+		const response = await backend.send(prompt, { system: ctx.agent.resolvedSystemPrompt });
+		return {
+			success: true,
+			duration: Date.now() - startTime,
+			content: response.content
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error),
+			duration: Date.now() - startTime
+		};
+	}
+}
+/**
+* Sleep helper
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Check if workflow is complete (all agents idle, no pending work)
+*/
+async function checkWorkflowIdle(controllers, provider, debounceMs = CONTROLLER_DEFAULTS.idleDebounceMs) {
+	if (![...controllers.values()].every((c) => c.state === "idle")) return false;
+	for (const [name] of controllers) if ((await provider.getInbox(name)).length > 0) return false;
+	await sleep(debounceMs);
+	return [...controllers.values()].every((c) => c.state === "idle");
+}
+
+//#endregion
+//#region src/workflow/controller/backend.ts
+/**
+* Get backend by explicit backend type
+*
+* All backends are created via the canonical createBackend() factory
+* from backends/index.ts. Mock backend is handled specially (no model needed).
+*/
+function getBackendByType(backendType, options) {
+	if (backendType === "mock") return createMockBackend(options?.debugLog);
+	const backendOptions = {};
+	if (options?.timeout) backendOptions.timeout = options.timeout;
+	if (options?.streamCallbacks) backendOptions.streamCallbacks = options.streamCallbacks;
+	return createBackend({
+		type: backendType,
+		model: options?.model,
+		...backendType === "default" && options?.provider ? { provider: options.provider } : {},
+		...Object.keys(backendOptions).length > 0 ? { options: backendOptions } : {}
+	});
+}
+/**
+* Get appropriate backend for a model identifier
+*
+* Infers backend type from model name and delegates to getBackendByType.
+* Prefer using getBackendByType with explicit backend field in workflow configs.
+*/
+function getBackendForModel(model, options) {
+	if (options?.provider) return getBackendByType("default", {
+		...options,
+		model
+	});
+	const { provider } = parseModel(model);
+	switch (provider) {
+		case "anthropic": return getBackendByType("default", {
+			...options,
+			model
+		});
+		case "claude": return getBackendByType("claude", {
+			...options,
+			model
+		});
+		case "codex": return getBackendByType("codex", {
+			...options,
+			model
+		});
+		default: throw new Error(`Unknown provider: ${provider}. Specify backend explicitly.`);
+	}
+}
+
+//#endregion
+//#region src/workflow/logger.ts
+var logger_exports = /* @__PURE__ */ __exportAll({
+	createChannelLogger: () => createChannelLogger,
+	createSilentLogger: () => createSilentLogger
+});
+/**
+* Create a silent logger (no output)
+*/
+function createSilentLogger() {
+	const noop = () => {};
+	return {
+		debug: noop,
+		info: noop,
+		warn: noop,
+		error: noop,
+		isDebug: () => false,
+		child: () => createSilentLogger()
+	};
+}
+/**
+* Create a logger that writes to the channel.
+*
+* - info/warn/error → channel entry with kind="system" (always shown to user)
+* - debug → channel entry with kind="debug" (only shown with --debug)
+*
+* The display layer handles formatting and filtering.
+*/
+function createChannelLogger(config) {
+	const { provider, from = "system" } = config;
+	const formatContent = (level, message, args) => {
+		const argsStr = args.length > 0 ? " " + args.map(formatArg).join(" ") : "";
+		if (level === "warn") return `[WARN] ${message}${argsStr}`;
+		if (level === "error") return `[ERROR] ${message}${argsStr}`;
+		return `${message}${argsStr}`;
+	};
+	const write = (level, message, args) => {
+		const content = formatContent(level, message, args);
+		const kind = level === "debug" ? "debug" : "system";
+		provider.appendChannel(from, content, { kind }).catch(() => {});
+	};
+	return {
+		debug: (message, ...args) => write("debug", message, args),
+		info: (message, ...args) => write("info", message, args),
+		warn: (message, ...args) => write("warn", message, args),
+		error: (message, ...args) => write("error", message, args),
+		isDebug: () => true,
+		child: (childPrefix) => {
+			return createChannelLogger({
+				provider,
+				from: from ? `${from}:${childPrefix}` : childPrefix
+			});
+		}
+	};
+}
+/** Format an argument for logging */
+function formatArg(arg) {
+	if (arg === null || arg === void 0) return String(arg);
+	if (typeof arg === "object") try {
+		return JSON.stringify(arg);
+	} catch {
+		return String(arg);
+	}
+	return String(arg);
+}
+
+//#endregion
+//#region src/workflow/factory.ts
+/**
+* Workflow Factory — Composable primitives for building workflow runtimes.
+*
+* These functions are the building blocks that both runner.ts (CLI direct)
+* and daemon.ts (service) use to create workflow infrastructure.
+*
+* Extracted from the monolithic runWorkflowWithControllers() so that
+* the daemon can create and manage workflow components independently.
+*
+* Usage:
+*   1. createMinimalRuntime()  — context + MCP + event log (the "workspace")
+*   2. createWiredController() — backend + workspace dir + controller (per agent)
+*   3. Caller manages lifecycle  — start/stop controllers, send kickoff, shutdown
+*/
+/**
+* Create a minimal workflow runtime.
+*
+* Sets up the shared infrastructure (context + MCP + event log) without
+* creating controllers or backends. The daemon can use this to create
+* workflow infrastructure for both standalone and multi-agent workflows.
+*
+* For standalone agents created via `POST /agents`, this gives them
+* the same context infrastructure that workflow agents get.
+*/
+async function createMinimalRuntime(config) {
+	const { workflowName, tag, agentNames, onMention, feedback: feedbackEnabled, debugLog } = config;
+	let contextProvider;
+	let contextDir;
+	let persistent = false;
+	if (config.contextProvider && config.contextDir) {
+		contextProvider = config.contextProvider;
+		contextDir = config.contextDir;
+		persistent = config.persistent ?? false;
+	} else {
+		contextDir = getDefaultContextDir(workflowName, tag);
+		if (!existsSync(contextDir)) mkdirSync(contextDir, { recursive: true });
+		contextProvider = createFileContextProvider(contextDir, agentNames);
+		persistent = false;
+	}
+	await contextProvider.markRunStart();
+	const projectDir = process.cwd();
+	let mcpGetFeedback;
+	let mcpToolNames = /* @__PURE__ */ new Set();
+	const eventLog = new EventLog(contextProvider);
+	const createMCPServerInstance = () => {
+		const mcp = createContextMCPServer({
+			provider: contextProvider,
+			validAgents: agentNames,
+			name: `${workflowName}-context`,
+			version: "1.0.0",
+			onMention,
+			feedback: feedbackEnabled,
+			debugLog
+		});
+		mcpGetFeedback = mcp.getFeedback;
+		mcpToolNames = mcp.mcpToolNames;
+		return mcp.server;
+	};
+	const httpMcpServer = await runWithHttp({
+		createServerInstance: createMCPServerInstance,
+		port: 0
+	});
+	const shutdown = async () => {
+		if (persistent) {
+			if (contextProvider instanceof FileContextProvider) contextProvider.releaseLock();
+		} else await contextProvider.destroy();
+		await httpMcpServer.close();
+	};
+	return {
+		contextProvider,
+		contextDir,
+		persistent,
+		eventLog,
+		httpMcpServer,
+		mcpUrl: httpMcpServer.url,
+		mcpToolNames,
+		projectDir,
+		getFeedback: mcpGetFeedback,
+		shutdown
+	};
+}
+/**
+* Create a fully-wired agent controller.
+*
+* This handles the full setup:
+* 1. Create backend from agent definition (or use custom factory)
+* 2. Create isolated workspace directory
+* 3. Configure stream callbacks for structured event logging
+* 4. Create the AgentController with all wiring
+*
+* Extracted from runWorkflowWithControllers() so both runner.ts and
+* daemon.ts can create controllers with the same quality.
+*/
+function createWiredController(config) {
+	const { name, agent, runtime, pollInterval, feedback: feedbackEnabled } = config;
+	const logger = config.logger ?? createSilentLogger();
+	const streamCallbacks = {
+		debugLog: (msg) => logger.debug(msg),
+		outputLog: (msg) => runtime.eventLog.output(name, msg),
+		toolCallLog: (toolName, args) => runtime.eventLog.toolCall(name, toolName, args, "backend"),
+		mcpToolNames: runtime.mcpToolNames
+	};
+	let backend;
+	if (config.createBackend) backend = config.createBackend(name, agent);
+	else if (agent.backend) backend = getBackendByType(agent.backend, {
+		model: agent.model,
+		provider: agent.provider,
+		debugLog: (msg) => logger.debug(msg),
+		streamCallbacks,
+		timeout: agent.timeout
+	});
+	else if (agent.model) backend = getBackendForModel(agent.model, {
+		provider: agent.provider,
+		debugLog: (msg) => logger.debug(msg),
+		streamCallbacks
+	});
+	else throw new Error(`Agent "${name}" requires either a backend or model field`);
+	const workspaceDir = join(runtime.contextDir, "workspaces", name);
+	if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
+	return {
+		controller: createAgentController({
+			name,
+			agent,
+			contextProvider: runtime.contextProvider,
+			eventLog: runtime.eventLog,
+			mcpUrl: runtime.mcpUrl,
+			workspaceDir,
+			projectDir: runtime.projectDir,
+			backend,
+			pollInterval,
+			log: (msg) => logger.debug(msg),
+			infoLog: (msg) => logger.info(msg),
+			errorLog: (msg) => logger.error(msg),
+			feedback: feedbackEnabled
+		}),
+		backend
+	};
+}
+
 //#endregion
 //#region src/daemon/daemon.ts
 /**
 * Daemon — Centralized agent coordinator.
 *
+* Architecture: Interface → Daemon → Controller (three layers)
+*   Interface: CLI/REST/MCP clients talk to daemon via HTTP
+*   Daemon:    This module — owns lifecycle, creates workflows + controllers
+*   Controller: AgentController + Backend — executes agent reasoning
+*
 * 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
+*   Registry (configs)    — what agents exist and their configuration
+*   Workflows (workflows) — running workflow instances with controllers + context
 *
-* The daemon is pure glue: receive request → lookup config →
-* dispatch to worker → persist state → return response.
+* Key principle: every agent lives in a workflow. Standalone agents created via
+* POST /agents get a 1-agent workflow (created lazily on first /run or /serve).
+* This unifies the runtime so there's one code path for execution.
 *
 * HTTP endpoints:
 *   GET  /health, POST /shutdown
@@ -1456,9 +2656,6 @@ async function gracefulShutdown() {
 			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 {
@@ -1476,6 +2673,82 @@ async function parseJsonBody(c) {
 		return null;
 	}
 }
+/** Map AgentConfig to the ResolvedAgent type needed by the factory */
+function configToResolvedAgent(cfg) {
+	return {
+		backend: cfg.backend,
+		model: cfg.model,
+		provider: cfg.provider,
+		resolvedSystemPrompt: cfg.system,
+		schedule: cfg.schedule
+	};
+}
+/**
+* Find an agent's controller across all workflows.
+* Returns the controller if the agent exists in any workflow.
+*/
+function findController(s, agentName) {
+	for (const wf of s.workflows.values()) {
+		const ctrl = wf.controllers.get(agentName);
+		if (ctrl) return {
+			controller: ctrl,
+			workflow: wf
+		};
+	}
+	return null;
+}
+/**
+* Ensure a standalone agent has a workflow + controller.
+* Creates the infrastructure lazily on first call (starts MCP server, etc.).
+*
+* This is the bridge between POST /agents (stores config only) and
+* POST /run or /serve (needs a controller to execute).
+*/
+async function ensureAgentController(s, agentName) {
+	const existing = findController(s, agentName);
+	if (existing) return existing;
+	const cfg = s.configs.get(agentName);
+	if (!cfg) throw new Error(`Agent not found: ${agentName}`);
+	const agentDef = configToResolvedAgent(cfg);
+	const wfKey = `standalone:${agentName}`;
+	const runtime = await createMinimalRuntime({
+		workflowName: cfg.workflow,
+		tag: cfg.tag,
+		agentNames: [agentName]
+	});
+	let controller;
+	try {
+		({controller} = createWiredController({
+			name: agentName,
+			agent: agentDef,
+			runtime
+		}));
+	} catch (err) {
+		await runtime.shutdown();
+		throw err;
+	}
+	const handle = {
+		name: cfg.workflow,
+		tag: cfg.tag,
+		key: wfKey,
+		agents: [agentName],
+		controllers: new Map([[agentName, controller]]),
+		contextProvider: runtime.contextProvider,
+		shutdown: async () => {
+			try {
+				await controller.stop();
+			} finally {
+				await runtime.shutdown();
+			}
+		},
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	s.workflows.set(wfKey, handle);
+	return {
+		controller,
+		workflow: handle
+	};
+}
 function createDaemonApp(optionsOrGetState) {
 	const { getState, token } = typeof optionsOrGetState === "function" ? {
 		getState: optionsOrGetState,
@@ -1516,15 +2789,19 @@ function createDaemonApp(optionsOrGetState) {
 	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 standaloneAgents = [...s.configs.values()].map((cfg) => {
+			const ctrl = findController(s, cfg.name);
+			return {
+				name: cfg.name,
+				model: cfg.model,
+				backend: cfg.backend,
+				workflow: cfg.workflow,
+				tag: cfg.tag,
+				createdAt: cfg.createdAt,
+				source: "standalone",
+				state: ctrl?.controller.state
+			};
+		});
 		const workflowAgents = [...s.workflows.values()].flatMap((wf) => wf.agents.map((agentName) => {
 			const controller = wf.controllers.get(agentName);
 			return {
@@ -1545,7 +2822,7 @@ function createDaemonApp(optionsOrGetState) {
 		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;
+		const { name, model, system, backend = "default", provider, workflow = "global", tag = "main", schedule } = 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 = {
@@ -1553,19 +2830,20 @@ function createDaemonApp(optionsOrGetState) {
 			model,
 			system,
 			backend,
+			provider,
 			workflow,
 			tag,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			schedule
 		};
-		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
+			tag,
+			schedule
 		}, 201);
 	});
 	app.get("/agents/:name", (c) => {
@@ -1580,7 +2858,8 @@ function createDaemonApp(optionsOrGetState) {
 			system: cfg.system,
 			workflow: cfg.workflow,
 			tag: cfg.tag,
-			createdAt: cfg.createdAt
+			createdAt: cfg.createdAt,
+			schedule: cfg.schedule
 		});
 	});
 	app.delete("/agents/:name", async (c) => {
@@ -1588,11 +2867,14 @@ function createDaemonApp(optionsOrGetState) {
 		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);
+		const wfKey = `standalone:${name}`;
+		const wf = s.workflows.get(wfKey);
+		if (wf) {
+			try {
+				await wf.shutdown();
+			} catch {}
+			s.workflows.delete(wfKey);
+		}
 		return c.json({ success: true });
 	});
 	app.post("/run", async (c) => {
@@ -1602,30 +2884,36 @@ function createDaemonApp(optionsOrGetState) {
 		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);
+		let controller;
+		const controllerResult = findController(s, agentName);
+		if (controllerResult) controller = controllerResult.controller;
+		else if (s.configs.has(agentName)) try {
+			controller = (await ensureAgentController(s, agentName)).controller;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to create agent runtime: ${msg}` }, 500);
+		}
+		if (!controller) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		const ctrl = controller;
 		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({
+				const result = await ctrl.sendDirect(message);
+				if (result.success) {
+					if (result.content) await stream.writeSSE({
 						event: "chunk",
 						data: JSON.stringify({
 							agent: agentName,
-							text: value
+							text: result.content
 						})
 					});
-				}
+					await stream.writeSSE({
+						event: "done",
+						data: JSON.stringify(result)
+					});
+				} else await stream.writeSSE({
+					event: "error",
+					data: JSON.stringify({ error: result.error })
+				});
 			} catch (error) {
 				const msg = error instanceof Error ? error.message : String(error);
 				await stream.writeSSE({
@@ -1642,12 +2930,24 @@ function createDaemonApp(optionsOrGetState) {
 		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);
+		let controller;
+		const controllerResult = findController(s, agentName);
+		if (controllerResult) controller = controllerResult.controller;
+		else if (s.configs.has(agentName)) try {
+			controller = (await ensureAgentController(s, agentName)).controller;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: msg }, 500);
+		}
+		if (!controller) return c.json({ error: `Agent not found: ${agentName}` }, 404);
 		try {
-			const response = await handle.send(message);
-			await s.store.save(agentName, handle.getState());
-			return c.json(response);
+			const result = await controller.sendDirect(message);
+			if (!result.success) return c.json({ error: result.error }, 500);
+			return c.json({
+				content: result.content ?? "",
+				duration: result.duration,
+				success: true
+			});
 		} catch (error) {
 			const msg = error instanceof Error ? error.message : String(error);
 			return c.json({ error: msg }, 500);
@@ -1674,15 +2974,18 @@ function createDaemonApp(optionsOrGetState) {
 			const agentCfg = s.configs.get(agentName);
 			const workflow = agentCfg?.workflow ?? "global";
 			const tag = agentCfg?.tag ?? "main";
+			const existingWf = findController(s, agentName)?.workflow ?? s.workflows.get(`${workflow}:${tag}`);
 			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 provider = existingWf?.contextProvider ?? (() => {
+				const contextDir = getDefaultContextDir(workflow, tag);
+				mkdirSync(contextDir, { recursive: true });
+				return createFileContextProvider(contextDir, allNames);
+			})();
 			const transport = new WebStandardStreamableHTTPServerTransport({
 				sessionIdGenerator: () => `${agentName}-${randomUUID().slice(0, 8)}`,
 				onsessioninitialized: (sid) => {
@@ -1718,7 +3021,7 @@ function createDaemonApp(optionsOrGetState) {
 		const key = `${workflowName}:${tag}`;
 		if (s.workflows.has(key)) return c.json({ error: `Workflow already running: ${key}` }, 409);
 		try {
-			const { runWorkflowWithControllers } = await import("../runner-CQJYnM7D.mjs");
+			const { runWorkflowWithControllers } = await import("../runner-DV86expc.mjs");
 			const result = await runWorkflowWithControllers({
 				workflow,
 				workflowName,
@@ -1820,7 +3123,6 @@ async function startDaemon(config = {}) {
 	});
 	state = {
 		configs: /* @__PURE__ */ new Map(),
-		workers: /* @__PURE__ */ new Map(),
 		workflows: /* @__PURE__ */ new Map(),
 		store,
 		server,
@@ -2069,25 +3371,46 @@ function registerAgentCommands(program) {
 		"claude",
 		"codex",
 		"cursor",
+		"opencode",
 		"mock"
-	]).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", `
+	]).default("default")).option("--provider <name>", "Provider SDK name (e.g., anthropic, openai)").option("--base-url <url>", "Override provider base URL").option("--api-key <ref>", "API key env var (e.g., $MINIMAX_API_KEY)").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("--wakeup <interval|cron>", "Periodic wakeup schedule (e.g., 30s, 5m, 0 9 * * 1-5)").option("--wakeup-prompt <text>", "Custom prompt for wakeup events").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 new alice -m anthropic/claude-sonnet-4-5
   $ agent-worker new bot -b mock
   $ agent-worker new reviewer --workflow review --tag pr-123
+  $ agent-worker new monitor --wakeup 30s --system "Check status"
+  $ agent-worker new coder -m MiniMax-M2.5 --provider anthropic --base-url https://api.minimax.io/anthropic/v1 --api-key '$MINIMAX_API_KEY'
       `).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();
+		let provider;
+		if (options.provider) if (options.baseUrl || options.apiKey) provider = {
+			name: options.provider,
+			base_url: options.baseUrl,
+			api_key: options.apiKey
+		};
+		else provider = options.provider;
+		if (options.wakeupPrompt && !options.wakeup) {
+			console.error("Error: --wakeup-prompt can only be used with --wakeup.");
+			process.exit(1);
+		}
+		let schedule;
+		if (options.wakeup) {
+			schedule = { wakeup: options.wakeup };
+			if (options.wakeupPrompt) schedule.prompt = options.wakeupPrompt;
+		}
 		await ensureDaemon(options.port ? parseInt(options.port, 10) : void 0, options.host);
 		const res = await createAgent({
 			name,
 			model,
 			system,
 			backend,
+			provider,
 			workflow: options.workflow,
-			tag: options.tag
+			tag: options.tag,
+			schedule
 		});
 		if (res.error) {
 			console.error("Error:", res.error);
@@ -2339,7 +3662,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CNlUyGit.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-DogkVjOs.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2350,8 +3673,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-CNlUyGit.mjs");
-				const { createSilentLogger } = await import("../logger-Bfdo83xL.mjs");
+				const { shutdownControllers } = await import("../workflow-DogkVjOs.mjs");
+				const { createSilentLogger } = await Promise.resolve().then(() => logger_exports);
 				await shutdownControllers(controllers, createSilentLogger());
 			}
 			process.exit(130);
@@ -2423,7 +3746,7 @@ Workflow runs inside the daemon. Use ls/stop to manage:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile } = await import("../workflow-CNlUyGit.mjs");
+		const { parseWorkflowFile } = await import("../workflow-DogkVjOs.mjs");
 		const { ensureDaemon } = await Promise.resolve().then(() => agent_exports);
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
@@ -2574,10 +3897,6 @@ const PROVIDER_API_KEYS = {
 	xai: {
 		envVar: "XAI_API_KEY",
 		description: "xAI Grok"
-	},
-	minimax: {
-		envVar: "MINIMAX_API_KEY",
-		description: "MiniMax"
 	}
 };
 function registerInfoCommands(program) {
@@ -2598,10 +3917,11 @@ function registerInfoCommands(program) {
 		console.log(`  Provider only:   provider         (e.g., openai → ${gatewayExample})`);
 		console.log(`  Gateway format:  provider/model   (e.g., ${gatewayExample})`);
 		console.log(`  Direct format:   provider:model   (e.g., ${directExample})`);
+		console.log(`  Custom endpoint: --provider anthropic --base-url <url> --api-key '$KEY'`);
 		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-DG5igQii.mjs");
+		const { listBackends } = await import("../backends-Cv0oM9Ru.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2631,7 +3951,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-BqEyt2SF.mjs");
+		const { createFileContextProvider } = await import("../context-CzqQeThq.mjs");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
@@ -2649,7 +3969,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
+		const { createFileContextProvider } = await import("../context-CzqQeThq.mjs");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
@@ -2667,7 +3987,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
+		const { createFileContextProvider } = await import("../context-CzqQeThq.mjs");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
@@ -2681,7 +4001,7 @@ async function resolveDir(targetInput) {
 
 //#endregion
 //#region package.json
-var version = "0.12.0";
+var version = "0.14.0";
 
 //#endregion
 //#region src/cli/index.ts
@@ -2704,4 +4024,4 @@ registerDocCommands(program);
 program.parse();
 
 //#endregion
-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 };
+export { extractMentions as A, EventLog as B, CONTEXT_DEFAULTS as C, RESOURCE_SCHEME as D, RESOURCE_PREFIX as E, formatProposalList as F, createLogTool as I, formatInbox$1 as L, shouldUseResource as M, createContextMCPServer as N, calculatePriority as O, formatProposal as P, formatToolParams as R, ContextProviderImpl as S, MESSAGE_LENGTH_THRESHOLD as T, createFileContextProvider as _, getBackendByType as a, FileStorage as b, createAgentController as c, generateWorkflowMCPConfig as d, buildAgentPrompt as f, FileContextProvider as g, runWithHttp as h, createSilentLogger as i, generateResourceId as j, createResourceRef as k, runSdkAgent as l, CONTROLLER_DEFAULTS as m, createWiredController as n, getBackendForModel as o, formatInbox as p, createChannelLogger as r, checkWorkflowIdle as s, createMinimalRuntime as t, runMockAgent as u, getDefaultContextDir as v, MENTION_PATTERN as w, MemoryStorage as x, resolveContextDir as y, getAgentId as z };