agent-worker 0.11.0 → 0.13.0

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 #!/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 { I as getDefaultModel, j as FRONTIER_MODELS, k as normalizeBackendType, n as createBackend } from "../backends-CziIqKRg.mjs";
+import { t as AgentWorker } from "../worker-DBJ8136Q.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";
@@ -9,7 +9,6 @@ import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { Command, Option } from "commander";
 import { Hono } from "hono";
-import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
 import { randomUUID } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -98,7 +97,8 @@ var LocalWorker = class {
 			model: config.model,
 			system: config.system,
 			tools: {},
-			backend
+			backend,
+			provider: config.provider
 		}, restore);
 	}
 	send(input, options) {
@@ -1430,17 +1430,22 @@ function createFileContextProvider(contextDir, validAgents) {
 *   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
 *
 * The daemon is pure glue: receive request → lookup config →
 * dispatch to worker → persist state → return response.
 *
-* 9 HTTP endpoints:
+* 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
 */
-var daemon_exports = /* @__PURE__ */ __exportAll({ startDaemon: () => startDaemon });
+var daemon_exports = /* @__PURE__ */ __exportAll({
+	createDaemonApp: () => createDaemonApp,
+	startDaemon: () => startDaemon
+});
 let state = null;
 let shuttingDown = false;
 const mcpSessions = /* @__PURE__ */ new Map();
@@ -1448,10 +1453,14 @@ 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 {}
-		await state.server.close();
+		if (state.server) await state.server.close();
 	}
 	for (const [, session] of mcpSessions) try {
 		await session.transport.close();
@@ -1460,28 +1469,45 @@ async function gracefulShutdown() {
 	removeDaemonInfo();
 	process.exit(0);
 }
-function getWorkflowAgentNames$1(workflow, tag) {
-	if (!state) return [];
-	return [...state.configs.values()].filter((c) => c.workflow === workflow && c.tag === tag).map((c) => c.name);
-}
-async function startDaemon(config = {}) {
-	const existing = isDaemonRunning();
-	if (existing) {
-		console.error(`Daemon already running: pid=${existing.pid} port=${existing.port}`);
-		process.exit(1);
+/** Safe JSON body parsing — returns null on malformed input */
+async function parseJsonBody(c) {
+	try {
+		return await c.req.json();
+	} catch {
+		return null;
 	}
-	const host = config.host ?? "127.0.0.1";
-	const store = config.store ?? new MemoryStateStore();
+}
+function createDaemonApp(optionsOrGetState) {
+	const { getState, token } = typeof optionsOrGetState === "function" ? {
+		getState: optionsOrGetState,
+		token: void 0
+	} : optionsOrGetState;
 	const app = new Hono();
-	app.use("*", cors());
+	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) => {
-		if (!state) return c.json({ status: "unavailable" }, 503);
+		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: state.port,
-			uptime: Date.now() - new Date(state.startedAt).getTime(),
-			agents: [...state.configs.keys()]
+			port: s.port,
+			uptime: Date.now() - new Date(s.startedAt).getTime(),
+			agents: standaloneAgents,
+			workflows: workflowList
 		});
 	});
 	app.post("/shutdown", (c) => {
@@ -1489,34 +1515,53 @@ async function startDaemon(config = {}) {
 		return c.json({ success: true });
 	});
 	app.get("/agents", (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
-		const agents = [...state.configs.values()].map((c) => ({
-			name: c.name,
-			model: c.model,
-			backend: c.backend,
-			workflow: c.workflow,
-			tag: c.tag,
-			createdAt: c.createdAt
+		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 {
+				name: agentName,
+				model: "",
+				backend: "",
+				workflow: wf.name,
+				tag: wf.tag,
+				createdAt: wf.startedAt,
+				source: "workflow",
+				state: controller?.state ?? "unknown"
+			};
 		}));
-		return c.json({ agents });
+		return c.json({ agents: [...standaloneAgents, ...workflowAgents] });
 	});
 	app.post("/agents", async (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
-		const { name, model, system, backend = "default", workflow = "global", tag = "main" } = await c.req.json();
+		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", provider, workflow = "global", tag = "main" } = body;
 		if (!name || !model || !system) return c.json({ error: "name, model, system required" }, 400);
-		if (state.configs.has(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
+		if (s.configs.has(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
 		const agentConfig = {
 			name,
 			model,
 			system,
 			backend,
+			provider,
 			workflow,
 			tag,
 			createdAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
-		const handle = new LocalWorker(agentConfig, await state.store.load(name) ?? void 0);
-		state.configs.set(name, agentConfig);
-		state.workers.set(name, handle);
+		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,
@@ -1526,8 +1571,9 @@ async function startDaemon(config = {}) {
 		}, 201);
 	});
 	app.get("/agents/:name", (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
-		const cfg = state.configs.get(c.req.param("name"));
+		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,
@@ -1540,21 +1586,25 @@ async function startDaemon(config = {}) {
 		});
 	});
 	app.delete("/agents/:name", async (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
 		const name = c.req.param("name");
-		if (!state.configs.delete(name)) return c.json({ error: "Agent not found" }, 404);
-		const handle = state.workers.get(name);
+		if (!s.configs.delete(name)) return c.json({ error: "Agent not found" }, 404);
+		const handle = s.workers.get(name);
 		if (handle) try {
-			await state.store.save(name, handle.getState());
+			await s.store.save(name, handle.getState());
 		} catch {}
-		state.workers.delete(name);
+		s.workers.delete(name);
 		return c.json({ success: true });
 	});
 	app.post("/run", async (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
-		const { agent: agentName, message } = await c.req.json();
+		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 = state.workers.get(agentName);
+		const handle = s.workers.get(agentName);
 		if (!handle) return c.json({ error: `Agent not found: ${agentName}` }, 404);
 		return streamSSE(c, async (stream) => {
 			try {
@@ -1562,7 +1612,8 @@ async function startDaemon(config = {}) {
 				while (true) {
 					const { value, done } = await gen.next();
 					if (done) {
-						if (state) await state.store.save(agentName, handle.getState());
+						const currentState = getState();
+						if (currentState) await currentState.store.save(agentName, handle.getState());
 						await stream.writeSSE({
 							event: "done",
 							data: JSON.stringify(value)
@@ -1587,14 +1638,17 @@ async function startDaemon(config = {}) {
 		});
 	});
 	app.post("/serve", async (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
-		const { agent: agentName, message } = await c.req.json();
+		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 = state.workers.get(agentName);
+		const handle = s.workers.get(agentName);
 		if (!handle) return c.json({ error: `Agent not found: ${agentName}` }, 404);
 		try {
 			const response = await handle.send(message);
-			await state.store.save(agentName, handle.getState());
+			await s.store.save(agentName, handle.getState());
 			return c.json(response);
 		} catch (error) {
 			const msg = error instanceof Error ? error.message : String(error);
@@ -1602,7 +1656,8 @@ async function startDaemon(config = {}) {
 		}
 	});
 	app.all("/mcp", async (c) => {
-		if (!state) return c.json({ error: "Not ready" }, 503);
+		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)) {
@@ -1618,10 +1673,10 @@ async function startDaemon(config = {}) {
 			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 = state.configs.get(agentName);
+			const agentCfg = s.configs.get(agentName);
 			const workflow = agentCfg?.workflow ?? "global";
 			const tag = agentCfg?.tag ?? "main";
-			const workflowAgents = getWorkflowAgentNames$1(workflow, tag);
+			const workflowAgents = getWorkflowAgentNames(workflow, tag);
 			const allNames = [...new Set([
 				...workflowAgents,
 				agentName,
@@ -1654,7 +1709,105 @@ async function startDaemon(config = {}) {
 		if (req.method === "GET") return c.json({ error: "Session ID required for GET requests" }, 400);
 		return c.json({ error: "Method not allowed" }, 405);
 	});
-	const server = await startHttpServer(app, {
+	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 {
+			const { runWorkflowWithControllers } = await import("../runner-CnxROIev.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) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to start workflow: ${msg}` }, 500);
+		}
+	});
+	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 {
+			await handle.shutdown();
+			s.workflows.delete(key);
+			return c.json({
+				success: true,
+				key
+			});
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to stop workflow: ${msg}` }, 500);
+		}
+	}
+	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;
+}
+async function startDaemon(config = {}) {
+	const existing = isDaemonRunning();
+	if (existing) {
+		console.error(`Daemon already running: pid=${existing.pid} port=${existing.port}`);
+		process.exit(1);
+	}
+	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
 	});
@@ -1664,11 +1817,13 @@ async function startDaemon(config = {}) {
 		pid: process.pid,
 		host,
 		port: actualPort,
-		startedAt
+		startedAt,
+		token
 	});
 	state = {
 		configs: /* @__PURE__ */ new Map(),
 		workers: /* @__PURE__ */ new Map(),
+		workflows: /* @__PURE__ */ new Map(),
 		store,
 		server,
 		port: actualPort,
@@ -1698,6 +1853,18 @@ async function startDaemon(config = {}) {
 *   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) {
@@ -1708,23 +1875,32 @@ function isRetryableError(error) {
 	}
 	return false;
 }
-function getDaemonUrl() {
+function getDaemonConnection() {
 	const daemon = isDaemonRunning();
 	if (!daemon) return null;
-	return `http://${daemon.host}:${daemon.port}`;
+	return {
+		url: `http://${daemon.host}:${daemon.port}`,
+		token: daemon.token
+	};
 }
 function requireDaemon() {
-	const url = getDaemonUrl();
-	if (!url) throw new Error("No daemon running. Start one with: agent-worker daemon");
-	return url;
+	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 baseUrl = requireDaemon();
+	const { url: baseUrl, token } = requireDaemon();
 	let lastError;
 	for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) try {
 		const init = {
 			method,
-			headers: body !== void 0 ? { "Content-Type": "application/json" } : void 0,
+			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)
 		};
@@ -1771,8 +1947,11 @@ function serve(body) {
 */
 async function run(body, onChunk) {
 	let baseUrl;
+	let token;
 	try {
-		baseUrl = requireDaemon();
+		const conn = requireDaemon();
+		baseUrl = conn.url;
+		token = conn.token;
 	} catch (error) {
 		return {
 			success: false,
@@ -1782,7 +1961,7 @@ async function run(body, onChunk) {
 	try {
 		const res = await fetch(`${baseUrl}/run`, {
 			method: "POST",
-			headers: { "Content-Type": "application/json" },
+			headers: authHeaders(token, { "Content-Type": "application/json" }),
 			body: JSON.stringify(body)
 		});
 		if (!res.ok || !res.body) return await res.json();
@@ -1819,13 +1998,22 @@ async function run(body, onChunk) {
 		};
 	}
 }
+/** 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 getDaemonUrl() !== null;
+	return getDaemonConnection() !== null;
 }
 
 //#endregion
 //#region src/cli/output.ts
+var output_exports = /* @__PURE__ */ __exportAll({ outputJson: () => outputJson });
 /**
 * CLI Output Utilities
 *
@@ -1844,6 +2032,10 @@ function outputJson(data) {
 
 //#endregion
 //#region src/cli/commands/agent.ts
+var agent_exports = /* @__PURE__ */ __exportAll({
+	ensureDaemon: () => ensureDaemon,
+	registerAgentCommands: () => registerAgentCommands
+});
 /**
 * Ensure daemon is running. If not, spawn it in background and wait.
 */
@@ -1879,23 +2071,33 @@ 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("--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 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;
 		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
 		});
@@ -1932,13 +2134,16 @@ Examples:
 		}
 		for (const a of agents) {
 			const wf = a.tag === "main" ? `@${a.workflow}` : `@${a.workflow}:${a.tag}`;
-			console.log(`${a.name.padEnd(12)} ${a.model.padEnd(30)} ${wf}`);
+			const info = a.model || a.state || "";
+			console.log(`${a.name.padEnd(12)} ${info.padEnd(30)} ${wf}`);
 		}
 	});
-	program.command("stop [name]").description("Stop agent or daemon").option("--all", "Stop daemon (all agents)").addHelpText("after", `
+	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 --all       # Stop daemon (all agents)
+  $ 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");
@@ -1951,11 +2156,17 @@ Examples:
 			return;
 		}
 		if (!name) {
-			console.error("Specify agent name or use --all");
+			console.error("Specify agent name, @workflow[:tag], or use --all");
 			process.exit(1);
 		}
-		const res = await deleteAgent(name);
-		if (res.success) console.log(`Stopped: ${name}`);
+		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.error("Error:", res.error);
 			process.exit(1);
@@ -1973,6 +2184,14 @@ Examples:
 			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`);
@@ -1981,8 +2200,8 @@ Examples:
 	});
 	program.command("ask <agent> <message>").description("Send message to agent (SSE streaming)").option("--json", "Output final response as JSON").addHelpText("after", `
 Examples:
-  $ agent-worker run alice "analyze this code"
-  $ agent-worker run alice "hello" --json
+  $ 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");
@@ -2132,7 +2351,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CfITD7TN.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CIE3WPNx.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2143,8 +2362,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-CfITD7TN.mjs");
-				const { createSilentLogger } = await import("../logger-CCFaMMV7.mjs");
+				const { shutdownControllers } = await import("../workflow-CIE3WPNx.mjs");
+				const { createSilentLogger } = await import("../logger-Bfdo83xL.mjs");
 				await shutdownControllers(controllers, createSilentLogger());
 			}
 			process.exit(130);
@@ -2181,7 +2400,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-BsCsnPqs.mjs");
+					const { showWorkflowSummary } = await import("../display-pretty-BCJq5v9d.mjs");
 					showWorkflowSummary({
 						duration: result.duration,
 						document: finalDoc,
@@ -2205,73 +2424,60 @@ 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-CfITD7TN.mjs");
+		const { parseWorkflowFile } = await import("../workflow-CIE3WPNx.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(() => {});
 	});
 }
 
@@ -2380,10 +2586,6 @@ const PROVIDER_API_KEYS = {
 	xai: {
 		envVar: "XAI_API_KEY",
 		description: "xAI Grok"
-	},
-	minimax: {
-		envVar: "MINIMAX_API_KEY",
-		description: "MiniMax"
 	}
 };
 function registerInfoCommands(program) {
@@ -2404,10 +2606,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-BWzhErjT.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2437,7 +2640,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-CKL-RY7a.mjs");
+		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
@@ -2455,7 +2658,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CKL-RY7a.mjs");
+		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
@@ -2473,7 +2676,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CKL-RY7a.mjs");
+		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
@@ -2487,7 +2690,7 @@ async function resolveDir(targetInput) {
 
 //#endregion
 //#region package.json
-var version = "0.11.0";
+var version = "0.13.0";
 
 //#endregion
 //#region src/cli/index.ts