agent-worker 0.4.0 → 0.6.0

package/dist/{backends-DenGdkrj.mjs → backends-BJyk6zvs.mjs}

@@ -1,5 +1,5 @@
 import { gateway, generateText } from "ai";
-import { ExecaError, execa } from "execa";
+import { execa } from "execa";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { stringify } from "yaml";
@@ -297,6 +297,335 @@ function parseModel(model) {
 	};
 }
 
+//#endregion
+//#region src/backends/idle-timeout.ts
+/**
+* Idle timeout for CLI subprocess execution
+*
+* Unlike a hard timeout (kill after N ms total), an idle timeout only fires
+* when the process produces no stdout/stderr output for the configured duration.
+* This allows long-running agent tasks to continue as long as they're actively
+* producing output (tool calls, analysis, etc.).
+*/
+/**
+* Execute a command with idle timeout.
+*
+* The timeout resets every time the process writes to stdout or stderr.
+* If the process goes silent for longer than `timeout` ms, it's killed.
+*/
+/** Minimum idle timeout to prevent accidental instant kills */
+const MIN_TIMEOUT_MS = 1e3;
+async function execWithIdleTimeout(options) {
+	const { command, args, cwd, onStdout } = options;
+	const timeout = Math.max(options.timeout, MIN_TIMEOUT_MS);
+	let idleTimedOut = false;
+	let timer;
+	let stdout = "";
+	let stderr = "";
+	const subprocess = execa(command, args, {
+		cwd,
+		stdin: "ignore",
+		buffer: false
+	});
+	const resetTimer = () => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			idleTimedOut = true;
+			subprocess.kill();
+		}, timeout);
+	};
+	subprocess.stdout?.on("data", (chunk) => {
+		const text = chunk.toString();
+		stdout += text;
+		if (onStdout) onStdout(text);
+		resetTimer();
+	});
+	subprocess.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+		resetTimer();
+	});
+	resetTimer();
+	try {
+		await subprocess;
+		clearTimeout(timer);
+		return {
+			stdout: stdout.trimEnd(),
+			stderr: stderr.trimEnd()
+		};
+	} catch (error) {
+		clearTimeout(timer);
+		if (idleTimedOut) throw new IdleTimeoutError(timeout, stdout, stderr);
+		throw error;
+	}
+}
+/**
+* Execute a command with idle timeout and return abort controller
+* This version returns both the promise and an abort function for external control
+*/
+function execWithIdleTimeoutAbortable(options) {
+	const { command, args, cwd, onStdout } = options;
+	const timeout = Math.max(options.timeout, MIN_TIMEOUT_MS);
+	let idleTimedOut = false;
+	let timer;
+	let stdout = "";
+	let stderr = "";
+	let isAborted = false;
+	const subprocess = execa(command, args, {
+		cwd,
+		stdin: "ignore",
+		buffer: false
+	});
+	const resetTimer = () => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			idleTimedOut = true;
+			subprocess.kill();
+		}, timeout);
+	};
+	subprocess.stdout?.on("data", (chunk) => {
+		const text = chunk.toString();
+		stdout += text;
+		if (onStdout) onStdout(text);
+		resetTimer();
+	});
+	subprocess.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+		resetTimer();
+	});
+	resetTimer();
+	const abort = () => {
+		if (!isAborted) {
+			isAborted = true;
+			clearTimeout(timer);
+			subprocess.kill("SIGTERM");
+			setTimeout(() => {
+				if (!subprocess.killed) subprocess.kill("SIGKILL");
+			}, 1e3);
+		}
+	};
+	return {
+		promise: (async () => {
+			try {
+				await subprocess;
+				clearTimeout(timer);
+				return {
+					stdout: stdout.trimEnd(),
+					stderr: stderr.trimEnd()
+				};
+			} catch (error) {
+				clearTimeout(timer);
+				if (isAborted) throw new Error("Process aborted by user");
+				if (idleTimedOut) throw new IdleTimeoutError(timeout, stdout, stderr);
+				throw error;
+			}
+		})(),
+		abort
+	};
+}
+/**
+* Error thrown when a process is killed due to idle timeout
+*/
+var IdleTimeoutError = class extends Error {
+	timeout;
+	stdout;
+	stderr;
+	constructor(timeout, stdout, stderr) {
+		super(`Process idle timed out after ${timeout}ms of inactivity`);
+		this.name = "IdleTimeoutError";
+		this.timeout = timeout;
+		this.stdout = stdout;
+		this.stderr = stderr;
+	}
+};
+
+//#endregion
+//#region src/backends/stream-json.ts
+/**
+* Format a standard StreamEvent into a human-readable progress message.
+* Returns null if the event doesn't need display.
+*
+* This function only knows about StreamEvent — it never touches
+* backend-specific raw JSON. Format-specific conversion is handled
+* by the EventAdapter.
+*/
+function formatEvent(event, backendName) {
+	switch (event.kind) {
+		case "init": {
+			const details = [];
+			if (event.model) details.push(`model: ${event.model}`);
+			if (event.sessionId) details.push(`session: ${event.sessionId}`);
+			return `${backendName} initialized${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
+		}
+		case "tool_call": {
+			const truncated = event.args.length > 100 ? event.args.slice(0, 100) + "..." : event.args;
+			return `CALL ${event.name}(${truncated})`;
+		}
+		case "completed": {
+			const parts = [backendName, "completed"];
+			const details = [];
+			if (event.durationMs) details.push(`${(event.durationMs / 1e3).toFixed(1)}s`);
+			if (event.costUsd) details.push(`$${event.costUsd.toFixed(4)}`);
+			if (event.usage) details.push(`${event.usage.input} in, ${event.usage.output} out`);
+			if (details.length > 0) parts.push(`(${details.join(", ")})`);
+			return parts.join(" ");
+		}
+	}
+}
+/**
+* Adapter for Claude/Cursor stream-json format.
+*
+* Events:
+*   { type: "system", subtype: "init", model: "..." }
+*   { type: "assistant", message: { content: [{ type: "tool_use", name, input }] } }
+*   { type: "result", duration_ms: N, total_cost_usd: N }
+*/
+const claudeAdapter = (raw) => {
+	const type = raw.type;
+	if (type === "system" && raw.subtype === "init") return {
+		kind: "init",
+		model: raw.model || void 0,
+		sessionId: raw.session_id
+	};
+	if (type === "assistant") {
+		const message = raw.message;
+		if (!message?.content) return null;
+		const toolCalls = message.content.filter((c) => c.type === "tool_use");
+		if (toolCalls.length > 0) {
+			const tc = toolCalls[0];
+			return {
+				kind: "tool_call",
+				name: tc.name || "unknown",
+				args: formatToolInput(tc.input)
+			};
+		}
+		return null;
+	}
+	if (type === "result") return {
+		kind: "completed",
+		durationMs: raw.duration_ms,
+		costUsd: raw.total_cost_usd
+	};
+	return null;
+};
+/**
+* Extract final result from Claude/Cursor stream-json output.
+*
+* Priority:
+* 1. type=result with result field
+* 2. Last assistant message with text content
+* 3. Raw stdout fallback
+*/
+function extractClaudeResult(stdout) {
+	const lines = stdout.trim().split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) try {
+		const event = JSON.parse(lines[i]);
+		if (event.type === "result" && event.result) return { content: event.result };
+	} catch {}
+	for (let i = lines.length - 1; i >= 0; i--) try {
+		const event = JSON.parse(lines[i]);
+		if (event.type === "assistant" && event.message?.content) {
+			const textParts = event.message.content.filter((c) => c.type === "text").map((c) => c.text);
+			if (textParts.length > 0) return { content: textParts.join("\n") };
+		}
+	} catch {}
+	return { content: stdout.trim() };
+}
+/**
+* Adapter for Codex --json format.
+*
+* Events:
+*   { type: "thread.started", thread_id: "..." }
+*   { type: "item.completed", item: { type: "function_call", name, arguments } }
+*   { type: "item.completed", item: { type: "agent_message", text } }  → skipped (result only)
+*   { type: "turn.completed", usage: { input_tokens, output_tokens } }
+*/
+const codexAdapter = (raw) => {
+	const type = raw.type;
+	if (type === "thread.started") {
+		const threadId = raw.thread_id;
+		return {
+			kind: "init",
+			sessionId: threadId ? `${threadId.slice(0, 8)}...` : void 0
+		};
+	}
+	if (type === "item.completed") {
+		const item = raw.item;
+		if (!item) return null;
+		if (item.type === "function_call") return {
+			kind: "tool_call",
+			name: item.name || "unknown",
+			args: item.arguments ?? ""
+		};
+		return null;
+	}
+	if (type === "turn.completed") {
+		const usage = raw.usage;
+		return {
+			kind: "completed",
+			usage: usage ? {
+				input: usage.input_tokens ?? 0,
+				output: usage.output_tokens ?? 0
+			} : void 0
+		};
+	}
+	return null;
+};
+/**
+* Extract final result from Codex --json output.
+*
+* Priority:
+* 1. Last item.completed with item.type=agent_message
+* 2. Raw stdout fallback
+*/
+function extractCodexResult(stdout) {
+	const lines = stdout.trim().split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) try {
+		const event = JSON.parse(lines[i]);
+		if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item?.text) return { content: event.item.text };
+	} catch {}
+	return { content: stdout.trim() };
+}
+/**
+* Create a line-buffered stream parser.
+*
+* Accumulates stdout chunks, parses each line through the given adapter,
+* and emits formatted progress messages via debugLog.
+*
+* @param debugLog - Callback for progress messages
+* @param backendName - Display name (e.g., "Cursor", "Claude", "Codex")
+* @param adapter - Format-specific adapter to convert raw JSON → StreamEvent
+*/
+function createStreamParser(debugLog, backendName, adapter) {
+	let lineBuf = "";
+	return (chunk) => {
+		lineBuf += chunk;
+		const lines = lineBuf.split("\n");
+		lineBuf = lines.pop() ?? "";
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				const event = adapter(JSON.parse(line));
+				if (event) {
+					const progress = formatEvent(event, backendName);
+					if (progress) debugLog(progress);
+				}
+			} catch {}
+		}
+	};
+}
+/**
+* Format tool call input for display (truncated JSON string)
+*/
+function formatToolInput(input) {
+	if (!input || typeof input !== "object") return "";
+	try {
+		const str = JSON.stringify(input);
+		return str.length > 100 ? str.slice(0, 100) + "..." : str;
+	} catch {
+		return "";
+	}
+}
+
 //#endregion
 //#region src/backends/claude-code.ts
 /**
@@ -312,6 +641,7 @@ function parseModel(model) {
 var ClaudeCodeBackend = class {
 	type = "claude";
 	options;
+	currentAbort;
 	constructor(options = {}) {
 		this.options = {
 			timeout: 3e5,
@@ -332,13 +662,22 @@ var ClaudeCodeBackend = class {
 	async send(message, options) {
 		const args = this.buildArgs(message, options);
 		const cwd = this.options.workspace || this.options.cwd;
+		const debugLog = this.options.debugLog;
+		const outputFormat = this.options.outputFormat ?? "stream-json";
+		const timeout = this.options.timeout ?? 3e5;
 		try {
-			const { stdout } = await execa("claude", args, {
+			const { promise, abort } = execWithIdleTimeoutAbortable({
+				command: "claude",
+				args,
 				cwd,
-				stdin: "ignore",
-				timeout: this.options.timeout
+				timeout,
+				onStdout: outputFormat === "stream-json" && debugLog ? createStreamParser(debugLog, "Claude", claudeAdapter) : void 0
 			});
-			if (this.options.outputFormat === "json") try {
+			this.currentAbort = abort;
+			const { stdout } = await promise;
+			this.currentAbort = void 0;
+			if (outputFormat === "stream-json") return extractClaudeResult(stdout);
+			if (outputFormat === "json") try {
 				const parsed = JSON.parse(stdout);
 				return {
 					content: parsed.content || parsed.result || stdout,
@@ -350,7 +689,12 @@ var ClaudeCodeBackend = class {
 			}
 			return { content: stdout.trim() };
 		} catch (error) {
-			if (error instanceof ExecaError) throw new Error(`claude failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			this.currentAbort = void 0;
+			if (error instanceof IdleTimeoutError) throw new Error(`claude timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`claude failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
+			}
 			throw error;
 		}
 	}
@@ -383,7 +727,9 @@ var ClaudeCodeBackend = class {
 			args.push("--append-system-prompt", system);
 		}
 		if (this.options.allowedTools?.length) args.push("--allowed-tools", this.options.allowedTools.join(","));
-		if (this.options.outputFormat) args.push("--output-format", this.options.outputFormat);
+		const outputFormat = this.options.outputFormat ?? "stream-json";
+		args.push("--output-format", outputFormat);
+		if (outputFormat === "stream-json") args.push("--verbose");
 		if (this.options.continue) args.push("--continue");
 		if (this.options.resume) args.push("--resume", this.options.resume);
 		if (this.options.mcpConfigPath) args.push("--mcp-config", this.options.mcpConfigPath);
@@ -395,13 +741,22 @@ var ClaudeCodeBackend = class {
 	setMcpConfigPath(path) {
 		this.options.mcpConfigPath = path;
 	}
+	/**
+	* Abort any running claude process
+	*/
+	abort() {
+		if (this.currentAbort) {
+			this.currentAbort();
+			this.currentAbort = void 0;
+		}
+	}
 };
 
 //#endregion
 //#region src/backends/codex.ts
 /**
 * OpenAI Codex CLI backend
-* Uses `codex exec` for non-interactive mode
+* Uses `codex exec` for non-interactive mode with JSON event output
 *
 * MCP Configuration:
 * Codex uses project-level MCP config. Use setWorkspace() to set up
@@ -432,28 +787,23 @@ var CodexBackend = class {
 	async send(message, _options) {
 		const args = this.buildArgs(message);
 		const cwd = this.options.workspace || this.options.cwd;
+		const debugLog = this.options.debugLog;
+		const timeout = this.options.timeout ?? 3e5;
 		try {
-			const { stdout } = await execa("codex", args, {
+			const { stdout } = await execWithIdleTimeout({
+				command: "codex",
+				args,
 				cwd,
-				stdin: "ignore",
-				timeout: this.options.timeout
+				timeout,
+				onStdout: debugLog ? createStreamParser(debugLog, "Codex", codexAdapter) : void 0
 			});
-			if (this.options.json) try {
-				const lines = stdout.trim().split("\n");
-				const lastLine = lines[lines.length - 1];
-				if (!lastLine) return { content: stdout.trim() };
-				const lastEvent = JSON.parse(lastLine);
-				return {
-					content: lastEvent.message || lastEvent.content || stdout,
-					toolCalls: lastEvent.toolCalls,
-					usage: lastEvent.usage
-				};
-			} catch {
-				return { content: stdout.trim() };
-			}
-			return { content: stdout.trim() };
+			return extractCodexResult(stdout);
 		} catch (error) {
-			if (error instanceof ExecaError) throw new Error(`codex failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			if (error instanceof IdleTimeoutError) throw new Error(`codex timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`codex failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
+			}
 			throw error;
 		}
 	}
@@ -477,13 +827,12 @@ var CodexBackend = class {
 	buildArgs(message) {
 		const args = [
 			"exec",
-			"--dangerously-bypass-approvals-and-sandbox",
+			"--full-auto",
+			"--json",
+			"--skip-git-repo-check",
 			message
 		];
 		if (this.options.model) args.push("--model", this.options.model);
-		if (this.options.json) args.push("--json");
-		if (this.options.skipGitRepoCheck) args.push("--skip-git-repo-check");
-		if (this.options.approvalMode) args.push("--approval-mode", this.options.approvalMode);
 		if (this.options.resume) args.push("--resume", this.options.resume);
 		return args;
 	}
@@ -493,7 +842,8 @@ var CodexBackend = class {
 //#region src/backends/cursor.ts
 /**
 * Cursor CLI backend
-* Uses `cursor-agent -p` for non-interactive mode
+* Uses `cursor agent -p` (preferred) or `cursor-agent -p` (fallback)
+* for non-interactive mode with stream-json output
 *
 * MCP Configuration:
 * Cursor uses project-level MCP config via .cursor/mcp.json in the workspace.
@@ -504,9 +854,11 @@ var CodexBackend = class {
 var CursorBackend = class {
 	type = "cursor";
 	options;
+	/** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
+	resolvedCommand = null;
 	constructor(options = {}) {
 		this.options = {
-			timeout: 12e4,
+			timeout: 3e5,
 			...options
 		};
 	}
@@ -521,32 +873,30 @@ var CursorBackend = class {
 		writeFileSync(join(cursorDir, "mcp.json"), JSON.stringify(mcpConfig, null, 2));
 	}
 	async send(message, _options) {
-		const { command, args } = this.buildCommand(message);
+		const { command, args } = await this.buildCommand(message);
 		const cwd = this.options.workspace || this.options.cwd;
+		const debugLog = this.options.debugLog;
+		const timeout = this.options.timeout ?? 3e5;
 		try {
-			const { stdout } = await execa(command, args, {
+			const { stdout } = await execWithIdleTimeout({
+				command,
+				args,
 				cwd,
-				stdin: "ignore",
-				timeout: this.options.timeout
+				timeout,
+				onStdout: debugLog ? createStreamParser(debugLog, "Cursor", claudeAdapter) : void 0
 			});
-			return { content: stdout.trim() };
+			return extractClaudeResult(stdout);
 		} catch (error) {
-			if (error instanceof ExecaError) {
-				if (error.timedOut) throw new Error(`cursor-agent timed out after ${this.options.timeout}ms`);
-				throw new Error(`cursor-agent failed (exit ${error.exitCode}): ${error.stderr || error.shortMessage}`);
+			if (error instanceof IdleTimeoutError) throw new Error(`cursor agent timed out after ${timeout}ms of inactivity`);
+			if (error && typeof error === "object" && "exitCode" in error) {
+				const execError = error;
+				throw new Error(`cursor agent failed (exit ${execError.exitCode}): ${execError.stderr || execError.shortMessage}`);
 			}
 			throw error;
 		}
 	}
 	async isAvailable() {
-		for (const cmd of ["cursor-agent", "agent"]) try {
-			await execa(cmd, ["--version"], {
-				stdin: "ignore",
-				timeout: 2e3
-			});
-			return true;
-		} catch {}
-		return false;
+		return await this.resolveCommand() !== null;
 	}
 	getInfo() {
 		return {
@@ -554,17 +904,48 @@ var CursorBackend = class {
 			model: this.options.model
 		};
 	}
-	buildCommand(message) {
-		const args = [
+	/**
+	* Resolve which cursor command is available.
+	* Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+	* Result is cached after first resolution.
+	*/
+	async resolveCommand() {
+		if (this.resolvedCommand !== null) return this.resolvedCommand;
+		try {
+			await execa("cursor", ["agent", "--version"], {
+				stdin: "ignore",
+				timeout: 2e3
+			});
+			this.resolvedCommand = "cursor";
+			return "cursor";
+		} catch {}
+		try {
+			await execa("cursor-agent", ["--version"], {
+				stdin: "ignore",
+				timeout: 2e3
+			});
+			this.resolvedCommand = "cursor-agent";
+			return "cursor-agent";
+		} catch {}
+		return null;
+	}
+	async buildCommand(message) {
+		const cmd = await this.resolveCommand();
+		const agentArgs = [
 			"-p",
 			"--force",
 			"--approve-mcps",
+			"--output-format=stream-json",
 			message
 		];
-		if (this.options.model) args.push("--model", this.options.model);
+		if (this.options.model) agentArgs.push("--model", this.options.model);
+		if (cmd === "cursor") return {
+			command: "cursor",
+			args: ["agent", ...agentArgs]
+		};
 		return {
 			command: "cursor-agent",
-			args
+			args: agentArgs
 		};
 	}
 };
