agent-worker 0.18.0 → 0.19.0

package/dist/index.mjs

@@ -1,1111 +1,36 @@
-import { F as createModelWithProvider, M as SUPPORTED_PROVIDERS, N as createModel, P as createModelAsync, a as createMockBackend, d as CodexBackend, f as ClaudeCodeBackend, i as MockAIBackend, j as FRONTIER_MODELS, n as createBackend, o as SdkBackend, r as listBackends, t as checkBackends, u as CursorBackend } from "./backends-D7DT0uox.mjs";
-import { t as createTool } from "./create-tool-gcUuI1FD.mjs";
-import { ToolLoopAgent, stepCountIs } from "ai";
-import { createBashTool } from "bash-tool";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join, normalize } from "node:path";
-import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { parse } from "yaml";
-import { z } from "zod";
-import { tmpdir } from "node:os";
-import { spawn } from "node:child_process";
-
-//#region src/agent/worker.ts
+import { a as isDaemonRunning, c as writeDaemonInfo, d as AgentHandle, i as DEFAULT_PORT, l as MemoryStateStore, n as startDaemon, o as readDaemonInfo, r as DaemonEventLog, s as removeDaemonInfo, u as AgentRegistry } from "./daemon-CwaHgxs6.mjs";
+import { AgentWorker, AgentWorker as AgentWorker$1, SkillImporter, createBackend, createSkillTool } from "@moniro/agent-loop";
+//#region src/agent/handle.ts
 /**
-* AgentWorker - Stateful worker for controlled agent execution
+* LocalWorker — In-process execution via AgentWorker.
 *
-* Uses ToolLoopAgent internally for multi-step reasoning loops.
-* Maintains conversation state across multiple send() calls,
-* enabling improvisational testing where you observe responses
-* and decide next actions.
-*
-* Tools are AI SDK tool() objects passed as Record<name, tool()>.
-* Approval is configured separately via Record<name, check>.
+* Wraps an AgentWorker instance. State lives in the AgentWorker's memory.
+* This is the default for single-machine deployments.
 */
