agent-worker 0.13.0 → 0.15.0

package/dist/cli/index.mjs

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
-import { I as getDefaultModel, j as FRONTIER_MODELS, k as normalizeBackendType, n as createBackend } from "../backends-CziIqKRg.mjs";
-import { t as AgentWorker } from "../worker-DBJ8136Q.mjs";
+import { 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-C7pQwuAx.mjs";
+import { t as createTool } from "../create-tool-gcUuI1FD.mjs";
+import { generateText, stepCountIs, tool } from "ai";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { appendFile, mkdir, open, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { stringify } from "yaml";
 import { z } from "zod";
 import { homedir } from "node:os";
-import { spawn } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { Command, Option } from "commander";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -14,6 +16,11 @@ import { randomUUID } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { nanoid } from "nanoid";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { createServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { MockLanguageModelV3, mockValues } from "ai/test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -77,40 +84,53 @@ function isDaemonRunning() {
 		return null;
 	}
 }
-
-//#endregion
-//#region src/agent/handle.ts
+const DURATION_RE = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/;
 /**
-* LocalWorker — In-process execution via AgentWorker.
-*
-* Wraps an AgentWorker instance. State lives in the AgentWorker's memory.
-* This is the default for single-machine deployments.
-*/
-var LocalWorker = class {
-	engine;
-	constructor(config, restore) {
-		const backend = config.backend !== "default" ? createBackend({
-			type: config.backend,
-			model: config.model
-		}) : void 0;
-		this.engine = new AgentWorker({
-			model: config.model,
-			system: config.system,
-			tools: {},
-			backend,
-			provider: config.provider
-		}, restore);
-	}
-	send(input, options) {
-		return this.engine.send(input, options);
-	}
-	sendStream(input, options) {
-		return this.engine.sendStream(input, options);
+* 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
+		};
 	}
-	getState() {
-		return this.engine.getState();
+	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
@@ -138,11 +158,11 @@ var MemoryStateStore = class {
 * Auto-detects runtime: Bun.serve() when available, @hono/node-server otherwise.
 */
 async function startHttpServer(app, options) {
-	if (typeof globalThis.Bun !== "undefined") return startBun(app, options);
+	if ("Bun" in globalThis) return startBun(app, options);
 	return startNode(app, options);
 }
 function startBun(app, options) {
-	const server = Bun.serve({
+	const server = globalThis.Bun.serve({
 		fetch: app.fetch,
 		port: options.port,
 		hostname: options.hostname
@@ -221,7 +241,7 @@ function getAgentId(extra) {
 /**
 * Format inbox messages for JSON display.
 */
-function formatInbox(messages) {
+function formatInbox$1(messages) {
 	if (messages.length === 0) return JSON.stringify({
 		messages: [],
 		count: 0
@@ -360,7 +380,7 @@ function registerInboxTools(server, ctx, options) {
 		if (debugLog && messages.length > 0) debugLog(`[mcp:${agent}] my_inbox → ${messages.length} unread`);
 		return { content: [{
 			type: "text",
-			text: formatInbox(messages)
+			text: formatInbox$1(messages)
 		}] };
 	});
 	server.tool("my_inbox_ack", "Acknowledge inbox messages up to a message ID. Call after processing messages.", { until: z.string().describe("Acknowledge messages up to and including this message ID") }, async ({ until }, extra) => {
@@ -378,7 +398,7 @@ function registerInboxTools(server, ctx, options) {
 	server.tool("my_status_set", "Update your status and current task. Call when starting or completing work.", {
 		task: z.string().optional().describe("Current task description (what you're working on)"),
 		state: z.enum(["idle", "running"]).optional().describe("Agent state (running = working, idle = available)"),
-		metadata: z.record(z.unknown()).optional().describe("Additional metadata (e.g., PR number, file path)")
+		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);
@@ -555,7 +575,7 @@ function registerProposalTools(server, ctx, proposalManager) {
 	}, async (params, extra) => {
 		const createdBy = getAgentId(extra) || "anonymous";
 		try {
-			const proposal = proposalManager.create({
+			const proposal = await proposalManager.create({
 				type: params.type,
 				title: params.title,
 				description: params.description,
@@ -596,7 +616,7 @@ function registerProposalTools(server, ctx, proposalManager) {
 		reason: z.string().optional().describe("Optional reason for your vote")
 	}, async ({ proposal: proposalId, choice, reason }, extra) => {
 		const voter = getAgentId(extra) || "anonymous";
-		const result = proposalManager.vote({
+		const result = await proposalManager.vote({
 			proposalId,
 			voter,
 			choice,
@@ -629,7 +649,7 @@ function registerProposalTools(server, ctx, proposalManager) {
 	});
 	server.tool("team_proposal_status", "Check status of team proposals. Omit proposal ID to see all active proposals.", { proposal: z.string().optional().describe("Proposal ID (omit for all active)") }, async ({ proposal: proposalId }) => {
 		if (proposalId) {
-			const proposal = proposalManager.get(proposalId);
+			const proposal = await proposalManager.get(proposalId);
 			if (!proposal) return { content: [{
 				type: "text",
 				text: JSON.stringify({
@@ -642,7 +662,7 @@ function registerProposalTools(server, ctx, proposalManager) {
 				text: formatProposal(proposal)
 			}] };
 		}
-		const activeProposals = proposalManager.list("active");
+		const activeProposals = await proposalManager.list("active");
 		return { content: [{
 			type: "text",
 			text: activeProposals.length > 0 ? formatProposalList(activeProposals) : "(no active proposals)"
@@ -650,7 +670,7 @@ function registerProposalTools(server, ctx, proposalManager) {
 	});
 	server.tool("team_proposal_cancel", "Cancel a proposal you created.", { proposal: z.string().describe("Proposal ID to cancel") }, async ({ proposal: proposalId }, extra) => {
 		const cancelledBy = getAgentId(extra) || "anonymous";
-		const result = proposalManager.cancel(proposalId, cancelledBy);
+		const result = await proposalManager.cancel(proposalId, cancelledBy);
 		if (!result.success) return { content: [{
 			type: "text",
 			text: JSON.stringify({
@@ -818,7 +838,7 @@ function createContextMCPServer(options) {
 //#endregion
 //#region src/workflow/context/types.ts
 /** Resource ID prefix */
-const RESOURCE_PREFIX = "res_";
+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 */
@@ -827,7 +847,7 @@ const MESSAGE_LENGTH_THRESHOLD = 1200;
 * Generate a unique resource ID
 */
 function generateResourceId() {
-	return `${RESOURCE_PREFIX}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+	return `${RESOURCE_PREFIX$1}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
 }
 /**
 * Create resource reference for use in markdown
@@ -876,98 +896,34 @@ function calculatePriority(msg) {
 //#endregion
 //#region src/workflow/context/provider.ts
 /**
-* Context Provider interface + unified implementation
-* Domain logic for channel, inbox, document, and resource operations.
-* Storage I/O is delegated to a StorageBackend.
-*/
-/** Logical storage key layout */
-const KEYS = {
-	channel: "channel.jsonl",
-	inboxState: "_state/inbox.json",
-	agentStatus: "_state/agent-status.json",
-	documentPrefix: "documents/",
-	resourcePrefix: "resources/"
-};
-/**
-* Unified ContextProvider implementation.
-* All domain logic lives here; storage I/O goes through StorageBackend.
+* Composite ContextProvider — delegates to domain-specific stores.
 *
-* Channel format: JSONL (one JSON object per line)
-* Documents: raw content strings
-* Resources: content-addressed blobs
-* Inbox state: JSON cursor file (ID-based)
+* 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 {
-	/** Cached parsed channel entries — incrementally synced from storage */
-	channelEntries = [];
-	/** Storage byte offset up to which the cache is synced */
-	channelOffset = 0;
-	/** Guards concurrent syncChannel calls (share one in-flight read) */
-	syncPromise = null;
-	/** Run epoch: channel entry count at run start. Inbox ignores entries before this index. */
-	runStartIndex = 0;
-	constructor(storage, validAgents) {
-		this.storage = storage;
+	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;
 	}
-	/** Expose storage backend (for ProposalManager, testing, etc.) */
-	getStorage() {
-		return this.storage;
-	}
-	/**
-	* Sync cached entries from storage via incremental read.
-	* Only parses newly appended JSONL lines since last sync.
-	* Concurrent callers share the same in-flight read to avoid duplicate pushes.
-	*/
-	syncChannel() {
-		if (!this.syncPromise) this.syncPromise = this.doSyncChannel().finally(() => {
-			this.syncPromise = null;
-		});
-		return this.syncPromise;
-	}
-	async doSyncChannel() {
-		const result = await this.storage.readFrom(KEYS.channel, this.channelOffset);
-		if (result.content) {
-			this.channelEntries.push(...parseJsonl(result.content));
-			this.channelOffset = result.offset;
-		}
-		return this.channelEntries;
-	}
-	async appendChannel(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(KEYS.channel, line);
-		return msg;
+	appendChannel(from, content, options) {
+		return this.channel.append(from, content, options);
 	}
-	async readChannel(options) {
-		let entries = await this.syncChannel();
-		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;
+	readChannel(options) {
+		return this.channel.read(options);
 	}
-	async tailChannel(cursor) {
-		const entries = await this.syncChannel();
-		return {
-			entries: entries.slice(cursor),
-			cursor: entries.length
-		};
+	tailChannel(cursor) {
+		return this.channel.tail(cursor);
 	}
 	/**
 	* Smart send: automatically converts long messages to resources
@@ -978,164 +934,60 @@ var ContextProviderImpl = class {
 	* 3. Logs the full content in debug channel for visibility
 	*/
 	async smartSend(from, content, options) {
-		if (!shouldUseResource(content)) return this.appendChannel(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.createResource(content, from, resourceType);
-		await this.appendChannel("system", `Created resource ${resource.id} (${content.length} chars) for @${from}:\n${content}`, { kind: "debug" });
+		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.appendChannel(from, shortMessage, options);
-	}
-	async getInbox(agent) {
-		const state = await this.loadInboxState();
-		const lastAckId = state.readCursors[agent];
-		const lastSeenId = state.seenCursors?.[agent];
-		let entries = await this.syncChannel();
-		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 markInboxSeen(agent, untilId) {
-		const state = await this.loadInboxState();
-		if (!state.seenCursors) state.seenCursors = {};
-		state.seenCursors[agent] = untilId;
-		await this.storage.write(KEYS.inboxState, JSON.stringify(state, null, 2));
-	}
-	async ackInbox(agent, untilId) {
-		const state = await this.loadInboxState();
-		state.readCursors[agent] = untilId;
-		await this.storage.write(KEYS.inboxState, JSON.stringify(state, null, 2));
-	}
-	async loadInboxState() {
-		const raw = await this.storage.read(KEYS.inboxState);
-		if (!raw) return { readCursors: {} };
-		try {
-			const data = JSON.parse(raw);
-			return {
-				readCursors: data.readCursors || {},
-				seenCursors: data.seenCursors
-			};
-		} catch {
-			return { readCursors: {} };
-		}
+		return this.channel.append(from, shortMessage, options);
 	}
-	docKey(file) {
-		return KEYS.documentPrefix + (file || CONTEXT_DEFAULTS.document);
+	getInbox(agent) {
+		return this.inbox.getInbox(agent);
 	}
-	async readDocument(file) {
-		return await this.storage.read(this.docKey(file)) ?? "";
+	markInboxSeen(agent, untilId) {
+		return this.inbox.markSeen(agent, untilId);
 	}
-	async writeDocument(content, file) {
-		await this.storage.write(this.docKey(file), content);
+	ackInbox(agent, untilId) {
+		return this.inbox.ack(agent, untilId);
 	}
-	async appendDocument(content, file) {
-		await this.storage.append(this.docKey(file), content);
+	readDocument(file) {
+		return this.documents.read(file);
 	}
-	async listDocuments() {
-		return (await this.storage.list(KEYS.documentPrefix)).filter((f) => f.endsWith(".md")).sort();
+	writeDocument(content, file) {
+		return this.documents.write(content, file);
 	}
-	async createDocument(file, content) {
-		const key = this.docKey(file);
-		if (await this.storage.exists(key)) throw new Error(`Document already exists: ${file}`);
-		await this.storage.write(key, content);
+	appendDocument(content, file) {
+		return this.documents.append(content, file);
 	}
-	async createResource(content, _createdBy, type = "text") {
-		const id = generateResourceId();
-		const ext = type === "json" ? "json" : type === "diff" ? "diff" : "md";
-		const key = `${KEYS.resourcePrefix}${id}.${ext}`;
-		await this.storage.write(key, content);
-		return {
-			id,
-			ref: createResourceRef(id)
-		};
+	listDocuments() {
+		return this.documents.list();
 	}
-	async readResource(id) {
-		for (const ext of [
-			"md",
-			"json",
-			"diff",
-			"txt"
-		]) {
-			const key = `${KEYS.resourcePrefix}${id}.${ext}`;
-			const content = await this.storage.read(key);
-			if (content !== null) return content;
-		}
-		return null;
+	createDocument(file, content) {
+		return this.documents.create(file, content);
 	}
-	async loadAgentStatus() {
-		const raw = await this.storage.read(KEYS.agentStatus);
-		if (!raw) return {};
-		try {
-			return JSON.parse(raw);
-		} catch {
-			return {};
-		}
+	createResource(content, createdBy, type) {
+		return this.resources.create(content, createdBy, type);
 	}
-	async saveAgentStatus(statuses) {
-		await this.storage.write(KEYS.agentStatus, JSON.stringify(statuses, null, 2));
+	readResource(id) {
+		return this.resources.read(id);
 	}
-	async setAgentStatus(agent, status) {
-		const statuses = await this.loadAgentStatus();
-		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.saveAgentStatus(statuses);
+	setAgentStatus(agent, status) {
+		return this.status.set(agent, status);
 	}
-	async getAgentStatus(agent) {
-		return (await this.loadAgentStatus())[agent] || null;
+	getAgentStatus(agent) {
+		return this.status.get(agent);
 	}
-	async listAgentStatus() {
-		return this.loadAgentStatus();
+	listAgentStatus() {
+		return this.status.list();
 	}
 	async markRunStart() {
-		this.runStartIndex = (await this.syncChannel()).length;
+		await this.inbox.markRunStart();
 	}
 	async destroy() {
-		await this.storage.delete(KEYS.inboxState);
+		await this.inbox.destroy();
 	}
 };
-/**
-* 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/storage.ts
@@ -1286,139 +1138,1676 @@ var FileStorage = class {
 			return [];
 		}
 	}
-	async delete(key) {
-		try {
-			await unlink(this.resolve(key));
-		} catch {}
-	}
-};
+	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");
+}
+/**
+* Build the complete agent prompt from run context
+*/
+function buildAgentPrompt(ctx) {
+	const sections = [];
+	sections.push("## Project");
+	sections.push(`Working on: ${ctx.projectDir}`);
+	sections.push("");
+	sections.push(`## Inbox (${ctx.inbox.length} message${ctx.inbox.length === 1 ? "" : "s"} for you)`);
+	sections.push(formatInbox(ctx.inbox));
+	sections.push("");
+	sections.push("## Recent Activity");
+	sections.push("Use channel_read tool to view recent channel messages and conversation context if needed.");
+	if (ctx.documentContent) {
+		sections.push("");
+		sections.push("## Shared Document");
+		sections.push(ctx.documentContent);
+	}
+	if (ctx.retryAttempt > 1) {
+		sections.push("");
+		sections.push(`## Note`);
+		sections.push(`This is retry attempt ${ctx.retryAttempt}. Previous attempt failed.`);
+	}
+	sections.push("");
+	sections.push("## Instructions");
+	sections.push("You are an agent in a multi-agent workflow. Communicate ONLY through the MCP tools below.");
+	sections.push("Your text output is NOT seen by other agents — you MUST use channel_send to communicate.");
+	sections.push("");
+	sections.push("### Channel Tools");
+	sections.push("- **channel_send**: Send a message to the shared channel. Use @agentname to mention/notify.");
+	sections.push("  Use the \"to\" parameter for private DMs: channel_send({ message: \"...\", to: \"bob\" })");
+	sections.push("- **channel_read**: Read recent channel messages (DMs and logs are auto-filtered).");
+	sections.push("");
+	sections.push("### Team Tools");
+	sections.push("- **team_members**: List all agents you can @mention. Pass includeStatus=true to see their current state and tasks.");
+	sections.push("- **team_doc_read/write/append/list/create**: Shared team documents.");
+	sections.push("");
+	sections.push("### Personal Tools");
+	sections.push("- **my_inbox**: Check your unread messages.");
+	sections.push("- **my_inbox_ack**: Acknowledge messages after processing (pass the latest message ID).");
+	sections.push("- **my_status_set**: Update your status. Call when starting work (state='running', task='...') or when done (state='idle').");
+	sections.push("");
+	sections.push("### Proposal & Voting Tools");
+	sections.push("- **team_proposal_create**: Create a proposal for team voting (types: election, decision, approval, assignment).");
+	sections.push("- **team_vote**: Cast your vote on an active proposal. You can change your vote by voting again.");
+	sections.push("- **team_proposal_status**: Check status of a proposal, or list all active proposals.");
+	sections.push("- **team_proposal_cancel**: Cancel a proposal you created.");
+	sections.push("");
+	sections.push("### Resource Tools");
+	sections.push("- **resource_create**: Store large content, get a reference (resource:id) for use anywhere.");
+	sections.push("- **resource_read**: Read resource content by ID.");
+	if (ctx.feedback) {
+		sections.push("");
+		sections.push("### Feedback Tool");
+		sections.push("- **feedback_submit**: Report workflow improvement needs — a missing tool, an awkward step, or a capability gap.");
+		sections.push("  Only use when you genuinely hit a pain point during your work.");
+	}
+	sections.push("");
+	sections.push("### Workflow");
+	sections.push("1. Read your inbox messages above");
+	sections.push("2. Do your assigned work using channel_send with @mentions");
+	sections.push("3. Acknowledge your inbox with my_inbox_ack");
+	sections.push("4. Exit when your task is complete");
+	sections.push("");
+	sections.push("### IMPORTANT: When to stop");
+	sections.push("- Once your assigned task is complete, acknowledge your inbox and exit. Do NOT keep chatting.");
+	sections.push("- Do NOT send pleasantries (\"you're welcome\", \"glad to help\", \"thanks again\") — they trigger unnecessary cycles.");
+	sections.push("- Do NOT @mention another agent in your final message unless you need them to do more work.");
+	sections.push("- If you receive a thank-you or acknowledgment, just call my_inbox_ack and exit. Do not reply.");
+	return sections.join("\n");
+}
+
+//#endregion
+//#region src/workflow/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;
+	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) {
+				errorLog(`ERROR max retries exhausted, acknowledging to prevent loop`);
+				await contextProvider.ackInbox(name, latestId);
+			}
+			if (lastResult && onRunComplete) onRunComplete(lastResult);
+			state = "idle";
+			await contextProvider.setAgentStatus(name, { state: "idle" });
+		}
+	}
+	return {
+		get name() {
+			return name;
+		},
+		get state() {
+			return state;
+		},
+		async start() {
+			if (state !== "stopped") throw new Error(`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/context/file-provider.ts
+//#region src/workflow/loop/backend.ts
 /**
-* File Context Provider
-* Thin wrapper around ContextProviderImpl + FileStorage.
-* Includes instance lock to prevent concurrent access to the same context directory.
+* 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).
 */
-var file_provider_exports = /* @__PURE__ */ __exportAll({
-	FileContextProvider: () => FileContextProvider,
-	createFileContextProvider: () => createFileContextProvider,
-	getDefaultContextDir: () => getDefaultContextDir,
-	resolveContextDir: () => resolveContextDir
+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
 });
-/** Lock file name within context directory */
-const LOCK_FILE = "_state/instance.lock";
 /**
-* File-based ContextProvider.
-* All domain logic is in ContextProviderImpl;
-* FileStorage handles I/O.
+* 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.
 *
-* Adds instance locking: only one process can hold the lock at a time.
-* Stale locks (from crashed processes) are automatically cleaned up.
+* - 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.
 */
-var FileContextProvider = class extends ContextProviderImpl {
-	lockPath;
-	constructor(storage, validAgents, contextDir) {
-		super(storage, 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;
+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
+			});
 		}
-		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();
+	};
+}
+/** 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
 /**
-* Resolve a context directory template to an absolute path.
+* Workflow Factory — Composable primitives for building workflow runtimes.
 *
-* Supports:
-* - ${{ workflow.name }} — substituted with workflowName
-* - ${{ instance }} — substituted with instance
-* - ~ expansion to home directory
-* - Relative paths resolved against baseDir (or cwd if not provided)
-* - Absolute paths used as-is
+* 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
 */
-function resolveContextDir(dirTemplate, opts) {
-	const workflow = opts.workflow ?? opts.workflowName ?? opts.instance ?? "global";
-	const workflowName = opts.workflowName ?? workflow;
-	const tag = opts.tag ?? "main";
-	let dir = dirTemplate.replace("${{ workflow.name }}", workflowName).replace("${{ workflow.tag }}", tag).replace("${{ instance }}", opts.instance ?? workflow);
-	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")
-* @param instanceOrWorkflowName (deprecated) Legacy parameter for backward compatibility
+* 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.
 */
-function getDefaultContextDir(workflow, tag, instanceOrWorkflowName) {
-	const wf = workflow ?? instanceOrWorkflowName ?? "global";
-	const t = tag ?? "main";
-	return resolveContextDir(CONTEXT_DEFAULTS.dir, {
-		workflow: wf,
-		tag: t
+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 FileContextProvider with default paths.
+* Create a fully-wired agent loop.
 *
-* 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
-*   └── ...
+* 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 createFileContextProvider(contextDir, validAgents) {
-	return new FileContextProvider(new FileStorage(contextDir), validAgents, contextDir);
+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
@@ -1426,14 +2815,18 @@ function createFileContextProvider(contextDir, validAgents) {
 /**
 * 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
-*   StateStore (store)  — conversation history and usage (pluggable)
-*   WorkerHandle (workers) — execution, local or remote
-*   Workflows (workflows) — running workflow instances with controllers
+*   Registry (configs)    — what agents exist and their configuration
+*   Workflows (workflows) — running workflow instances with loops + context
 *
-* The daemon is pure glue: receive request → lookup config →
-* dispatch to worker → persist state → return response.
+* Key principle: every agent lives in a workflow. Standalone agents created via
+* POST /agents get a 1-agent workflow (created lazily on first /run or /serve).
+* This unifies the runtime so there's one code path for execution.
 *
 * HTTP endpoints:
 *   GET  /health, POST /shutdown
@@ -1457,9 +2850,6 @@ async function gracefulShutdown() {
 			await wf.shutdown();
 		} catch {}
 		state.workflows.clear();
-		for (const [name, handle] of state.workers) try {
-			await state.store.save(name, handle.getState());
-		} catch {}
 		if (state.server) await state.server.close();
 	}
 	for (const [, session] of mcpSessions) try {
@@ -1477,11 +2867,93 @@ async function parseJsonBody(c) {
 		return null;
 	}
 }
-function createDaemonApp(optionsOrGetState) {
-	const { getState, token } = typeof optionsOrGetState === "function" ? {
-		getState: optionsOrGetState,
-		token: void 0
-	} : optionsOrGetState;
+/** Map AgentConfig to the ResolvedAgent type needed by the factory */
+function configToResolvedAgent(cfg) {
+	return {
+		backend: cfg.backend,
+		model: cfg.model,
+		provider: cfg.provider,
+		resolvedSystemPrompt: cfg.system,
+		schedule: cfg.schedule
+	};
+}
+/**
+* Find an agent's loop across all workflows.
+* Returns the loop if the agent exists in any workflow.
+*/
+function findLoop(s, agentName) {
+	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 workflow + loop.
+* Creates the infrastructure lazily on first call (starts MCP server, etc.).
+*
+* This is the bridge between POST /agents (stores config only) and
+* POST /run or /serve (needs a 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 = configToResolvedAgent(cfg);
+	const wfKey = `standalone:${agentName}`;
+	const runtime = await createMinimalRuntime({
+		workflowName: cfg.workflow,
+		tag: cfg.tag,
+		agentNames: [agentName]
+	});
+	let loop;
+	try {
+		({loop} = createWiredLoop({
+			name: agentName,
+			agent: agentDef,
+			runtime
+		}));
+	} catch (err) {
+		await runtime.shutdown();
+		throw err;
+	}
+	const handle = {
+		name: cfg.workflow,
+		tag: cfg.tag,
+		key: wfKey,
+		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);
@@ -1517,17 +2989,21 @@ function createDaemonApp(optionsOrGetState) {
 	app.get("/agents", (c) => {
 		const s = getState();
 		if (!s) return c.json({ error: "Not ready" }, 503);
-		const standaloneAgents = [...s.configs.values()].map((cfg) => ({
-			name: cfg.name,
-			model: cfg.model,
-			backend: cfg.backend,
-			workflow: cfg.workflow,
-			tag: cfg.tag,
-			createdAt: cfg.createdAt,
-			source: "standalone"
-		}));
+		const standaloneAgents = [...s.configs.values()].map((cfg) => {
+			const 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 controller = wf.controllers.get(agentName);
+			const loop = wf.loops.get(agentName);
 			return {
 				name: agentName,
 				model: "",
@@ -1536,7 +3012,7 @@ function createDaemonApp(optionsOrGetState) {
 				tag: wf.tag,
 				createdAt: wf.startedAt,
 				source: "workflow",
-				state: controller?.state ?? "unknown"
+				state: loop?.state ?? "unknown"
 			};
 		}));
 		return c.json({ agents: [...standaloneAgents, ...workflowAgents] });
@@ -1546,7 +3022,7 @@ function createDaemonApp(optionsOrGetState) {
 		if (!s) return c.json({ error: "Not ready" }, 503);
 		const body = await parseJsonBody(c);
 		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
-		const { name, model, system, backend = "default", provider, workflow = "global", tag = "main" } = body;
+		const { name, model, system, backend = "default", provider, workflow = "global", tag = "main", schedule } = body;
 		if (!name || !model || !system) return c.json({ error: "name, model, system required" }, 400);
 		if (s.configs.has(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
 		const agentConfig = {
@@ -1557,17 +3033,17 @@ function createDaemonApp(optionsOrGetState) {
 			provider,
 			workflow,
 			tag,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			schedule
 		};
-		const handle = new LocalWorker(agentConfig, await s.store.load(name) ?? void 0);
 		s.configs.set(name, agentConfig);
-		s.workers.set(name, handle);
 		return c.json({
 			name,
 			model,
 			backend,
 			workflow,
-			tag
+			tag,
+			schedule
 		}, 201);
 	});
 	app.get("/agents/:name", (c) => {
@@ -1582,7 +3058,8 @@ function createDaemonApp(optionsOrGetState) {
 			system: cfg.system,
 			workflow: cfg.workflow,
 			tag: cfg.tag,
-			createdAt: cfg.createdAt
+			createdAt: cfg.createdAt,
+			schedule: cfg.schedule
 		});
 	});
 	app.delete("/agents/:name", async (c) => {
@@ -1590,11 +3067,14 @@ function createDaemonApp(optionsOrGetState) {
 		if (!s) return c.json({ error: "Not ready" }, 503);
 		const name = c.req.param("name");
 		if (!s.configs.delete(name)) return c.json({ error: "Agent not found" }, 404);
-		const handle = s.workers.get(name);
-		if (handle) try {
-			await s.store.save(name, handle.getState());
-		} catch {}
-		s.workers.delete(name);
+		const wfKey = `standalone:${name}`;
+		const wf = s.workflows.get(wfKey);
+		if (wf) {
+			try {
+				await wf.shutdown();
+			} catch {}
+			s.workflows.delete(wfKey);
+		}
 		return c.json({ success: true });
 	});
 	app.post("/run", async (c) => {
@@ -1604,30 +3084,36 @@ function createDaemonApp(optionsOrGetState) {
 		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
 		const { agent: agentName, message } = body;
 		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
-		const handle = s.workers.get(agentName);
-		if (!handle) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		let 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 gen = handle.sendStream(message);
-				while (true) {
-					const { value, done } = await gen.next();
-					if (done) {
-						const currentState = getState();
-						if (currentState) await currentState.store.save(agentName, handle.getState());
-						await stream.writeSSE({
-							event: "done",
-							data: JSON.stringify(value)
-						});
-						break;
-					}
-					await stream.writeSSE({
+				const result = await agentLoop.sendDirect(message);
+				if (result.success) {
+					if (result.content) await stream.writeSSE({
 						event: "chunk",
 						data: JSON.stringify({
 							agent: agentName,
-							text: value
+							text: result.content
 						})
 					});
-				}
+					await stream.writeSSE({
+						event: "done",
+						data: JSON.stringify(result)
+					});
+				} else await stream.writeSSE({
+					event: "error",
+					data: JSON.stringify({ error: result.error })
+				});
 			} catch (error) {
 				const msg = error instanceof Error ? error.message : String(error);
 				await stream.writeSSE({
@@ -1644,12 +3130,24 @@ function createDaemonApp(optionsOrGetState) {
 		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
 		const { agent: agentName, message } = body;
 		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
-		const handle = s.workers.get(agentName);
-		if (!handle) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		let 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 response = await handle.send(message);
-			await s.store.save(agentName, handle.getState());
-			return c.json(response);
+			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);
@@ -1676,15 +3174,18 @@ function createDaemonApp(optionsOrGetState) {
 			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 contextDir = getDefaultContextDir(workflow, tag);
-			mkdirSync(contextDir, { recursive: true });
-			const provider = createFileContextProvider(contextDir, allNames);
+			const provider = existingWf?.contextProvider ?? (() => {
+				const contextDir = getDefaultContextDir(workflow, tag);
+				mkdirSync(contextDir, { recursive: true });
+				return createFileContextProvider(contextDir, allNames);
+			})();
 			const transport = new WebStandardStreamableHTTPServerTransport({
 				sessionIdGenerator: () => `${agentName}-${randomUUID().slice(0, 8)}`,
 				onsessioninitialized: (sid) => {
@@ -1714,14 +3215,14 @@ function createDaemonApp(optionsOrGetState) {
 		if (!s) return c.json({ error: "Not ready" }, 503);
 		const body = await parseJsonBody(c);
 		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
-		const { workflow, tag = "main", feedback, pollInterval } = body;
+		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 { runWorkflowWithControllers } = await import("../runner-CnxROIev.mjs");
-			const result = await runWorkflowWithControllers({
+			const { runWorkflowWithLoops } = await import("../runner-DB-b57iZ.mjs");
+			const result = await runWorkflowWithLoops({
 				workflow,
 				workflowName,
 				tag,
@@ -1729,6 +3230,7 @@ function createDaemonApp(optionsOrGetState) {
 				headless: true,
 				feedback,
 				pollInterval,
+				params,
 				log: () => {}
 			});
 			if (!result.success) return c.json({ error: result.error || "Workflow failed to start" }, 500);
@@ -1737,7 +3239,7 @@ function createDaemonApp(optionsOrGetState) {
 				tag,
 				key,
 				agents: Object.keys(workflow.agents),
-				controllers: result.controllers,
+				loops: result.loops,
 				contextProvider: result.contextProvider,
 				shutdown: result.shutdown,
 				workflowPath: workflow.filePath,
@@ -1760,7 +3262,7 @@ function createDaemonApp(optionsOrGetState) {
 		if (!s) return c.json({ error: "Not ready" }, 503);
 		const workflows = [...s.workflows.values()].map((wf) => {
 			const agentStates = {};
-			for (const [name, controller] of wf.controllers) agentStates[name] = controller.state;
+			for (const [name, loop] of wf.loops) agentStates[name] = loop.state;
 			return {
 				name: wf.name,
 				tag: wf.tag,
@@ -1822,7 +3324,6 @@ async function startDaemon(config = {}) {
 	});
 	state = {
 		configs: /* @__PURE__ */ new Map(),
-		workers: /* @__PURE__ */ new Map(),
 		workflows: /* @__PURE__ */ new Map(),
 		store,
 		server,
@@ -2073,11 +3574,12 @@ 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("--port <port>", `Daemon port if starting new daemon (default: ${DEFAULT_PORT})`).option("--host <host>", "Daemon host (default: 127.0.0.1)").option("--json", "Output as JSON").addHelpText("after", `
+	]).default("default")).option("--provider <name>", "Provider SDK name (e.g., anthropic, openai)").option("--base-url <url>", "Override provider base URL").option("--api-key <ref>", "API key env var (e.g., $MINIMAX_API_KEY)").option("-s, --system <prompt>", "System prompt", "You are a helpful assistant.").option("-f, --system-file <file>", "Read system prompt from file").option("--workflow <name>", "Workflow name (default: global)").option("--tag <tag>", "Workflow instance tag (default: main)").option("--wakeup <interval|cron>", "Periodic wakeup schedule (e.g., 30s, 5m, 0 9 * * 1-5)").option("--wakeup-prompt <text>", "Custom prompt for wakeup events").option("--port <port>", `Daemon port if starting new daemon (default: ${DEFAULT_PORT})`).option("--host <host>", "Daemon host (default: 127.0.0.1)").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
   $ agent-worker new alice -m anthropic/claude-sonnet-4-5
   $ agent-worker new bot -b mock
   $ agent-worker new reviewer --workflow review --tag pr-123
+  $ agent-worker new monitor --wakeup 30s --system "Check status"
   $ agent-worker new coder -m MiniMax-M2.5 --provider anthropic --base-url https://api.minimax.io/anthropic/v1 --api-key '$MINIMAX_API_KEY'
       `).action(async (name, options) => {
 		let system = options.system;
@@ -2091,6 +3593,15 @@ Examples:
 			api_key: options.apiKey
 		};
 		else provider = options.provider;
+		if (options.wakeupPrompt && !options.wakeup) {
+			console.error("Error: --wakeup-prompt can only be used with --wakeup.");
+			process.exit(1);
+		}
+		let schedule;
+		if (options.wakeup) {
+			schedule = { wakeup: options.wakeup };
+			if (options.wakeupPrompt) schedule.prompt = options.wakeupPrompt;
+		}
 		await ensureDaemon(options.port ? parseInt(options.port, 10) : void 0, options.host);
 		const res = await createAgent({
 			name,
@@ -2099,7 +3610,8 @@ Examples:
 			backend,
 			provider,
 			workflow: options.workflow,
-			tag: options.tag
+			tag: options.tag,
+			schedule
 		});
 		if (res.error) {
 			console.error("Error:", res.error);
@@ -2343,28 +3855,49 @@ function buildDisplay(agent, workflow, tag) {
 //#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").addHelpText("after", `
+	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", `
 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 --json | jq .document  # Machine-readable output
+  $ agent-worker run review.yaml -- --target main -n 3  # With workflow 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
 
-Note: Workflow name is inferred from YAML 'name' field or filename
+Note: Workflow name is inferred from YAML 'name' field or filename.
+      Workflow-defined params (see 'params:' in YAML) are passed after '--'.
+      Set GITHUB_TOKEN env var to access private repositories.
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CIE3WPNx.mjs");
+		const { parseWorkflowFile, parseWorkflowParams, formatParamHelp, runWorkflowWithLoops } = await import("../workflow-DQ6Eju4n.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
-		let controllers;
+		let params;
+		if (parsedWorkflow.params && parsedWorkflow.params.length > 0) {
+			const extraArgs = getArgsAfterSeparator();
+			try {
+				params = parseWorkflowParams(parsedWorkflow.params, extraArgs);
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				console.error(`Error: ${msg}`);
+				console.error(formatParamHelp(parsedWorkflow.params));
+				process.exit(1);
+			}
+		}
+		let loops;
 		let isCleaningUp = false;
 		const cleanup = async () => {
 			if (isCleaningUp) return;
 			isCleaningUp = true;
 			console.log("\nInterrupted, cleaning up...");
-			if (controllers) {
-				const { shutdownControllers } = await import("../workflow-CIE3WPNx.mjs");
-				const { createSilentLogger } = await import("../logger-Bfdo83xL.mjs");
-				await shutdownControllers(controllers, createSilentLogger());
+			if (loops) {
+				const { shutdownLoops } = await import("../workflow-DQ6Eju4n.mjs");
+				const { createSilentLogger } = await Promise.resolve().then(() => logger_exports);
+				await shutdownLoops(loops, createSilentLogger());
 			}
 			process.exit(130);
 		};
@@ -2372,19 +3905,19 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 		process.on("SIGTERM", cleanup);
 		try {
 			const log = options.json ? console.error : console.log;
-			const result = await runWorkflowWithControllers({
+			const result = await runWorkflowWithLoops({
 				workflow: parsedWorkflow,
 				workflowName,
 				tag,
 				workflowPath: file,
-				instance: `${workflowName}:${tag}`,
 				debug: options.debug,
 				log,
 				mode: "run",
 				feedback: options.feedback,
-				prettyDisplay: !options.debug && !options.json
+				prettyDisplay: !options.debug && !options.json,
+				params
 			});
-			controllers = result.controllers;
+			loops = result.loops;
 			process.off("SIGINT", cleanup);
 			process.off("SIGTERM", cleanup);
 			if (!result.success) {
@@ -2400,7 +3933,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-BCJq5v9d.mjs");
+					const { showWorkflowSummary } = await import("../display-pretty-Kyd40DEF.mjs");
 					showWorkflowSummary({
 						duration: result.duration,
 						document: finalDoc,
@@ -2424,27 +3957,42 @@ 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").addHelpText("after", `
+	program.command("start <file>").description("Start workflow via daemon and keep agents running").option("--tag <tag>", "Workflow instance tag (default: main)", DEFAULT_TAG).option("--feedback", "Enable feedback tool (agents can report tool/workflow observations)").option("--json", "Output as JSON").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
 
 Workflow runs inside the daemon. Use ls/stop to manage:
   $ agent-worker ls                                   # List all agents
   $ agent-worker stop @review:pr-123                  # Stop workflow
 
-Note: Workflow name is inferred from YAML 'name' field or filename
+Note: Workflow name is inferred from YAML 'name' field or filename.
+      Workflow-defined params (see 'params:' in YAML) are passed after '--'.
     `).action(async (file, options) => {
-		const { parseWorkflowFile } = await import("../workflow-CIE3WPNx.mjs");
+		const { parseWorkflowFile, parseWorkflowParams, formatParamHelp } = await import("../workflow-DQ6Eju4n.mjs");
 		const { ensureDaemon } = await Promise.resolve().then(() => agent_exports);
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
+		let params;
+		if (parsedWorkflow.params && parsedWorkflow.params.length > 0) {
+			const extraArgs = getArgsAfterSeparator();
+			try {
+				params = parseWorkflowParams(parsedWorkflow.params, extraArgs);
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				console.error(`Error: ${msg}`);
+				console.error(formatParamHelp(parsedWorkflow.params));
+				process.exit(1);
+			}
+		}
 		await ensureDaemon();
 		const res = await startWorkflow({
 			workflow: parsedWorkflow,
 			tag,
-			feedback: options.feedback
+			feedback: options.feedback,
+			params
 		});
 		if (res.error) {
 			console.error("Error:", res.error);
@@ -2480,6 +4028,15 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 		await new Promise(() => {});
 	});
 }
+/**
+* Get arguments after the '--' separator.
+* Standard Unix convention: everything after '--' is passed through
+* without being interpreted as options by the CLI framework.
+*/
+function getArgsAfterSeparator() {
+	const idx = process.argv.indexOf("--");
+	return idx === -1 ? [] : process.argv.slice(idx + 1);
+}
 
 //#endregion
 //#region src/cli/commands/send.ts
@@ -2607,10 +4164,12 @@ function registerInfoCommands(program) {
 		console.log(`  Gateway format:  provider/model   (e.g., ${gatewayExample})`);
 		console.log(`  Direct format:   provider:model   (e.g., ${directExample})`);
 		console.log(`  Custom endpoint: --provider anthropic --base-url <url> --api-key '$KEY'`);
+		console.log(`  Auto-detect:     model: auto         (scan env vars, pick best available)`);
 		console.log(`\nDefault: ${defaultModel} (when no model specified)`);
+		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-BWzhErjT.mjs");
+		const { listBackends } = await import("../backends-BYWmuyF9.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2640,7 +4199,7 @@ Examples:
   $ agent-worker doc read @review:pr-123     # Read specific workflow:tag document
     `).action(async (targetInput) => {
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
+		const { createFileContextProvider } = await import("../context-CdcZpO-0.mjs");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
@@ -2658,7 +4217,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
+		const { createFileContextProvider } = await import("../context-CdcZpO-0.mjs");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
@@ -2676,7 +4235,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-BqEyt2SF.mjs");
+		const { createFileContextProvider } = await import("../context-CdcZpO-0.mjs");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
@@ -2690,18 +4249,25 @@ async function resolveDir(targetInput) {
 
 //#endregion
 //#region package.json
-var version = "0.13.0";
+var version = "0.15.0";
 
 //#endregion
 //#region src/cli/index.ts
 globalThis.AI_SDK_LOG_WARNINGS = false;
 const originalStderrWrite = process.stderr.write.bind(process.stderr);
-process.stderr.write = function(chunk, ...rest) {
-	if (process.argv.includes("--debug") || process.argv.includes("-d")) {
-		const message = typeof chunk === "string" ? chunk : chunk.toString();
-		return originalStderrWrite.call(process.stderr, message, ...rest);
-	}
-	return true;
+const isDebugMode = process.argv.includes("--debug") || process.argv.includes("-d");
+const SDK_NOISE_PATTERNS = [
+	"specificationVersion",
+	"AI_SDK",
+	"ai-sdk",
+	"deprecated",
+	"ExperimentalWarning"
+];
+process.stderr.write = function(chunk, encodingOrCb, cb) {
+	const message = typeof chunk === "string" ? chunk : chunk.toString();
+	if (isDebugMode) return originalStderrWrite(message, encodingOrCb, cb);
+	if (SDK_NOISE_PATTERNS.some((pattern) => message.includes(pattern))) return true;
+	return originalStderrWrite(message, encodingOrCb, cb);
 };
 const program = new Command();
 program.name("agent-worker").description("CLI for creating and managing AI agents").version(version);
@@ -2713,4 +4279,4 @@ registerDocCommands(program);
 program.parse();
 
 //#endregion
-export { formatToolParams as C, formatInbox as S, EventLog as T, shouldUseResource as _, FileStorage as a, formatProposalList as b, CONTEXT_DEFAULTS as c, RESOURCE_PREFIX as d, RESOURCE_SCHEME as f, generateResourceId as g, extractMentions as h, resolveContextDir as i, MENTION_PATTERN as l, createResourceRef as m, createFileContextProvider as n, MemoryStorage as o, calculatePriority as p, getDefaultContextDir as r, ContextProviderImpl as s, FileContextProvider as t, MESSAGE_LENGTH_THRESHOLD as u, createContextMCPServer as v, getAgentId as w, createLogTool as x, formatProposal as y };
+export { MENTION_PATTERN as A, formatProposal as B, DefaultDocumentStore as C, MemoryStorage as D, FileStorage as E, createResourceRef as F, getAgentId as G, createLogTool as H, extractMentions as I, EventLog as K, generateResourceId as L, RESOURCE_PREFIX$1 as M, RESOURCE_SCHEME as N, ContextProviderImpl as O, calculatePriority as P, shouldUseResource as R, DefaultResourceStore as S, DefaultChannelStore as T, formatInbox$1 as U, formatProposalList as V, formatToolParams as W, FileContextProvider as _, getBackendByType as a, resolveContextDir as b, createAgentLoop as c, generateWorkflowMCPConfig as d, writeBackendMcpConfig as f, runWithHttp as g, LOOP_DEFAULTS as h, createSilentLogger as i, MESSAGE_LENGTH_THRESHOLD as j, CONTEXT_DEFAULTS as k, runSdkAgent as l, formatInbox as m, createWiredLoop as n, getBackendForModel as o, buildAgentPrompt as p, createChannelLogger as r, checkWorkflowIdle as s, createMinimalRuntime as t, runMockAgent as u, createFileContextProvider as v, DefaultInboxStore as w, DefaultStatusStore as x, getDefaultContextDir as y, createContextMCPServer as z };