@@ -732,4 +1113,4 @@ async function listBackends() {
 }
 
 //#endregion
-export { FRONTIER_MODELS as _, createMockBackend as a, createModelAsync as b, CodexBackend as c, CLAUDE_MODEL_MAP as d, CODEX_MODEL_MAP as f, parseModel as g, getModelForBackend as h, MockAIBackend as i, ClaudeCodeBackend as l, SDK_MODEL_ALIASES as m, createBackend as n, SdkBackend as o, CURSOR_MODEL_MAP as p, listBackends as r, CursorBackend as s, checkBackends as t, BACKEND_DEFAULT_MODELS as u, SUPPORTED_PROVIDERS as v, getDefaultModel as x, createModel as y };
+export { getModelForBackend as C, createModel as D, SUPPORTED_PROVIDERS as E, createModelAsync as O, SDK_MODEL_ALIASES as S, FRONTIER_MODELS as T, execWithIdleTimeout as _, createMockBackend as a, CODEX_MODEL_MAP as b, CodexBackend as c, codexAdapter as d, createStreamParser as f, IdleTimeoutError as g, formatEvent as h, MockAIBackend as i, getDefaultModel as k, ClaudeCodeBackend as l, extractCodexResult as m, createBackend as n, SdkBackend as o, extractClaudeResult as p, listBackends as r, CursorBackend as s, checkBackends as t, claudeAdapter as u, BACKEND_DEFAULT_MODELS as v, parseModel as w, CURSOR_MODEL_MAP as x, CLAUDE_MODEL_MAP as y };

