agent-worker 0.14.0 → 0.15.0

package/dist/cli/index.mjs

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
-import { A as parseModel, I as getDefaultModel, P as createModelAsync, a as createMockBackend, j as FRONTIER_MODELS, k as normalizeBackendType, n as createBackend } from "../backends-C6WBIn9H.mjs";
-import { generateText, jsonSchema, stepCountIs, tool } from "ai";
+import { 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 { execSync, spawn } from "node:child_process";
@@ -156,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
@@ -396,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);
@@ -573,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,
@@ -614,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,
@@ -647,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({
@@ -660,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)"
@@ -668,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({
@@ -836,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 */
@@ -845,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
@@ -894,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;
+	appendChannel(from, content, options) {
+		return this.channel.append(from, content, options);
 	}
-	/**
-	* 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;
+	readChannel(options) {
+		return this.channel.read(options);
 	}
-	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;
-	}
-	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;
-	}
-	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
@@ -996,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);
+		return this.channel.append(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
-			};
-		});
+	getInbox(agent) {
+		return this.inbox.getInbox(agent);
 	}
-	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));
+	markInboxSeen(agent, untilId) {
+		return this.inbox.markSeen(agent, untilId);
 	}
-	async ackInbox(agent, untilId) {
-		const state = await this.loadInboxState();
-		state.readCursors[agent] = untilId;
-		await this.storage.write(KEYS.inboxState, JSON.stringify(state, null, 2));
+	ackInbox(agent, untilId) {
+		return this.inbox.ack(agent, untilId);
 	}
-	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: {} };
-		}
+	readDocument(file) {
+		return this.documents.read(file);
 	}
-	docKey(file) {
-		return KEYS.documentPrefix + (file || CONTEXT_DEFAULTS.document);
+	writeDocument(content, file) {
+		return this.documents.write(content, file);
 	}
-	async readDocument(file) {
-		return await this.storage.read(this.docKey(file)) ?? "";
+	appendDocument(content, file) {
+		return this.documents.append(content, file);
 	}
-	async writeDocument(content, file) {
-		await this.storage.write(this.docKey(file), content);
+	listDocuments() {
+		return this.documents.list();
 	}
-	async appendDocument(content, file) {
-		await this.storage.append(this.docKey(file), content);
+	createDocument(file, content) {
+		return this.documents.create(file, content);
 	}
-	async listDocuments() {
-		return (await this.storage.list(KEYS.documentPrefix)).filter((f) => f.endsWith(".md")).sort();
+	createResource(content, createdBy, type) {
+		return this.resources.create(content, createdBy, type);
 	}
-	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);
+	readResource(id) {
+		return this.resources.read(id);
 	}
-	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)
-		};
+	setAgentStatus(agent, status) {
+		return this.status.set(agent, status);
 	}
-	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;
+	getAgentStatus(agent) {
+		return this.status.get(agent);
 	}
-	async loadAgentStatus() {
-		const raw = await this.storage.read(KEYS.agentStatus);
-		if (!raw) return {};
-		try {
-			return JSON.parse(raw);
-		} catch {
-			return {};
-		}
-	}
-	async saveAgentStatus(statuses) {
-		await this.storage.write(KEYS.agentStatus, JSON.stringify(statuses, null, 2));
-	}
-	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);
-	}
-	async getAgentStatus(agent) {
-		return (await this.loadAgentStatus())[agent] || null;
-	}
-	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
@@ -1311,11 +1145,287 @@ var FileStorage = class {
 	}
 };
 
+//#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
-* Thin wrapper around ContextProviderImpl + FileStorage.
+* Composes default stores with FileStorage backend.
 * Includes instance lock to prevent concurrent access to the same context directory.
 */
 var file_provider_exports = /* @__PURE__ */ __exportAll({
@@ -1328,8 +1438,7 @@ var file_provider_exports = /* @__PURE__ */ __exportAll({
 const LOCK_FILE = "_state/instance.lock";
 /**
 * File-based ContextProvider.
-* All domain logic is in ContextProviderImpl;
-* FileStorage handles I/O.
+* 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.
@@ -1337,7 +1446,12 @@ const LOCK_FILE = "_state/instance.lock";
 var FileContextProvider = class extends ContextProviderImpl {
 	lockPath;
 	constructor(storage, validAgents, contextDir) {
-		super(storage, validAgents);
+		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);
 	}
@@ -1390,16 +1504,16 @@ var FileContextProvider = class extends ContextProviderImpl {
 *
 * Supports:
 * - ${{ workflow.name }} — substituted with workflowName
-* - ${{ instance }} — substituted with instance
+* - ${{ 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 ?? opts.instance ?? "global";
+	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).replace("${{ instance }}", opts.instance ?? workflow);
+	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);
@@ -1410,10 +1524,9 @@ function resolveContextDir(dirTemplate, opts) {
 * 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
 */
-function getDefaultContextDir(workflow, tag, instanceOrWorkflowName) {
-	const wf = workflow ?? instanceOrWorkflowName ?? "global";
+function getDefaultContextDir(workflow, tag) {
+	const wf = workflow ?? "global";
 	const t = tag ?? "main";
 	return resolveContextDir(CONTEXT_DEFAULTS.dir, {
 		workflow: wf,
@@ -1569,9 +1682,9 @@ async function runWithHttp(options) {
 }
 
 //#endregion
-//#region src/workflow/controller/types.ts
-/** Default controller configuration values */
-const CONTROLLER_DEFAULTS = {
+//#region src/workflow/loop/types.ts
+/** Default loop configuration values */
+const LOOP_DEFAULTS = {
 	pollInterval: 5e3,
 	retry: {
 		maxAttempts: 3,
@@ -1583,7 +1696,7 @@ const CONTROLLER_DEFAULTS = {
 };
 
 //#endregion
-//#region src/workflow/controller/prompt.ts
+//#region src/workflow/loop/prompt.ts
 /**
 * Format inbox messages for display
 */
@@ -1669,7 +1782,18 @@ function buildAgentPrompt(ctx) {
 }
 
 //#endregion
-//#region src/workflow/controller/mcp-config.ts
+//#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.
 *
@@ -1683,6 +1807,62 @@ function generateWorkflowMCPConfig(mcpUrl, agentName) {
 		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
@@ -1779,14 +1959,14 @@ function msUntilNextCron(expr, from = /* @__PURE__ */ new Date()) {
 }
 
 //#endregion
-//#region src/workflow/controller/mock-runner.ts
+//#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 controller layer (not backends) because it does orchestration:
+* 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.
 */
@@ -1804,9 +1984,9 @@ async function createMCPToolBridge$1(mcpUrl, agentName) {
 	const aiTools = {};
 	for (const mcpTool of mcpTools) {
 		const toolName = mcpTool.name;
-		aiTools[toolName] = tool({
+		aiTools[toolName] = createTool({
 			description: mcpTool.description || toolName,
-			inputSchema: jsonSchema(mcpTool.inputSchema),
+			schema: mcpTool.inputSchema,
 			execute: async (args) => {
 				return (await client.callTool({
 					name: toolName,
@@ -1823,7 +2003,7 @@ async function createMCPToolBridge$1(mcpUrl, agentName) {
 /**
 * Run a mock agent with AI SDK and real MCP tools.
 *
-* Used by the controller when backend.type === 'mock'.
+* 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
@@ -1915,7 +2095,7 @@ async function runMockAgent(ctx, debugLog) {
 }
 
 //#endregion
-//#region src/workflow/controller/sdk-runner.ts
+//#region src/workflow/loop/sdk-runner.ts
 /**
 * SDK Agent Runner
 *
@@ -1968,9 +2148,9 @@ async function createMCPToolBridge(mcpUrl, agentName) {
 	const aiTools = {};
 	for (const mcpTool of mcpTools) {
 		const toolName = mcpTool.name;
-		aiTools[toolName] = tool({
+		aiTools[toolName] = createTool({
 			description: mcpTool.description || toolName,
-			inputSchema: jsonSchema(mcpTool.inputSchema),
+			schema: mcpTool.inputSchema,
 			execute: async (args) => {
 				return (await client.callTool({
 					name: toolName,
@@ -1985,17 +2165,18 @@ async function createMCPToolBridge(mcpUrl, agentName) {
 	};
 }
 function createBashTool() {
-	return tool({
+	return createTool({
 		description: "Execute a shell command and return stdout/stderr.",
-		inputSchema: jsonSchema({
+		schema: {
 			type: "object",
 			properties: { command: {
 				type: "string",
 				description: "The shell command to execute"
 			} },
 			required: ["command"]
-		}),
-		execute: async ({ command }) => {
+		},
+		execute: async (args) => {
+			const command = args.command;
 			try {
 				return execSync(command, {
 					encoding: "utf-8",
@@ -2010,7 +2191,7 @@ function createBashTool() {
 /**
 * Run an SDK agent with real model + MCP tools + bash.
 *
-* Used by the controller when backend.type === 'default'.
+* 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
@@ -2074,30 +2255,30 @@ async function runSdkAgent(ctx, debugLog) {
 }
 
 //#endregion
-//#region src/workflow/controller/controller.ts
-/** Check if controller should continue running */
+//#region src/workflow/loop/loop.ts
+/** Check if loop should continue running */
 function shouldContinue(state) {
 	return state !== "stopped";
 }
 /**
-* Create an agent controller
+* Create an agent loop
 *
-* The controller:
+* 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 createAgentController(config) {
+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 ?? CONTROLLER_DEFAULTS.pollInterval;
+	const pollInterval = config.pollInterval ?? LOOP_DEFAULTS.pollInterval;
 	const retryConfig = {
-		maxAttempts: config.retry?.maxAttempts ?? CONTROLLER_DEFAULTS.retry.maxAttempts,
-		backoffMs: config.retry?.backoffMs ?? CONTROLLER_DEFAULTS.retry.backoffMs,
-		backoffMultiplier: config.retry?.backoffMultiplier ?? CONTROLLER_DEFAULTS.retry.backoffMultiplier
+		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;
@@ -2125,7 +2306,7 @@ function createAgentController(config) {
 		});
 	}
 	/**
-	* Main controller loop
+	* Main poll loop
 	*/
 	async function runLoop() {
 		while (shouldContinue(state)) {
@@ -2175,7 +2356,7 @@ function createAgentController(config) {
 					agent,
 					inbox,
 					recentChannel: await contextProvider.readChannel({
-						limit: CONTROLLER_DEFAULTS.recentChannelLimit,
+						limit: LOOP_DEFAULTS.recentChannelLimit,
 						agent: name
 					}),
 					documentContent: await contextProvider.readDocument(),
@@ -2219,7 +2400,7 @@ function createAgentController(config) {
 			return state;
 		},
 		async start() {
-			if (state !== "stopped") throw new Error(`Controller ${name} is already running`);
+			if (state !== "stopped") throw new Error(`Loop ${name} is already running`);
 			state = "idle";
 			lastActivityTime = Date.now();
 			await contextProvider.setAgentStatus(name, { state: "idle" });
@@ -2281,7 +2462,7 @@ function createAgentController(config) {
 					agent,
 					inbox,
 					recentChannel: await contextProvider.readChannel({
-						limit: CONTROLLER_DEFAULTS.recentChannelLimit,
+						limit: LOOP_DEFAULTS.recentChannelLimit,
 						agent: name
 					}),
 					documentContent: await contextProvider.readDocument(),
@@ -2312,7 +2493,7 @@ function createAgentController(config) {
 /**
 * Run an agent: build prompt, configure workspace, call backend.send()
 *
-* This is the single orchestration function that the controller calls.
+* 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,
@@ -2324,10 +2505,8 @@ async function runAgent(backend, ctx, log, infoLog) {
 	if (backend.type === "default") return runSdkAgent(ctx, (msg) => log(msg));
 	const startTime = Date.now();
 	try {
-		if (backend.setWorkspace) {
-			const mcpConfig = generateWorkflowMCPConfig(ctx.mcpUrl, ctx.name);
-			backend.setWorkspace(ctx.workspaceDir, mcpConfig);
-		}
+		const 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 });
@@ -2353,15 +2532,15 @@ function sleep(ms) {
 /**
 * Check if workflow is complete (all agents idle, no pending work)
 */
-async function checkWorkflowIdle(controllers, provider, debounceMs = CONTROLLER_DEFAULTS.idleDebounceMs) {
-	if (![...controllers.values()].every((c) => c.state === "idle")) return false;
-	for (const [name] of controllers) if ((await provider.getInbox(name)).length > 0) return false;
+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 [...controllers.values()].every((c) => c.state === "idle");
+	return [...loops.values()].every((c) => c.state === "idle");
 }
 
 //#endregion
-//#region src/workflow/controller/backend.ts
+//#region src/workflow/loop/backend.ts
 /**
 * Get backend by explicit backend type
 *
@@ -2373,6 +2552,7 @@ function getBackendByType(backendType, options) {
 	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,
@@ -2392,21 +2572,18 @@ function getBackendForModel(model, options) {
 		model
 	});
 	const { provider } = parseModel(model);
-	switch (provider) {
-		case "anthropic": return getBackendByType("default", {
-			...options,
-			model
-		});
-		case "claude": return getBackendByType("claude", {
-			...options,
-			model
-		});
-		case "codex": return getBackendByType("codex", {
-			...options,
-			model
-		});
-		default: throw new Error(`Unknown provider: ${provider}. Specify backend explicitly.`);
-	}
+	if (provider === "claude") return getBackendByType("claude", {
+		...options,
+		model
+	});
+	if (provider === "codex") return getBackendByType("codex", {
+		...options,
+		model
+	});
+	return getBackendByType("default", {
+		...options,
+		model
+	});
 }
 
 //#endregion
@@ -2483,19 +2660,19 @@ function formatArg(arg) {
 * These functions are the building blocks that both runner.ts (CLI direct)
 * and daemon.ts (service) use to create workflow infrastructure.
 *
-* Extracted from the monolithic runWorkflowWithControllers() so that
+* 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. createWiredController() — backend + workspace dir + controller (per agent)
-*   3. Caller manages lifecycle  — start/stop controllers, send kickoff, shutdown
+*   2. createWiredLoop()       — backend + workspace dir + loop (per agent)
+*   3. Caller manages lifecycle  — start/stop loops, send kickoff, shutdown
 */
 /**
 * Create a minimal workflow runtime.
 *
 * Sets up the shared infrastructure (context + MCP + event log) without
-* creating controllers or backends. The daemon can use this to create
+* 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
@@ -2559,47 +2736,64 @@ async function createMinimalRuntime(config) {
 	};
 }
 /**
-* Create a fully-wired agent controller.
+* Create a fully-wired agent loop.
 *
 * This handles the full setup:
 * 1. Create backend from agent definition (or use custom factory)
 * 2. Create isolated workspace directory
 * 3. Configure stream callbacks for structured event logging
-* 4. Create the AgentController with all wiring
+* 4. Create the AgentLoop with all wiring
 *
-* Extracted from runWorkflowWithControllers() so both runner.ts and
-* daemon.ts can create controllers with the same quality.
+* Extracted from runWorkflowWithLoops() so both runner.ts and
+* daemon.ts can create loops with the same quality.
 */
-function createWiredController(config) {
+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: agent.model,
-		provider: agent.provider,
+		model: effectiveModel,
+		provider: effectiveProvider,
 		debugLog: (msg) => logger.debug(msg),
 		streamCallbacks,
-		timeout: agent.timeout
+		timeout: agent.timeout,
+		workspace: workspaceDir
 	});
-	else if (agent.model) backend = getBackendForModel(agent.model, {
-		provider: agent.provider,
+	else if (effectiveModel) backend = getBackendForModel(effectiveModel, {
+		provider: effectiveProvider,
 		debugLog: (msg) => logger.debug(msg),
-		streamCallbacks
+		streamCallbacks,
+		workspace: workspaceDir
 	});
 	else throw new Error(`Agent "${name}" requires either a backend or model field`);
-	const workspaceDir = join(runtime.contextDir, "workspaces", name);
-	if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
 	return {
-		controller: createAgentController({
+		loop: createAgentLoop({
 			name,
-			agent,
+			agent: effectiveModel !== agent.model || effectiveProvider !== agent.provider ? {
+				...agent,
+				model: effectiveModel,
+				provider: effectiveProvider
+			} : agent,
 			contextProvider: runtime.contextProvider,
 			eventLog: runtime.eventLog,
 			mcpUrl: runtime.mcpUrl,
@@ -2621,14 +2815,14 @@ function createWiredController(config) {
 /**
 * Daemon — Centralized agent coordinator.
 *
-* Architecture: Interface → Daemon → Controller (three layers)
+* Architecture: Interface → Daemon → Loop (three layers)
 *   Interface: CLI/REST/MCP clients talk to daemon via HTTP
-*   Daemon:    This module — owns lifecycle, creates workflows + controllers
-*   Controller: AgentController + Backend — executes agent reasoning
+*   Daemon:    This module — owns lifecycle, creates workflows + loops
+*   Loop:      AgentLoop + Backend — executes agent reasoning
 *
 * Data ownership:
 *   Registry (configs)    — what agents exist and their configuration
-*   Workflows (workflows) — running workflow instances with controllers + context
+*   Workflows (workflows) — running workflow instances with loops + context
 *
 * Key principle: every agent lives in a workflow. Standalone agents created via
 * POST /agents get a 1-agent workflow (created lazily on first /run or /serve).
@@ -2684,28 +2878,28 @@ function configToResolvedAgent(cfg) {
 	};
 }
 /**
-* Find an agent's controller across all workflows.
-* Returns the controller if the agent exists in any workflow.
+* Find an agent's loop across all workflows.
+* Returns the loop if the agent exists in any workflow.
 */
-function findController(s, agentName) {
+function findLoop(s, agentName) {
 	for (const wf of s.workflows.values()) {
-		const ctrl = wf.controllers.get(agentName);
-		if (ctrl) return {
-			controller: ctrl,
+		const l = wf.loops.get(agentName);
+		if (l) return {
+			loop: l,
 			workflow: wf
 		};
 	}
 	return null;
 }
 /**
-* Ensure a standalone agent has a workflow + controller.
+* 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 controller to execute).
+* POST /run or /serve (needs a loop to execute).
 */
-async function ensureAgentController(s, agentName) {
-	const existing = findController(s, agentName);
+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}`);
@@ -2716,9 +2910,9 @@ async function ensureAgentController(s, agentName) {
 		tag: cfg.tag,
 		agentNames: [agentName]
 	});
-	let controller;
+	let loop;
 	try {
-		({controller} = createWiredController({
+		({loop} = createWiredLoop({
 			name: agentName,
 			agent: agentDef,
 			runtime
@@ -2732,11 +2926,11 @@ async function ensureAgentController(s, agentName) {
 		tag: cfg.tag,
 		key: wfKey,
 		agents: [agentName],
-		controllers: new Map([[agentName, controller]]),
+		loops: new Map([[agentName, loop]]),
 		contextProvider: runtime.contextProvider,
 		shutdown: async () => {
 			try {
-				await controller.stop();
+				await loop.stop();
 			} finally {
 				await runtime.shutdown();
 			}
@@ -2745,15 +2939,21 @@ async function ensureAgentController(s, agentName) {
 	};
 	s.workflows.set(wfKey, handle);
 	return {
-		controller,
+		loop,
 		workflow: handle
 	};
 }
-function createDaemonApp(optionsOrGetState) {
-	const { getState, token } = typeof optionsOrGetState === "function" ? {
-		getState: optionsOrGetState,
-		token: void 0
-	} : optionsOrGetState;
+/**
+* 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);
@@ -2790,7 +2990,7 @@ function createDaemonApp(optionsOrGetState) {
 		const s = getState();
 		if (!s) return c.json({ error: "Not ready" }, 503);
 		const standaloneAgents = [...s.configs.values()].map((cfg) => {
-			const ctrl = findController(s, cfg.name);
+			const found = findLoop(s, cfg.name);
 			return {
 				name: cfg.name,
 				model: cfg.model,
@@ -2799,11 +2999,11 @@ function createDaemonApp(optionsOrGetState) {
 				tag: cfg.tag,
 				createdAt: cfg.createdAt,
 				source: "standalone",
-				state: ctrl?.controller.state
+				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: "",
@@ -2812,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] });
@@ -2884,20 +3084,20 @@ 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);
-		let controller;
-		const controllerResult = findController(s, agentName);
-		if (controllerResult) controller = controllerResult.controller;
+		let loop;
+		const loopResult = findLoop(s, agentName);
+		if (loopResult) loop = loopResult.loop;
 		else if (s.configs.has(agentName)) try {
-			controller = (await ensureAgentController(s, agentName)).controller;
+			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 (!controller) return c.json({ error: `Agent not found: ${agentName}` }, 404);
-		const ctrl = controller;
+		if (!loop) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		const agentLoop = loop;
 		return streamSSE(c, async (stream) => {
 			try {
-				const result = await ctrl.sendDirect(message);
+				const result = await agentLoop.sendDirect(message);
 				if (result.success) {
 					if (result.content) await stream.writeSSE({
 						event: "chunk",
@@ -2930,18 +3130,18 @@ 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);
-		let controller;
-		const controllerResult = findController(s, agentName);
-		if (controllerResult) controller = controllerResult.controller;
+		let loop;
+		const loopResult = findLoop(s, agentName);
+		if (loopResult) loop = loopResult.loop;
 		else if (s.configs.has(agentName)) try {
-			controller = (await ensureAgentController(s, agentName)).controller;
+			loop = (await ensureAgentLoop(s, agentName)).loop;
 		} catch (error) {
 			const msg = error instanceof Error ? error.message : String(error);
 			return c.json({ error: msg }, 500);
 		}
-		if (!controller) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		if (!loop) return c.json({ error: `Agent not found: ${agentName}` }, 404);
 		try {
-			const result = await controller.sendDirect(message);
+			const result = await loop.sendDirect(message);
 			if (!result.success) return c.json({ error: result.error }, 500);
 			return c.json({
 				content: result.content ?? "",
@@ -2974,7 +3174,7 @@ function createDaemonApp(optionsOrGetState) {
 			const agentCfg = s.configs.get(agentName);
 			const workflow = agentCfg?.workflow ?? "global";
 			const tag = agentCfg?.tag ?? "main";
-			const existingWf = findController(s, agentName)?.workflow ?? s.workflows.get(`${workflow}:${tag}`);
+			const existingWf = findLoop(s, agentName)?.workflow ?? s.workflows.get(`${workflow}:${tag}`);
 			const workflowAgents = getWorkflowAgentNames(workflow, tag);
 			const allNames = [...new Set([
 				...workflowAgents,
@@ -3015,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-DV86expc.mjs");
-			const result = await runWorkflowWithControllers({
+			const { runWorkflowWithLoops } = await import("../runner-DB-b57iZ.mjs");
+			const result = await runWorkflowWithLoops({
 				workflow,
 				workflowName,
 				tag,
@@ -3030,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);
@@ -3038,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,
@@ -3061,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,
@@ -3654,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-DogkVjOs.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-DogkVjOs.mjs");
+			if (loops) {
+				const { shutdownLoops } = await import("../workflow-DQ6Eju4n.mjs");
 				const { createSilentLogger } = await Promise.resolve().then(() => logger_exports);
-				await shutdownControllers(controllers, createSilentLogger());
+				await shutdownLoops(loops, createSilentLogger());
 			}
 			process.exit(130);
 		};
@@ -3683,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) {
@@ -3711,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,
@@ -3735,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-DogkVjOs.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);
@@ -3791,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
@@ -3918,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-Cv0oM9Ru.mjs");
+		const { listBackends } = await import("../backends-BYWmuyF9.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -3951,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-CzqQeThq.mjs");
+		const { createFileContextProvider } = await import("../context-CdcZpO-0.mjs");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
@@ -3969,7 +4217,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CzqQeThq.mjs");
+		const { createFileContextProvider } = await import("../context-CdcZpO-0.mjs");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
@@ -3987,7 +4235,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-CzqQeThq.mjs");
+		const { createFileContextProvider } = await import("../context-CdcZpO-0.mjs");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
@@ -4001,18 +4249,25 @@ async function resolveDir(targetInput) {
 
 //#endregion
 //#region package.json
-var version = "0.14.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);
@@ -4024,4 +4279,4 @@ registerDocCommands(program);
 program.parse();
 
 //#endregion
-export { extractMentions as A, EventLog as B, CONTEXT_DEFAULTS as C, RESOURCE_SCHEME as D, RESOURCE_PREFIX as E, formatProposalList as F, createLogTool as I, formatInbox$1 as L, shouldUseResource as M, createContextMCPServer as N, calculatePriority as O, formatProposal as P, formatToolParams as R, ContextProviderImpl as S, MESSAGE_LENGTH_THRESHOLD as T, createFileContextProvider as _, getBackendByType as a, FileStorage as b, createAgentController as c, generateWorkflowMCPConfig as d, buildAgentPrompt as f, FileContextProvider as g, runWithHttp as h, createSilentLogger as i, generateResourceId as j, createResourceRef as k, runSdkAgent as l, CONTROLLER_DEFAULTS as m, createWiredController as n, getBackendForModel as o, formatInbox as p, createChannelLogger as r, checkWorkflowIdle as s, createMinimalRuntime as t, runMockAgent as u, getDefaultContextDir as v, MENTION_PATTERN as w, MemoryStorage as x, resolveContextDir as y, getAgentId as z };
+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 };