-var AgentWorker = class {
-	id;
-	model;
-	system;
-	createdAt;
-	tools;
-	approval;
-	maxTokens;
-	maxSteps;
-	messages = [];
-	totalUsage = {
-		input: 0,
-		output: 0,
-		total: 0
-	};
-	pendingApprovals = [];
-	backend;
-	provider;
-	cachedAgent = null;
-	toolsChanged = false;
-	/**
-	* Whether this session supports tool management (SDK backend only)
-	*/
-	get supportsTools() {
-		return this.backend === null;
-	}
-	/**
-	* Convert AgentMessage[] to ModelMessage[] for AI SDK
-	*/
-	toModelMessages() {
-		return this.messages.filter((m) => m.status !== "responding").map((m) => ({
-			role: m.role,
-			content: m.content
-		}));
-	}
+var LocalWorker = class {
+	engine;
 	constructor(config, restore) {
-		if (restore) {
-			this.id = restore.id;
-			this.createdAt = restore.createdAt;
-			this.messages = [...restore.messages];
-			this.totalUsage = { ...restore.totalUsage };
-			this.pendingApprovals = [...restore.pendingApprovals ?? []];
-		} else {
-			this.id = crypto.randomUUID();
-			this.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		}
-		this.model = config.model;
-		this.system = config.system;
-		this.tools = config.tools ? { ...config.tools } : {};
-		this.approval = config.approval ? { ...config.approval } : {};
-		this.maxTokens = config.maxTokens ?? 4096;
-		this.maxSteps = config.maxSteps ?? 200;
-		this.backend = config.backend ?? null;
-		this.provider = config.provider;
-	}
-	/**
-	* Check if a tool needs approval for given arguments
-	*/
-	checkApproval(name, args) {
-		const check = this.approval[name];
-		if (!check) return false;
-		if (typeof check === "function") return check(args);
-		return check;
-	}
-	/**
-	* Build tools with approval wrapping for ToolLoopAgent
-	*/
-	buildTools(autoApprove) {
-		if (Object.keys(this.tools).length === 0) return void 0;
-		if (autoApprove || Object.keys(this.approval).length === 0) return this.tools;
-		const wrapped = {};
-		for (const [name, t] of Object.entries(this.tools)) {
-			if (!this.approval[name]) {
-				wrapped[name] = t;
-				continue;
-			}
-			wrapped[name] = {
-				...t,
-				execute: async (args, options) => {
-					if (this.checkApproval(name, args)) {
-						const approval = {
-							id: crypto.randomUUID(),
-							toolName: name,
-							toolCallId: crypto.randomUUID(),
-							arguments: args,
-							requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-							status: "pending"
-						};
-						this.pendingApprovals.push(approval);
-						return {
-							__approvalRequired: true,
-							approvalId: approval.id
-						};
-					}
-					return t.execute?.(args, options);
-				}
-			};
-		}
-		return wrapped;
-	}
-	/**
-	* Get or create cached agent, rebuild if tools changed
-	*/
-	async getAgent(autoApprove) {
-		if (!this.cachedAgent || this.toolsChanged || !autoApprove) {
-			this.cachedAgent = new ToolLoopAgent({
-				model: this.provider ? await createModelWithProvider(this.model, this.provider) : await createModelAsync(this.model),
-				instructions: this.system,
-				tools: this.buildTools(autoApprove),
-				maxOutputTokens: this.maxTokens,
-				stopWhen: stepCountIs(this.maxSteps)
-			});
-			if (autoApprove) this.toolsChanged = false;
-		}
-		return this.cachedAgent;
-	}
-	/**
-	* Send a message via CLI backend (non-SDK path)
-	*/
-	async sendViaBackend(content) {
-		const startTime = performance.now();
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		this.messages.push({
-			role: "user",
-			content,
-			status: "complete",
-			timestamp
-		});
-		const result = await this.backend.send(content, { system: this.system });
-		const latency = Math.round(performance.now() - startTime);
-		this.messages.push({
-			role: "assistant",
-			content: result.content,
-			status: "complete",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		});
-		const usage = {
-			input: result.usage?.input ?? 0,
-			output: result.usage?.output ?? 0,
-			total: result.usage?.total ?? 0
-		};
-		this.totalUsage.input += usage.input;
-		this.totalUsage.output += usage.output;
-		this.totalUsage.total += usage.total;
-		const toolCalls = (result.toolCalls ?? []).map((tc) => ({
-			name: tc.name,
-			arguments: tc.arguments,
-			result: tc.result,
-			timing: 0
-		}));
-		return {
-			content: result.content,
-			toolCalls,
-			pendingApprovals: [],
-			usage,
-			latency
-		};
-	}
-	/**
-	* Send a message and get the agent's response
-	*/
-	async send(content, options = {}) {
-		if (this.backend) return this.sendViaBackend(content);
-		const { autoApprove = true, onStepFinish } = options;
-		const startTime = performance.now();
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		this.messages.push({
-			role: "user",
-			content,
-			status: "complete",
-			timestamp
-		});
-		const agent = await this.getAgent(autoApprove);
-		const allToolCalls = [];
-		let stepNumber = 0;
-		const result = await agent.generate({
-			messages: this.toModelMessages(),
-			onStepFinish: async ({ usage, toolCalls, toolResults }) => {
-				stepNumber++;
-				const stepToolCalls = [];
-				if (toolCalls) for (const tc of toolCalls) {
-					const toolResult = toolResults?.find((tr) => tr.toolCallId === tc.toolCallId);
-					const toolCall = {
-						name: tc.toolName,
-						arguments: tc.input,
-						result: toolResult?.output ?? null,
-						timing: 0
-					};
-					stepToolCalls.push(toolCall);
-					allToolCalls.push(toolCall);
-				}
-				if (onStepFinish) {
-					const stepUsage = {
-						input: usage?.inputTokens ?? 0,
-						output: usage?.outputTokens ?? 0,
-						total: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
-					};
-					await onStepFinish({
-						stepNumber,
-						toolCalls: stepToolCalls,
-						usage: stepUsage
-					});
-				}
-			}
-		});
-		const latency = Math.round(performance.now() - startTime);
-		this.messages.push({
-			role: "assistant",
-			content: result.text,
-			status: "complete",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		});
-		const usage = {
-			input: result.usage?.inputTokens ?? 0,
-			output: result.usage?.outputTokens ?? 0,
-			total: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0)
-		};
-		this.totalUsage.input += usage.input;
-		this.totalUsage.output += usage.output;
-		this.totalUsage.total += usage.total;
-		if (this.maxSteps > 0 && stepNumber >= this.maxSteps && allToolCalls.length > 0) console.warn(`⚠️  Agent reached maxSteps limit (${this.maxSteps}) but wanted to continue. Consider increasing maxSteps or removing the limit.`);
-		const currentPending = this.pendingApprovals.filter((p) => p.status === "pending");
-		return {
-			content: result.text,
-			toolCalls: allToolCalls,
-			pendingApprovals: currentPending,
-			usage,
-			latency
-		};
-	}
-	/**
-	* Send a message and stream the response
-	*/
-	async *sendStream(content, options = {}) {
-		if (this.backend) {
-			const response = await this.sendViaBackend(content);
-			yield response.content;
-			return response;
-		}
-		const { autoApprove = true, onStepFinish } = options;
-		const startTime = performance.now();
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		this.messages.push({
-			role: "user",
-			content,
-			status: "complete",
-			timestamp
-		});
-		const assistantMsg = {
-			role: "assistant",
-			content: "",
-			status: "responding",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		this.messages.push(assistantMsg);
-		const agent = await this.getAgent(autoApprove);
-		const allToolCalls = [];
-		let stepNumber = 0;
-		const result = await agent.stream({
-			messages: this.toModelMessages(),
-			onStepFinish: async ({ usage, toolCalls, toolResults }) => {
-				stepNumber++;
-				const stepToolCalls = [];
-				if (toolCalls) for (const tc of toolCalls) {
-					const toolResult = toolResults?.find((tr) => tr.toolCallId === tc.toolCallId);
-					const toolCall = {
-						name: tc.toolName,
-						arguments: tc.input,
-						result: toolResult?.output ?? null,
-						timing: 0
-					};
-					stepToolCalls.push(toolCall);
-					allToolCalls.push(toolCall);
-				}
-				if (onStepFinish) {
-					const stepUsage = {
-						input: usage?.inputTokens ?? 0,
-						output: usage?.outputTokens ?? 0,
-						total: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
-					};
-					await onStepFinish({
-						stepNumber,
-						toolCalls: stepToolCalls,
-						usage: stepUsage
-					});
-				}
-			}
-		});
-		for await (const chunk of result.textStream) {
-			assistantMsg.content += chunk;
-			yield chunk;
-		}
-		const latency = Math.round(performance.now() - startTime);
-		const text = await result.text;
-		assistantMsg.content = text;
-		assistantMsg.status = "complete";
-		const finalUsage = await result.usage;
-		const usage = {
-			input: finalUsage?.inputTokens ?? 0,
-			output: finalUsage?.outputTokens ?? 0,
-			total: (finalUsage?.inputTokens ?? 0) + (finalUsage?.outputTokens ?? 0)
-		};
-		this.totalUsage.input += usage.input;
-		this.totalUsage.output += usage.output;
-		this.totalUsage.total += usage.total;
-		return {
-			content: text,
-			toolCalls: allToolCalls,
-			pendingApprovals: this.pendingApprovals.filter((p) => p.status === "pending"),
-			usage,
-			latency
-		};
-	}
-	/**
-	* Add an AI SDK tool
-	* Only supported for SDK backends (ToolLoopAgent)
-	*/
-	addTool(name, t) {
-		if (this.backend) throw new Error("Tool management not supported for CLI backends");
-		this.tools[name] = t;
-		this.toolsChanged = true;
-		this.cachedAgent = null;
-	}
-	/**
-	* Set approval requirement for a tool
-	*/
-	setApproval(name, check) {
-		this.approval[name] = check;
-	}
-	/**
-	* Replace a tool's execute function (for testing)
-	*/
-	mockTool(name, mockFn) {
-		if (this.backend) throw new Error("Tool management not supported for CLI backends");
-		const t = this.tools[name];
-		if (!t) throw new Error(`Tool not found: ${name}`);
-		this.tools[name] = {
-			...t,
-			execute: mockFn
-		};
-		this.toolsChanged = true;
-		this.cachedAgent = null;
-	}
-	/**
-	* Set a static mock response for an existing tool
-	*/
-	setMockResponse(name, response) {
-		if (this.backend) throw new Error("Tool management not supported for CLI backends");
-		const t = this.tools[name];
-		if (!t) throw new Error(`Tool not found: ${name}`);
-		this.tools[name] = {
-			...t,
-			execute: () => response
-		};
-		this.toolsChanged = true;
-		this.cachedAgent = null;
-	}
-	/**
-	* Get tool info (names, descriptions, approval status)
-	*/
-	getTools() {
-		return Object.entries(this.tools).map(([name, t]) => {
-			return {
-				name,
-				description: t?.description,
-				needsApproval: !!this.approval[name]
-			};
-		});
-	}
-	history() {
-		return [...this.messages];
-	}
-	stats() {
-		return {
-			messageCount: this.messages.length,
-			usage: { ...this.totalUsage }
-		};
-	}
-	export() {
-		return {
-			sessionId: this.id,
-			model: this.model,
-			system: this.system,
-			messages: [...this.messages],
-			totalUsage: { ...this.totalUsage },
-			createdAt: this.createdAt
-		};
+		const backend = config.backend !== "default" ? createBackend({
+			type: config.backend,
+			model: config.model
+		}) : void 0;
+		this.engine = new AgentWorker$1({
+			model: config.model,
+			system: config.system,
+			tools: {},
+			backend,
+			provider: config.provider
+		}, restore);
+	}
+	send(input, options) {
+		return this.engine.send(input, options);
+	}
+	sendStream(input, options) {
+		return this.engine.sendStream(input, options);
 	}
 	getState() {
-		return {
-			id: this.id,
-			createdAt: this.createdAt,
-			messages: [...this.messages],
-			totalUsage: { ...this.totalUsage },
-			pendingApprovals: [...this.pendingApprovals]
-		};
-	}
-	getPendingApprovals() {
-		return this.pendingApprovals.filter((p) => p.status === "pending");
-	}
-	async approve(approvalId) {
-		const approval = this.pendingApprovals.find((p) => p.id === approvalId);
-		if (!approval) throw new Error(`Approval not found: ${approvalId}`);
-		if (approval.status !== "pending") throw new Error(`Approval already ${approval.status}: ${approvalId}`);
-		const t = this.tools[approval.toolName];
-		if (!t) throw new Error(`Tool not found: ${approval.toolName}`);
-		let result;
-		const tool = t;
-		if (typeof tool.execute === "function") result = await tool.execute(approval.arguments);
-		else result = { error: "No implementation provided" };
-		approval.status = "approved";
-		return result;
-	}
-	deny(approvalId, reason) {
-		const approval = this.pendingApprovals.find((p) => p.id === approvalId);
-		if (!approval) throw new Error(`Approval not found: ${approvalId}`);
-		if (approval.status !== "pending") throw new Error(`Approval already ${approval.status}: ${approvalId}`);
-		approval.status = "denied";
-		approval.denyReason = reason;
-	}
-	clear() {
-		this.messages = [];
-		this.totalUsage = {
-			input: 0,
-			output: 0,
-			total: 0
-		};
-		this.pendingApprovals = [];
-	}
-};
-
-//#endregion
-//#region src/agent/tools/bash.ts
-/**
-* Integration with Vercel's bash-tool for file system operations
-*
-* Provides bash, readFile, writeFile tools for AI agents in a sandboxed environment
-*/
-/**
-* Create bash tools as AI SDK tool() objects for use with AgentWorker
-*
-* @example
-* ```typescript
-* const { tools } = await createBashTools({
-*   files: { 'src/index.ts': 'console.log("hello")' }
-* })
-*
-* const session = new AgentWorker({
-*   model: 'anthropic/claude-sonnet-4-5',
-*   system: 'You are a coding assistant.',
-*   tools
-* })
-* ```
-*/
-async function createBashTools(options = {}) {
-	const { includeReadFile = true, includeWriteFile = true, ...bashOptions } = options;
-	const toolkit = await createBashTool(bashOptions);
-	const tools = {};
-	tools.bash = createTool({
-		description: "Execute bash commands in a sandboxed environment. Returns stdout, stderr, and exit code.",
-		schema: {
-			type: "object",
-			properties: { command: {
-				type: "string",
-				description: "The bash command to execute"
-			} },
-			required: ["command"]
-		},
-		execute: async (args) => {
-			const bashTool = toolkit.tools.bash;
-			if (!bashTool?.execute) throw new Error("Bash tool not available");
-			return bashTool.execute(args, {});
-		}
-	});
-	if (includeReadFile) tools.readFile = createTool({
-		description: "Read the contents of a file from the sandbox filesystem.",
-		schema: {
-			type: "object",
-			properties: { path: {
-				type: "string",
-				description: "The path to the file to read"
-			} },
-			required: ["path"]
-		},
-		execute: async (args) => {
-			const readFileTool = toolkit.tools.readFile;
-			if (!readFileTool?.execute) throw new Error("ReadFile tool not available");
-			return readFileTool.execute(args, {});
-		}
-	});
-	if (includeWriteFile) tools.writeFile = createTool({
-		description: "Write content to a file in the sandbox filesystem. Creates parent directories if needed.",
-		schema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "The path to the file to write"
-				},
-				content: {
-					type: "string",
-					description: "The content to write to the file"
-				}
-			},
-			required: ["path", "content"]
-		},
-		execute: async (args) => {
-			const writeFileTool = toolkit.tools.writeFile;
-			if (!writeFileTool?.execute) throw new Error("WriteFile tool not available");
-			return writeFileTool.execute(args, {});
-		}
-	});
-	return {
-		tools,
-		toolkit
-	};
-}
-/**
-* Quick helper to create bash tools with a directory
-*/
-async function createBashToolsFromDirectory(source, options = {}) {
-	return createBashTools({
-		...options,
-		uploadDirectory: { source }
-	});
-}
-/**
-* Quick helper to create bash tools with inline files
-*/
-async function createBashToolsFromFiles(files, options = {}) {
-	return createBashTools({
-		...options,
-		files
-	});
-}
-
-//#endregion
-//#region src/agent/tools/feedback.ts
-/**
-* Feedback tool — lets agents surface workflow improvement needs
-*
-* When enabled, agents can report what's missing or inconvenient during work:
-* a tool they wished they had, a step that felt unnecessarily slow, or a
-* capability gap. The purpose is workflow improvement, not bug reporting.
-*
-* @example
-* ```typescript
-* const { tool, getFeedback } = createFeedbackTool();
-*
-* const session = new AgentWorker({
-*   model: 'anthropic/claude-sonnet-4-5',
-*   system: FEEDBACK_PROMPT + '\nYou are a coding assistant.',
-*   tools: { feedback: tool, bash: bashTool },
-* });
-*
-* await session.send('...');
-* console.log(getFeedback()); // review what the agent reported
-* ```
-*/
-/**
-* Append this to the system prompt when the feedback tool is enabled.
-* Tells the agent the tool exists and when to use it.
-*/
-const FEEDBACK_PROMPT = `
-## Feedback
-
-You have a \`feedback\` tool. If you run into something inconvenient during your work — a tool you wish you had, a workflow step that feels unnecessarily slow, a capability gap — use it to report what you needed.
-
-The purpose is to improve the workflow for future runs. Don't force feedback; only call it when you genuinely hit a pain point.
-`.trim();
-function createFeedbackTool(options = {}) {
-	const { onFeedback, maxEntries = 50 } = options;
-	const entries = [];
-	return {
-		tool: createTool({
-			description: "Report a workflow improvement need. Use when you hit something inconvenient — a missing tool, an awkward step, or a capability you wished you had.",
-			schema: {
-				type: "object",
-				properties: {
-					target: {
-						type: "string",
-						description: "The area this is about — a tool name (e.g. bash, readFile), a workflow step, or a general area (e.g. file search, code review)."
-					},
-					type: {
-						type: "string",
-						enum: [
-							"missing",
-							"friction",
-							"suggestion"
-						],
-						description: "missing: a tool or capability you needed but didn't have. friction: something that works but is awkward or slow. suggestion: a concrete improvement idea."
-					},
-					description: {
-						type: "string",
-						description: "What you needed or what could be improved. Be specific."
-					},
-					context: {
-						type: "string",
-						description: "Optional: what you were trying to do when you hit this."
-					}
-				},
-				required: [
-					"target",
-					"type",
-					"description"
-				]
-			},
-			execute: async (args) => {
-				const validTypes = [
-					"missing",
-					"friction",
-					"suggestion"
-				];
-				const rawType = args.type;
-				const type = validTypes.includes(rawType) ? rawType : "suggestion";
-				const entry = {
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					target: args.target,
-					type,
-					description: args.description,
-					...args.context ? { context: args.context } : {}
-				};
-				if (entries.length >= maxEntries) entries.shift();
-				entries.push(entry);
-				onFeedback?.(entry);
-				return { recorded: true };
-			}
-		}),
-		getFeedback: () => [...entries],
-		clearFeedback: () => {
-			entries.length = 0;
-		}
-	};
-}
-
-//#endregion
-//#region src/agent/skills/provider.ts
-const frontmatterSchema = z.object({
-	name: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).max(64),
-	description: z.string().min(1).max(1024),
-	license: z.string().optional(),
-	compatibility: z.string().max(500).optional(),
-	metadata: z.record(z.string(), z.string()).optional(),
-	"allowed-tools": z.string().optional()
-});
-var SkillsProvider = class {
-	skills = /* @__PURE__ */ new Map();
-	/**
-	* Add a single skill directory
-	*/
-	async addSkill(skillPath) {
-		const skillMdPath = join(skillPath, "SKILL.md");
-		try {
-			await stat(skillMdPath);
-		} catch {
-			throw new Error(`SKILL.md not found in ${skillPath}`);
-		}
-		const frontmatter = await this.parseFrontmatter(skillMdPath);
-		this.skills.set(frontmatter.name, {
-			name: frontmatter.name,
-			description: frontmatter.description,
-			path: skillPath
-		});
-	}
-	/**
-	* Scan a directory and add all valid skills found
-	*/
-	async scanDirectory(dir) {
-		const resolved = this.resolvePath(dir);
-		try {
-			const entries = await readdir(resolved, { withFileTypes: true });
-			for (const entry of entries) if (entry.isDirectory()) {
-				const skillPath = join(resolved, entry.name);
-				try {
-					await this.addSkill(skillPath);
-				} catch {}
-			}
-		} catch {}
-	}
-	/**
-	* List all available skills (metadata only)
-	*/
-	list() {
-		return Array.from(this.skills.values()).map(({ name, description }) => ({
-			name,
-			description
-		}));
-	}
-	/**
-	* View the full SKILL.md content
-	*/
-	async view(skillName) {
-		const skill = this.skills.get(skillName);
-		if (!skill) throw new Error(`Skill "${skillName}" not found`);
-		return await readFile(join(skill.path, "SKILL.md"), "utf-8");
-	}
-	/**
-	* Read a file within a skill directory (relative path)
-	*/
-	async readFile(skillName, relativePath) {
-		const skill = this.skills.get(skillName);
-		if (!skill) throw new Error(`Skill "${skillName}" not found`);
-		const normalized = normalize(relativePath);
-		if (normalized.startsWith("..")) throw new Error("Path traversal not allowed");
-		return await readFile(join(skill.path, normalized), "utf-8");
-	}
-	/**
-	* Parse YAML frontmatter from SKILL.md
-	*/
-	async parseFrontmatter(skillMdPath) {
-		const match = (await readFile(skillMdPath, "utf-8")).match(/^---\n([\s\S]+?)\n---/);
-		if (!match || !match[1]) throw new Error(`Invalid SKILL.md: missing frontmatter in ${skillMdPath}`);
-		try {
-			return frontmatterSchema.parse(parse(match[1]));
-		} catch (error) {
-			throw new Error(`Invalid frontmatter in ${skillMdPath}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	/**
-	* Resolve tilde and relative paths
-	*/
-	resolvePath(path) {
-		if (path.startsWith("~/")) {
-			const home = process.env.HOME || process.env.USERPROFILE;
-			if (!home) throw new Error("Cannot resolve ~/ without HOME environment variable");
-			return join(home, path.slice(2));
-		}
-		return path;
-	}
-	/**
-	* Synchronous version: Add a single skill directory
-	*/
-	addSkillSync(skillPath) {
-		const skillMdPath = join(skillPath, "SKILL.md");
-		try {
-			statSync(skillMdPath);
-		} catch {
-			throw new Error(`SKILL.md not found in ${skillPath}`);
-		}
-		const frontmatter = this.parseFrontmatterSync(skillMdPath);
-		this.skills.set(frontmatter.name, {
-			name: frontmatter.name,
-			description: frontmatter.description,
-			path: skillPath
-		});
-	}
-	/**
-	* Synchronous version: Scan a directory and add all valid skills found
-	*/
-	scanDirectorySync(dir) {
-		const resolved = this.resolvePath(dir);
-		try {
-			const entries = readdirSync(resolved, { withFileTypes: true });
-			for (const entry of entries) if (entry.isDirectory()) {
-				const skillPath = join(resolved, entry.name);
-				try {
-					this.addSkillSync(skillPath);
-				} catch {}
-			}
-		} catch {}
-	}
-	/**
-	* Synchronous version: Parse YAML frontmatter from SKILL.md
-	*/
-	parseFrontmatterSync(skillMdPath) {
-		const match = readFileSync(skillMdPath, "utf-8").match(/^---\n([\s\S]+?)\n---/);
-		if (!match || !match[1]) throw new Error(`Invalid SKILL.md: missing frontmatter in ${skillMdPath}`);
-		try {
-			return frontmatterSchema.parse(parse(match[1]));
-		} catch (error) {
-			throw new Error(`Invalid frontmatter in ${skillMdPath}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	/**
-	* Add skills from a SkillImporter (async)
-	* Used for temporary imported skills during session lifecycle
-	*/
-	async addImportedSkills(importer) {
-		const skillPaths = importer.getAllImportedSkillPaths();
-		for (const skillPath of skillPaths) await this.addSkill(skillPath);
-	}
-	/**
-	* Add skills from a SkillImporter (sync)
-	*/
-	addImportedSkillsSync(importer) {
-		const skillPaths = importer.getAllImportedSkillPaths();
-		for (const skillPath of skillPaths) this.addSkillSync(skillPath);
-	}
-};
-
-//#endregion
-//#region src/agent/tools/skills.ts
-/**
-* Create a Skills tool as an AI SDK tool() object
-*/
-function createSkillsTool(provider) {
-	return createTool({
-		description: "Interact with available agent skills. Use \"list\" to see all skills with their descriptions, \"view\" to read a complete SKILL.md file, \"readFile\" to read files within a skill directory (e.g., references/, scripts/, assets/).",
-		schema: {
-			type: "object",
-			properties: {
-				operation: {
-					type: "string",
-					enum: [
-						"list",
-						"view",
-						"readFile"
-					],
-					description: "Operation to perform"
-				},
-				skillName: {
-					type: "string",
-					description: "Skill name (required for view and readFile operations)"
-				},
-				filePath: {
-					type: "string",
-					description: "Relative file path within the skill directory (required for readFile operation, e.g., \"references/search-strategies.md\")"
-				}
-			},
-			required: ["operation"]
-		},
-		execute: async (args) => {
-			const operation = args.operation;
-			const skillName = args.skillName;
-			const filePath = args.filePath;
-			switch (operation) {
-				case "list": {
-					const skills = provider.list();
-					if (skills.length === 0) return { message: "No skills available" };
-					return { skills: skills.map((s) => ({
-						name: s.name,
-						description: s.description
-					})) };
-				}
-				case "view":
-					if (!skillName) throw new Error("skillName is required for view operation");
-					return { content: await provider.view(skillName) };
-				case "readFile":
-					if (!skillName || !filePath) throw new Error("skillName and filePath are required for readFile operation");
-					return { content: await provider.readFile(skillName, filePath) };
-				default: throw new Error(`Unknown operation: ${operation}`);
-			}
-		}
-	});
-}
-
-//#endregion
-//#region src/agent/skills/import-spec.ts
-const providerUrls = {
-	github: "https://github.com",
-	gitlab: "https://gitlab.com",
-	gitee: "https://gitee.com"
-};
-/**
-* Parse import spec: [provider:]owner/repo[@ref]:{skill1,skill2,...}
-*
-* Examples:
-*   vercel-labs/agent-skills:react-best-practices
-*   vercel-labs/agent-skills:{react,web}
-*   vercel-labs/agent-skills@v1.0.0:react
-*   github:vercel-labs/agent-skills@main:react
-*   vercel-labs/agent-skills  (imports all)
-*/
-function parseImportSpec(spec) {
-	const match = spec.match(/^(?:([a-z]+):)?([^/@:]+)\/([^/@:]+)(?:@([^:]+))?(?::(.+))?$/);
-	if (!match) throw new Error(`Invalid import spec: ${spec}\nFormat: [provider:]owner/repo[@ref]:{skill1,skill2,...}`);
-	const [, providerMatch = "github", ownerMatch, repoMatch, refMatch = "main", skillsStr] = match;
-	if (!ownerMatch || !repoMatch) throw new Error(`Invalid import spec: ${spec}\nFormat: [provider:]owner/repo[@ref]:{skill1,skill2,...}`);
-	const provider = providerMatch;
-	const owner = ownerMatch;
-	const repo = repoMatch;
-	const ref = refMatch;
-	if (![
-		"github",
-		"gitlab",
-		"gitee"
-	].includes(provider)) throw new Error(`Unsupported provider: ${provider}. Supported: github, gitlab, gitee`);
-	const safeNamePattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-	if (!safeNamePattern.test(owner)) throw new Error(`Invalid owner: "${owner}". Must start with alphanumeric and only contain alphanumeric, hyphen, underscore, or dot`);
-	if (!safeNamePattern.test(repo)) throw new Error(`Invalid repo: "${repo}". Must start with alphanumeric and only contain alphanumeric, hyphen, underscore, or dot`);
-	if (!safeNamePattern.test(ref)) throw new Error(`Invalid ref: "${ref}". Must start with alphanumeric and only contain alphanumeric, hyphen, underscore, or dot`);
-	let skills = "all";
-	if (skillsStr) if (skillsStr.startsWith("{") && skillsStr.endsWith("}")) {
-		const skillList = skillsStr.slice(1, -1).split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-		if (skillList.length === 0) throw new Error("Empty skill list in braces");
-		skills = skillList;
-	} else skills = [skillsStr.trim()];
-	return {
-		provider,
-		owner,
-		repo,
-		ref,
-		skills,
-		rawSpec: spec
-	};
-}
-/**
-* Build Git URL from import spec
-*/
-function buildGitUrl(spec) {
-	return `${providerUrls[spec.provider]}/${spec.owner}/${spec.repo}.git`;
-}
-/**
-* Get display name for import spec
-*/
-function getSpecDisplayName(spec) {
-	const skillsDisplay = spec.skills === "all" ? "all skills" : spec.skills.length === 1 ? spec.skills[0] : `${spec.skills.length} skills`;
-	return `${spec.owner}/${spec.repo}@${spec.ref} (${skillsDisplay})`;
-}
-
-//#endregion
-//#region src/agent/skills/importer.ts
-/**
-* Temporary skill importer for session lifecycle
-* Clones Git repos to temp directory and manages imported skills
-*/
-var SkillImporter = class {
-	tempDir;
-	imported = /* @__PURE__ */ new Map();
-	constructor(sessionId) {
-		this.tempDir = join(tmpdir(), `agent-worker-skills-${sessionId}`);
-	}
-	/**
-	* Import skills from a Git repository
-	*/
-	async import(spec) {
-		const parsed = parseImportSpec(spec);
-		console.log(`Importing: ${getSpecDisplayName(parsed)}`);
-		const repoDir = await this.cloneRepo(parsed);
-		const skillNames = await this.extractSkills(repoDir, parsed);
-		console.log(`✓ Imported ${skillNames.length} skill(s): ${skillNames.join(", ")}`);
-		return skillNames;
-	}
-	/**
-	* Import skills from multiple specs
-	*/
-	async importMultiple(specs) {
-		const allSkillNames = [];
-		for (const spec of specs) try {
-			const skillNames = await this.import(spec);
-			allSkillNames.push(...skillNames);
-		} catch (error) {
-			console.error(`Failed to import ${spec}:`, error);
-		}
-		return allSkillNames;
-	}
-	/**
-	* Get path for an imported skill
-	*/
-	getImportedSkillPath(skillName) {
-		return this.imported.get(skillName)?.tempPath || null;
-	}
-	/**
-	* Get all imported skill paths
-	*/
-	getAllImportedSkillPaths() {
-		return Array.from(this.imported.values()).map((s) => s.tempPath);
-	}
-	/**
-	* Get all imported skills metadata
-	*/
-	getImportedSkills() {
-		return Array.from(this.imported.values());
-	}
-	/**
-	* Get temporary directory path
-	*/
-	getTempDir() {
-		return this.tempDir;
-	}
-	/**
-	* Cleanup temporary directory
-	*/
-	async cleanup() {
-		if (existsSync(this.tempDir)) await rm(this.tempDir, {
-			recursive: true,
-			force: true
-		});
-	}
-	/**
-	* Clone Git repository (shallow clone)
-	*/
-	async cloneRepo(spec) {
-		await mkdir(this.tempDir, { recursive: true });
-		const repoDir = join(this.tempDir, `${spec.owner}-${spec.repo}`);
-		if (existsSync(repoDir)) return repoDir;
-		const gitUrl = buildGitUrl(spec);
-		await this.execGit([
-			"clone",
-			"--depth",
-			"1",
-			"--branch",
-			spec.ref,
-			"--single-branch",
-			gitUrl,
-			repoDir
-		]);
-		return repoDir;
-	}
-	/**
-	* Extract skills from cloned repository
-	*/
-	async extractSkills(repoDir, spec) {
-		const skillsDir = await this.findSkillsDirectory(repoDir);
-		const skillsToImport = spec.skills === "all" ? await this.findAllSkills(skillsDir) : spec.skills;
-		const importedSkills = [];
-		for (const skillName of skillsToImport) {
-			const skillPath = join(skillsDir, skillName);
-			const skillMdPath = join(skillPath, "SKILL.md");
-			try {
-				await stat(skillMdPath);
-				this.imported.set(skillName, {
-					name: skillName,
-					source: spec.rawSpec,
-					tempPath: skillPath
-				});
-				importedSkills.push(skillName);
-			} catch {
-				console.warn(`Skipping ${skillName}: SKILL.md not found`);
-			}
-		}
-		if (importedSkills.length === 0) throw new Error(`No valid skills found in ${spec.owner}/${spec.repo}`);
-		return importedSkills;
-	}
-	/**
-	* Find skills directory in repository
-	* Tries: skills/, agent-skills/, . (root)
-	*/
-	async findSkillsDirectory(repoDir) {
-		for (const candidate of [
-			"skills",
-			"agent-skills",
-			"."
-		]) {
-			const dir = join(repoDir, candidate);
-			try {
-				if ((await stat(dir)).isDirectory()) {
-					if ((await readdir(dir, { withFileTypes: true })).some((entry) => entry.isDirectory() && existsSync(join(dir, entry.name, "SKILL.md")))) return dir;
-				}
-			} catch {
-				continue;
-			}
-		}
-		throw new Error(`No skills directory found in ${repoDir}`);
-	}
-	/**
-	* Find all skills in a directory
-	*/
-	async findAllSkills(skillsDir) {
-		const entries = await readdir(skillsDir, { withFileTypes: true });
-		const skills = [];
-		for (const entry of entries) if (entry.isDirectory()) {
-			if (existsSync(join(skillsDir, entry.name, "SKILL.md"))) skills.push(entry.name);
-		}
-		return skills;
-	}
-	/**
-	* Execute git command
-	*/
-	async execGit(args) {
-		return new Promise((resolve, reject) => {
-			const git = spawn("git", args, { stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			] });
-			let stdout = "";
-			let stderr = "";
-			git.stdout?.on("data", (data) => {
-				stdout += data.toString();
-			});
-			git.stderr?.on("data", (data) => {
-				stderr += data.toString();
-			});
-			git.on("close", (code) => {
-				if (code === 0) resolve();
-				else reject(/* @__PURE__ */ new Error(`Git command failed (exit ${code}): ${stderr || stdout}`));
-			});
-			git.on("error", (error) => {
-				reject(/* @__PURE__ */ new Error(`Failed to spawn git: ${error.message}`));
-			});
-		});
+		return this.engine.getState();
 	}
 };
-
 //#endregion
-export { AgentWorker, ClaudeCodeBackend, CodexBackend, CursorBackend, FEEDBACK_PROMPT, FRONTIER_MODELS, MockAIBackend, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };
+export { AgentHandle, AgentRegistry, AgentWorker, DEFAULT_PORT, DaemonEventLog, LocalWorker, MemoryStateStore, SkillImporter, createSkillTool, isDaemonRunning, readDaemonInfo, removeDaemonInfo, startDaemon, writeDaemonInfo };