package/dist/backends-fLwD_6G_.mjs

@@ -0,0 +1,3 @@
+import { C as getModelForBackend, S as SDK_MODEL_ALIASES, _ as execWithIdleTimeout, a as createMockBackend, b as CODEX_MODEL_MAP, c as CodexBackend, d as codexAdapter, f as createStreamParser, g as IdleTimeoutError, h as formatEvent, i as MockAIBackend, l as ClaudeCodeBackend, m as extractCodexResult, n as createBackend, o as SdkBackend, p as extractClaudeResult, r as listBackends, s as CursorBackend, t as checkBackends, u as claudeAdapter, v as BACKEND_DEFAULT_MODELS, x as CURSOR_MODEL_MAP, y as CLAUDE_MODEL_MAP } from "./backends-BJyk6zvs.mjs";
+
+export { listBackends };

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { _ as FRONTIER_MODELS, n as createBackend, x as getDefaultModel } from "../backends-DenGdkrj.mjs";
-import { a as createSkillsTool, c as createFeedbackTool, l as AgentSession, o as SkillsProvider, s as FEEDBACK_PROMPT, t as SkillImporter } from "../skills-VyC7eQyK.mjs";
+import { T as FRONTIER_MODELS, k as getDefaultModel, n as createBackend } from "../backends-BJyk6zvs.mjs";
+import { a as createSkillsTool, c as createFeedbackTool, l as AgentSession, o as SkillsProvider, s as FEEDBACK_PROMPT, t as SkillImporter } from "../skills-CuAfAkHU.mjs";
 import { jsonSchema, tool } from "ai";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
