agent-worker 0.18.0 → 0.19.0

package/dist/cli/index.mjs

@@ -1,4000 +1,42 @@
 #!/usr/bin/env node
-import { A as parseModel, I as getDefaultModel, L as isAutoProvider, P as createModelAsync, R as resolveModelFallback, a as createMockBackend, j as FRONTIER_MODELS, k as normalizeBackendType, n as createBackend } from "../backends-D7DT0uox.mjs";
-import { t as createTool } from "../create-tool-gcUuI1FD.mjs";
-import { generateText, stepCountIs, tool } from "ai";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { appendFile, mkdir, open, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
-import { parse, stringify } from "yaml";
-import { z } from "zod";
-import { homedir } from "node:os";
-import { execSync, spawn } from "node:child_process";
+import { t as __exportAll } from "../rolldown-runtime-wcPFST8Q.mjs";
+import { a as isDaemonRunning, i as DEFAULT_PORT } from "../daemon-CwaHgxs6.mjs";
+import { a as isDaemonActive, c as serve, d as stopWorkflow, i as health, l as shutdown, n as createAgent, o as listAgents, r as deleteAgent, s as run, u as startWorkflow } from "../client-DAKkzdOn.mjs";
+import { t as outputJson } from "../output-B0mwPqjv.mjs";
+import { n as parseTarget } from "../target-9yiBRXxa.mjs";
+import { mkdirSync, readFileSync } from "node:fs";
+import { FRONTIER_MODELS, getDefaultModel, normalizeBackendType } from "@moniro/agent-loop";
+import { createFileContextProvider, getDefaultContextDir } from "@moniro/workspace";
 import { Command, Option } from "commander";
-import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
-import { randomUUID } from "node:crypto";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { nanoid } from "nanoid";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-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";
-import { z as z$1 } from "zod/v4";
-
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __exportAll = (all, symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-//#region src/daemon/registry.ts
-/**
-* Daemon Registry
-*
-* Discovery: daemon.json = { pid, host, port, startedAt }
-* One daemon process on a fixed port. Clients read daemon.json to find it.
-*
-* Legacy: per-session files in sessions/{id}.json (deprecated, kept for transition)
-*/
-const CONFIG_DIR = join(homedir(), ".agent-worker");
-const SESSIONS_DIR = join(CONFIG_DIR, "sessions");
-const DEFAULT_PORT = 5099;
-const DAEMON_FILE = join(CONFIG_DIR, "daemon.json");
-const DEFAULT_FILE = join(CONFIG_DIR, "default");
-/** Write daemon.json for client discovery */
-function writeDaemonInfo(info) {
-	mkdirSync(CONFIG_DIR, { recursive: true });
-	writeFileSync(DAEMON_FILE, JSON.stringify(info, null, 2));
-}
-/** Read daemon.json. Returns null if missing or malformed. */
-function readDaemonInfo() {
-	try {
-		return JSON.parse(readFileSync(DAEMON_FILE, "utf-8"));
-	} catch {
-		return null;
-	}
-}
-/** Remove daemon.json (on shutdown) */
-function removeDaemonInfo() {
-	try {
-		unlinkSync(DAEMON_FILE);
-	} catch {}
-}
-/** Check if a daemon is already running (daemon.json exists + PID alive) */
-function isDaemonRunning() {
-	const info = readDaemonInfo();
-	if (!info) return null;
-	try {
-		process.kill(info.pid, 0);
-		return info;
-	} catch {
-		removeDaemonInfo();
-		return null;
-	}
-}
-const DURATION_RE = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/;
-/**
-* Parse a duration string like "30s", "5m", "2h" into milliseconds.
-* Returns null if not a valid duration format.
-*/
-function parseDuration(value) {
-	const match = value.match(DURATION_RE);
-	if (!match) return null;
-	return parseFloat(match[1]) * {
-		ms: 1,
-		s: 1e3,
-		m: 60 * 1e3,
-		h: 3600 * 1e3,
-		d: 1440 * 60 * 1e3
-	}[match[2]];
-}
-/**
-* Resolve a wakeup value into a typed schedule.
-* - number → interval (ms)
-* - "30s"/"5m"/"2h" → interval (converted to ms)
-* - cron expression → cron
-*/
-function resolveSchedule(config) {
-	const { wakeup, prompt } = config;
-	if (typeof wakeup === "number") {
-		if (wakeup <= 0) throw new Error("Wakeup interval must be positive");
-		return {
-			type: "interval",
-			ms: wakeup,
-			prompt
-		};
-	}
-	const ms = parseDuration(wakeup);
-	if (ms !== null) {
-		if (ms <= 0) throw new Error("Wakeup duration must be positive");
-		return {
-			type: "interval",
-			ms,
-			prompt
-		};
-	}
-	return {
-		type: "cron",
-		expr: wakeup,
-		prompt
-	};
-}
-
-//#endregion
-//#region src/agent/store.ts
-/**
-* In-memory state store. State is lost when the daemon stops.
-* Suitable for development and single-machine deployments.
-*/
-var MemoryStateStore = class {
-	states = /* @__PURE__ */ new Map();
-	async load(agentId) {
-		return this.states.get(agentId) ?? null;
-	}
-	async save(agentId, state) {
-		this.states.set(agentId, state);
-	}
-	async delete(agentId) {
-		this.states.delete(agentId);
-	}
-};
-
-//#endregion
-//#region src/daemon/serve.ts
-/**
-* Start an HTTP server for a Hono app.
-* Auto-detects runtime: Bun.serve() when available, @hono/node-server otherwise.
-*/
-async function startHttpServer(app, options) {
-	if ("Bun" in globalThis) return startBun(app, options);
-	return startNode(app, options);
-}
-function startBun(app, options) {
-	const server = globalThis.Bun.serve({
-		fetch: app.fetch,
-		port: options.port,
-		hostname: options.hostname
-	});
-	return {
-		port: server.port ?? options.port,
-		close: async () => server.stop(true)
-	};
-}
-async function startNode(app, options) {
-	const mod = await import("@hono/node-server");
-	return new Promise((resolve, reject) => {
-		const server = mod.serve({
-			fetch: app.fetch,
-			port: options.port,
-			hostname: options.hostname
-		}, (info) => {
-			resolve({
-				port: info.port,
-				close: () => new Promise((r) => server.close(() => r()))
-			});
-		});
-		server.on("error", reject);
-	});
-}
-
-//#endregion
-//#region src/workflow/context/event-log.ts
-var EventLog = class {
-	constructor(provider) {
-		this.provider = provider;
-	}
-	/** Record a tool invocation (MCP, SDK, or backend native) */
-	toolCall(agent, name, args, source) {
-		this.provider.appendChannel(agent, `${name}(${args})`, {
-			kind: "tool_call",
-			toolCall: {
-				name,
-				args,
-				source
-			}
-		}).catch(() => {});
-	}
-	/** Record an operational log (workflow lifecycle, warnings, errors) */
-	system(from, message) {
-		this.provider.appendChannel(from, message, { kind: "system" }).catch(() => {});
-	}
-	/** Record backend streaming text output (not tool calls) */
-	output(agent, text) {
-		this.provider.appendChannel(agent, text, { kind: "output" }).catch(() => {});
-	}
-	/** Record debug-level detail (only shown with --debug) */
-	debug(from, message) {
-		this.provider.appendChannel(from, message, { kind: "debug" }).catch(() => {});
-	}
-};
-
-//#endregion
-//#region src/workflow/context/mcp/helpers.ts
-/**
-* Extract agent ID from MCP extra context.
-* Session ID format: "agentName-uuid8chars" — extract agent name.
-*/
-function getAgentId(extra) {
-	if (!extra || typeof extra !== "object") return void 0;
-	if ("sessionId" in extra && typeof extra.sessionId === "string") {
-		const sid = extra.sessionId;
-		const match = sid.match(/^(.+)-[0-9a-f]{8}$/);
-		return match ? match[1] : sid;
-	}
-	if ("meta" in extra && extra.meta && typeof extra.meta === "object") {
-		const meta = extra.meta;
-		if ("agentId" in meta && typeof meta.agentId === "string") return meta.agentId;
-	}
-}
-/**
-* Format inbox messages for JSON display.
-*/
-function formatInbox$1(messages) {
-	if (messages.length === 0) return JSON.stringify({
-		messages: [],
-		count: 0
-	});
-	return JSON.stringify({
-		messages: messages.map((m) => ({
-			id: m.entry.id,
-			from: m.entry.from,
-			content: m.entry.content,
-			timestamp: m.entry.timestamp,
-			priority: m.priority
-		})),
-		count: messages.length
-	});
-}
-/**
-* Format tool call parameters as a concise string.
-*/
-function formatToolParams(params) {
-	return Object.entries(params).filter(([_, v]) => v !== void 0).map(([k, v]) => {
-		const val = typeof v === "string" && v.length > 50 ? v.slice(0, 50) + "..." : v;
-		return `${k}=${JSON.stringify(val)}`;
-	}).join(", ");
-}
-/**
-* Create a logTool function that records tool calls via EventLog.
-*/
-function createLogTool(eventLog) {
-	return (tool, agent, params) => {
-		if (!agent) return;
-		const args = formatToolParams(params);
-		eventLog.toolCall(agent, tool, args, "mcp");
-	};
-}
-
-//#endregion
-//#region src/workflow/context/mcp/channel.ts
-const CHANNEL_MSG_LIMIT = 2e3;
-function registerChannelTools(server, ctx, options) {
-	const { provider, getAgentId, logTool } = ctx;
-	const { onMention } = options ?? {};
-	server.tool("channel_send", `Send a message to the shared channel. Use @agent to mention/notify. Use "to" for private DMs. Long messages (> ${CHANNEL_MSG_LIMIT} chars) are automatically converted to resources.`, {
-		message: z.string().describe("Message content, can include @mentions like @reviewer or @coder. Long messages are auto-converted to resources."),
-		to: z.string().optional().describe("Send as DM to a specific agent (private, only you and recipient see it)")
-	}, async ({ message, to }, extra) => {
-		const from = getAgentId(extra) || "anonymous";
-		logTool("channel_send", from, {
-			message,
-			to
-		});
-		const sendOpts = to ? { to } : void 0;
-		const msg = await provider.smartSend(from, message, sendOpts);
-		for (const target of msg.mentions) onMention?.(from, target, msg);
-		if (to && !msg.mentions.includes(to)) onMention?.(from, to, msg);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "sent",
-				timestamp: msg.timestamp,
-				mentions: msg.mentions,
-				to: msg.to
-			})
-		}] };
-	});
-	server.tool("channel_read", "Read messages from the shared channel. DMs and logs are automatically filtered based on your identity.", {
-		since: z.string().optional().describe("Read entries after this timestamp (ISO format)"),
-		limit: z.number().optional().describe("Maximum entries to return")
-	}, async ({ since, limit }, extra) => {
-		const agent = getAgentId(extra);
-		logTool("channel_read", agent, {
-			since,
-			limit
-		});
-		const entries = await provider.readChannel({
-			since,
-			limit,
-			agent
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(entries)
-		}] };
-	});
-}
-
-//#endregion
-//#region src/workflow/context/mcp/resource.ts
-function registerResourceTools(server, ctx) {
-	const { provider, getAgentId, logTool } = ctx;
-	server.tool("resource_create", "Store large content as a resource. Returns a reference (resource:id) usable in channel messages or documents.", {
-		content: z.string().describe("Content to store as resource"),
-		type: z.enum([
-			"markdown",
-			"json",
-			"text",
-			"diff"
-		]).optional().describe("Content type hint (default: text)")
-	}, async ({ content, type }, extra) => {
-		const createdBy = getAgentId(extra) || "anonymous";
-		logTool("resource_create", createdBy, {
-			type,
-			contentLen: content.length
-		});
-		const result = await provider.createResource(content, createdBy, type);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				id: result.id,
-				ref: result.ref,
-				hint: `Use [description](${result.ref}) in messages or documents`
-			})
-		}] };
-	});
-	server.tool("resource_read", "Read resource content by ID. Use when you encounter resource:id references.", { id: z.string().describe("Resource ID (e.g., res_abc123)") }, async ({ id }) => {
-		const content = await provider.readResource(id);
-		if (content === null) return { content: [{
-			type: "text",
-			text: JSON.stringify({ error: `Resource not found: ${id}` })
-		}] };
-		return { content: [{
-			type: "text",
-			text: content
-		}] };
-	});
-}
-
-//#endregion
-//#region src/workflow/context/mcp/inbox.ts
-function registerInboxTools(server, ctx, options) {
-	const { provider, getAgentId, logTool } = ctx;
-	const { debugLog } = options ?? {};
-	server.tool("my_inbox", "Check your unread inbox messages. Does NOT acknowledge — use my_inbox_ack after processing.", {}, async (_args, extra) => {
-		const agent = getAgentId(extra) || "anonymous";
-		logTool("my_inbox", agent, {});
-		const messages = await provider.getInbox(agent);
-		if (debugLog && messages.length > 0) debugLog(`[mcp:${agent}] my_inbox → ${messages.length} unread`);
-		return { content: [{
-			type: "text",
-			text: formatInbox$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) => {
-		const agent = getAgentId(extra) || "anonymous";
-		logTool("my_inbox_ack", agent, { until });
-		await provider.ackInbox(agent, until);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "acknowledged",
-				until
-			})
-		}] };
-	});
-	server.tool("my_status_set", "Update your status and current task. Call when starting or completing work.", {
-		task: z.string().optional().describe("Current task description (what you're working on)"),
-		state: z.enum(["idle", "running"]).optional().describe("Agent state (running = working, idle = available)"),
-		metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata (e.g., PR number, file path)")
-	}, async (args, extra) => {
-		const agent = getAgentId(extra) || "anonymous";
-		logTool("my_status_set", agent, args);
-		const status = {};
-		if (args.task !== void 0) status.task = args.task;
-		if (args.state !== void 0) status.state = args.state;
-		if (args.metadata !== void 0) status.metadata = args.metadata;
-		await provider.setAgentStatus(agent, status);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "updated",
-				agent,
-				...status
-			})
-		}] };
-	});
-}
-
-//#endregion
-//#region src/workflow/context/mcp/team.ts
-function registerTeamTools(server, ctx) {
-	const { provider, validAgents, getAgentId, logTool } = ctx;
-	server.tool("team_members", "List all agents in this workflow. Use to discover who you can @mention. Optionally includes agent status (state, current task).", { includeStatus: z.boolean().optional().describe("Include agent status information") }, async (args, extra) => {
-		const currentAgent = getAgentId(extra) || "anonymous";
-		const includeStatus = args.includeStatus ?? false;
-		const agents = validAgents.map((name) => ({
-			name,
-			mention: `@${name}`,
-			isYou: name === currentAgent
-		}));
-		const result = {
-			agents,
-			count: agents.length,
-			hint: "Use @agent in channel_send to mention other agents"
-		};
-		if (includeStatus) result.status = await provider.listAgentStatus();
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result)
-		}] };
-	});
-	server.tool("team_doc_read", "Read a shared team document.", { file: z.string().optional().describe("Document file path (default: notes.md)") }, async ({ file }, extra) => {
-		logTool("team_doc_read", getAgentId(extra), { file });
-		return { content: [{
-			type: "text",
-			text: await provider.readDocument(file) || "(empty document)"
-		}] };
-	});
-	server.tool("team_doc_write", "Write/replace a shared team document.", {
-		content: z.string().describe("New document content (replaces existing)"),
-		file: z.string().optional().describe("Document file path (default: notes.md)")
-	}, async ({ content, file }, extra) => {
-		logTool("team_doc_write", getAgentId(extra), {
-			file,
-			contentLen: content.length
-		});
-		await provider.writeDocument(content, file);
-		return { content: [{
-			type: "text",
-			text: `Document ${file || "notes.md"} written successfully`
-		}] };
-	});
-	server.tool("team_doc_append", "Append content to a shared team document.", {
-		content: z.string().describe("Content to append to the document"),
-		file: z.string().optional().describe("Document file path (default: notes.md)")
-	}, async ({ content, file }, extra) => {
-		logTool("team_doc_append", getAgentId(extra), {
-			file,
-			contentLen: content.length
-		});
-		await provider.appendDocument(content, file);
-		return { content: [{
-			type: "text",
-			text: `Content appended to ${file || "notes.md"}`
-		}] };
-	});
-	server.tool("team_doc_list", "List all shared team document files.", {}, async () => {
-		const files = await provider.listDocuments();
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				files,
-				count: files.length
-			})
-		}] };
-	});
-	server.tool("team_doc_create", "Create a new shared team document file.", {
-		file: z.string().describe("Document file path (e.g., \"findings/auth.md\")"),
-		content: z.string().describe("Initial document content")
-	}, async ({ file, content }) => {
-		await provider.createDocument(file, content);
-		return { content: [{
-			type: "text",
-			text: `Document ${file} created successfully`
-		}] };
-	});
-}
-
-//#endregion
-//#region src/workflow/context/proposals.ts
-/**
-* Format a proposal for display
-*/
-function formatProposal(proposal) {
-	const lines = [];
-	lines.push(`📋 **${proposal.title}** (${proposal.id})`);
-	lines.push(`Type: ${proposal.type} | Status: ${proposal.status}`);
-	if (proposal.description) lines.push(`\n${proposal.description}`);
-	lines.push("\nOptions:");
-	for (const option of proposal.options) {
-		const count = proposal.result?.counts[option.id] || 0;
-		const marker = proposal.result?.winner === option.id ? "✓ " : "  ";
-		lines.push(`${marker}- ${option.label} (${option.id}): ${count} votes`);
-	}
-	if (proposal.result && Object.keys(proposal.result.votes).length > 0) {
-		lines.push("\nVotes:");
-		for (const [voter, choice] of Object.entries(proposal.result.votes)) lines.push(`  @${voter} → ${choice}`);
-	}
-	if (proposal.status === "active" && proposal.expiresAt) {
-		const remaining = new Date(proposal.expiresAt).getTime() - Date.now();
-		const minutes = Math.max(0, Math.floor(remaining / 6e4));
-		lines.push(`\nExpires in: ${minutes} minutes`);
-	}
-	if (proposal.status === "resolved" && proposal.result?.winner) {
-		const winningOption = proposal.options.find((o) => o.id === proposal.result?.winner);
-		lines.push(`\n🏆 Winner: ${winningOption?.label || proposal.result.winner}`);
-	}
-	return lines.join("\n");
-}
-/**
-* Format multiple proposals as a summary
-*/
-function formatProposalList(proposals) {
-	if (proposals.length === 0) return "(no proposals)";
-	return proposals.map((p) => {
-		const votes = Object.keys(p.result?.votes || {}).length;
-		return `- ${p.id}: ${p.title} [${p.status}] (${votes} votes)`;
-	}).join("\n");
-}
-
-//#endregion
-//#region src/workflow/context/mcp/proposal.ts
-function registerProposalTools(server, ctx, proposalManager) {
-	const { provider, validAgents, getAgentId } = ctx;
-	server.tool("team_proposal_create", "Create a new proposal for team voting. Use for decisions, elections, approvals, or assignments.", {
-		type: z.enum([
-			"election",
-			"decision",
-			"approval",
-			"assignment"
-		]).describe("Type of proposal"),
-		title: z.string().describe("Brief title for the proposal"),
-		description: z.string().optional().describe("Detailed description"),
-		options: z.array(z.object({
-			id: z.string().describe("Unique option identifier"),
-			label: z.string().describe("Display label for the option")
-		})).optional().describe("Voting options (required except for approval type)"),
-		resolution: z.object({
-			type: z.enum([
-				"plurality",
-				"majority",
-				"unanimous"
-			]).optional().describe("How to determine winner"),
-			quorum: z.number().optional().describe("Minimum votes required"),
-			tieBreaker: z.enum([
-				"first",
-				"random",
-				"creator-decides"
-			]).optional().describe("How to break ties")
-		}).optional().describe("Resolution rules"),
-		binding: z.boolean().optional().describe("Whether result is binding (default: true)"),
-		timeoutSeconds: z.number().optional().describe("Timeout in seconds (default: 3600)")
-	}, async (params, extra) => {
-		const createdBy = getAgentId(extra) || "anonymous";
-		try {
-			const proposal = await proposalManager.create({
-				type: params.type,
-				title: params.title,
-				description: params.description,
-				options: params.options,
-				resolution: params.resolution,
-				binding: params.binding,
-				timeoutSeconds: params.timeoutSeconds,
-				createdBy
-			});
-			const optionsList = proposal.options.map((o) => `${o.id}: ${o.label}`).join(", ");
-			const otherAgents = validAgents.filter((a) => a !== createdBy).map((a) => `@${a}`).join(" ");
-			await provider.appendChannel(createdBy, `Created proposal "${proposal.title}" (${proposal.id})\nOptions: ${optionsList}\nUse team_vote tool to cast your vote. ${otherAgents}`);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					status: "created",
-					proposal: {
-						id: proposal.id,
-						title: proposal.title,
-						options: proposal.options,
-						expiresAt: proposal.expiresAt
-					}
-				})
-			}] };
-		} catch (error) {
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					status: "error",
-					error: error instanceof Error ? error.message : String(error)
-				})
-			}] };
-		}
-	});
-	server.tool("team_vote", "Cast your vote on a team proposal.", {
-		proposal: z.string().describe("Proposal ID (e.g., prop-1)"),
-		choice: z.string().describe("Option ID to vote for"),
-		reason: z.string().optional().describe("Optional reason for your vote")
-	}, async ({ proposal: proposalId, choice, reason }, extra) => {
-		const voter = getAgentId(extra) || "anonymous";
-		const result = await proposalManager.vote({
-			proposalId,
-			voter,
-			choice,
-			reason
-		});
-		if (!result.success) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "error",
-				error: result.error
-			})
-		}] };
-		const reasonText = reason ? ` (reason: ${reason})` : "";
-		await provider.appendChannel(voter, `Voted "${choice}" on ${proposalId}${reasonText}`);
-		if (result.resolved && result.proposal) {
-			const winnerOption = result.proposal.options.find((o) => o.id === result.proposal.result?.winner);
-			const mentions = Object.keys(result.proposal.result?.votes || {}).map((v) => `@${v}`).join(" ");
-			await provider.appendChannel("system", `Proposal ${proposalId} resolved! Winner: ${winnerOption?.label || result.proposal.result?.winner || "none"} ${mentions}`);
-		}
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "voted",
-				proposal: proposalId,
-				choice,
-				resolved: result.resolved,
-				winner: result.proposal?.result?.winner
-			})
-		}] };
-	});
-	server.tool("team_proposal_status", "Check status of team proposals. Omit proposal ID to see all active proposals.", { proposal: z.string().optional().describe("Proposal ID (omit for all active)") }, async ({ proposal: proposalId }) => {
-		if (proposalId) {
-			const proposal = await proposalManager.get(proposalId);
-			if (!proposal) return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					status: "error",
-					error: `Proposal not found: ${proposalId}`
-				})
-			}] };
-			return { content: [{
-				type: "text",
-				text: formatProposal(proposal)
-			}] };
-		}
-		const activeProposals = await proposalManager.list("active");
-		return { content: [{
-			type: "text",
-			text: activeProposals.length > 0 ? formatProposalList(activeProposals) : "(no active proposals)"
-		}] };
-	});
-	server.tool("team_proposal_cancel", "Cancel a proposal you created.", { proposal: z.string().describe("Proposal ID to cancel") }, async ({ proposal: proposalId }, extra) => {
-		const cancelledBy = getAgentId(extra) || "anonymous";
-		const result = await proposalManager.cancel(proposalId, cancelledBy);
-		if (!result.success) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "error",
-				error: result.error
-			})
-		}] };
-		await provider.appendChannel(cancelledBy, `Cancelled proposal ${proposalId}`);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				status: "cancelled",
-				proposal: proposalId
-			})
-		}] };
-	});
-}
-
-//#endregion
-//#region src/workflow/context/mcp/feedback.ts
-/**
-* Register the feedback_submit tool and return a getter for collected entries.
-*/
-function registerFeedbackTool(server, ctx) {
-	const { getAgentId, logTool } = ctx;
-	const entries = [];
-	server.tool("feedback_submit", "Report a workflow improvement need. Use when you hit something inconvenient — a missing tool, an awkward step, or a capability you wished you had.", {
-		target: z.string().describe("The area this is about — a tool name, a workflow step, or a general area (e.g. file search, code review)."),
-		type: z.enum([
-			"missing",
-			"friction",
-			"suggestion"
-		]).describe("missing: a tool or capability you needed but didn't have. friction: something that works but is awkward or slow. suggestion: a concrete improvement idea."),
-		description: z.string().describe("What you needed or what could be improved. Be specific."),
-		context: z.string().optional().describe("Optional: what you were trying to do when you hit this.")
-	}, async ({ target, type, description, context: ctx }, extra) => {
-		logTool("feedback_submit", getAgentId(extra) || "anonymous", {
-			target,
-			type
-		});
-		const entry = {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			target,
-			type,
-			description,
-			...ctx ? { context: ctx } : {}
-		};
-		if (entries.length >= 50) entries.shift();
-		entries.push(entry);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({ status: "recorded" })
-		}] };
-	});
-	return { getFeedback: () => [...entries] };
-}
-
-//#endregion
-//#region src/workflow/context/mcp/skills.ts
-function registerSkillsTools(server, provider) {
-	server.tool("skills_list", "List all available agent skills with their descriptions.", {}, async () => {
-		const skills = provider.list();
-		if (skills.length === 0) return { content: [{
-			type: "text",
-			text: JSON.stringify({ message: "No skills available" })
-		}] };
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({ skills: skills.map((s) => ({
-				name: s.name,
-				description: s.description
-			})) })
-		}] };
-	});
-	server.tool("skills_view", "Read the complete SKILL.md file for a skill.", { skillName: z.string().describe("Skill name to view") }, async ({ skillName }) => {
-		return { content: [{
-			type: "text",
-			text: await provider.view(skillName)
-		}] };
-	});
-	server.tool("skills_read", "Read a file within a skill directory (e.g., references/, scripts/, assets/).", {
-		skillName: z.string().describe("Skill name"),
-		filePath: z.string().describe("Relative file path within the skill (e.g., \"references/search-strategies.md\")")
-	}, async ({ skillName, filePath }) => {
-		return { content: [{
-			type: "text",
-			text: await provider.readFile(skillName, filePath)
-		}] };
-	});
-}
-
-//#endregion
-//#region src/workflow/context/mcp/server.ts
-/**
-* Context MCP Server — thin orchestrator.
-*
-* Creates an McpServer and registers tools from each category.
-* The actual tool implementations live in their own files:
-*   channel.ts, resource.ts, inbox.ts, team.ts, proposal.ts,
-*   feedback.ts, skills.ts
-*/
-function createContextMCPServer(options) {
-	const { provider, validAgents, name = "workflow-context", version = "1.0.0", onMention, proposalManager, feedback: feedbackEnabled, skills, debugLog } = options;
-	const server = new McpServer({
-		name,
-		version
-	});
-	const eventLog = new EventLog(provider);
-	const ctx = {
-		provider,
-		eventLog,
-		validAgents,
-		getAgentId,
-		logTool: createLogTool(eventLog)
-	};
-	const agentConnections = /* @__PURE__ */ new Map();
-	const mcpToolNames = new Set([
-		"channel_send",
-		"channel_read",
-		"resource_create",
-		"resource_read",
-		"my_inbox",
-		"my_inbox_ack",
-		"my_status_set",
-		"team_members",
-		"team_doc_read",
-		"team_doc_write",
-		"team_doc_append",
-		"team_doc_list",
-		"team_doc_create"
-	]);
-	registerChannelTools(server, ctx, { onMention });
-	registerResourceTools(server, ctx);
-	registerInboxTools(server, ctx, { debugLog });
-	registerTeamTools(server, ctx);
-	if (proposalManager) {
-		registerProposalTools(server, ctx, proposalManager);
-		mcpToolNames.add("team_proposal_create");
-		mcpToolNames.add("team_vote");
-		mcpToolNames.add("team_proposal_status");
-		mcpToolNames.add("team_proposal_cancel");
-	}
-	let getFeedback = () => [];
-	if (feedbackEnabled) {
-		getFeedback = registerFeedbackTool(server, ctx).getFeedback;
-		mcpToolNames.add("feedback_submit");
-	}
-	if (skills) {
-		registerSkillsTools(server, skills);
-		mcpToolNames.add("skills_list");
-		mcpToolNames.add("skills_view");
-		mcpToolNames.add("skills_read");
-	}
-	return {
-		server,
-		agentConnections,
-		validAgents,
-		proposalManager,
-		getFeedback,
-		mcpToolNames,
-		eventLog
-	};
-}
-
-//#endregion
-//#region src/workflow/context/types.ts
-/** Resource ID prefix */
-const RESOURCE_PREFIX$1 = "res_";
-/** Resource URI scheme */
-const RESOURCE_SCHEME = "resource:";
-/** Message length threshold for channel messages - content longer than this should use resources or documents */
-const MESSAGE_LENGTH_THRESHOLD = 1200;
-/**
-* Generate a unique resource ID
-*/
-function generateResourceId() {
-	return `${RESOURCE_PREFIX$1}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
-}
-/**
-* Create resource reference for use in markdown
-* Example: resource:res_abc123
-*/
-function createResourceRef(id) {
-	return `${RESOURCE_SCHEME}${id}`;
-}
-/**
-* Check if content should be stored as a resource instead of inline
-*/
-function shouldUseResource(content) {
-	return content.length > MESSAGE_LENGTH_THRESHOLD;
-}
-/** Default context configuration values */
-const CONTEXT_DEFAULTS = {
-	dir: "~/.agent-worker/workflows/${{ workflow.name }}/${{ workflow.tag }}/",
-	document: "notes.md"
-};
-/** Mention pattern for extracting @mentions */
-const MENTION_PATTERN = /@([a-zA-Z][a-zA-Z0-9_-]*)/g;
-/**
-* Extract @mentions from a message
-*/
-function extractMentions(content, validAgents) {
-	const mentions = [];
-	let match;
-	MENTION_PATTERN.lastIndex = 0;
-	while ((match = MENTION_PATTERN.exec(content)) !== null) {
-		const agent = match[1];
-		if (agent && validAgents.includes(agent) && !mentions.includes(agent)) mentions.push(agent);
-	}
-	return mentions;
-}
-/** Urgent keyword pattern */
-const URGENT_PATTERN = /\b(urgent|asap|blocked|critical)\b/i;
-/**
-* Calculate priority for an inbox message
-*/
-function calculatePriority(msg) {
-	if (msg.mentions.length > 1) return "high";
-	if (URGENT_PATTERN.test(msg.content)) return "high";
-	return "normal";
-}
-
-//#endregion
-//#region src/workflow/context/provider.ts
-/**
-* Composite ContextProvider — delegates to domain-specific stores.
-*
-* Each store owns one concern:
-* - ChannelStore:  append-only JSONL message log
-* - InboxStore:    filtered view of channel with per-agent cursors
-* - DocumentStore: raw text documents
-* - ResourceStore: content-addressed blobs
-* - StatusStore:   agent status tracking
-*
-* smartSend is the only cross-store orchestration (channel + resource).
-*/
-var ContextProviderImpl = class {
-	constructor(channel, inbox, documents, resources, status, validAgents) {
-		this.channel = channel;
-		this.inbox = inbox;
-		this.documents = documents;
-		this.resources = resources;
-		this.status = status;
-		this.validAgents = validAgents;
-	}
-	appendChannel(from, content, options) {
-		return this.channel.append(from, content, options);
-	}
-	readChannel(options) {
-		return this.channel.read(options);
-	}
-	tailChannel(cursor) {
-		return this.channel.tail(cursor);
-	}
-	/**
-	* Smart send: automatically converts long messages to resources
-	*
-	* If content exceeds MESSAGE_LENGTH_THRESHOLD:
-	* 1. Creates a resource with the full content
-	* 2. Sends a short message referencing the resource
-	* 3. Logs the full content in debug channel for visibility
-	*/
-	async smartSend(from, content, options) {
-		if (!shouldUseResource(content)) return this.channel.append(from, content, options);
-		const resourceType = content.startsWith("```") || content.includes("\n```") ? "markdown" : "text";
-		const resource = await this.resources.create(content, from, resourceType);
-		await this.channel.append("system", `Created resource ${resource.id} (${content.length} chars) for @${from}:\n${content}`, { kind: "debug" });
-		const mentions = extractMentions(content, this.validAgents);
-		const shortMessage = `${mentions.length > 0 ? mentions.map((m) => `@${m}`).join(" ") + " " : ""}[Long content stored as resource]\n\nRead the full content: resource_read("${resource.id}")\n\nReference: ${resource.ref}`;
-		return this.channel.append(from, shortMessage, options);
-	}
-	getInbox(agent) {
-		return this.inbox.getInbox(agent);
-	}
-	markInboxSeen(agent, untilId) {
-		return this.inbox.markSeen(agent, untilId);
-	}
-	ackInbox(agent, untilId) {
-		return this.inbox.ack(agent, untilId);
-	}
-	readDocument(file) {
-		return this.documents.read(file);
-	}
-	writeDocument(content, file) {
-		return this.documents.write(content, file);
-	}
-	appendDocument(content, file) {
-		return this.documents.append(content, file);
-	}
-	listDocuments() {
-		return this.documents.list();
-	}
-	createDocument(file, content) {
-		return this.documents.create(file, content);
-	}
-	createResource(content, createdBy, type) {
-		return this.resources.create(content, createdBy, type);
-	}
-	readResource(id) {
-		return this.resources.read(id);
-	}
-	setAgentStatus(agent, status) {
-		return this.status.set(agent, status);
-	}
-	getAgentStatus(agent) {
-		return this.status.get(agent);
-	}
-	listAgentStatus() {
-		return this.status.list();
-	}
-	async markRunStart() {
-		await this.inbox.markRunStart();
-	}
-	async destroy() {
-		await this.inbox.destroy();
-	}
-};
-
-//#endregion
-//#region src/workflow/context/storage.ts
-/**
-* Storage Backend
-* Abstract storage layer for workflow context persistence.
-*
-* Keys are logical paths (e.g., "channel.jsonl", "documents/notes.md", "_state/inbox.json").
-* Implementations map these to actual storage (filesystem, memory, DB, etc.).
-*/
-/**
-* In-memory storage backend for testing and ephemeral workflows.
-*/
-var MemoryStorage = class {
-	data = /* @__PURE__ */ new Map();
-	async read(key) {
-		return this.data.get(key) ?? null;
-	}
-	async readFrom(key, offset) {
-		const data = this.data.get(key) ?? "";
-		if (offset >= data.length) return {
-			content: "",
-			offset: data.length
-		};
-		return {
-			content: data.slice(offset),
-			offset: data.length
-		};
-	}
-	async write(key, content) {
-		this.data.set(key, content);
-	}
-	async append(key, content) {
-		const existing = this.data.get(key) ?? "";
-		this.data.set(key, existing + content);
-	}
-	async exists(key) {
-		return this.data.has(key);
-	}
-	async list(prefix) {
-		const normalizedPrefix = prefix.endsWith("/") ? prefix : prefix + "/";
-		const results = [];
-		for (const key of this.data.keys()) if (key.startsWith(normalizedPrefix)) results.push(key.slice(normalizedPrefix.length));
-		return results.sort();
-	}
-	async delete(key) {
-		this.data.delete(key);
-	}
-	/** Clear all data (for testing) */
-	clear() {
-		this.data.clear();
-	}
-	/** Get the number of stored keys (for testing) */
-	get size() {
-		return this.data.size;
-	}
-	/** Get all keys (for testing) */
-	keys() {
-		return [...this.data.keys()];
-	}
-};
-/**
-* File-based storage backend.
-* Keys map to file paths relative to a base directory.
-*/
-var FileStorage = class {
-	constructor(baseDir) {
-		this.baseDir = baseDir;
-		if (!existsSync(baseDir)) mkdirSync(baseDir, { recursive: true });
-	}
-	resolve(key) {
-		return join(this.baseDir, key);
-	}
-	async ensureParentDir(filePath) {
-		await mkdir(dirname(filePath), { recursive: true });
-	}
-	async read(key) {
-		const filePath = this.resolve(key);
-		try {
-			return await readFile(filePath, "utf-8");
-		} catch {
-			return null;
-		}
-	}
-	async readFrom(key, offset) {
-		const filePath = this.resolve(key);
-		let fh;
-		try {
-			fh = await open(filePath, "r");
-			const { size } = await fh.stat();
-			if (offset >= size) return {
-				content: "",
-				offset: size
-			};
-			const length = size - offset;
-			const buffer = Buffer.alloc(length);
-			await fh.read(buffer, 0, length, offset);
-			return {
-				content: buffer.toString("utf-8"),
-				offset: size
-			};
-		} catch (err) {
-			if (err.code === "ENOENT") return {
-				content: "",
-				offset: 0
-			};
-			return {
-				content: "",
-				offset
-			};
-		} finally {
-			await fh?.close();
-		}
-	}
-	async write(key, content) {
-		const filePath = this.resolve(key);
-		await this.ensureParentDir(filePath);
-		await writeFile(filePath, content);
-	}
-	async append(key, content) {
-		const filePath = this.resolve(key);
-		await this.ensureParentDir(filePath);
-		await appendFile(filePath, content);
-	}
-	async exists(key) {
-		try {
-			await stat(this.resolve(key));
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	async list(prefix) {
-		const dir = this.resolve(prefix);
-		try {
-			const results = [];
-			const walk = async (currentDir) => {
-				const entries = await readdir(currentDir, { withFileTypes: true });
-				for (const entry of entries) {
-					const fullPath = join(currentDir, entry.name);
-					if (entry.isDirectory()) await walk(fullPath);
-					else if (entry.isFile()) results.push(relative(dir, fullPath));
-				}
-			};
-			await walk(dir);
-			return results.sort();
-		} catch {
-			return [];
-		}
-	}
-	async delete(key) {
-		try {
-			await unlink(this.resolve(key));
-		} catch {}
-	}
-};
-
-//#endregion
-//#region src/workflow/context/stores/channel.ts
-/**
-* Channel Store
-* Append-only JSONL message log with incremental sync and visibility filtering.
-*/
-const CHANNEL_KEY = "channel.jsonl";
-/**
-* JSONL-backed channel store.
-* Incrementally syncs from a StorageBackend using byte offsets.
-*/
-var DefaultChannelStore = class {
-	entries = [];
-	offset = 0;
-	syncPromise = null;
-	constructor(storage, validAgents) {
-		this.storage = storage;
-		this.validAgents = validAgents;
-	}
-	sync() {
-		if (!this.syncPromise) this.syncPromise = this.doSync().finally(() => {
-			this.syncPromise = null;
-		});
-		return this.syncPromise;
-	}
-	async doSync() {
-		const result = await this.storage.readFrom(CHANNEL_KEY, this.offset);
-		if (result.content) {
-			this.entries.push(...parseJsonl(result.content));
-			this.offset = result.offset;
-		}
-		return this.entries;
-	}
-	length() {
-		return this.entries.length;
-	}
-	async append(from, content, options) {
-		const msg = {
-			id: nanoid(),
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			from,
-			content,
-			mentions: extractMentions(content, this.validAgents)
-		};
-		if (options?.to) msg.to = options.to;
-		if (options?.kind) msg.kind = options.kind;
-		if (options?.toolCall) msg.toolCall = options.toolCall;
-		const line = JSON.stringify(msg) + "\n";
-		await this.storage.append(CHANNEL_KEY, line);
-		return msg;
-	}
-	async read(options) {
-		let entries = await this.sync();
-		if (options?.agent) {
-			const agent = options.agent;
-			entries = entries.filter((e) => {
-				if (e.kind === "system" || e.kind === "debug" || e.kind === "output") return false;
-				if (e.to) return e.to === agent || e.from === agent;
-				return true;
-			});
-		}
-		if (options?.since) entries = entries.filter((e) => e.timestamp > options.since);
-		if (options?.limit && options.limit > 0) entries = entries.slice(-options.limit);
-		return entries;
-	}
-	async tail(cursor) {
-		const entries = await this.sync();
-		return {
-			entries: entries.slice(cursor),
-			cursor: entries.length
-		};
-	}
-};
-/**
-* Parse JSONL content into an array of objects.
-* Skips empty lines and lines that fail to parse.
-*/
-function parseJsonl(content) {
-	const results = [];
-	for (const line of content.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			results.push(JSON.parse(trimmed));
-		} catch {}
-	}
-	return results;
-}
-
-//#endregion
-//#region src/workflow/context/stores/inbox.ts
-const INBOX_STATE_KEY = "_state/inbox.json";
-/**
-* Default inbox store backed by channel + JSON cursor file.
-* Inbox is a filtered view of the channel, not a separate log.
-*/
-var DefaultInboxStore = class {
-	runStartIndex = 0;
-	constructor(channel, storage) {
-		this.channel = channel;
-		this.storage = storage;
-	}
-	async getInbox(agent) {
-		const state = await this.loadState();
-		const lastAckId = state.readCursors[agent];
-		const lastSeenId = state.seenCursors?.[agent];
-		let entries = await this.channel.sync();
-		if (this.runStartIndex > 0) entries = entries.slice(this.runStartIndex);
-		if (lastAckId) {
-			const ackIdx = entries.findIndex((e) => e.id === lastAckId);
-			if (ackIdx >= 0) entries = entries.slice(ackIdx + 1);
-		}
-		let seenIdx = -1;
-		if (lastSeenId) seenIdx = entries.findIndex((e) => e.id === lastSeenId);
-		return entries.filter((e) => {
-			if (e.kind === "system" || e.kind === "debug" || e.kind === "output" || e.kind === "tool_call") return false;
-			if (e.from === agent) return false;
-			return e.mentions.includes(agent) || e.to === agent;
-		}).map((entry) => {
-			const entryIdx = entries.indexOf(entry);
-			return {
-				entry,
-				priority: calculatePriority(entry),
-				seen: seenIdx >= 0 && entryIdx <= seenIdx
-			};
-		});
-	}
-	async markSeen(agent, untilId) {
-		const state = await this.loadState();
-		if (!state.seenCursors) state.seenCursors = {};
-		state.seenCursors[agent] = untilId;
-		await this.storage.write(INBOX_STATE_KEY, JSON.stringify(state, null, 2));
-	}
-	async ack(agent, untilId) {
-		const state = await this.loadState();
-		state.readCursors[agent] = untilId;
-		await this.storage.write(INBOX_STATE_KEY, JSON.stringify(state, null, 2));
-	}
-	async markRunStart() {
-		this.runStartIndex = (await this.channel.sync()).length;
-	}
-	async destroy() {
-		await this.storage.delete(INBOX_STATE_KEY);
-	}
-	async loadState() {
-		const raw = await this.storage.read(INBOX_STATE_KEY);
-		if (!raw) return { readCursors: {} };
-		try {
-			const data = JSON.parse(raw);
-			return {
-				readCursors: data.readCursors || {},
-				seenCursors: data.seenCursors
-			};
-		} catch {
-			return { readCursors: {} };
-		}
-	}
-};
-
-//#endregion
-//#region src/workflow/context/stores/document.ts
-const DOCUMENT_PREFIX = "documents/";
-/**
-* Default document store backed by a StorageBackend.
-* Documents are stored as raw text under a key prefix.
-*/
-var DefaultDocumentStore = class {
-	constructor(storage) {
-		this.storage = storage;
-	}
-	key(file) {
-		return DOCUMENT_PREFIX + (file || CONTEXT_DEFAULTS.document);
-	}
-	async read(file) {
-		return await this.storage.read(this.key(file)) ?? "";
-	}
-	async write(content, file) {
-		await this.storage.write(this.key(file), content);
-	}
-	async append(content, file) {
-		await this.storage.append(this.key(file), content);
-	}
-	async list() {
-		return (await this.storage.list(DOCUMENT_PREFIX)).filter((f) => f.endsWith(".md")).sort();
-	}
-	async create(file, content) {
-		const key = this.key(file);
-		if (await this.storage.exists(key)) throw new Error(`Document already exists: ${file}`);
-		await this.storage.write(key, content);
-	}
-};
-
-//#endregion
-//#region src/workflow/context/stores/resource.ts
-const RESOURCE_PREFIX = "resources/";
-/**
-* Default resource store backed by a StorageBackend.
-* Resources are keyed by generated ID with type-based extensions.
-*/
-var DefaultResourceStore = class {
-	constructor(storage) {
-		this.storage = storage;
-	}
-	async create(content, _createdBy, type = "text") {
-		const id = generateResourceId();
-		const key = `${RESOURCE_PREFIX}${id}.${type === "json" ? "json" : type === "diff" ? "diff" : "md"}`;
-		await this.storage.write(key, content);
-		return {
-			id,
-			ref: createResourceRef(id)
-		};
-	}
-	async read(id) {
-		for (const ext of [
-			"md",
-			"json",
-			"diff",
-			"txt"
-		]) {
-			const key = `${RESOURCE_PREFIX}${id}.${ext}`;
-			const content = await this.storage.read(key);
-			if (content !== null) return content;
-		}
-		return null;
-	}
-};
-
-//#endregion
-//#region src/workflow/context/stores/status.ts
-const STATUS_KEY = "_state/agent-status.json";
-/**
-* Default status store backed by a JSON file via StorageBackend.
-* All agent statuses are stored in a single JSON object.
-*/
-var DefaultStatusStore = class {
-	constructor(storage) {
-		this.storage = storage;
-	}
-	async set(agent, status) {
-		const statuses = await this.loadAll();
-		const existing = statuses[agent] || {
-			state: "idle",
-			lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		statuses[agent] = {
-			...existing,
-			...status,
-			lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		if (status.state === "running" && existing.state !== "running") statuses[agent].startedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (status.state === "idle") {
-			statuses[agent].startedAt = void 0;
-			statuses[agent].task = void 0;
-		}
-		await this.save(statuses);
-	}
-	async get(agent) {
-		return (await this.loadAll())[agent] || null;
-	}
-	async list() {
-		return this.loadAll();
-	}
-	async loadAll() {
-		const raw = await this.storage.read(STATUS_KEY);
-		if (!raw) return {};
-		try {
-			return JSON.parse(raw);
-		} catch {
-			return {};
-		}
-	}
-	async save(statuses) {
-		await this.storage.write(STATUS_KEY, JSON.stringify(statuses, null, 2));
-	}
-};
-
-//#endregion
-//#region src/workflow/context/file-provider.ts
-/**
-* File Context Provider
-* Composes default stores with FileStorage backend.
-* Includes instance lock to prevent concurrent access to the same context directory.
-*/
-var file_provider_exports = /* @__PURE__ */ __exportAll({
-	FileContextProvider: () => FileContextProvider,
-	createFileContextProvider: () => createFileContextProvider,
-	getDefaultContextDir: () => getDefaultContextDir,
-	resolveContextDir: () => resolveContextDir
-});
-/** Lock file name within context directory */
-const LOCK_FILE = "_state/instance.lock";
-/**
-* File-based ContextProvider.
-* Creates default stores backed by a shared FileStorage.
-*
-* Adds instance locking: only one process can hold the lock at a time.
-* Stale locks (from crashed processes) are automatically cleaned up.
-*/
-var FileContextProvider = class extends ContextProviderImpl {
-	lockPath;
-	constructor(storage, validAgents, contextDir) {
-		const channel = new DefaultChannelStore(storage, validAgents);
-		const inbox = new DefaultInboxStore(channel, storage);
-		const documents = new DefaultDocumentStore(storage);
-		const resources = new DefaultResourceStore(storage);
-		const status = new DefaultStatusStore(storage);
-		super(channel, inbox, documents, resources, status, validAgents);
-		this.contextDir = contextDir;
-		this.lockPath = join(contextDir, LOCK_FILE);
-	}
-	/**
-	* Acquire instance lock.
-	* Throws if another live process holds the lock.
-	* Automatically cleans up stale locks from dead processes.
-	*/
-	acquireLock() {
-		if (existsSync(this.lockPath)) try {
-			const existing = JSON.parse(readFileSync(this.lockPath, "utf-8"));
-			try {
-				process.kill(existing.pid, 0);
-				throw new Error(`Context directory is locked by another process (PID ${existing.pid}, started ${existing.startedAt}). If the process is no longer running, delete ${this.lockPath}`);
-			} catch (e) {
-				if (e instanceof Error && e.message.includes("Context directory is locked")) throw e;
-			}
-		} catch (e) {
-			if (e instanceof Error && e.message.includes("Context directory is locked")) throw e;
-		}
-		const lock = {
-			pid: process.pid,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		const stateDir = join(this.contextDir, "_state");
-		if (!existsSync(stateDir)) mkdirSync(stateDir, { recursive: true });
-		writeFileSync(this.lockPath, JSON.stringify(lock, null, 2));
-	}
-	/**
-	* Release instance lock.
-	* Safe to call even if lock is not held (no-op).
-	*/
-	releaseLock() {
-		try {
-			if (existsSync(this.lockPath)) {
-				if (JSON.parse(readFileSync(this.lockPath, "utf-8")).pid === process.pid) unlinkSync(this.lockPath);
-			}
-		} catch {}
-	}
-	/**
-	* Override destroy to release lock and clean up transient state.
-	*/
-	async destroy() {
-		await super.destroy();
-		this.releaseLock();
-	}
-};
-/**
-* Resolve a context directory template to an absolute path.
-*
-* Supports:
-* - ${{ workflow.name }} — substituted with workflowName
-* - ${{ workflow.tag }} — substituted with tag
-* - ~ expansion to home directory
-* - Relative paths resolved against baseDir (or cwd if not provided)
-* - Absolute paths used as-is
-*/
-function resolveContextDir(dirTemplate, opts) {
-	const workflow = opts.workflow ?? opts.workflowName ?? "global";
-	const workflowName = opts.workflowName ?? workflow;
-	const tag = opts.tag ?? "main";
-	let dir = dirTemplate.replace("${{ workflow.name }}", workflowName).replace("${{ workflow.tag }}", tag);
-	if (dir.startsWith("~/")) dir = join(homedir(), dir.slice(2));
-	else if (dir === "~") dir = homedir();
-	else if (!isAbsolute(dir)) dir = join(opts.baseDir ?? process.cwd(), dir);
-	return dir;
-}
-/**
-* Resolve context dir for a workflow:tag using default template.
-* Shorthand for the common case.
-* @param workflow Workflow name (defaults to "global")
-* @param tag Workflow instance tag (defaults to "main")
-*/
-function getDefaultContextDir(workflow, tag) {
-	const wf = workflow ?? "global";
-	const t = tag ?? "main";
-	return resolveContextDir(CONTEXT_DEFAULTS.dir, {
-		workflow: wf,
-		tag: t
-	});
-}
-/**
-* Create a FileContextProvider with default paths.
-*
-* Directory layout:
-*   contextDir/
-*   ├── channel.jsonl        # Channel log (JSONL)
-*   ├── documents/           # Team documents
-*   │   └── notes.md         # Default document
-*   ├── resources/           # Resource blobs
-*   ├── _state/
-*   │   ├── inbox.json       # Inbox read cursors
-*   │   ├── instance.lock    # Instance lock (PID-based)
-*   │   └── proposals.json   # Proposal state
-*   └── ...
-*/
-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/loop/types.ts
-/** Default loop configuration values */
-const LOOP_DEFAULTS = {
-	pollInterval: 5e3,
-	retry: {
-		maxAttempts: 3,
-		backoffMs: 1e3,
-		backoffMultiplier: 2
-	},
-	recentChannelLimit: 50,
-	idleDebounceMs: 2e3
-};
-
-//#endregion
-//#region src/workflow/loop/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");
-}
-/** Project context (what codebase to work on) */
-const projectSection = (ctx) => `## Project\nWorking on: ${ctx.projectDir}`;
-/** Inbox (unread messages for this agent) */
-const inboxSection = (ctx) => {
-	const count = ctx.inbox.length;
-	return `## Inbox (${count} ${count === 1 ? "message" : "messages"} for you)\n${formatInbox(ctx.inbox)}`;
-};
-/** Recent activity hint (use tool instead of injecting messages) */
-const activitySection = () => "## Recent Activity\nUse channel_read tool to view recent channel messages and conversation context if needed.";
-/** Shared document section */
-const documentSection = (ctx) => ctx.documentContent ? `## Shared Document\n${ctx.documentContent}` : null;
-/** Retry notice */
-const retrySection = (ctx) => ctx.retryAttempt > 1 ? `## Note\nThis is retry attempt ${ctx.retryAttempt}. Previous attempt failed.` : null;
-/** MCP tool instructions */
-const instructionsSection = (ctx) => {
-	const lines = [];
-	lines.push("## Instructions");
-	lines.push("You are an agent in a multi-agent workflow. Communicate ONLY through the MCP tools below.");
-	lines.push("Your text output is NOT seen by other agents — you MUST use channel_send to communicate.");
-	lines.push("");
-	lines.push("### Channel Tools");
-	lines.push("- **channel_send**: Send a message to the shared channel. Use @agentname to mention/notify.");
-	lines.push("  Use the \"to\" parameter for private DMs: channel_send({ message: \"...\", to: \"bob\" })");
-	lines.push("- **channel_read**: Read recent channel messages (DMs and logs are auto-filtered).");
-	lines.push("");
-	lines.push("### Team Tools");
-	lines.push("- **team_members**: List all agents you can @mention. Pass includeStatus=true to see their current state and tasks.");
-	lines.push("- **team_doc_read/write/append/list/create**: Shared team documents.");
-	lines.push("");
-	lines.push("### Personal Tools");
-	lines.push("- **my_inbox**: Check your unread messages.");
-	lines.push("- **my_inbox_ack**: Acknowledge messages after processing (pass the latest message ID).");
-	lines.push("- **my_status_set**: Update your status. Call when starting work (state='running', task='...') or when done (state='idle').");
-	lines.push("");
-	lines.push("### Proposal & Voting Tools");
-	lines.push("- **team_proposal_create**: Create a proposal for team voting (types: election, decision, approval, assignment).");
-	lines.push("- **team_vote**: Cast your vote on an active proposal. You can change your vote by voting again.");
-	lines.push("- **team_proposal_status**: Check status of a proposal, or list all active proposals.");
-	lines.push("- **team_proposal_cancel**: Cancel a proposal you created.");
-	lines.push("");
-	lines.push("### Resource Tools");
-	lines.push("- **resource_create**: Store large content, get a reference (resource:id) for use anywhere.");
-	lines.push("- **resource_read**: Read resource content by ID.");
-	if (ctx.feedback) {
-		lines.push("");
-		lines.push("### Feedback Tool");
-		lines.push("- **feedback_submit**: Report workflow improvement needs — a missing tool, an awkward step, or a capability gap.");
-		lines.push("  Only use when you genuinely hit a pain point during your work.");
-	}
-	return lines.join("\n");
-};
-/** Workflow instructions (read → work → ack → exit) */
-const workflowSection = () => {
-	const lines = [];
-	lines.push("### Workflow");
-	lines.push("1. Read your inbox messages above");
-	lines.push("2. Do your assigned work using channel_send with @mentions");
-	lines.push("3. Acknowledge your inbox with my_inbox_ack");
-	lines.push("4. Exit when your task is complete");
-	return lines.join("\n");
-};
-/** Exit guidance (when to stop) */
-const exitSection = () => {
-	const lines = [];
-	lines.push("### IMPORTANT: When to stop");
-	lines.push("- Once your assigned task is complete, acknowledge your inbox and exit. Do NOT keep chatting.");
-	lines.push("- Do NOT send pleasantries (\"you're welcome\", \"glad to help\", \"thanks again\") — they trigger unnecessary cycles.");
-	lines.push("- Do NOT @mention another agent in your final message unless you need them to do more work.");
-	lines.push("- If you receive a thank-you or acknowledgment, just call my_inbox_ack and exit. Do not reply.");
-	return lines.join("\n");
-};
-/**
-* Default prompt sections — produces the same output as the original
-* monolithic buildAgentPrompt. New sections (soul, memory, todo) can
-* be inserted at specific positions without touching these.
-*/
-const DEFAULT_SECTIONS = [
-	projectSection,
-	inboxSection,
-	activitySection,
-	documentSection,
-	retrySection,
-	instructionsSection,
-	workflowSection,
-	exitSection
-];
-/**
-* Assemble prompt from sections. Joins non-null sections with blank lines.
-*/
-function assemblePrompt(sections, ctx) {
-	return sections.map((section) => section(ctx)).filter((content) => content !== null).join("\n\n");
-}
-/**
-* Build the complete agent prompt from run context.
-*
-* Uses the default section list. For custom section lists,
-* use assemblePrompt() directly.
-*/
-function buildAgentPrompt(ctx) {
-	return assemblePrompt(DEFAULT_SECTIONS, ctx);
-}
-
-//#endregion
-//#region src/workflow/loop/mcp-config.ts
-/**
-* Workflow MCP Config Generation & Writing
-*
-* Two responsibilities:
-* 1. Generate MCP config for workflow HTTP transport
-* 2. Write backend-specific MCP config files to workspace
-*
-* Writing lives here (not in backends) because it's workspace infrastructure,
-* not a backend concern. Backends only need their cwd set — they don't
-* need to know about MCP config file layout.
-*/
-/**
-* 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
-	} } };
-}
-/**
-* Write MCP config to a workspace directory in the format expected by a backend.
-*
-* Each CLI backend reads MCP config from a different location:
-* - claude:   {workspace}/mcp-config.json        (passed via --mcp-config flag)
-* - cursor:   {workspace}/.cursor/mcp.json       (auto-discovered by cursor)
-* - codex:    {workspace}/.codex/config.yaml      (auto-discovered by codex)
-* - opencode: {workspace}/opencode.json           (auto-discovered by opencode)
-* - default/mock: no config file needed (MCP handled by loop via SDK)
-*/
-function writeBackendMcpConfig(backendType, workspaceDir, mcpConfig) {
-	ensureDir(workspaceDir);
-	switch (backendType) {
-		case "claude":
-			writeJsonConfig(join(workspaceDir, "mcp-config.json"), mcpConfig);
-			break;
-		case "cursor": {
-			const cursorDir = join(workspaceDir, ".cursor");
-			ensureDir(cursorDir);
-			writeJsonConfig(join(cursorDir, "mcp.json"), mcpConfig);
-			break;
-		}
-		case "codex": {
-			const codexDir = join(workspaceDir, ".codex");
-			ensureDir(codexDir);
-			const codexConfig = { mcp_servers: mcpConfig.mcpServers };
-			writeFileSync(join(codexDir, "config.yaml"), stringify(codexConfig));
-			break;
-		}
-		case "opencode": {
-			const opencodeMcp = {};
-			for (const [name, config] of Object.entries(mcpConfig.mcpServers)) {
-				const serverConfig = config;
-				if (serverConfig.type === "http") opencodeMcp[name] = serverConfig;
-				else opencodeMcp[name] = {
-					type: "local",
-					command: [serverConfig.command, ...serverConfig.args || []],
-					enabled: true,
-					...serverConfig.env ? { environment: serverConfig.env } : {}
-				};
-			}
-			const opencodeConfig = {
-				$schema: "https://opencode.ai/config.json",
-				mcp: opencodeMcp
-			};
-			writeJsonConfig(join(workspaceDir, "opencode.json"), opencodeConfig);
-			break;
-		}
-	}
-}
-function ensureDir(dir) {
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-}
-function writeJsonConfig(path, data) {
-	writeFileSync(path, JSON.stringify(data, null, 2));
-}
-
-//#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/loop/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 loop 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] = createTool({
-			description: mcpTool.description || toolName,
-			schema: 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 loop 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/loop/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] = createTool({
-			description: mcpTool.description || toolName,
-			schema: mcpTool.inputSchema,
-			execute: async (args) => {
-				return (await client.callTool({
-					name: toolName,
-					arguments: args
-				})).content;
-			}
-		});
-	}
-	return {
-		tools: aiTools,
-		close: () => client.close()
-	};
-}
-function createBashTool() {
-	return createTool({
-		description: "Execute a shell command and return stdout/stderr.",
-		schema: {
-			type: "object",
-			properties: { command: {
-				type: "string",
-				description: "The shell command to execute"
-			} },
-			required: ["command"]
-		},
-		execute: async (args) => {
-			const command = args.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 loop 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/loop/loop.ts
-/** Check if loop should continue running */
-function shouldContinue(state) {
-	return state !== "stopped";
-}
-/**
-* Create an agent loop
-*
-* The loop:
-* 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 createAgentLoop(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 ?? LOOP_DEFAULTS.pollInterval;
-	const retryConfig = {
-		maxAttempts: config.retry?.maxAttempts ?? LOOP_DEFAULTS.retry.maxAttempts,
-		backoffMs: config.retry?.backoffMs ?? LOOP_DEFAULTS.retry.backoffMs,
-		backoffMultiplier: config.retry?.backoffMultiplier ?? LOOP_DEFAULTS.retry.backoffMultiplier
-	};
-	let state = "stopped";
-	let wakeResolver = null;
-	let pollTimeout = null;
-	let directRunning = false;
-	let _hasFailures = false;
-	let _lastError;
-	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 poll 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: LOOP_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) {
-				_hasFailures = true;
-				_lastError = lastResult.error;
-				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;
-		},
-		get hasFailures() {
-			return _hasFailures;
-		},
-		get lastError() {
-			return _lastError;
-		},
-		async start() {
-			if (state !== "stopped") throw new Error(`Loop ${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: LOOP_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 loop 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 {
-		const mcpConfig = generateWorkflowMCPConfig(ctx.mcpUrl, ctx.name);
-		writeBackendMcpConfig(backend.type, 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(loops, provider, debounceMs = LOOP_DEFAULTS.idleDebounceMs) {
-	if (![...loops.values()].every((c) => c.state === "idle")) return false;
-	for (const [name] of loops) if ((await provider.getInbox(name)).length > 0) return false;
-	await sleep(debounceMs);
-	return [...loops.values()].every((c) => c.state === "idle");
-}
-
-//#endregion
-//#region src/workflow/loop/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;
-	if (options?.workspace) backendOptions.workspace = options.workspace;
-	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);
-	if (provider === "claude") return getBackendByType("claude", {
-		...options,
-		model
-	});
-	if (provider === "codex") return getBackendByType("codex", {
-		...options,
-		model
-	});
-	return getBackendByType("default", {
-		...options,
-		model
-	});
-}
-
-//#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 runWorkflowWithLoops() so that
-* the daemon can create and manage workflow components independently.
-*
-* Usage:
-*   1. createMinimalRuntime()  — context + MCP + event log (the "workspace")
-*   2. createWiredLoop()       — backend + workspace dir + loop (per agent)
-*   3. Caller manages lifecycle  — start/stop loops, send kickoff, shutdown
-*/
-/**
-* Create a minimal workflow runtime.
-*
-* Sets up the shared infrastructure (context + MCP + event log) without
-* creating loops 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 loop.
-*
-* 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 AgentLoop with all wiring
-*
-* Extracted from runWorkflowWithLoops() so both runner.ts and
-* daemon.ts can create loops with the same quality.
-*/
-function createWiredLoop(config) {
-	const { name, agent, runtime, pollInterval, feedback: feedbackEnabled } = config;
-	const logger = config.logger ?? createSilentLogger();
-	const workspaceDir = join(runtime.contextDir, "workspaces", name);
-	if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
-	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 effectiveModel;
-	let effectiveProvider = agent.provider;
-	if (isAutoProvider(agent.model) || isAutoProvider(agent.provider)) {
-		const resolved = resolveModelFallback({
-			model: agent.model,
-			provider: typeof agent.provider === "string" ? agent.provider : void 0
-		});
-		effectiveModel = resolved.model;
-		effectiveProvider = resolved.provider;
-		logger.info(`Model resolved: ${effectiveModel}`);
-	} else effectiveModel = agent.model;
-	let backend;
-	if (config.createBackend) backend = config.createBackend(name, agent);
-	else if (agent.backend) backend = getBackendByType(agent.backend, {
-		model: effectiveModel,
-		provider: effectiveProvider,
-		debugLog: (msg) => logger.debug(msg),
-		streamCallbacks,
-		timeout: agent.timeout,
-		workspace: workspaceDir
-	});
-	else if (effectiveModel) backend = getBackendForModel(effectiveModel, {
-		provider: effectiveProvider,
-		debugLog: (msg) => logger.debug(msg),
-		streamCallbacks,
-		workspace: workspaceDir
-	});
-	else throw new Error(`Agent "${name}" requires either a backend or model field`);
-	return {
-		loop: createAgentLoop({
-			name,
-			agent: effectiveModel !== agent.model || effectiveProvider !== agent.provider ? {
-				...agent,
-				model: effectiveModel,
-				provider: effectiveProvider
-			} : 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 → Loop (three layers)
-*   Interface: CLI/REST/MCP clients talk to daemon via HTTP
-*   Daemon:    This module — owns lifecycle, creates workflows + loops
-*   Loop:      AgentLoop + Backend — executes agent reasoning
-*
-* Data ownership:
-*   Registry (configs)    — what agents exist and their configuration
-*   Workflows (workflows) — running workflow instances with loops + context
-*
-* 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
-*   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({
-	createDaemonApp: () => createDaemonApp,
-	startDaemon: () => startDaemon
-});
-/** Key prefix for standalone agent workflow handles */
-const STANDALONE_PREFIX = "standalone:";
-/** Build a workflow key for standalone agents */
-function standaloneKey(agentName) {
-	return `${STANDALONE_PREFIX}${agentName}`;
-}
-let state = null;
-let shuttingDown = false;
-const mcpSessions = /* @__PURE__ */ new Map();
-async function gracefulShutdown() {
-	if (shuttingDown) return;
-	shuttingDown = true;
-	if (state) {
-		for (const [, loop] of state.loops) try {
-			await loop.stop();
-		} catch {}
-		state.loops.clear();
-		for (const [, wf] of state.workflows) try {
-			await wf.shutdown();
-		} catch {}
-		state.workflows.clear();
-		if (state.server) await state.server.close();
-	}
-	for (const [, session] of mcpSessions) try {
-		await session.transport.close();
-	} catch {}
-	mcpSessions.clear();
-	removeDaemonInfo();
-	process.exit(0);
-}
-/** Safe JSON body parsing — returns null on malformed input */
-async function parseJsonBody(c) {
-	try {
-		return await c.req.json();
-	} catch {
-		return null;
-	}
-}
-/** Map AgentConfig to the ResolvedWorkflowAgent type needed by the factory */
-function configToResolvedWorkflowAgent(cfg) {
-	return {
-		backend: cfg.backend,
-		model: cfg.model,
-		provider: cfg.provider,
-		resolvedSystemPrompt: cfg.system,
-		schedule: cfg.schedule
-	};
-}
-/**
-* Find an agent's loop.
-* First checks daemon-level loops (standalone agents),
-* then falls back to workflow-scoped loops (workflow agents).
-*/
-function findLoop(s, agentName) {
-	const daemonLoop = s.loops.get(agentName);
-	if (daemonLoop) return {
-		loop: daemonLoop,
-		workflow: s.workflows.get(standaloneKey(agentName)) ?? null
-	};
-	for (const wf of s.workflows.values()) {
-		const l = wf.loops.get(agentName);
-		if (l) return {
-			loop: l,
-			workflow: wf
-		};
-	}
-	return null;
-}
-/**
-* Ensure a standalone agent has a loop + runtime.
-* Creates the infrastructure lazily on first call (starts MCP server, etc.).
-*
-* The loop is stored in `s.loops` (daemon-owned).
-* A WorkflowHandle is still created for runtime resource management (MCP, context).
-*
-* This is the bridge between POST /agents (stores config only) and
-* POST /run or /serve (needs a loop to execute).
-*/
-async function ensureAgentLoop(s, agentName) {
-	const existing = findLoop(s, agentName);
-	if (existing) return existing;
-	const cfg = s.configs.get(agentName);
-	if (!cfg) throw new Error(`Agent not found: ${agentName}`);
-	const agentDef = configToResolvedWorkflowAgent(cfg);
-	const wfKey = standaloneKey(agentName);
-	const workflowName = cfg.workflow ?? "global";
-	const workflowTag = cfg.tag ?? "main";
-	const runtime = await createMinimalRuntime({
-		workflowName,
-		tag: workflowTag,
-		agentNames: [agentName]
-	});
-	let loop;
-	try {
-		({loop} = createWiredLoop({
-			name: agentName,
-			agent: agentDef,
-			runtime
-		}));
-	} catch (err) {
-		await runtime.shutdown();
-		throw err;
-	}
-	s.loops.set(agentName, loop);
-	const handle = {
-		name: workflowName,
-		tag: workflowTag,
-		key: wfKey,
-		standalone: true,
-		agents: [agentName],
-		loops: new Map([[agentName, loop]]),
-		contextProvider: runtime.contextProvider,
-		shutdown: async () => {
-			try {
-				await loop.stop();
-			} finally {
-				await runtime.shutdown();
-			}
-		},
-		startedAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	s.workflows.set(wfKey, handle);
-	return {
-		loop,
-		workflow: handle
-	};
-}
-/**
-* Create the Hono app with all daemon routes.
-*
-* Accepts a state getter so the app can be used both in production
-* (module-level state set by startDaemon) and in tests (injected state).
-*
-* When a token is provided, all endpoints require `Authorization: Bearer <token>`.
-* This prevents cross-origin attacks from malicious websites.
-*/
-function createDaemonApp(options) {
-	const { getState, token } = options;
-	const app = new Hono();
-	if (token) app.use("*", async (c, next) => {
-		if (c.req.header("authorization") !== `Bearer ${token}`) return c.json({ error: "Unauthorized" }, 401);
-		await next();
-	});
-	function getWorkflowAgentNames(workflow, tag) {
-		const s = getState();
-		if (!s) return [];
-		return [...s.configs.values()].filter((c) => c.workflow === workflow && c.tag === tag).map((c) => c.name);
-	}
-	app.get("/health", (c) => {
-		const s = getState();
-		if (!s) return c.json({ status: "unavailable" }, 503);
-		const standaloneAgents = [...s.configs.keys()];
-		const workflowList = [...s.workflows.values()].filter((wf) => !wf.standalone).map((wf) => ({
-			name: wf.name,
-			tag: wf.tag,
-			agents: wf.agents
-		}));
-		return c.json({
-			status: "ok",
-			pid: process.pid,
-			port: s.port,
-			uptime: Date.now() - new Date(s.startedAt).getTime(),
-			agents: standaloneAgents,
-			workflows: workflowList
-		});
-	});
-	app.post("/shutdown", (c) => {
-		setImmediate(() => gracefulShutdown());
-		return c.json({ success: true });
-	});
-	app.get("/agents", (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const standaloneAgents = [...s.configs.values()].map((cfg) => {
-			const found = findLoop(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: found?.loop.state
-			};
-		});
-		const workflowAgents = [...s.workflows.values()].flatMap((wf) => wf.agents.map((agentName) => {
-			const loop = wf.loops.get(agentName);
-			return {
-				name: agentName,
-				model: "",
-				backend: "",
-				workflow: wf.name,
-				tag: wf.tag,
-				createdAt: wf.startedAt,
-				source: "workflow",
-				state: loop?.state ?? "unknown"
-			};
-		}));
-		return c.json({ agents: [...standaloneAgents, ...workflowAgents] });
-	});
-	app.post("/agents", async (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const body = await parseJsonBody(c);
-		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
-		const { name, model, system, backend = "default", provider, workflow, tag, 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 = {
-			name,
-			model,
-			system,
-			backend,
-			provider,
-			workflow,
-			tag,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			schedule
-		};
-		s.configs.set(name, agentConfig);
-		return c.json({
-			name,
-			model,
-			backend,
-			workflow,
-			tag,
-			schedule
-		}, 201);
-	});
-	app.get("/agents/:name", (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const cfg = s.configs.get(c.req.param("name"));
-		if (!cfg) return c.json({ error: "Agent not found" }, 404);
-		return c.json({
-			name: cfg.name,
-			model: cfg.model,
-			backend: cfg.backend,
-			system: cfg.system,
-			workflow: cfg.workflow,
-			tag: cfg.tag,
-			createdAt: cfg.createdAt,
-			schedule: cfg.schedule
-		});
-	});
-	app.delete("/agents/:name", async (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const name = c.req.param("name");
-		if (!s.configs.delete(name)) return c.json({ error: "Agent not found" }, 404);
-		const daemonLoop = s.loops.get(name);
-		if (daemonLoop) {
-			try {
-				await daemonLoop.stop();
-			} catch {}
-			s.loops.delete(name);
-		}
-		const wfKey = standaloneKey(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) => {
-		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);
-		let loop;
-		const loopResult = findLoop(s, agentName);
-		if (loopResult) loop = loopResult.loop;
-		else if (s.configs.has(agentName)) try {
-			loop = (await ensureAgentLoop(s, agentName)).loop;
-		} catch (error) {
-			const msg = error instanceof Error ? error.message : String(error);
-			return c.json({ error: `Failed to create agent runtime: ${msg}` }, 500);
-		}
-		if (!loop) return c.json({ error: `Agent not found: ${agentName}` }, 404);
-		const agentLoop = loop;
-		return streamSSE(c, async (stream) => {
-			try {
-				const result = await agentLoop.sendDirect(message);
-				if (result.success) {
-					if (result.content) await stream.writeSSE({
-						event: "chunk",
-						data: JSON.stringify({
-							agent: agentName,
-							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({
-					event: "error",
-					data: JSON.stringify({ error: msg })
-				});
-			}
-		});
-	});
-	app.post("/serve", async (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const body = await parseJsonBody(c);
-		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
-		const { agent: agentName, message } = body;
-		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
-		let loop;
-		const loopResult = findLoop(s, agentName);
-		if (loopResult) loop = loopResult.loop;
-		else if (s.configs.has(agentName)) try {
-			loop = (await ensureAgentLoop(s, agentName)).loop;
-		} catch (error) {
-			const msg = error instanceof Error ? error.message : String(error);
-			return c.json({ error: msg }, 500);
-		}
-		if (!loop) return c.json({ error: `Agent not found: ${agentName}` }, 404);
-		try {
-			const result = await loop.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);
-		}
-	});
-	app.all("/mcp", async (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const req = c.req.raw;
-		const sessionId = req.headers.get("mcp-session-id");
-		if (sessionId && mcpSessions.has(sessionId)) {
-			const session = mcpSessions.get(sessionId);
-			if (req.method === "DELETE") {
-				await session.transport.close();
-				mcpSessions.delete(sessionId);
-				return new Response(null, { status: 200 });
-			}
-			return session.transport.handleRequest(req);
-		}
-		if (req.method === "POST") {
-			const body = await req.json();
-			if (!(Array.isArray(body) ? body.some((m) => m?.method === "initialize") : body?.method === "initialize")) return c.json({ error: "Bad request: session required" }, 400);
-			const agentName = new URL(req.url).searchParams.get("agent") || "user";
-			const agentCfg = s.configs.get(agentName);
-			const workflow = agentCfg?.workflow ?? "global";
-			const tag = agentCfg?.tag ?? "main";
-			const existingWf = findLoop(s, agentName)?.workflow ?? s.workflows.get(`${workflow}:${tag}`);
-			const workflowAgents = getWorkflowAgentNames(workflow, tag);
-			const allNames = [...new Set([
-				...workflowAgents,
-				agentName,
-				"user"
-			])];
-			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) => {
-					mcpSessions.set(sid, {
-						transport,
-						agentId: agentName
-					});
-				},
-				onsessionclosed: (sid) => {
-					mcpSessions.delete(sid);
-				},
-				enableJsonResponse: true
-			});
-			await createContextMCPServer({
-				provider,
-				validAgents: allNames,
-				name: `${workflow}-context`,
-				version: "1.0.0"
-			}).server.connect(transport);
-			return transport.handleRequest(req, { parsedBody: body });
-		}
-		if (req.method === "GET") return c.json({ error: "Session ID required for GET requests" }, 400);
-		return c.json({ error: "Method not allowed" }, 405);
-	});
-	app.post("/workflows", async (c) => {
-		const s = getState();
-		if (!s) return c.json({ error: "Not ready" }, 503);
-		const body = await parseJsonBody(c);
-		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
-		const { workflow, tag = "main", feedback, pollInterval, params } = 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 { runWorkflowWithLoops } = await import("../runner-BmT0Y8MD.mjs");
-			const result = await runWorkflowWithLoops({
-				workflow,
-				workflowName,
-				tag,
-				mode: "start",
-				headless: true,
-				feedback,
-				pollInterval,
-				params,
-				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),
-				loops: result.loops,
-				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()].filter((wf) => !wf.standalone).map((wf) => {
-			const agentStates = {};
-			for (const [name, loop] of wf.loops) agentStates[name] = loop.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
-	});
-	const actualPort = server.port;
-	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-	writeDaemonInfo({
-		pid: process.pid,
-		host,
-		port: actualPort,
-		startedAt,
-		token
-	});
-	state = {
-		configs: /* @__PURE__ */ new Map(),
-		loops: /* @__PURE__ */ new Map(),
-		workflows: /* @__PURE__ */ new Map(),
-		store,
-		server,
-		port: actualPort,
-		host,
-		startedAt
-	};
-	console.log(`Daemon started: pid=${process.pid}`);
-	console.log(`Listening: http://${host}:${actualPort}`);
-	console.log(`MCP: http://${host}:${actualPort}/mcp`);
-	process.on("SIGINT", () => {
-		console.log("\nShutting down...");
-		gracefulShutdown();
-	});
-	process.on("SIGTERM", () => {
-		gracefulShutdown();
-	});
-}
-
-//#endregion
-//#region src/cli/client.ts
-/**
-* CLI client — HTTP client for daemon REST API.
-*
-* Talks to the 9-endpoint daemon:
-*   GET  /health, POST /shutdown
-*   GET/POST /agents, GET/DELETE /agents/:name
-*   POST /run (SSE), POST /serve
-*   ALL  /mcp
-*/
-var client_exports = /* @__PURE__ */ __exportAll({
-	createAgent: () => createAgent,
-	deleteAgent: () => deleteAgent,
-	health: () => health,
-	isDaemonActive: () => isDaemonActive,
-	listAgents: () => listAgents,
-	run: () => run,
-	serve: () => serve,
-	shutdown: () => shutdown,
-	startWorkflow: () => startWorkflow,
-	stopWorkflow: () => stopWorkflow
-});
-const MAX_RETRIES = 3;
-const BASE_DELAY_MS = 200;
-function isRetryableError(error) {
-	if (error instanceof TypeError) return true;
-	if (error instanceof Error) {
-		const code = error.code;
-		return code === "ECONNREFUSED" || code === "ECONNRESET";
-	}
-	return false;
-}
-function getDaemonConnection() {
-	const daemon = isDaemonRunning();
-	if (!daemon) return null;
-	return {
-		url: `http://${daemon.host}:${daemon.port}`,
-		token: daemon.token
-	};
-}
-function requireDaemon() {
-	const conn = getDaemonConnection();
-	if (!conn) throw new Error("No daemon running. Start one with: agent-worker daemon");
-	return conn;
-}
-/** Build headers with auth token */
-function authHeaders(token, extra) {
-	const headers = { ...extra };
-	if (token) headers["Authorization"] = `Bearer ${token}`;
-	return headers;
-}
-async function request(method, path, body) {
-	const { url: baseUrl, token } = requireDaemon();
-	let lastError;
-	for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) try {
-		const init = {
-			method,
-			headers: authHeaders(token, body !== void 0 ? { "Content-Type": "application/json" } : void 0),
-			body: body !== void 0 ? JSON.stringify(body) : void 0,
-			signal: AbortSignal.timeout(6e4)
-		};
-		return await (await fetch(`${baseUrl}${path}`, init)).json();
-	} catch (error) {
-		lastError = error;
-		if (attempt < MAX_RETRIES && isRetryableError(error)) {
-			const delay = BASE_DELAY_MS * Math.pow(2, attempt);
-			await new Promise((resolve) => setTimeout(resolve, delay));
-		} else break;
-	}
-	return {
-		success: false,
-		error: `Connection failed: ${lastError instanceof Error ? lastError.message : String(lastError)}`
-	};
-}
-/** GET /health */
-function health() {
-	return request("GET", "/health");
-}
-/** POST /shutdown */
-function shutdown() {
-	return request("POST", "/shutdown");
-}
-/** GET /agents */
-function listAgents() {
-	return request("GET", "/agents");
-}
-/** POST /agents */
-function createAgent(body) {
-	return request("POST", "/agents", body);
-}
-/** DELETE /agents/:name */
-function deleteAgent(name) {
-	return request("DELETE", `/agents/${encodeURIComponent(name)}`);
-}
-/** POST /serve (sync JSON response) */
-function serve(body) {
-	return request("POST", "/serve", body);
-}
-/**
-* POST /run (SSE stream).
-* Calls onChunk for each chunk, returns final response.
-*/
-async function run(body, onChunk) {
-	let baseUrl;
-	let token;
-	try {
-		const conn = requireDaemon();
-		baseUrl = conn.url;
-		token = conn.token;
-	} catch (error) {
-		return {
-			success: false,
-			error: error instanceof Error ? error.message : String(error)
-		};
-	}
-	try {
-		const res = await fetch(`${baseUrl}/run`, {
-			method: "POST",
-			headers: authHeaders(token, { "Content-Type": "application/json" }),
-			body: JSON.stringify(body)
-		});
-		if (!res.ok || !res.body) return await res.json();
-		const reader = res.body.getReader();
-		const decoder = new TextDecoder();
-		let buffer = "";
-		let finalResponse = { success: true };
-		while (true) {
-			const { value, done } = await reader.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n");
-			buffer = lines.pop() ?? "";
-			let currentEvent = "";
-			for (const line of lines) if (line.startsWith("event: ")) currentEvent = line.slice(7);
-			else if (line.startsWith("data: ")) {
-				const data = line.slice(6);
-				try {
-					const parsed = JSON.parse(data);
-					if (currentEvent === "chunk" && onChunk) onChunk(parsed);
-					else if (currentEvent === "done") finalResponse = parsed;
-					else if (currentEvent === "error") return {
-						success: false,
-						error: parsed.error
-					};
-				} catch {}
-			}
-		}
-		return finalResponse;
-	} catch (error) {
-		return {
-			success: false,
-			error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`
-		};
-	}
-}
-/** POST /workflows — start a workflow via daemon */
-function startWorkflow(body) {
-	return request("POST", "/workflows", body);
-}
-/** DELETE /workflows/:name/:tag — stop a workflow */
-function stopWorkflow(name, tag = "main") {
-	return request("DELETE", `/workflows/${encodeURIComponent(name)}/${encodeURIComponent(tag)}`);
-}
-/** Check if daemon is running */
-function isDaemonActive() {
-	return getDaemonConnection() !== null;
-}
-
-//#endregion
-//#region src/cli/output.ts
-var output_exports = /* @__PURE__ */ __exportAll({ outputJson: () => outputJson });
-/**
-* CLI Output Utilities
-*
-* Rules:
-* - --json mode: stdout = pure JSON data only, everything else to stderr
-* - Errors: always to stderr via console.error + process.exit(1)
-* - Exit codes: 0 = success, 1 = failure (authoritative for agent callers)
-*/
-/**
-* Output JSON data to stdout.
-* Use this instead of raw console.log(JSON.stringify(...)) for consistency.
-*/
-function outputJson(data) {
-	console.log(JSON.stringify(data, null, 2));
-}
-
-//#endregion
-//#region src/agent/definition.ts
-/**
-* AgentDefinition — Top-level persistent agent identity.
-*
-* This is the NEW AgentDefinition from AGENT-TOP-LEVEL architecture.
-* It describes WHO an agent is (prompt, soul, context) — not how it runs in a workflow.
-*
-* Loaded from .agents/*.yaml files. Workflows reference agents by name.
-*
-* Distinct from:
-*   - WorkflowAgentDef (workflow/types.ts) — inline agent config within a workflow
-*   - AgentConfig (agent/config.ts)        — runtime config for daemon-created agents
-*/
-/**
-* Standard subdirectories within an agent's context directory.
-* Created automatically when the agent is loaded.
-*/
-const CONTEXT_SUBDIRS = [
-	"memory",
-	"notes",
-	"conversations",
-	"todo"
-];
-const AgentSoulSchema = z$1.object({
-	role: z$1.string().optional(),
-	expertise: z$1.array(z$1.string()).optional(),
-	style: z$1.string().optional(),
-	principles: z$1.array(z$1.string()).optional()
-}).passthrough();
-const ProviderConfigSchema = z$1.object({
-	name: z$1.string(),
-	base_url: z$1.string().optional(),
-	api_key: z$1.string().optional()
-}).passthrough();
-const AgentPromptConfigSchema = z$1.union([z$1.object({
-	system: z$1.string(),
-	system_file: z$1.undefined().optional()
-}), z$1.object({
-	system_file: z$1.string(),
-	system: z$1.undefined().optional()
-})]);
-const AgentContextConfigSchema = z$1.object({
-	dir: z$1.string().optional(),
-	thin_thread: z$1.number().int().min(1).optional()
-});
-const ScheduleConfigSchema = z$1.object({
-	wakeup: z$1.union([z$1.string(), z$1.number()]),
-	prompt: z$1.string().optional()
-});
-const AgentDefinitionSchema = z$1.object({
-	name: z$1.string().min(1),
-	model: z$1.string().min(1),
-	backend: z$1.enum([
-		"sdk",
-		"claude",
-		"cursor",
-		"codex",
-		"opencode",
-		"mock"
-	]).optional(),
-	provider: z$1.union([z$1.string(), ProviderConfigSchema]).optional(),
-	prompt: AgentPromptConfigSchema,
-	soul: AgentSoulSchema.optional(),
-	context: AgentContextConfigSchema.optional(),
-	max_tokens: z$1.number().int().positive().optional(),
-	max_steps: z$1.number().int().positive().optional(),
-	schedule: ScheduleConfigSchema.optional()
-});
-
-//#endregion
-//#region src/agent/agent-handle.ts
-/**
-* AgentHandle — Runtime wrapper for an agent definition + persistent context.
-*
-* Created by AgentRegistry when an agent is loaded. Provides:
-*   - Context directory management (memory/, notes/, conversations/, todo/)
-*   - Read/write operations for personal context
-*   - State tracking (idle, running, stopped, error)
-*
-* Phase 1 scope: context directory + read/write ops.
-* Phase 3 adds: loop, workspaces, threads.
-*/
-var AgentHandle = class {
-	/** Agent definition (from YAML) */
-	definition;
-	/** Absolute path to agent's persistent context directory */
-	contextDir;
-	/** Current agent state */
-	state = "idle";
-	constructor(definition, contextDir) {
-		this.definition = definition;
-		this.contextDir = contextDir;
-	}
-	/** Agent name (convenience accessor) */
-	get name() {
-		return this.definition.name;
-	}
-	/**
-	* Ensure the context directory and all subdirectories exist.
-	* Called on agent load/creation. Idempotent.
-	*/
-	ensureContextDir() {
-		for (const sub of CONTEXT_SUBDIRS) mkdirSync(join(this.contextDir, sub), { recursive: true });
-	}
-	/**
-	* Read all memory entries as key-value records.
-	* Memory files are YAML in memory/<key>.yaml.
-	*/
-	async readMemory() {
-		const memDir = join(this.contextDir, "memory");
-		if (!existsSync(memDir)) return {};
-		const result = {};
-		const files = await readdir(memDir);
-		for (const file of files) {
-			if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-			const key = basename(file).replace(/\.ya?ml$/i, "");
-			try {
-				result[key] = parse(await readFile(join(memDir, file), "utf-8"));
-			} catch (err) {
-				console.warn(`Skipping malformed memory file ${file}:`, err);
-			}
-		}
-		return result;
-	}
-	/**
-	* Write a memory entry. Creates/overwrites memory/<key>.yaml.
-	*/
-	async writeMemory(key, value) {
-		const memDir = join(this.contextDir, "memory");
-		await mkdir(memDir, { recursive: true });
-		await writeFile(join(memDir, `${key}.yaml`), stringify(value));
-	}
-	/**
-	* Read agent's notes, most recent first.
-	* Notes are markdown files in notes/.
-	*/
-	async readNotes(limit) {
-		const notesDir = join(this.contextDir, "notes");
-		if (!existsSync(notesDir)) return [];
-		const files = (await readdir(notesDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-		const selected = limit ? files.slice(0, limit) : files;
-		return Promise.all(selected.map((f) => readFile(join(notesDir, f), "utf-8")));
-	}
-	/**
-	* Append a note. Creates notes/<date>-<slug>.md.
-	*/
-	async appendNote(content, slug) {
-		const notesDir = join(this.contextDir, "notes");
-		await mkdir(notesDir, { recursive: true });
-		const filename = `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}-${slug ?? `note-${Date.now().toString(36)}`}.md`;
-		await writeFile(join(notesDir, filename), content);
-		return filename;
-	}
-	/**
-	* Read active todos from todo/index.md.
-	* Returns lines that look like incomplete tasks: "- [ ] ..."
-	*/
-	async readTodos() {
-		const todoFile = join(this.contextDir, "todo", "index.md");
-		if (!existsSync(todoFile)) return [];
-		return (await readFile(todoFile, "utf-8")).split("\n").filter((line) => line.match(/^\s*-\s*\[\s*\]/)).map((line) => line.replace(/^\s*-\s*\[\s*\]\s*/, "").trim());
-	}
-	/**
-	* Write the full todo list. Replaces todo/index.md.
-	*/
-	async writeTodos(todos) {
-		const todoDir = join(this.contextDir, "todo");
-		await mkdir(todoDir, { recursive: true });
-		const content = todos.map((t) => `- [ ] ${t}`).join("\n") + "\n";
-		await writeFile(join(todoDir, "index.md"), content);
-	}
-};
-
-//#endregion
-//#region src/agent/yaml-parser.ts
-/**
-* Agent YAML Parser — Load agent definitions from .agents/*.yaml files.
-*
-* Handles:
-*   - Single file: parseAgentFile("path/to/alice.yaml")
-*   - Directory:   discoverAgents("path/to/project") → scans .agents/*.yaml
-*   - Validation:  Zod schema + semantic checks (system XOR system_file)
-*   - Resolution:  system_file → reads content into system (relative to YAML dir)
-*
-* The name field is optional in YAML — defaults to filename (without .yaml).
-*/
-/** Default directory for agent definitions (relative to project root) */
-const AGENTS_DIR = ".agents";
-/**
-* Parse an agent definition from a YAML file.
-*
-* Validates the schema, resolves system_file to inline content,
-* and infers name from filename if not specified.
-*
-* @throws Error if file doesn't exist, YAML is malformed, or validation fails.
-*/
-function parseAgentFile(filePath) {
-	if (!existsSync(filePath)) throw new Error(`Agent file not found: ${filePath}`);
-	const data = parse(readFileSync(filePath, "utf-8"));
-	if (!data || typeof data !== "object") throw new Error(`Invalid YAML in ${filePath}: expected an object`);
-	const obj = data;
-	if (!obj.name) obj.name = basename(filePath).replace(/\.ya?ml$/i, "");
-	const result = AgentDefinitionSchema.safeParse(obj);
-	if (!result.success) {
-		const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-		throw new Error(`Invalid agent definition in ${filePath}:\n${issues}`);
-	}
-	const def = result.data;
-	if (def.prompt.system_file) {
-		const promptPath = join(dirname(filePath), def.prompt.system_file);
-		if (!existsSync(promptPath)) throw new Error(`system_file not found: ${def.prompt.system_file} (resolved: ${promptPath})`);
-		const content = readFileSync(promptPath, "utf-8");
-		return {
-			...def,
-			prompt: { system: content }
-		};
-	}
-	return def;
-}
-/**
-* Discover all agent YAML files in a project's .agents/ directory.
-* Returns parsed and validated definitions.
-*
-* Non-fatal: logs warnings for invalid files, skips them.
-*
-* @param projectDir - Project root directory
-* @param log - Optional warning logger (default: console.warn)
-* @returns Array of valid agent definitions
-*/
-function discoverAgents(projectDir, log) {
-	const agentsDir = join(projectDir, AGENTS_DIR);
-	if (!existsSync(agentsDir)) return [];
-	const warn = log ?? console.warn;
-	const agents = [];
-	let entries;
-	try {
-		entries = readdirSync(agentsDir);
-	} catch {
-		return [];
-	}
-	for (const entry of entries) {
-		if (!entry.endsWith(".yaml") && !entry.endsWith(".yml")) continue;
-		const filePath = join(agentsDir, entry);
-		try {
-			agents.push(parseAgentFile(filePath));
-		} catch (err) {
-			warn(`Skipping ${entry}: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-	return agents;
-}
-/**
-* Serialize an agent definition to YAML string.
-* Used by CLI `agent create` to write .agents/<name>.yaml.
-*/
-function serializeAgent(def) {
-	const obj = {
-		name: def.name,
-		model: def.model
-	};
-	if (def.backend) obj.backend = def.backend;
-	if (def.provider) obj.provider = def.provider;
-	obj.prompt = def.prompt;
-	if (def.soul) obj.soul = def.soul;
-	if (def.context) obj.context = def.context;
-	if (def.max_tokens) obj.max_tokens = def.max_tokens;
-	if (def.max_steps) obj.max_steps = def.max_steps;
-	if (def.schedule) obj.schedule = def.schedule;
-	return stringify(obj, { lineWidth: 120 });
-}
-
-//#endregion
-//#region src/agent/agent-registry.ts
-/**
-* AgentRegistry — Loads and manages top-level agent definitions.
-*
-* Responsibilities:
-*   - Discover agents from .agents/*.yaml
-*   - Load definitions → create AgentHandles
-*   - Register/unregister agents at runtime
-*   - Ensure context directories exist
-*   - Provide agent lookup by name
-*
-* Owned by the daemon. One registry per daemon process.
-*/
-var AgentRegistry = class {
-	/** Loaded agent handles, keyed by name */
-	agents = /* @__PURE__ */ new Map();
-	/** Project root directory */
-	projectDir;
-	/** Agents directory (.agents/) */
-	agentsDir;
-	constructor(projectDir) {
-		this.projectDir = projectDir;
-		this.agentsDir = join(projectDir, AGENTS_DIR);
-	}
-	/**
-	* Load all agents from .agents/*.yaml.
-	* Skips invalid files (logs warnings).
-	* Creates context directories for each loaded agent.
-	*/
-	loadFromDisk(log) {
-		const defs = discoverAgents(this.projectDir, log);
-		for (const def of defs) this.registerDefinition(def);
-	}
-	/**
-	* Register an agent definition. Creates AgentHandle + ensures context dir.
-	* Overwrites existing agent with same name (reload semantics).
-	*/
-	registerDefinition(def) {
-		const handle = new AgentHandle(def, this.resolveContextDir(def));
-		handle.ensureContextDir();
-		this.agents.set(def.name, handle);
-		return handle;
-	}
-	/**
-	* Create a new agent: write YAML file + register.
-	* @throws Error if agent already exists on disk.
-	*/
-	create(def) {
-		const yamlPath = this.agentYamlPath(def.name);
-		if (existsSync(yamlPath)) throw new Error(`Agent file already exists: ${yamlPath}`);
-		mkdirSync(this.agentsDir, { recursive: true });
-		writeFileSync(yamlPath, serializeAgent(def));
-		return this.registerDefinition(def);
-	}
-	/**
-	* Delete an agent: remove YAML file + context directory + unregister.
-	* @returns true if agent existed and was deleted.
-	*/
-	delete(name) {
-		const handle = this.agents.get(name);
-		if (!handle) return false;
-		this.agents.delete(name);
-		const yamlPath = this.agentYamlPath(name);
-		if (existsSync(yamlPath)) try {
-			unlinkSync(yamlPath);
-		} catch {}
-		if (existsSync(handle.contextDir)) try {
-			rmSync(handle.contextDir, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-		return true;
-	}
-	/** Get agent handle by name */
-	get(name) {
-		return this.agents.get(name);
-	}
-	/** Check if agent exists */
-	has(name) {
-		return this.agents.has(name);
-	}
-	/** List all registered agent handles */
-	list() {
-		return [...this.agents.values()];
-	}
-	/** Number of registered agents */
-	get size() {
-		return this.agents.size;
-	}
-	/** Resolve agent's context directory (absolute path) */
-	resolveContextDir(def) {
-		if (def.context?.dir) return join(this.projectDir, def.context.dir);
-		return join(this.agentsDir, def.name);
-	}
-	/** Path to agent's YAML file */
-	agentYamlPath(name) {
-		return join(this.agentsDir, `${name}.yaml`);
-	}
-};
-
-//#endregion
+import { spawn } from "node:child_process";
 //#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.
-*/
-async function ensureDaemon(port, host) {
-	if (isDaemonRunning()) return;
-	const args = [process.argv[1] ?? "", "daemon"];
+/** Start a detached daemon child process. */
+function spawnDaemonProcess(port, host) {
+	const args = [
+		process.argv[1] ?? "",
+		"up",
+		"-f"
+	];
 	if (port) args.push("--port", String(port));
 	if (host) args.push("--host", host);
 	spawn(process.execPath, args, {
 		detached: true,
 		stdio: "ignore"
 	}).unref();
+}
+/**
+* Ensure daemon is running. If not, start a detached child and wait for readiness.
+*
+* The detached child runs `agent-worker up -f` so the daemon itself stays in the
+* child process foreground while the parent CLI command returns immediately.
+*/
+async function ensureDaemon(port, host) {
+	if (isDaemonRunning()) return;
+	spawnDaemonProcess(port, host);
 	const maxWait = 5e3;
 	const start = Date.now();
 	while (Date.now() - start < maxWait) {
@@ -4005,14 +47,40 @@ async function ensureDaemon(port, host) {
 	process.exit(1);
 }
 function registerAgentCommands(program) {
-	program.command("daemon").description("Start daemon in foreground").option("--port <port>", `HTTP port (default: ${DEFAULT_PORT})`).option("--host <host>", "Host to bind to (default: 127.0.0.1)").action(async (options) => {
-		const { startDaemon } = await Promise.resolve().then(() => daemon_exports);
-		await startDaemon({
-			port: options.port ? parseInt(options.port, 10) : void 0,
-			host: options.host
-		});
+	program.command("up").description("Start daemon, load config.yml agents").option("-f, --foreground", "Run in foreground (for debugging)").option("--port <port>", `HTTP port (default: ${DEFAULT_PORT})`).option("--host <host>", "Host to bind to (default: 127.0.0.1)").addHelpText("after", `
+Examples:
+  $ agent-worker up              # Start daemon in background
+  $ agent-worker up -f           # Start daemon in foreground
+  $ agent-worker up --port 5100  # Custom port
+      `).action(async (options) => {
+		if (options.foreground) {
+			const { startDaemon } = await import("../daemon-CwaHgxs6.mjs").then((n) => n.t);
+			await startDaemon({
+				port: options.port ? parseInt(options.port, 10) : void 0,
+				host: options.host
+			});
+		} else {
+			if (isDaemonRunning()) {
+				console.log("Daemon already running");
+				return;
+			}
+			await ensureDaemon(options.port ? parseInt(options.port, 10) : void 0, options.host);
+			console.log("Daemon started");
+		}
+	});
+	program.command("down").description("Stop daemon (all agents and workspaces)").action(async () => {
+		if (!isDaemonActive()) {
+			console.log("No daemon running");
+			return;
+		}
+		const res = await shutdown();
+		if (res.success) console.log("Daemon stopped");
+		else {
+			console.error("Error:", res.error);
+			process.exit(1);
+		}
 	});
-	program.command("new <name>").description("Create a new agent").option("-m, --model <model>", `Model identifier (default: ${getDefaultModel()})`).addOption(new Option("-b, --backend <type>", "Backend type").choices([
+	program.command("new <name>").description("Create a new ephemeral agent").option("-m, --model <model>", `Model identifier (default: ${getDefaultModel()})`).addOption(new Option("-b, --backend <type>", "Backend type").choices([
 		"default",
 		"sdk",
 		"claude",
@@ -4020,11 +88,10 @@ function registerAgentCommands(program) {
 		"cursor",
 		"opencode",
 		"mock"
-	]).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", `
+	]).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("--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) => {
@@ -4055,9 +122,8 @@ Examples:
 			system,
 			backend,
 			provider,
-			workflow: options.workflow,
-			tag: options.tag,
-			schedule
+			schedule,
+			ephemeral: true
 		});
 		if (res.error) {
 			console.error("Error:", res.error);
@@ -4066,7 +132,29 @@ Examples:
 		if (options.json) outputJson(res);
 		else console.log(`${name} (${model})`);
 	});
-	program.command("ls").description("List agents").option("--json", "Output as JSON").addHelpText("after", `
+	program.command("rm <name>").description("Remove an ephemeral agent").addHelpText("after", `
+Removes an ephemeral agent created with 'new'.
+Config agents (defined in config.yml) cannot be removed — edit config.yml instead.
+
+Examples:
+  $ agent-worker rm alice
+      `).action(async (name) => {
+		if (!isDaemonActive()) {
+			console.error("No daemon running");
+			process.exit(1);
+		}
+		if (((await health()).configAgents ?? []).includes(name)) {
+			console.error(`Error: "${name}" is defined in config.yml — edit config to remove`);
+			process.exit(1);
+		}
+		const res = await deleteAgent(name);
+		if (res.success) console.log(`Removed: ${name}`);
+		else {
+			console.error("Error:", res.error);
+			process.exit(1);
+		}
+	});
+	program.command("ls").description("List running agents").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
   $ agent-worker ls
   $ agent-worker ls --json
@@ -4091,38 +179,31 @@ Examples:
 			return;
 		}
 		for (const a of agents) {
-			const wf = a.workflow ? a.tag === "main" ? `@${a.workflow}` : `@${a.workflow}:${a.tag}` : "";
+			const wf = a.workflow ? a.tag ? `@${a.workflow}:${a.tag}` : `@${a.workflow}` : "";
 			const info = a.model || a.state || "";
 			console.log(`${a.name.padEnd(12)} ${info.padEnd(30)} ${wf}`);
 		}
 	});
-	program.command("stop [name]").description("Stop agent, workflow, or daemon").option("--all", "Stop daemon (all agents and workflows)").addHelpText("after", `
+	program.command("stop [name]").description("Stop agent or workspace").addHelpText("after", `
 Examples:
   $ agent-worker stop alice           # Stop specific agent
-  $ agent-worker stop @review:pr-123  # Stop workflow
-  $ agent-worker stop @review         # Stop workflow (tag defaults to main)
-  $ agent-worker stop --all           # Stop daemon (everything)
-      `).action(async (name, options) => {
+  $ agent-worker stop @review:pr-123  # Stop workspace
+  $ agent-worker stop @review         # Stop workspace (no tag)
+      `).action(async (name) => {
 		if (!isDaemonActive()) {
 			console.error("No daemon running");
 			process.exit(1);
 		}
-		if (options.all) {
-			const res = await shutdown();
-			if (res.success) console.log("Daemon stopped");
-			else console.error("Error:", res.error);
-			return;
-		}
 		if (!name) {
-			console.error("Specify agent name, @workflow[:tag], or use --all");
+			console.error("Specify agent name or @workspace[:tag]. Use 'down' to stop daemon.");
 			process.exit(1);
 		}
-		const { parseTarget } = await Promise.resolve().then(() => target_exports);
+		const { parseTarget } = await import("../target-9yiBRXxa.mjs").then((n) => n.r);
 		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);
+			const { stopWorkflow: stopWf } = await import("../client-DAKkzdOn.mjs").then((n) => n.t);
+			res = await stopWf(target.workspace, target.tag);
 		} else res = await deleteAgent(target.agent);
 		if (res.success) console.log(`Stopped: ${target.display}`);
 		else {
@@ -4144,9 +225,9 @@ Examples:
 			console.log(`Agents: ${agents.length > 0 ? agents.join(", ") : "(none)"}`);
 			const workflows = res.workflows ?? [];
 			if (workflows.length > 0) {
-				console.log(`Workflows:`);
+				console.log(`Workspaces:`);
 				for (const wf of workflows) {
-					const display = wf.tag === "main" ? `@${wf.name}` : `@${wf.name}:${wf.tag}`;
+					const display = wf.tag ? `@${wf.name}:${wf.tag}` : `@${wf.name}`;
 					console.log(`  ${display} → ${wf.agents.join(", ")}`);
 				}
 			}
@@ -4156,285 +237,97 @@ Examples:
 			}
 		}
 	});
-	program.command("ask <agent> <message>").description("Send message to agent (SSE streaming)").option("--json", "Output final response as JSON").addHelpText("after", `
+	program.command("ask <agent> <message>").description("Send message to agent and get response").option("--no-stream", "Sync response (no streaming)").option("--json", "Output response as JSON").addHelpText("after", `
 Examples:
   $ agent-worker ask alice "analyze this code"
+  $ agent-worker ask alice "hello" --no-stream
   $ agent-worker ask alice "hello" --json
       `).action(async (agent, message, options) => {
 		if (!isDaemonActive()) {
 			console.error("No daemon running");
 			process.exit(1);
 		}
-		const res = await run({
-			agent,
-			message
-		}, (chunk) => {
-			if (!options.json) process.stdout.write(chunk.text);
-		});
-		if (options.json) outputJson(res);
-		else console.log();
-	});
-	program.command("serve <agent> <message>").description("Send message to agent (sync response)").option("--json", "Output as JSON").action(async (agent, message, options) => {
-		if (!isDaemonActive()) {
-			console.error("No daemon running");
-			process.exit(1);
+		if (options.stream === false) {
+			const res = await serve({
+				agent,
+				message
+			});
+			if (options.json) outputJson(res);
+			else if (res.error) {
+				console.error("Error:", res.error);
+				process.exit(1);
+			} else console.log(res.content ?? JSON.stringify(res));
+		} else {
+			const res = await run({
+				agent,
+				message
+			}, (chunk) => {
+				if (!options.json) process.stdout.write(chunk.text);
+			});
+			if (options.json) outputJson(res);
+			else console.log();
 		}
-		const res = await serve({
-			agent,
-			message
-		});
-		if (options.json) outputJson(res);
-		else if (res.error) {
-			console.error("Error:", res.error);
-			process.exit(1);
-		} else console.log(res.content ?? JSON.stringify(res));
 	});
-	const agentCmd = program.command("agent").description("Manage persistent agent definitions (.agents/*.yaml)");
-	agentCmd.command("create <name>").description("Create a persistent agent definition").option("-m, --model <model>", `Model (default: ${getDefaultModel()})`).addOption(new Option("-b, --backend <type>", "Backend type").choices([
-		"sdk",
-		"claude",
-		"codex",
-		"cursor",
-		"opencode",
-		"mock"
-	]).default(void 0)).option("-s, --system <prompt>", "System prompt").option("-f, --system-file <file>", "Read system prompt from file").option("--role <role>", "Soul: agent role").option("--expertise <items>", "Soul: expertise (comma-separated)").option("--style <style>", "Soul: communication style").option("--dir <path>", "Project directory", ".").option("--json", "Output as JSON").addHelpText("after", `
-Creates .agents/<name>.yaml and context directory (.agents/<name>/).
+	program.command("onboard").description("Interactive config.yml setup").addHelpText("after", `
+Creates or updates ~/.agent-worker/config.yml interactively.
+Guides you through defining agents and channel bridges.
 
 Examples:
-  $ agent-worker agent create alice -m anthropic/claude-sonnet-4-5 -s "You are a code reviewer."
-  $ agent-worker agent create bob --role developer --expertise "typescript,testing"
-  $ agent-worker agent create coder -f ./prompts/coder.md
-      `).action(async (name, options) => {
-		const registry = new AgentRegistry(resolve(options.dir));
-		let system = options.system ?? "You are a helpful assistant.";
-		if (options.systemFile) system = readFileSync(options.systemFile, "utf-8");
-		const def = {
-			name,
-			model: options.model || getDefaultModel(),
-			prompt: { system }
-		};
-		if (options.backend) def.backend = options.backend;
-		if (options.role || options.expertise || options.style) {
-			def.soul = {};
-			if (options.role) def.soul.role = options.role;
-			if (options.expertise) def.soul.expertise = options.expertise.split(",").map((s) => s.trim());
-			if (options.style) def.soul.style = options.style;
-		}
-		try {
-			const handle = registry.create(def);
-			if (options.json) outputJson({
-				name,
-				model: def.model,
-				contextDir: handle.contextDir
-			});
-			else {
-				console.log(`Created: .agents/${name}.yaml`);
-				console.log(`Context: ${handle.contextDir}`);
-			}
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			console.error(`Error: ${msg}`);
-			process.exit(1);
-		}
-	});
-	agentCmd.command("list").description("List persistent agent definitions").option("--dir <path>", "Project directory", ".").option("--json", "Output as JSON").action(async (options) => {
-		const registry = new AgentRegistry(resolve(options.dir));
-		registry.loadFromDisk();
-		const agents = registry.list();
-		if (options.json) {
-			outputJson({ agents: agents.map((h) => ({
-				name: h.name,
-				model: h.definition.model,
-				backend: h.definition.backend,
-				soul: h.definition.soul,
-				contextDir: h.contextDir
-			})) });
-			return;
-		}
-		if (agents.length === 0) {
-			console.log("No agent definitions found in .agents/");
-			return;
-		}
-		for (const h of agents) {
-			const soul = h.definition.soul?.role ? ` (${h.definition.soul.role})` : "";
-			console.log(`${h.name.padEnd(16)} ${h.definition.model}${soul}`);
-		}
-	});
-	agentCmd.command("info <name>").description("Show agent definition details").option("--dir <path>", "Project directory", ".").option("--json", "Output as JSON").action(async (name, options) => {
-		const registry = new AgentRegistry(resolve(options.dir));
-		registry.loadFromDisk();
-		const handle = registry.get(name);
-		if (!handle) {
-			console.error(`Agent not found: ${name}`);
-			process.exit(1);
-		}
-		const def = handle.definition;
-		if (options.json) {
-			outputJson({
-				...def,
-				contextDir: handle.contextDir
-			});
+  $ agent-worker onboard
+      `).action(async () => {
+		const { existsSync: exists } = await import("node:fs");
+		const { join } = await import("node:path");
+		const { homedir } = await import("node:os");
+		const configDir = join(homedir(), ".agent-worker");
+		const configPath = join(configDir, "config.yml");
+		if (exists(configPath)) {
+			console.log(`Config already exists: ${configPath}`);
+			console.log("Edit it directly to add/remove agents and channels.");
 			return;
 		}
-		console.log(`Name:    ${def.name}`);
-		console.log(`Model:   ${def.model}`);
-		if (def.backend) console.log(`Backend: ${def.backend}`);
-		if (def.prompt.system) {
-			const preview = def.prompt.system.length > 80 ? def.prompt.system.slice(0, 77) + "..." : def.prompt.system;
-			console.log(`Prompt:  ${preview}`);
-		}
-		if (def.soul) {
-			if (def.soul.role) console.log(`Role:    ${def.soul.role}`);
-			if (def.soul.expertise) console.log(`Expert:  ${def.soul.expertise.join(", ")}`);
-			if (def.soul.style) console.log(`Style:   ${def.soul.style}`);
-			if (def.soul.principles) {
-				console.log(`Principles:`);
-				for (const p of def.soul.principles) console.log(`  - ${p}`);
-			}
-		}
-		console.log(`Context: ${handle.contextDir}`);
-	});
-	agentCmd.command("delete <name>").description("Delete agent definition and context").option("--dir <path>", "Project directory", ".").action(async (name, options) => {
-		const registry = new AgentRegistry(resolve(options.dir));
-		registry.loadFromDisk();
-		if (!registry.has(name)) {
-			console.error(`Agent not found: ${name}`);
-			process.exit(1);
-		}
-		registry.delete(name);
-		console.log(`Deleted: ${name}`);
-	});
-}
+		const { mkdirSync, writeFileSync } = await import("node:fs");
+		mkdirSync(configDir, { recursive: true });
+		writeFileSync(configPath, `# agent-worker config
+# Agents defined here are loaded when the daemon starts (agent-worker up).
+# Edit this file to add/remove agents. Changes take effect on next 'up'.
 
-//#endregion
-//#region src/cli/target.ts
-var target_exports = /* @__PURE__ */ __exportAll({
-	DEFAULT_TAG: () => DEFAULT_TAG,
-	DEFAULT_WORKFLOW: () => DEFAULT_WORKFLOW,
-	parseTarget: () => parseTarget
-});
-/**
-* Target identifier utilities
-*
-* Format: agent@workflow:tag (inspired by Docker image:tag)
-* - agent: agent name (optional for @workflow references)
-* - workflow: workflow name (optional, defaults to 'global')
-* - tag: workflow instance tag (optional, defaults to 'main')
-*
-* Examples:
-* - "alice"              → { agent: "alice", workflow: "global", tag: "main", display: "alice" }
-* - "alice@review"       → { agent: "alice", workflow: "review", tag: "main", display: "alice@review" }
-* - "alice@review:pr-123"→ { agent: "alice", workflow: "review", tag: "pr-123", display: "alice@review:pr-123" }
-* - "@review"            → { agent: undefined, workflow: "review", tag: "main", display: "@review" }
-* - "@review:pr-123"     → { agent: undefined, workflow: "review", tag: "pr-123", display: "@review:pr-123" }
-*
-* Display rules:
-* - Omit @global (standalone agents): "alice" not "alice@global"
-* - Omit :main (default tag): "alice@review" not "alice@review:main"
-*/
-const DEFAULT_WORKFLOW = "global";
-const DEFAULT_TAG = "main";
-/**
-* Parse target identifier from string
-* Supports: "agent", "agent@workflow", "agent@workflow:tag", "@workflow", "@workflow:tag"
-*/
-function parseTarget(input) {
-	if (input.startsWith("@")) {
-		const workflowPart = input.slice(1);
-		const colonIndex = workflowPart.indexOf(":");
-		if (colonIndex === -1) {
-			const workflow = workflowPart || DEFAULT_WORKFLOW;
-			return {
-				agent: void 0,
-				workflow,
-				tag: DEFAULT_TAG,
-				full: `@${workflow}:${DEFAULT_TAG}`,
-				display: workflow === DEFAULT_WORKFLOW ? `@${workflow}` : `@${workflow}`
-			};
-		} else {
-			const workflow = workflowPart.slice(0, colonIndex) || DEFAULT_WORKFLOW;
-			const tag = workflowPart.slice(colonIndex + 1) || DEFAULT_TAG;
-			return {
-				agent: void 0,
-				workflow,
-				tag,
-				full: `@${workflow}:${tag}`,
-				display: buildDisplay(void 0, workflow, tag)
-			};
-		}
-	}
-	const atIndex = input.indexOf("@");
-	if (atIndex === -1) return {
-		agent: input,
-		workflow: DEFAULT_WORKFLOW,
-		tag: DEFAULT_TAG,
-		full: `${input}@${DEFAULT_WORKFLOW}:${DEFAULT_TAG}`,
-		display: input
-	};
-	const agent = input.slice(0, atIndex);
-	const workflowPart = input.slice(atIndex + 1);
-	const colonIndex = workflowPart.indexOf(":");
-	if (colonIndex === -1) {
-		const workflow = workflowPart || DEFAULT_WORKFLOW;
-		return {
-			agent,
-			workflow,
-			tag: DEFAULT_TAG,
-			full: `${agent}@${workflow}:${DEFAULT_TAG}`,
-			display: buildDisplay(agent, workflow, DEFAULT_TAG)
-		};
-	} else {
-		const workflow = workflowPart.slice(0, colonIndex) || DEFAULT_WORKFLOW;
-		const tag = workflowPart.slice(colonIndex + 1) || DEFAULT_TAG;
-		return {
-			agent,
-			workflow,
-			tag,
-			full: `${agent}@${workflow}:${tag}`,
-			display: buildDisplay(agent, workflow, tag)
-		};
-	}
-}
-/**
-* Build display string following display rules:
-* - Omit @global for standalone agents
-* - Omit :main for default tag
-*/
-function buildDisplay(agent, workflow, tag) {
-	const isGlobal = workflow === DEFAULT_WORKFLOW;
-	const isMainTag = tag === DEFAULT_TAG;
-	if (agent === void 0) {
-		if (isMainTag) return `@${workflow}`;
-		return `@${workflow}:${tag}`;
-	}
-	if (isGlobal && isMainTag) return agent;
-	if (isGlobal && !isMainTag) return `${agent}@${workflow}:${tag}`;
-	if (!isGlobal && isMainTag) return `${agent}@${workflow}`;
-	return `${agent}@${workflow}:${tag}`;
-}
+agents:
+  # Example agent:
+  # assistant:
+  #   model: anthropic/claude-sonnet-4-5
+  #   system: You are a helpful assistant.
 
+# channels:
+#   telegram:
+#     type: telegram
+#     token: \${{ env.TELEGRAM_BOT_TOKEN }}
+`);
+		console.log(`Created: ${configPath}`);
+		console.log("Edit this file to define your agents, then run: agent-worker up");
+	});
+}
 //#endregion
 //#region src/cli/commands/workflow.ts
 function registerWorkflowCommands(program) {
-	program.command("run <file>").description("Execute workflow and exit when complete").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("--json", "Output results as JSON").allowExcessArguments().addHelpText("after", `
+	program.command("run <file>").description("Execute workspace and exit when complete").option("--tag <tag>", "Workspace instance tag (optional)").option("-d, --debug", "Show debug details (internal logs, MCP traces, idle checks)").option("--feedback", "Enable feedback tool").option("--json", "Output results as JSON").allowExcessArguments().addHelpText("after", `
 Examples:
-  $ agent-worker run review.yaml                        # Run review:main
-  $ agent-worker run review.yaml --tag pr-123           # Run review:pr-123
+  $ agent-worker run review.yaml                        # Run workspace
+  $ agent-worker run review.yaml --tag pr-123           # Run with tag
   $ agent-worker run review.yaml --json | jq .document  # Machine-readable output
-  $ agent-worker run review.yaml -- --target main -n 3  # With workflow params
+  $ agent-worker run review.yaml -- --target main -n 3  # With params
 
-Remote workflows (github:owner/repo@ref/path):
-  $ agent-worker run github:acme/workflows/review.yml           # Default branch
-  $ agent-worker run github:acme/workflows@v1.0/review.yml      # Pinned version
-  $ agent-worker run github:acme/workflows#review               # Shorthand
-  $ agent-worker run github:acme/workflows#review -- --target main  # With params
+Remote workspaces (github:owner/repo@ref/path):
+  $ agent-worker run github:acme/workspaces/review.yml           # Default branch
+  $ agent-worker run github:acme/workspaces@v1.0/review.yml      # Pinned version
+  $ agent-worker run github:acme/workspaces#review               # Shorthand
+  $ agent-worker run github:acme/workspaces#review -- --target main  # With params
 
-Note: Workflow name is inferred from YAML 'name' field or filename.
-      Workflow-defined params (see 'params:' in YAML) are passed after '--'.
+Note: Workspace name is inferred from YAML 'name' field or filename.
+      Params (see 'params:' in YAML) are passed after '--'.
       Set GITHUB_TOKEN env var to access private repositories.
     `).action(async (file, options) => {
-		const { parseWorkflowFile, parseWorkflowParams, formatParamHelp, runWorkflowWithLoops } = await import("../workflow-LOZUlaDo.mjs");
-		const tag = options.tag || DEFAULT_TAG;
+		const { parseWorkflowFile, parseWorkflowParams, formatParamHelp, runWorkflowWithLoops } = await import("@moniro/workspace");
+		const tag = options.tag || void 0;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
 		let params;
@@ -4456,8 +349,8 @@ Note: Workflow name is inferred from YAML 'name' field or filename.
 			isCleaningUp = true;
 			console.log("\nInterrupted, cleaning up...");
 			if (loops) {
-				const { shutdownLoops } = await import("../workflow-LOZUlaDo.mjs");
-				const { createSilentLogger } = await Promise.resolve().then(() => logger_exports);
+				const { shutdownLoops } = await import("@moniro/workspace");
+				const { createSilentLogger } = await import("@moniro/workspace");
 				await shutdownLoops(loops, createSilentLogger());
 			}
 			process.exit(130);
@@ -4482,7 +375,7 @@ Note: Workflow name is inferred from YAML 'name' field or filename.
 			process.off("SIGINT", cleanup);
 			process.off("SIGTERM", cleanup);
 			if (!result.success) {
-				console.error("Workflow failed:", result.error);
+				console.error("Failed:", result.error);
 				process.exit(1);
 			}
 			if (result.contextProvider) {
@@ -4494,7 +387,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-Kyd40DEF.mjs");
+					const { showWorkflowSummary } = await import("@moniro/workspace");
 					showWorkflowSummary({
 						duration: result.duration,
 						document: finalDoc,
@@ -4518,22 +411,22 @@ Note: Workflow name is inferred from YAML 'name' field or filename.
 			process.exit(1);
 		}
 	});
-	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").allowExcessArguments().addHelpText("after", `
+	program.command("start <file>").description("Start workspace via daemon and keep agents running").option("--tag <tag>", "Workspace instance tag (optional)").option("--feedback", "Enable feedback tool").option("--json", "Output as JSON").allowExcessArguments().addHelpText("after", `
 Examples:
-  $ agent-worker start review.yaml                    # Start review:main (Ctrl+C to stop)
-  $ agent-worker start review.yaml --tag pr-123       # Start review:pr-123
-  $ agent-worker start review.yaml -- --target main   # With workflow params
+  $ agent-worker start review.yaml                    # Start workspace (Ctrl+C to stop)
+  $ agent-worker start review.yaml --tag pr-123       # Start with tag
+  $ agent-worker start review.yaml -- --target main   # With params
 
-Workflow runs inside the daemon. Use ls/stop to manage:
+Workspace runs inside the daemon. Use ls/stop to manage:
   $ agent-worker ls                                   # List all agents
-  $ agent-worker stop @review:pr-123                  # Stop workflow
+  $ agent-worker stop @review:pr-123                  # Stop workspace
 
-Note: Workflow name is inferred from YAML 'name' field or filename.
-      Workflow-defined params (see 'params:' in YAML) are passed after '--'.
+Note: Workspace name is inferred from YAML 'name' field or filename.
+      Params (see 'params:' in YAML) are passed after '--'.
     `).action(async (file, options) => {
-		const { parseWorkflowFile, parseWorkflowParams, formatParamHelp } = await import("../workflow-LOZUlaDo.mjs");
+		const { parseWorkflowFile, parseWorkflowParams, formatParamHelp } = await import("@moniro/workspace");
 		const { ensureDaemon } = await Promise.resolve().then(() => agent_exports);
-		const tag = options.tag || DEFAULT_TAG;
+		const tag = options.tag || void 0;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
 		let params;
@@ -4561,7 +454,7 @@ Note: Workflow name is inferred from YAML 'name' field or filename.
 		}
 		const agents = res.agents ?? [];
 		if (options.json) {
-			const { outputJson } = await Promise.resolve().then(() => output_exports);
+			const { outputJson } = await import("../output-B0mwPqjv.mjs").then((n) => n.n);
 			outputJson({
 				name: workflowName,
 				tag,
@@ -4569,18 +462,19 @@ Note: Workflow name is inferred from YAML 'name' field or filename.
 			});
 			return;
 		}
-		console.log(`Workflow: @${workflowName}${tag !== "main" ? ":" + tag : ""}`);
+		const tagSuffix = tag ? `:${tag}` : "";
+		console.log(`Workspace: @${workflowName}${tagSuffix}`);
 		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(`  agent-worker peek @${workflowName}${tagSuffix}`);
 		console.log(`\nTo stop:`);
-		console.log(`  agent-worker stop @${workflowName}${tag !== "main" ? ":" + tag : ""}`);
+		console.log(`  agent-worker stop @${workflowName}${tagSuffix}`);
 		let isCleaningUp = false;
 		const cleanup = async () => {
 			if (isCleaningUp) return;
 			isCleaningUp = true;
-			console.log("\nStopping workflow...");
+			console.log("\nStopping workspace...");
 			await stopWorkflow(workflowName, tag);
 			process.exit(0);
 		};
@@ -4598,39 +492,38 @@ function getArgsAfterSeparator() {
 	const idx = process.argv.indexOf("--");
 	return idx === -1 ? [] : process.argv.slice(idx + 1);
 }
-
 //#endregion
 //#region src/cli/commands/send.ts
 /**
-* Get agent names for a workflow from the daemon.
+* Get agent names for a workspace from the daemon.
 * Falls back to ["user"] if daemon is not running.
 */
-async function getWorkflowAgentNames(workflow, tag) {
+async function getWorkspaceAgentNames(workspace, tag) {
 	if (!isDaemonActive()) return ["user"];
 	try {
-		const names = ((await listAgents()).agents ?? []).filter((a) => a.workflow === workflow && a.tag === tag).map((a) => a.name);
+		const names = ((await listAgents()).agents ?? []).filter((a) => a.workflow === workspace && a.tag === tag).map((a) => a.name);
 		return [...new Set([...names, "user"])];
 	} catch {
 		return ["user"];
 	}
 }
 /**
-* Get a context provider for the given workflow:tag.
+* Get a context provider for the given workspace.
 */
-async function getContextProvider(workflow, tag) {
-	const dir = getDefaultContextDir(workflow, tag);
+async function getContextProvider(workspace, tag) {
+	const dir = getDefaultContextDir(workspace, tag);
 	mkdirSync(dir, { recursive: true });
-	return createFileContextProvider(dir, await getWorkflowAgentNames(workflow, tag));
+	return createFileContextProvider(dir, await getWorkspaceAgentNames(workspace, tag));
 }
 function registerSendCommands(program) {
-	program.command("send <target> <message>").description("Send message to agent or workflow channel").option("--json", "Output as JSON").addHelpText("after", `
+	program.command("send <target> <message>").description("Send message to agent or workspace channel").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
   $ agent-worker send alice "analyze this code"
   $ agent-worker send @review "team update"
   $ agent-worker send @review "@alice @bob discuss this"
     `).action(async (targetInput, message, options) => {
 		const target = parseTarget(targetInput);
-		const entry = await (await getContextProvider(target.workflow, target.tag)).appendChannel("user", message);
+		const entry = await (await getContextProvider(target.workspace, target.tag)).appendChannel("user", message);
 		if (options.json) outputJson({
 			id: entry.id,
 			timestamp: entry.timestamp,
@@ -4646,8 +539,8 @@ Examples:
   $ agent-worker peek @review
   $ agent-worker peek @review:pr-123
     `).action(async (targetInput, options) => {
-		const target = parseTarget(targetInput || `@${DEFAULT_WORKFLOW}`);
-		const provider = await getContextProvider(target.workflow, target.tag);
+		const target = parseTarget(targetInput || `@global`);
+		const provider = await getContextProvider(target.workspace, target.tag);
 		const limit = options.all ? void 0 : options.last ?? 10;
 		let messages = await provider.readChannel({ limit });
 		if (options.find) {
@@ -4669,7 +562,6 @@ Examples:
 		}
 	});
 }
-
 //#endregion
 //#region src/cli/commands/info.ts
 const PROVIDER_API_KEYS = {
@@ -4730,7 +622,7 @@ function registerInfoCommands(program) {
 		console.log(`Auto:    AGENT_DEFAULT_MODELS="deepseek-chat, anthropic/claude-sonnet-4-5"`);
 	});
 	program.command("backends").description("Check available backends (SDK, CLI tools)").action(async () => {
-		const { listBackends } = await import("../backends-DUvcm-ce.mjs");
+		const { listBackends } = await import("@moniro/agent-loop");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -4749,22 +641,21 @@ function registerInfoCommands(program) {
 		console.log("Tool management (add, mock, import) is only supported with SDK backend.");
 	});
 }
-
 //#endregion
 //#region src/cli/commands/doc.ts
 function registerDocCommands(program) {
-	const docCmd = program.command("doc").description("Read/write workflow documents");
-	docCmd.command("read <target>").description("Read the workflow document").addHelpText("after", `
+	const docCmd = program.command("doc").description("Read/write workspace documents");
+	docCmd.command("read <target>").description("Read the workspace document").addHelpText("after", `
 Examples:
-  $ agent-worker doc read @review            # Read @review:main document
-  $ agent-worker doc read @review:pr-123     # Read specific workflow:tag document
+  $ agent-worker doc read @review            # Read @review document
+  $ agent-worker doc read @review:pr-123     # Read specific workspace:tag document
     `).action(async (targetInput) => {
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CoRTddGx.mjs");
+		const { createFileContextProvider } = await import("@moniro/workspace");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
-	docCmd.command("write <target>").description("Write content to the workflow document").option("--content <text>", "Content to write").option("--file <path>", "Read content from file").addHelpText("after", `
+	docCmd.command("write <target>").description("Write content to the workspace document").option("--content <text>", "Content to write").option("--file <path>", "Read content from file").addHelpText("after", `
 Examples:
   $ agent-worker doc write @review --content "Document content"
   $ agent-worker doc write @review:pr-123 --file content.txt
@@ -4778,11 +669,11 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CoRTddGx.mjs");
+		const { createFileContextProvider } = await import("@moniro/workspace");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
-	docCmd.command("append <target>").description("Append content to the workflow document").option("--content <text>", "Content to append (use $'...' for newlines in bash)").option("--file <path>", "Read content from file").addHelpText("after", `
+	docCmd.command("append <target>").description("Append content to the workspace document").option("--content <text>", "Content to append (use $'...' for newlines in bash)").option("--file <path>", "Read content from file").addHelpText("after", `
 Examples:
   $ agent-worker doc append @review --content $'\\nNew line'
   $ agent-worker doc append @review:pr-123 --file content.txt
@@ -4796,22 +687,20 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CoRTddGx.mjs");
+		const { createFileContextProvider } = await import("@moniro/workspace");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
 }
 async function resolveDir(targetInput) {
-	const { getDefaultContextDir } = await Promise.resolve().then(() => file_provider_exports);
-	const { parseTarget } = await Promise.resolve().then(() => target_exports);
+	const { getDefaultContextDir } = await import("@moniro/workspace");
+	const { parseTarget } = await import("../target-9yiBRXxa.mjs").then((n) => n.r);
 	const target = parseTarget(targetInput);
-	return getDefaultContextDir(target.workflow, target.tag);
+	return getDefaultContextDir(target.workspace, target.tag);
 }
-
 //#endregion
 //#region package.json
-var version = "0.18.0";
-
+var version = "0.19.0";
 //#endregion
 //#region src/cli/index.ts
 globalThis.AI_SDK_LOG_WARNINGS = false;
@@ -4838,6 +727,5 @@ registerSendCommands(program);
 registerInfoCommands(program);
 registerDocCommands(program);
 program.parse();
-
 //#endregion
-export { formatInbox$1 as $, resolveContextDir as A, MENTION_PATTERN as B, retrySection as C, FileContextProvider as D, runWithHttp as E, DefaultChannelStore as F, createResourceRef as G, RESOURCE_PREFIX$1 as H, FileStorage as I, shouldUseResource as J, extractMentions as K, MemoryStorage as L, DefaultResourceStore as M, DefaultDocumentStore as N, createFileContextProvider as O, DefaultInboxStore as P, createLogTool as Q, ContextProviderImpl as R, projectSection as S, LOOP_DEFAULTS as T, RESOURCE_SCHEME as U, MESSAGE_LENGTH_THRESHOLD as V, calculatePriority as W, formatProposal as X, createContextMCPServer as Y, formatProposalList as Z, documentSection as _, getBackendByType as a, inboxSection as b, createAgentLoop as c, generateWorkflowMCPConfig as d, formatToolParams as et, writeBackendMcpConfig as f, buildAgentPrompt as g, assemblePrompt as h, createSilentLogger as i, DefaultStatusStore as j, getDefaultContextDir as k, runSdkAgent as l, activitySection as m, createWiredLoop as n, EventLog as nt, getBackendForModel as o, DEFAULT_SECTIONS as p, generateResourceId as q, createChannelLogger as r, checkWorkflowIdle as s, createMinimalRuntime as t, getAgentId as tt, runMockAgent as u, exitSection as v, workflowSection as w, instructionsSection as x, formatInbox as y, CONTEXT_DEFAULTS as z };
+export {};