@@ -541,6 +541,8 @@ async function handleRequest(getState, req, resetIdleTimer, gracefulShutdown, re
 const RESOURCE_PREFIX = "res_";
 /** Resource URI scheme */
 const RESOURCE_SCHEME = "resource:";
+/** Message length threshold for channel messages - content longer than this should use resources or documents */
+const MESSAGE_LENGTH_THRESHOLD = 1200;
 /**
 * Generate a unique resource ID
 */
@@ -554,6 +556,12 @@ function generateResourceId() {
 function createResourceRef(id) {
 	return `${RESOURCE_SCHEME}${id}`;
 }
+/**
+* Check if content should be stored as a resource instead of inline
+*/
+function shouldUseResource(content) {
+	return content.length > MESSAGE_LENGTH_THRESHOLD;
+}
 /** Default context configuration values */
 const CONTEXT_DEFAULTS = {
 	dir: "~/.agent-worker/workflows/${{ workflow.name }}/${{ workflow.tag }}/",
@@ -679,6 +687,23 @@ var ContextProviderImpl = class {
 			cursor: entries.length
 		};
 	}
+	/**
+	* Smart send: automatically converts long messages to resources
+	*
+	* If content exceeds MESSAGE_LENGTH_THRESHOLD:
+	* 1. Creates a resource with the full content
+	* 2. Sends a short message referencing the resource
+	* 3. Logs the full content in debug channel for visibility
+	*/
+	async smartSend(from, content, options) {
+		if (!shouldUseResource(content)) return this.appendChannel(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 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];
@@ -2094,10 +2119,25 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CaRCNEh6.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-C26F4PpH.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
+		let controllers;
+		let isCleaningUp = false;
+		const cleanup = async () => {
+			if (isCleaningUp) return;
+			isCleaningUp = true;
+			console.log("\nInterrupted, cleaning up...");
+			if (controllers) {
+				const { shutdownControllers } = await import("../workflow-C26F4PpH.mjs");
+				const { createSilentLogger } = await import("../logger-L9AtbIPS.mjs");
+				await shutdownControllers(controllers, createSilentLogger());
+			}
+			process.exit(130);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
 		try {
 			const log = options.json ? console.error : console.log;
 			const result = await runWorkflowWithControllers({
@@ -2110,6 +2150,9 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 				mode: "run",
 				feedback: options.feedback
 			});
+			controllers = result.controllers;
+			process.off("SIGINT", cleanup);
+			process.off("SIGTERM", cleanup);
 			if (!result.success) {
 				console.error("Workflow failed:", result.error);
 				process.exit(1);
@@ -2132,6 +2175,8 @@ Note: Workflow name is inferred from YAML 'name' field or filename
 				for (const entry of result.feedback) console.log(`  [${entry.type}] ${entry.target}: ${entry.description}`);
 			}
 		} catch (error) {
+			process.off("SIGINT", cleanup);
+			process.off("SIGTERM", cleanup);
 			console.error("Error:", error instanceof Error ? error.message : String(error));
 			process.exit(1);
 		}
@@ -2144,7 +2189,7 @@ Examples:
 
 Note: Workflow name is inferred from YAML 'name' field or filename
     `).action(async (file, options) => {
-		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-CaRCNEh6.mjs");
+		const { parseWorkflowFile, runWorkflowWithControllers } = await import("../workflow-C26F4PpH.mjs");
 		const tag = options.tag || DEFAULT_TAG;
 		const parsedWorkflow = await parseWorkflowFile(file, { tag });
 		const workflowName = parsedWorkflow.name;
@@ -2339,7 +2384,7 @@ function registerInfoCommands(program) {
 		console.log(`\nDefault: ${defaultModel} (when no model specified)`);
 	});
 	program.command("backends").description("Check available backends (SDK, CLI tools)").action(async () => {
-		const { listBackends } = await import("../backends-D3MAlJBX.mjs");
+		const { listBackends } = await import("../backends-fLwD_6G_.mjs");
 		const backends = await listBackends();
 		console.log("Backend Status:\n");
 		for (const backend of backends) {
@@ -2369,7 +2414,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-C7nBmU5D.mjs");
+		const { createFileContextProvider } = await import("../context-DW7xrslO.mjs");
 		const content = await createFileContextProvider(dir, []).readDocument();
 		console.log(content || "(empty document)");
 	});
@@ -2387,7 +2432,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-C7nBmU5D.mjs");
+		const { createFileContextProvider } = await import("../context-DW7xrslO.mjs");
 		await createFileContextProvider(dir, []).writeDocument(content);
 		console.log("Document written");
 	});
@@ -2405,7 +2450,7 @@ Examples:
 			process.exit(1);
 		}
 		const dir = await resolveDir(targetInput);
-		const { createFileContextProvider } = await import("../context-C7nBmU5D.mjs");
+		const { createFileContextProvider } = await import("../context-DW7xrslO.mjs");
 		await createFileContextProvider(dir, []).appendDocument(content);
 		console.log("Content appended");
 	});
@@ -2485,16 +2530,23 @@ Note: Requires agent to be created with --feedback flag
 	});
 }
 
+//#endregion
+//#region package.json
+var version = "0.6.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, ...args) {
-	if (process.argv.includes("--debug") || process.argv.includes("-d")) return originalStderrWrite(typeof chunk === "string" ? chunk : chunk.toString(), ...args);
+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 program = new Command();
-program.name("agent-worker").description("CLI for creating and managing AI agents").version("0.0.1");
+program.name("agent-worker").description("CLI for creating and managing AI agents").version(version);
 registerAgentCommands(program);
 registerSendCommands(program);
 registerMockCommands(program);
@@ -2506,4 +2558,4 @@ registerDocCommands(program);
 program.parse();
 
 //#endregion
-export { FileStorage as a, CONTEXT_DEFAULTS as c, RESOURCE_SCHEME as d, calculatePriority as f, generateResourceId as h, resolveContextDir as i, MENTION_PATTERN as l, extractMentions as m, createFileContextProvider as n, MemoryStorage as o, createResourceRef as p, getDefaultContextDir as r, ContextProviderImpl as s, FileContextProvider as t, RESOURCE_PREFIX as u };
+export { shouldUseResource as _, FileStorage as a, 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 };

package/dist/context-DW7xrslO.mjs

@@ -0,0 +1,4 @@
+import { _ as shouldUseResource, a as FileStorage, c as CONTEXT_DEFAULTS, d as RESOURCE_PREFIX, f as RESOURCE_SCHEME, g as generateResourceId, h as extractMentions, i as resolveContextDir, l as MENTION_PATTERN, m as createResourceRef, n as createFileContextProvider, o as MemoryStorage, p as calculatePriority, r as getDefaultContextDir, s as ContextProviderImpl, t as FileContextProvider, u as MESSAGE_LENGTH_THRESHOLD } from "./cli/index.mjs";
+import { a as createMemoryContextProvider, i as MemoryContextProvider, n as formatProposal, r as formatProposalList, t as createContextMCPServer } from "./mcp-server-ONSDOpt5.mjs";
+
+export { createFileContextProvider };

package/dist/index.d.mts

@@ -175,6 +175,8 @@ interface Backend {
   setWorkspace?(workspaceDir: string, mcpConfig: {
     mcpServers: Record<string, unknown>;
   }): void;
+  /** Abort any running operations and cleanup resources */
+  abort?(): void;
 }
 //#endregion
 //#region src/agent/session.d.ts
@@ -467,7 +469,7 @@ interface ClaudeCodeOptions {
   cwd?: string;
   /** Workspace directory for agent isolation */
   workspace?: string;
-  /** Timeout in milliseconds */
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
   timeout?: number;
   /** MCP config file path (for workflow context) */
   mcpConfigPath?: string;
@@ -477,6 +479,7 @@ interface ClaudeCodeOptions {
 declare class ClaudeCodeBackend implements Backend {
   readonly type: "claude";
   private options;
+  private currentAbort?;
   constructor(options?: ClaudeCodeOptions);
   /**
    * Set up workspace directory with MCP config
@@ -499,25 +502,23 @@ declare class ClaudeCodeBackend implements Backend {
    * Set MCP config path (for workflow integration)
    */
   setMcpConfigPath(path: string): void;
+  /**
+   * Abort any running claude process
+   */
+  abort(): void;
 }
 //#endregion
 //#region src/backends/codex.d.ts
 interface CodexOptions {
   /** Model to use (e.g., 'gpt-5.2-codex') */
   model?: string;
-  /** Output as JSON events */
-  json?: boolean;
   /** Working directory (defaults to workspace if set) */
   cwd?: string;
   /** Workspace directory for agent isolation */
   workspace?: string;
-  /** Skip git repo check */
-  skipGitRepoCheck?: boolean;
-  /** Approval mode: 'suggest' | 'auto-edit' | 'full-auto' */
-  approvalMode?: "suggest" | "auto-edit" | "full-auto";
   /** Resume a previous session */
   resume?: string;
-  /** Timeout in milliseconds */
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
   timeout?: number;
   /** Debug log function (for workflow diagnostics) */
   debugLog?: (message: string) => void;
@@ -553,7 +554,7 @@ interface CursorOptions {
   cwd?: string;
   /** Workspace directory for agent isolation (contains .cursor/mcp.json) */
   workspace?: string;
-  /** Timeout in milliseconds */
+  /** Idle timeout in milliseconds — kills process if no output for this duration */
   timeout?: number;
   /** Debug log function (for workflow diagnostics) */
   debugLog?: (message: string) => void;
@@ -561,6 +562,8 @@ interface CursorOptions {
 declare class CursorBackend implements Backend {
   readonly type: "cursor";
   private options;
+  /** Resolved command: "cursor" (subcommand style) or "cursor-agent" (standalone) */
+  private resolvedCommand;
   constructor(options?: CursorOptions);
   /**
    * Set up workspace directory with MCP config
@@ -578,10 +581,16 @@ declare class CursorBackend implements Backend {
     version?: string;
     model?: string;
   };
-  protected buildCommand(message: string): {
+  /**
+   * Resolve which cursor command is available.
+   * Prefers `cursor agent` (subcommand), falls back to `cursor-agent` (standalone).
+   * Result is cached after first resolution.
+   */
+  private resolveCommand;
+  protected buildCommand(message: string): Promise<{
     command: string;
     args: string[];
-  };
+  }>;
 }
 //#endregion
 //#region src/backends/sdk.d.ts

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { _ as FRONTIER_MODELS, a as createMockBackend, b as createModelAsync, c as CodexBackend, i as MockAIBackend, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends, v as SUPPORTED_PROVIDERS, y as createModel } from "./backends-DenGdkrj.mjs";
-import { a as createSkillsTool, c as createFeedbackTool, i as parseImportSpec, l as AgentSession, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as FEEDBACK_PROMPT, t as SkillImporter } from "./skills-VyC7eQyK.mjs";
+import { D as createModel, E as SUPPORTED_PROVIDERS, O as createModelAsync, T as FRONTIER_MODELS, a as createMockBackend, c as CodexBackend, i as MockAIBackend, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends } from "./backends-BJyk6zvs.mjs";
+import { a as createSkillsTool, c as createFeedbackTool, i as parseImportSpec, l as AgentSession, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as FEEDBACK_PROMPT, t as SkillImporter } from "./skills-CuAfAkHU.mjs";
 import { jsonSchema, tool } from "ai";
 import { createBashTool } from "bash-tool";
 

package/dist/logger-L9AtbIPS.mjs

@@ -0,0 +1,63 @@
+//#region src/workflow/logger.ts
+/**
+* Create a silent logger (no output)
+*/
+function createSilentLogger() {
+	const noop = () => {};
+	return {
+		debug: noop,
+		info: noop,
+		warn: noop,
+		error: noop,
+		isDebug: () => false,
+		child: () => createSilentLogger()
+	};
+}
+/**
+* Create a logger that writes to the channel.
+*
+* - info/warn/error → channel entry with kind="log" (always shown to user)
+* - debug → channel entry with kind="debug" (only shown with --debug)
+*
+* The display layer handles formatting and filtering.
+*/
+function createChannelLogger(config) {
+	const { provider, from = "system" } = config;
+	const formatContent = (level, message, args) => {
+		const argsStr = args.length > 0 ? " " + args.map(formatArg).join(" ") : "";
+		if (level === "warn") return `[WARN] ${message}${argsStr}`;
+		if (level === "error") return `[ERROR] ${message}${argsStr}`;
+		return `${message}${argsStr}`;
+	};
+	const write = (level, message, args) => {
+		const content = formatContent(level, message, args);
+		const kind = level === "debug" ? "debug" : "log";
+		provider.appendChannel(from, content, { kind }).catch(() => {});
+	};
+	return {
+		debug: (message, ...args) => write("debug", message, args),
+		info: (message, ...args) => write("info", message, args),
+		warn: (message, ...args) => write("warn", message, args),
+		error: (message, ...args) => write("error", message, args),
+		isDebug: () => true,
+		child: (childPrefix) => {
+			return createChannelLogger({
+				provider,
+				from: from ? `${from}:${childPrefix}` : childPrefix
+			});
+		}
+	};
+}
+/** Format an argument for logging */
+function formatArg(arg) {
+	if (arg === null || arg === void 0) return String(arg);
+	if (typeof arg === "object") try {
+		return JSON.stringify(arg);
+	} catch {
+		return String(arg);
+	}
+	return String(arg);
+}
+
+//#endregion
+export { createChannelLogger, createSilentLogger };

package/dist/{mcp-server-DtIApaBD.mjs → mcp-server-ONSDOpt5.mjs}

@@ -169,9 +169,8 @@ function createContextMCPServer(options) {
 		version
 	});
 	const agentConnections = /* @__PURE__ */ new Map();
-	const CHANNEL_MSG_LIMIT = 2e3;
-	server.tool("channel_send", `Send a message to the shared channel. Use @agent to mention/notify. Use "to" for private DMs. Max ${CHANNEL_MSG_LIMIT} chars — for longer content, use resource_create first then reference the resource ID in your message.`, {
-		message: z.string().describe("Message content, can include @mentions like @reviewer or @coder"),
+	server.tool("channel_send", `Send a message to the shared channel. Use @agent to mention/notify. Use "to" for private DMs. Long messages (> 2000 chars) are automatically converted to resources.`, {
+		message: z.string().describe("Message content, can include @mentions like @reviewer or @coder. Long messages are auto-converted to resources."),
 		to: z.string().optional().describe("Send as DM to a specific agent (private, only you and recipient see it)")
 	}, async ({ message, to }, extra) => {
 		const from = getAgentId(extra) || "anonymous";
@@ -179,15 +178,8 @@ function createContextMCPServer(options) {
 			message,
 			to
 		});
-		if (message.length > CHANNEL_MSG_LIMIT) return {
-			isError: true,
-			content: [{
-				type: "text",
-				text: `Message too long (${message.length} chars, max ${CHANNEL_MSG_LIMIT}). Use resource_create to store the full content, then send a short message referencing the resource ID.`
-			}]
-		};
 		const sendOpts = to ? { to } : void 0;
-		const msg = await provider.appendChannel(from, message, sendOpts);
+		const msg = await provider.smartSend(from, message, sendOpts);
 		for (const target of msg.mentions) if (onMention) onMention(from, target, msg);
 		if (to && !msg.mentions.includes(to) && onMention) onMention(from, to, msg);
 		return { content: [{

package/dist/{skills-VyC7eQyK.mjs → skills-CuAfAkHU.mjs}

@@ -1,4 +1,4 @@
-import { b as createModelAsync } from "./backends-DenGdkrj.mjs";
+import { O as createModelAsync } from "./backends-BJyk6zvs.mjs";
 import { ToolLoopAgent, jsonSchema, stepCountIs, tool } from "ai";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, normalize } from "node:path";

package/dist/{workflow-CaRCNEh6.mjs → workflow-C26F4PpH.mjs}

@@ -1,6 +1,7 @@
-import { a as createMockBackend, b as createModelAsync, g as parseModel, n as createBackend } from "./backends-DenGdkrj.mjs";
+import { O as createModelAsync, a as createMockBackend, n as createBackend, w as parseModel } from "./backends-BJyk6zvs.mjs";
 import { c as CONTEXT_DEFAULTS, i as resolveContextDir, n as createFileContextProvider, t as FileContextProvider } from "./cli/index.mjs";
-import { a as createMemoryContextProvider, t as createContextMCPServer } from "./mcp-server-DtIApaBD.mjs";
+import { a as createMemoryContextProvider, t as createContextMCPServer } from "./mcp-server-ONSDOpt5.mjs";
+import { createChannelLogger, createSilentLogger } from "./logger-L9AtbIPS.mjs";
 import { generateText, jsonSchema, stepCountIs, tool } from "ai";
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
@@ -459,16 +460,6 @@ function formatInbox(inbox) {
 	}).join("\n");
 }
 /**
-* Format channel messages for display
-*/
-function formatChannel(entries) {
-	if (entries.length === 0) return "(no messages)";
-	return entries.map((e) => {
-		const dm = e.to ? ` [DM→@${e.to}]` : "";
-		return `[${e.timestamp.slice(11, 19)}] @${e.from}${dm}: ${e.content}`;
-	}).join("\n");
-}
-/**
 * Build the complete agent prompt from run context
 */
 function buildAgentPrompt(ctx) {
@@ -479,8 +470,8 @@ function buildAgentPrompt(ctx) {
 	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 (last ${ctx.recentChannel.length} messages)`);
-	sections.push(formatChannel(ctx.recentChannel));
+	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");
@@ -860,6 +851,7 @@ function shouldContinue(state) {
 */
 function createAgentController(config) {
 	const { name, agent, contextProvider, mcpUrl, workspaceDir, projectDir, backend, onRunComplete, log = () => {}, feedback } = config;
+	const infoLog = config.infoLog ?? log;
 	const errorLog = config.errorLog ?? log;
 	const pollInterval = config.pollInterval ?? CONTROLLER_DEFAULTS.pollInterval;
 	const retryConfig = {
@@ -895,7 +887,7 @@ function createAgentController(config) {
 				continue;
 			}
 			const senders = inbox.map((m) => m.entry.from);
-			log(`Inbox: ${inbox.length} message(s) from [${senders.join(", ")}]`);
+			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}`);
@@ -907,7 +899,7 @@ function createAgentController(config) {
 			while (attempt < retryConfig.maxAttempts && shouldContinue(state)) {
 				attempt++;
 				state = "running";
-				log(`Running (attempt ${attempt}/${retryConfig.maxAttempts})`);
+				infoLog(`Running (attempt ${attempt}/${retryConfig.maxAttempts})`);
 				lastResult = await runAgent(backend, {
 					name,
 					agent,
@@ -922,9 +914,9 @@ function createAgentController(config) {
 					projectDir,
 					retryAttempt: attempt,
 					feedback
-				}, log);
+				}, log, infoLog);
 				if (lastResult.success) {
-					log(`DONE ${lastResult.steps ? `${lastResult.steps} steps, ${lastResult.toolCalls} tool calls, ${lastResult.duration}ms` : `${lastResult.duration}ms`}`);
+					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);
 					break;
@@ -954,7 +946,7 @@ function createAgentController(config) {
 		async start() {
 			if (state !== "stopped") throw new Error(`Controller ${name} is already running`);
 			state = "idle";
-			log(`Starting`);
+			infoLog(`Starting`);
 			runLoop().catch((error) => {
 				errorLog(`ERROR ${error instanceof Error ? error.message : String(error)}`);
 				state = "stopped";
@@ -963,6 +955,7 @@ function createAgentController(config) {
 		async stop() {
 			log(`Stopping`);
 			state = "stopped";
+			if (backend.abort) backend.abort();
 			if (pollTimeout) {
 				clearTimeout(pollTimeout);
 				pollTimeout = null;
@@ -994,7 +987,8 @@ function createAgentController(config) {
 * 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) {
+async function runAgent(backend, ctx, log, infoLog) {
+	const info = infoLog ?? log;
 	if (backend.type === "mock") return runMockAgent(ctx, (msg) => log(msg));
 	if (backend.type === "sdk") return runSdkAgent(ctx, (msg) => log(msg));
 	const startTime = Date.now();
@@ -1004,7 +998,7 @@ async function runAgent(backend, ctx, log) {
 			backend.setWorkspace(ctx.workspaceDir, mcpConfig);
 		}
 		const prompt = buildAgentPrompt(ctx);
-		log(`Prompt (${prompt.length} chars) → ${backend.type} backend`);
+		info(`Prompt (${prompt.length} chars) → ${backend.type} backend`);
 		await backend.send(prompt, { system: ctx.agent.resolvedSystemPrompt });
 		return {
 			success: true,
@@ -1044,9 +1038,13 @@ async function checkWorkflowIdle(controllers, provider, debounceMs = CONTROLLER_
 */
 function getBackendByType(backendType, options) {
 	if (backendType === "mock") return createMockBackend(options?.debugLog);
+	const backendOptions = {};
+	if (options?.timeout) backendOptions.timeout = options.timeout;
+	if (options?.debugLog) backendOptions.debugLog = options.debugLog;
 	return createBackend({
 		type: backendType,
-		model: options?.model
+		model: options?.model,
+		...Object.keys(backendOptions).length > 0 ? { options: backendOptions } : {}
 	});
 }
 /**
@@ -1362,68 +1360,6 @@ function startChannelWatcher(config) {
 	} };
 }
 
-//#endregion
-//#region src/workflow/logger.ts
-/**
-* Create a silent logger (no output)
-*/
-function createSilentLogger() {
-	const noop = () => {};
-	return {
-		debug: noop,
-		info: noop,
-		warn: noop,
-		error: noop,
-		isDebug: () => false,
-		child: () => createSilentLogger()
-	};
-}
-/**
-* Create a logger that writes to the channel.
-*
-* - info/warn/error → channel entry with kind="log" (always shown to user)
-* - debug → channel entry with kind="debug" (only shown with --debug)
-*
-* The display layer handles formatting and filtering.
-*/
-function createChannelLogger(config) {
-	const { provider, from = "system" } = config;
-	const formatContent = (level, message, args) => {
-		const argsStr = args.length > 0 ? " " + args.map(formatArg).join(" ") : "";
-		if (level === "warn") return `[WARN] ${message}${argsStr}`;
-		if (level === "error") return `[ERROR] ${message}${argsStr}`;
-		return `${message}${argsStr}`;
-	};
-	const write = (level, message, args) => {
-		const content = formatContent(level, message, args);
-		const kind = level === "debug" ? "debug" : "log";
-		provider.appendChannel(from, content, { kind }).catch(() => {});
-	};
-	return {
-		debug: (message, ...args) => write("debug", message, args),
-		info: (message, ...args) => write("info", message, args),
-		warn: (message, ...args) => write("warn", message, args),
-		error: (message, ...args) => write("error", message, args),
-		isDebug: () => true,
-		child: (childPrefix) => {
-			return createChannelLogger({
-				provider,
-				from: from ? `${from}:${childPrefix}` : childPrefix
-			});
-		}
-	};
-}
-/** Format an argument for logging */
-function formatArg(arg) {
-	if (arg === null || arg === void 0) return String(arg);
-	if (typeof arg === "object") try {
-		return JSON.stringify(arg);
-	} catch {
-		return String(arg);
-	}
-	return String(arg);
-}
-
 //#endregion
 //#region src/workflow/runner.ts
 /**
@@ -1554,7 +1490,7 @@ async function initWorkflow(config) {
 				return;
 			}
 			logger.debug(`Kickoff: ${interpolatedKickoff.slice(0, 100)}...`);
-			await contextProvider.appendChannel("system", interpolatedKickoff);
+			await contextProvider.smartSend("system", interpolatedKickoff);
 		},
 		async shutdown() {
 			logger.debug("Shutting down...");
@@ -1658,7 +1594,8 @@ async function runWorkflowWithControllers(config) {
 			if (createBackend) backend = createBackend(agentName, agentDef);
 			else if (agentDef.backend) backend = getBackendByType(agentDef.backend, {
 				model: agentDef.model,
-				debugLog: backendDebugLog
+				debugLog: backendDebugLog,
+				timeout: agentDef.timeout
 			});
 			else if (agentDef.model) backend = getBackendForModel(agentDef.model, { debugLog: backendDebugLog });
 			else throw new Error(`Agent "${agentName}" requires either a backend or model field`);
@@ -1676,6 +1613,7 @@ async function runWorkflowWithControllers(config) {
 				backend,
 				pollInterval,
 				log: (msg) => controllerLogger.debug(msg),
+				infoLog: (msg) => controllerLogger.info(msg),
 				errorLog: (msg) => controllerLogger.error(msg),
 				feedback: feedbackEnabled
 			});
@@ -1781,4 +1719,4 @@ function sleep(ms) {
 }
 
 //#endregion
-export { parseWorkflowFile, runWorkflowWithControllers };
+export { parseWorkflowFile, runWorkflowWithControllers, shutdownControllers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-worker",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "SDK and CLI for creating and testing agent workers with Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.mjs",

package/dist/backends-D3MAlJBX.mjs

@@ -1,3 +0,0 @@
-import { a as createMockBackend, c as CodexBackend, d as CLAUDE_MODEL_MAP, f as CODEX_MODEL_MAP, h as getModelForBackend, i as MockAIBackend, l as ClaudeCodeBackend, m as SDK_MODEL_ALIASES, n as createBackend, o as SdkBackend, p as CURSOR_MODEL_MAP, r as listBackends, s as CursorBackend, t as checkBackends, u as BACKEND_DEFAULT_MODELS } from "./backends-DenGdkrj.mjs";
-
-export { listBackends };

package/dist/context-C7nBmU5D.mjs

@@ -1,4 +0,0 @@
-import { a as FileStorage, c as CONTEXT_DEFAULTS, d as RESOURCE_SCHEME, f as calculatePriority, h as generateResourceId, i as resolveContextDir, l as MENTION_PATTERN, m as extractMentions, n as createFileContextProvider, o as MemoryStorage, p as createResourceRef, r as getDefaultContextDir, s as ContextProviderImpl, t as FileContextProvider, u as RESOURCE_PREFIX } from "./cli/index.mjs";
-import { a as createMemoryContextProvider, i as MemoryContextProvider, n as formatProposal, r as formatProposalList, t as createContextMCPServer } from "./mcp-server-DtIApaBD.mjs";
-
-export { createFileContextProvider };