agent-worker 0.17.0 → 0.19.0

package/dist/daemon-CwaHgxs6.mjs

@@ -0,0 +1,1071 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { randomUUID } from "node:crypto";
+import { basename, join } from "node:path";
+import { mkdir, open, readFile, readdir, writeFile } from "node:fs/promises";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { parse, stringify } from "yaml";
+import { CONTEXT_SUBDIRS } from "@moniro/agent-loop";
+import { ConversationLog, DEFAULT_THIN_THREAD_SIZE, ThinThread } from "@moniro/agent-worker";
+import { createChannelAdapters, createContextMCPServer, createEventLogger, createMinimalRuntime, createSilentLogger, createWiredLoop, generateInstructionId } from "@moniro/workspace";
+import { homedir } from "node:os";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { nanoid } from "nanoid";
+//#region src/agent/agent-handle.ts
+/**
+* AgentHandle — Runtime wrapper for an agent definition + persistent context.
+*
+* Created by AgentRegistry when an agent is loaded. Provides:
+*   - Context directory management (memory/, notes/, conversations/, todo/)
+*   - Read/write operations for personal context
+*   - State tracking (idle, running, stopped, error)
+*   - Loop ownership (lazy — created on first message)
+*   - Ephemeral vs persistent mode
+*/
+var AgentHandle = class {
+	/** Agent definition (from YAML or API) */
+	definition;
+	/** Absolute path to agent's persistent context directory */
+	contextDir;
+	/**
+	* Whether this agent is ephemeral (in-memory only).
+	* Ephemeral agents are created via the daemon API (POST /agents) and
+	* lost on daemon restart. Config agents are defined in config.yml.
+	*/
+	ephemeral;
+	/** Current agent state */
+	state = "idle";
+	/** The agent's execution loop (lazy — created on first run/serve) */
+	loop = null;
+	/** Conversation log (lazy — created on first access) */
+	_conversationLog;
+	/** Thin thread (lazy — created on first access) */
+	_thinThread;
+	/** Optional logger (injected by registry; absent in standalone CLI) */
+	log;
+	constructor(definition, contextDir, logger, ephemeral = false) {
+		this.definition = definition;
+		this.contextDir = contextDir;
+		this.log = logger;
+		this.ephemeral = ephemeral;
+	}
+	/** Agent name (convenience accessor) */
+	get name() {
+		return this.definition.name;
+	}
+	/**
+	* Get the conversation log (JSONL persistence).
+	* Returns null for ephemeral agents (no disk).
+	* Lazy — created on first access.
+	*/
+	get conversationLog() {
+		if (this.ephemeral) return null;
+		if (!this._conversationLog) this._conversationLog = new ConversationLog(join(this.contextDir, "conversations", "personal.jsonl"));
+		return this._conversationLog;
+	}
+	/**
+	* Get the thin thread (bounded in-memory conversation buffer).
+	* Restores from ConversationLog on first access if history exists.
+	* Lazy — created on first access.
+	*/
+	get thinThread() {
+		if (!this._thinThread) {
+			const maxMessages = this.definition.context?.thin_thread ?? DEFAULT_THIN_THREAD_SIZE;
+			const log = this.conversationLog;
+			this._thinThread = log?.exists ? ThinThread.fromLog(log, maxMessages) : new ThinThread(maxMessages);
+		}
+		return this._thinThread;
+	}
+	/**
+	* Send a typed instruction to this agent's loop.
+	*
+	* Convenience method that creates an AgentInstruction and enqueues it.
+	* The loop must exist (call ensureAgentLoop first for standalone agents).
+	*
+	* @throws if no loop is attached
+	*/
+	send(instruction) {
+		if (!this.loop) throw new Error(`Agent "${this.name}" has no loop — call ensureAgentLoop first`);
+		this.loop.enqueue(instruction);
+	}
+	/**
+	* Send a simple message with auto-classified priority.
+	*
+	* Shorthand for creating an AgentInstruction from a raw message string.
+	*/
+	sendMessage(message, options = {}) {
+		this.send({
+			id: generateInstructionId(),
+			message,
+			source: options.source ?? "mention",
+			priority: options.priority ?? "immediate",
+			queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+	/**
+	* Ensure the context directory and all subdirectories exist.
+	* Called on agent load/creation. Idempotent.
+	*/
+	ensureContextDir() {
+		for (const sub of CONTEXT_SUBDIRS) mkdirSync(join(this.contextDir, sub), { recursive: true });
+	}
+	/**
+	* Read all memory entries as key-value records.
+	* Memory files are YAML in memory/<key>.yaml.
+	*/
+	async readMemory() {
+		const memDir = join(this.contextDir, "memory");
+		if (!existsSync(memDir)) return {};
+		const result = {};
+		const files = await readdir(memDir);
+		for (const file of files) {
+			if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+			const key = basename(file).replace(/\.ya?ml$/i, "");
+			try {
+				result[key] = parse(await readFile(join(memDir, file), "utf-8"));
+			} catch (err) {
+				this.log?.warn(`Skipping malformed memory file ${file}: ${err}`);
+			}
+		}
+		return result;
+	}
+	/**
+	* Write a memory entry. Creates/overwrites memory/<key>.yaml.
+	*/
+	async writeMemory(key, value) {
+		const memDir = join(this.contextDir, "memory");
+		await mkdir(memDir, { recursive: true });
+		await writeFile(join(memDir, `${key}.yaml`), stringify(value));
+	}
+	/**
+	* Read agent's notes, most recent first.
+	* Notes are markdown files in notes/.
+	*/
+	async readNotes(limit) {
+		const notesDir = join(this.contextDir, "notes");
+		if (!existsSync(notesDir)) return [];
+		const files = (await readdir(notesDir)).filter((f) => f.endsWith(".md")).sort().reverse();
+		const selected = limit ? files.slice(0, limit) : files;
+		return Promise.all(selected.map((f) => readFile(join(notesDir, f), "utf-8")));
+	}
+	/**
+	* Append a note. Creates notes/<date>-<slug>.md.
+	*/
+	async appendNote(content, slug) {
+		const notesDir = join(this.contextDir, "notes");
+		await mkdir(notesDir, { recursive: true });
+		const filename = `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}-${slug ?? `note-${Date.now().toString(36)}`}.md`;
+		await writeFile(join(notesDir, filename), content);
+		return filename;
+	}
+	/**
+	* Read active todos from todo/index.md.
+	* Returns lines that look like incomplete tasks: "- [ ] ..."
+	*/
+	async readTodos() {
+		const todoFile = join(this.contextDir, "todo", "index.md");
+		if (!existsSync(todoFile)) return [];
+		return (await readFile(todoFile, "utf-8")).split("\n").filter((line) => line.match(/^\s*-\s*\[\s*\]/)).map((line) => line.replace(/^\s*-\s*\[\s*\]\s*/, "").trim());
+	}
+	/**
+	* Write the full todo list. Replaces todo/index.md.
+	*/
+	async writeTodos(todos) {
+		const todoDir = join(this.contextDir, "todo");
+		await mkdir(todoDir, { recursive: true });
+		const content = todos.map((t) => `- [ ] ${t}`).join("\n") + "\n";
+		await writeFile(join(todoDir, "index.md"), content);
+	}
+};
+//#endregion
+//#region src/agent/agent-registry.ts
+/**
+* AgentRegistry — In-memory agent registry.
+*
+* Responsibilities:
+*   - Register/unregister agents at runtime
+*   - Ensure context directories exist (for config agents)
+*   - Provide agent lookup by name
+*
+* All agents are registered programmatically (from config.yml or daemon API).
+* No disk-based discovery (.agents/ is deprecated).
+*
+* Owned by the daemon. One registry per daemon process.
+*/
+var AgentRegistry = class {
+	/** Loaded agent handles, keyed by name */
+	agents = /* @__PURE__ */ new Map();
+	/** Workspace root directory (e.g. ~/.agent-worker/ for global) */
+	projectDir;
+	/** Optional logger (injected by daemon) */
+	log;
+	constructor(projectDir, logger) {
+		this.projectDir = projectDir;
+		this.log = logger;
+	}
+	/**
+	* Register a config agent (from config.yml). Creates context dir on disk.
+	* Overwrites existing agent with same name (reload semantics).
+	*/
+	registerDefinition(def) {
+		const contextDir = this.resolveContextDir(def);
+		const agentLogger = this.log?.child(def.name);
+		const handle = new AgentHandle(def, contextDir, agentLogger, false);
+		handle.ensureContextDir();
+		this.agents.set(def.name, handle);
+		return handle;
+	}
+	/**
+	* Register an ephemeral agent (from daemon API).
+	* Exists only in memory, lost on restart.
+	*/
+	registerEphemeral(def) {
+		const contextDir = this.resolveContextDir(def);
+		const agentLogger = this.log?.child(def.name);
+		const handle = new AgentHandle(def, contextDir, agentLogger, true);
+		this.agents.set(def.name, handle);
+		return handle;
+	}
+	/**
+	* Unregister an agent from memory.
+	* @returns true if agent existed and was removed.
+	*/
+	delete(name) {
+		return this.agents.delete(name);
+	}
+	/** Get agent handle by name */
+	get(name) {
+		return this.agents.get(name);
+	}
+	/** Check if agent exists */
+	has(name) {
+		return this.agents.has(name);
+	}
+	/** List all registered agent handles */
+	list() {
+		return [...this.agents.values()];
+	}
+	/** Number of registered agents */
+	get size() {
+		return this.agents.size;
+	}
+	/** Resolve agent's context directory (absolute path) */
+	resolveContextDir(def) {
+		if (def.context?.dir) return join(this.projectDir, def.context.dir);
+		return join(this.projectDir, "agents", def.name);
+	}
+};
+//#endregion
+//#region src/agent/store.ts
+/**
+* In-memory state store. State is lost when the daemon stops.
+* Suitable for development and single-machine deployments.
+*/
+var MemoryStateStore = class {
+	states = /* @__PURE__ */ new Map();
+	async load(agentId) {
+		return this.states.get(agentId) ?? null;
+	}
+	async save(agentId, state) {
+		this.states.set(agentId, state);
+	}
+	async delete(agentId) {
+		this.states.delete(agentId);
+	}
+};
+//#endregion
+//#region src/daemon/registry.ts
+/**
+* Daemon Registry
+*
+* Discovery: daemon.json = { pid, host, port, startedAt, token }
+* One daemon process on a fixed port. Clients read daemon.json to find it.
+*/
+const CONFIG_DIR = join(homedir(), ".agent-worker");
+const DEFAULT_PORT = 5099;
+const DAEMON_FILE = join(CONFIG_DIR, "daemon.json");
+/** Write daemon.json for client discovery */
+function writeDaemonInfo(info) {
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(DAEMON_FILE, JSON.stringify(info, null, 2));
+}
+/** Read daemon.json. Returns null if missing or malformed. */
+function readDaemonInfo() {
+	try {
+		return JSON.parse(readFileSync(DAEMON_FILE, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** Remove daemon.json (on shutdown) */
+function removeDaemonInfo() {
+	try {
+		unlinkSync(DAEMON_FILE);
+	} catch {}
+}
+/** Check if a daemon is already running (daemon.json exists + PID alive) */
+function isDaemonRunning() {
+	const info = readDaemonInfo();
+	if (!info) return null;
+	try {
+		process.kill(info.pid, 0);
+		return info;
+	} catch {
+		removeDaemonInfo();
+		return null;
+	}
+}
+//#endregion
+//#region src/daemon/config.ts
+/**
+* Daemon Config — Parse ~/.agent-worker/config.yml
+*
+* The daemon config IS a workflow YAML file. It defines agents (identity +
+* model + prompt) and channels (external platforms) in the standard workflow
+* format.
+*
+* Example config.yml:
+*   agents:
+*     alice:
+*       model: anthropic/claude-sonnet-4-5
+*       system_prompt: "You are a helpful assistant."
+*       wakeup: "0 9 * * *"
+*   channels:
+*     - adapter: telegram
+*       bot_token: ${TELEGRAM_BOT_TOKEN}
+*       chat_id: ${TELEGRAM_CHAT_ID}
+*/
+/**
+* Load daemon config from ~/.agent-worker/config.yml.
+* Returns null if file doesn't exist or parsing fails.
+*
+* Uses the standard workflow parser — same format as workflow YAML files.
+*/
+async function loadDaemonConfig(configDir) {
+	const configPath = join(configDir, "config.yml");
+	if (!existsSync(configPath)) return null;
+	try {
+		const { parseWorkflowFile } = await import("@moniro/workspace");
+		return await parseWorkflowFile(configPath, { workflow: "global" });
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/daemon/serve.ts
+/**
+* Start an HTTP server for a Hono app.
+* Auto-detects runtime: Bun.serve() when available, @hono/node-server otherwise.
+*/
+async function startHttpServer(app, options) {
+	if ("Bun" in globalThis) return startBun(app, options);
+	return startNode(app, options);
+}
+function startBun(app, options) {
+	const server = globalThis.Bun.serve({
+		fetch: app.fetch,
+		port: options.port,
+		hostname: options.hostname
+	});
+	return {
+		port: server.port ?? options.port,
+		close: async () => server.stop(true)
+	};
+}
+async function startNode(app, options) {
+	const mod = await import("@hono/node-server");
+	return new Promise((resolve, reject) => {
+		const server = mod.serve({
+			fetch: app.fetch,
+			port: options.port,
+			hostname: options.hostname
+		}, (info) => {
+			resolve({
+				port: info.port,
+				close: () => new Promise((r) => server.close(() => r()))
+			});
+		});
+		server.on("error", reject);
+	});
+}
+//#endregion
+//#region src/daemon/event-log.ts
+/**
+* DaemonEventLog — Daemon-level append-only JSONL event log.
+*
+* Persists to `~/.agent-worker/events.jsonl`.
+* Records daemon startup/shutdown, registry operations, importer progress.
+*
+* Uses the same Message format as ChannelStore and TimelineStore,
+* enabling read-time merge for unified timeline views.
+*/
+const EVENTS_FILE = "events.jsonl";
+/**
+* Append-only JSONL event log for daemon-level events.
+* Uses synchronous writes — daemon events are infrequent and must not be lost.
+*/
+var DaemonEventLog = class {
+	filePath;
+	constructor(daemonDir) {
+		if (!existsSync(daemonDir)) mkdirSync(daemonDir, { recursive: true });
+		this.filePath = join(daemonDir, EVENTS_FILE);
+	}
+	append(from, content, options) {
+		const event = {
+			id: nanoid(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			from,
+			content,
+			mentions: [],
+			kind: options?.kind ?? "system"
+		};
+		const line = JSON.stringify(event) + "\n";
+		try {
+			appendFileSync(this.filePath, line);
+		} catch {}
+	}
+	/** Read all events (full file read). */
+	async readAll() {
+		try {
+			return (await readFile(this.filePath, "utf-8")).split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+		} catch {
+			return [];
+		}
+	}
+	/** Read events from byte offset (incremental sync). */
+	async readFrom(offset) {
+		let fh;
+		try {
+			fh = await open(this.filePath, "r");
+			const { size } = await fh.stat();
+			if (offset >= size) return {
+				events: [],
+				offset: size
+			};
+			const length = size - offset;
+			const buffer = Buffer.alloc(length);
+			await fh.read(buffer, 0, length, offset);
+			const content = buffer.toString("utf-8");
+			const events = [];
+			for (const line of content.split("\n")) {
+				const trimmed = line.trim();
+				if (!trimmed) continue;
+				try {
+					events.push(JSON.parse(trimmed));
+				} catch {}
+			}
+			return {
+				events,
+				offset: size
+			};
+		} catch {
+			return {
+				events: [],
+				offset
+			};
+		} finally {
+			await fh?.close();
+		}
+	}
+};
+//#endregion
+//#region src/daemon/daemon.ts
+/**
+* Daemon — Centralized agent coordinator.
+*
+* Architecture: Interface → Daemon → Loop (three layers)
+*   Interface: CLI/REST/MCP clients talk to daemon via HTTP
+*   Daemon:    This module — owns lifecycle, creates workspaces + loops
+*   Loop:      AgentLoop + Backend — executes agent reasoning
+*
+* Data ownership:
+*   AgentRegistry (agents) — what agents exist + their handles (loop, state)
+*   defaultWorkspace       — shared workspace for all standalone agents
+*   Workflows (workflows)  — running workflow instances (each with own workspace)
+*
+* Key principle: agents own their loops (stored on AgentHandle). One shared
+* default workspace provides infrastructure (context, MCP, channels) for all
+* standalone agents. Workflows get their own isolated workspaces.
+* Bridge config comes from ~/.agent-worker/config.yml.
+*
+* HTTP endpoints:
+*   GET  /health, POST /shutdown
+*   GET/POST /agents, GET/DELETE /agents/:name
+*   POST /run (SSE), POST /serve
+*   GET/POST /workflows, DELETE /workflows/:name/:tag
+*   ALL  /mcp
+*/
+var daemon_exports = /* @__PURE__ */ __exportAll({
+	createDaemonApp: () => createDaemonApp,
+	startDaemon: () => startDaemon
+});
+let state = null;
+let shuttingDown = false;
+let log = createSilentLogger();
+const mcpSessions = /* @__PURE__ */ new Map();
+async function gracefulShutdown() {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	if (state) {
+		for (const handle of state.agents.list()) if (handle.loop) {
+			try {
+				await handle.loop.stop();
+			} catch {}
+			handle.loop = null;
+		}
+		for (const [, wf] of state.workflows) try {
+			await wf.shutdown();
+		} catch {}
+		state.workflows.clear();
+		if (state.defaultWorkspace) try {
+			await state.defaultWorkspace.shutdown();
+		} catch {}
+		if (state.server) await state.server.close();
+	}
+	for (const [, session] of mcpSessions) try {
+		await session.transport.close();
+	} catch {}
+	mcpSessions.clear();
+	removeDaemonInfo();
+	process.exit(0);
+}
+/** Safe JSON body parsing — returns null on malformed input */
+async function parseJsonBody(c) {
+	try {
+		return await c.req.json();
+	} catch {
+		return null;
+	}
+}
+/** Map AgentDefinition to the ResolvedWorkflowAgent type needed by the factory */
+function defToResolvedAgent(def) {
+	return {
+		backend: def.backend,
+		model: def.model,
+		provider: def.provider,
+		resolvedSystemPrompt: def.prompt.system ?? "",
+		schedule: def.schedule
+	};
+}
+/** Convert a ResolvedWorkflowAgent (from workflow parser) to AgentDefinition (for registry) */
+function resolvedToAgentDef(name, agent) {
+	return {
+		name,
+		model: agent.model ?? "auto",
+		backend: agent.backend === "default" ? "sdk" : agent.backend,
+		provider: agent.provider,
+		prompt: { system: agent.resolvedSystemPrompt ?? "" },
+		schedule: agent.schedule,
+		max_tokens: agent.max_tokens,
+		max_steps: agent.max_steps
+	};
+}
+/**
+* Find an agent's loop.
+* First checks the agent handle (standalone agents own their loop),
+* then falls back to workflow-scoped loops (workflow agents).
+*/
+function findLoop(s, agentName) {
+	const handle = s.agents.get(agentName);
+	if (handle?.loop) return handle.loop;
+	for (const wf of s.workflows.values()) {
+		const l = wf.loops.get(agentName);
+		if (l) return l;
+	}
+	return null;
+}
+/**
+* Ensure the default workspace exists.
+* Creates it lazily on first call (starts MCP server, channels, etc.).
+*/
+async function ensureDefaultWorkspace(s) {
+	if (s.defaultWorkspace) return s.defaultWorkspace;
+	const agentNames = s.agents.list().map((h) => h.name);
+	const channelAdapters = s.config?.channels ? createChannelAdapters(s.config.channels) : void 0;
+	const workspace = await createMinimalRuntime({
+		workflowName: "global",
+		tag: void 0,
+		agentNames: agentNames.length > 0 ? agentNames : ["user"],
+		resolveHandle: (name) => s.agents.get(name) ?? void 0,
+		channelAdapters: channelAdapters && channelAdapters.length > 0 ? channelAdapters : void 0,
+		onMention: (_from, target) => {
+			const handle = s.agents.get(target);
+			if (handle?.loop) handle.loop.wake();
+		}
+	});
+	s.defaultWorkspace = workspace;
+	if (workspace.bridge) workspace.bridge.subscribe({}, (msg) => {
+		if (!msg.from.includes(":")) return;
+		const targeted = /* @__PURE__ */ new Set();
+		for (const target of msg.mentions) {
+			targeted.add(target);
+			const handle = s.agents.get(target);
+			if (handle?.loop) handle.loop.wake();
+		}
+		if (msg.to && !targeted.has(msg.to)) {
+			targeted.add(msg.to);
+			const handle = s.agents.get(msg.to);
+			if (handle?.loop) handle.loop.wake();
+		}
+		if (targeted.size === 0) {
+			for (const handle of s.agents.list()) if (handle.loop) handle.loop.enqueue({
+				id: generateInstructionId(),
+				message: `[${msg.from}]: ${msg.content}`,
+				source: "channel",
+				priority: "normal",
+				queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+	});
+	if (channelAdapters && channelAdapters.length > 0) log.info(`Channels: ${channelAdapters.map((a) => a.platform).join(", ")}`);
+	return workspace;
+}
+/**
+* Ensure a standalone agent has a loop.
+* Uses the shared default workspace.
+*
+* This is the bridge between POST /agents (stores definition only) and
+* POST /run or /serve (needs a loop to execute).
+*/
+async function ensureAgentLoop(s, agentName) {
+	const existing = findLoop(s, agentName);
+	if (existing) return existing;
+	const handle = s.agents.get(agentName);
+	if (!handle) throw new Error(`Agent not found: ${agentName}`);
+	const { loop } = createWiredLoop({
+		name: agentName,
+		agent: defToResolvedAgent(handle.definition),
+		runtime: await ensureDefaultWorkspace(s),
+		conversationLog: handle.conversationLog ?? void 0,
+		thinThread: handle.thinThread
+	});
+	handle.loop = loop;
+	return loop;
+}
+/**
+* Create the Hono app with all daemon routes.
+*
+* Accepts a state getter so the app can be used both in production
+* (module-level state set by startDaemon) and in tests (injected state).
+*
+* When a token is provided, all endpoints require `Authorization: Bearer <token>`.
+* This prevents cross-origin attacks from malicious websites.
+*/
+function createDaemonApp(options) {
+	const { getState, token } = options;
+	const app = new Hono();
+	if (token) app.use("*", async (c, next) => {
+		if (c.req.header("authorization") !== `Bearer ${token}`) return c.json({ error: "Unauthorized" }, 401);
+		await next();
+	});
+	app.get("/health", (c) => {
+		const s = getState();
+		if (!s) return c.json({ status: "unavailable" }, 503);
+		const agentNames = s.agents.list().map((h) => h.name);
+		const workflowList = [...s.workflows.values()].map((wf) => ({
+			name: wf.name,
+			tag: wf.tag,
+			agents: wf.agents
+		}));
+		const configAgentNames = s.agents.list().filter((h) => !h.ephemeral).map((h) => h.name);
+		return c.json({
+			status: "ok",
+			pid: process.pid,
+			port: s.port,
+			uptime: Date.now() - new Date(s.startedAt).getTime(),
+			agents: agentNames,
+			configAgents: configAgentNames,
+			workflows: workflowList
+		});
+	});
+	app.post("/shutdown", (c) => {
+		setImmediate(() => gracefulShutdown());
+		return c.json({ success: true });
+	});
+	app.get("/agents", (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const standaloneAgents = s.agents.list().map((handle) => {
+			const def = handle.definition;
+			return {
+				name: def.name,
+				model: def.model,
+				backend: def.backend ?? "default",
+				workflow: "global",
+				tag: void 0,
+				createdAt: void 0,
+				source: handle.ephemeral ? "ephemeral" : "config",
+				state: handle.loop?.state
+			};
+		});
+		const workflowAgents = [...s.workflows.values()].flatMap((wf) => wf.agents.map((agentName) => {
+			const loop = wf.loops.get(agentName);
+			return {
+				name: agentName,
+				model: "",
+				backend: "",
+				workflow: wf.name,
+				tag: wf.tag,
+				createdAt: wf.startedAt,
+				source: "workflow",
+				state: loop?.state ?? "unknown"
+			};
+		}));
+		return c.json({ agents: [...standaloneAgents, ...workflowAgents] });
+	});
+	app.post("/agents", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { name, model, system, backend = "default", provider, workflow, tag, schedule } = body;
+		if (!name || !model || !system) return c.json({ error: "name, model, system required" }, 400);
+		if (s.agents.has(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
+		const def = {
+			name,
+			model,
+			backend,
+			provider,
+			prompt: { system },
+			schedule
+		};
+		s.agents.registerEphemeral(def);
+		return c.json({
+			name,
+			model,
+			backend,
+			workflow,
+			tag,
+			schedule
+		}, 201);
+	});
+	app.get("/agents/:name", (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const handle = s.agents.get(c.req.param("name"));
+		if (!handle) return c.json({ error: "Agent not found" }, 404);
+		const def = handle.definition;
+		return c.json({
+			name: def.name,
+			model: def.model,
+			backend: def.backend ?? "default",
+			system: def.prompt.system,
+			workflow: void 0,
+			tag: void 0,
+			createdAt: void 0,
+			schedule: def.schedule
+		});
+	});
+	app.delete("/agents/:name", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const name = c.req.param("name");
+		const handle = s.agents.get(name);
+		if (!handle) return c.json({ error: "Agent not found" }, 404);
+		if (!handle.ephemeral) return c.json({ error: `"${name}" is defined in config.yml — edit config to remove` }, 403);
+		if (handle.loop) {
+			try {
+				await handle.loop.stop();
+			} catch {}
+			handle.loop = null;
+		}
+		s.agents.delete(name);
+		return c.json({ success: true });
+	});
+	app.post("/run", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { agent: agentName, message } = body;
+		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
+		let loop;
+		const existingLoop = findLoop(s, agentName);
+		if (existingLoop) loop = existingLoop;
+		else if (s.agents.has(agentName)) try {
+			loop = await ensureAgentLoop(s, agentName);
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to create agent runtime: ${msg}` }, 500);
+		}
+		if (!loop) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		const agentLoop = loop;
+		return streamSSE(c, async (stream) => {
+			try {
+				const result = await agentLoop.sendDirect(message);
+				if (result.success) {
+					if (result.content) await stream.writeSSE({
+						event: "chunk",
+						data: JSON.stringify({
+							agent: agentName,
+							text: result.content
+						})
+					});
+					await stream.writeSSE({
+						event: "done",
+						data: JSON.stringify(result)
+					});
+				} else await stream.writeSSE({
+					event: "error",
+					data: JSON.stringify({ error: result.error })
+				});
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				await stream.writeSSE({
+					event: "error",
+					data: JSON.stringify({ error: msg })
+				});
+			}
+		});
+	});
+	app.post("/serve", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { agent: agentName, message } = body;
+		if (!agentName || !message) return c.json({ error: "agent and message required" }, 400);
+		let loop;
+		const existingLoop = findLoop(s, agentName);
+		if (existingLoop) loop = existingLoop;
+		else if (s.agents.has(agentName)) try {
+			loop = await ensureAgentLoop(s, agentName);
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: msg }, 500);
+		}
+		if (!loop) return c.json({ error: `Agent not found: ${agentName}` }, 404);
+		try {
+			const result = await loop.sendDirect(message);
+			if (!result.success) return c.json({ error: result.error }, 500);
+			return c.json({
+				content: result.content ?? "",
+				duration: result.duration,
+				success: true
+			});
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: msg }, 500);
+		}
+	});
+	app.all("/mcp", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const req = c.req.raw;
+		const sessionId = req.headers.get("mcp-session-id");
+		if (sessionId && mcpSessions.has(sessionId)) {
+			const session = mcpSessions.get(sessionId);
+			if (req.method === "DELETE") {
+				await session.transport.close();
+				mcpSessions.delete(sessionId);
+				return new Response(null, { status: 200 });
+			}
+			return session.transport.handleRequest(req);
+		}
+		if (req.method === "POST") {
+			const body = await req.json();
+			if (!(Array.isArray(body) ? body.some((m) => m?.method === "initialize") : body?.method === "initialize")) return c.json({ error: "Bad request: session required" }, 400);
+			const agentName = new URL(req.url).searchParams.get("agent") || "user";
+			const handle = s.agents.get(agentName);
+			const provider = (await ensureDefaultWorkspace(s)).contextProvider;
+			const transport = new WebStandardStreamableHTTPServerTransport({
+				sessionIdGenerator: () => `${agentName}-${randomUUID().slice(0, 8)}`,
+				onsessioninitialized: (sid) => {
+					mcpSessions.set(sid, {
+						transport,
+						agentId: agentName
+					});
+				},
+				onsessionclosed: (sid) => {
+					mcpSessions.delete(sid);
+				},
+				enableJsonResponse: true
+			});
+			await createContextMCPServer({
+				provider,
+				validAgents: [...new Set([
+					agentName,
+					...s.agents.list().map((h) => h.name),
+					"user"
+				])],
+				name: `${handle?.definition.name ?? agentName}-context`,
+				version: "1.0.0",
+				resolveHandle: (name) => s.agents.get(name) ?? void 0
+			}).server.connect(transport);
+			return transport.handleRequest(req, { parsedBody: body });
+		}
+		if (req.method === "GET") return c.json({ error: "Session ID required for GET requests" }, 400);
+		return c.json({ error: "Method not allowed" }, 405);
+	});
+	app.post("/workflows", async (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const body = await parseJsonBody(c);
+		if (!body || typeof body !== "object") return c.json({ error: "Invalid JSON body" }, 400);
+		const { workflow, tag, feedback, pollInterval, params } = body;
+		if (!workflow || !workflow.agents) return c.json({ error: "workflow (parsed YAML) required" }, 400);
+		const workflowName = workflow.name || "global";
+		const key = tag ? `${workflowName}:${tag}` : workflowName;
+		if (s.workflows.has(key)) return c.json({ error: `Workflow already running: ${key}` }, 409);
+		try {
+			const { runWorkflowWithLoops } = await import("@moniro/workspace");
+			const result = await runWorkflowWithLoops({
+				workflow,
+				workflowName,
+				tag,
+				mode: "start",
+				headless: true,
+				feedback,
+				pollInterval,
+				params,
+				log: () => {}
+			});
+			if (!result.success) return c.json({ error: result.error || "Workflow failed to start" }, 500);
+			const workspace = {
+				contextProvider: result.contextProvider,
+				contextDir: "",
+				persistent: false,
+				eventLog: null,
+				httpMcpServer: null,
+				mcpUrl: result.mcpUrl ?? "",
+				mcpToolNames: /* @__PURE__ */ new Set(),
+				projectDir: process.cwd(),
+				shutdown: result.shutdown
+			};
+			const handle = {
+				name: workflowName,
+				tag,
+				key,
+				agents: Object.keys(workflow.agents),
+				loops: result.loops,
+				workspace,
+				shutdown: result.shutdown,
+				workflowPath: workflow.filePath,
+				startedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			s.workflows.set(key, handle);
+			return c.json({
+				key,
+				name: workflowName,
+				tag,
+				agents: handle.agents
+			}, 201);
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to start workflow: ${msg}` }, 500);
+		}
+	});
+	app.get("/workflows", (c) => {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const workflows = [...s.workflows.values()].map((wf) => {
+			const agentStates = {};
+			for (const [name, loop] of wf.loops) agentStates[name] = loop.state;
+			return {
+				name: wf.name,
+				tag: wf.tag,
+				key: wf.key,
+				agents: wf.agents,
+				agentStates,
+				workflowPath: wf.workflowPath,
+				startedAt: wf.startedAt
+			};
+		});
+		return c.json({ workflows });
+	});
+	async function deleteWorkflow(c, name, tag) {
+		const s = getState();
+		if (!s) return c.json({ error: "Not ready" }, 503);
+		const key = tag ? `${name}:${tag}` : name;
+		const handle = s.workflows.get(key);
+		if (!handle) return c.json({ error: `Workflow not found: ${key}` }, 404);
+		try {
+			await handle.shutdown();
+			s.workflows.delete(key);
+			return c.json({
+				success: true,
+				key
+			});
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			return c.json({ error: `Failed to stop workflow: ${msg}` }, 500);
+		}
+	}
+	app.delete("/workflows/:name/:tag", (c) => deleteWorkflow(c, c.req.param("name"), c.req.param("tag")));
+	app.delete("/workflows/:name", (c) => deleteWorkflow(c, c.req.param("name"), void 0));
+	return app;
+}
+async function startDaemon(config = {}) {
+	log = createEventLogger(new DaemonEventLog(CONFIG_DIR), "daemon");
+	const existing = isDaemonRunning();
+	if (existing) {
+		log.error(`Daemon already running: pid=${existing.pid} port=${existing.port}`);
+		process.exit(1);
+	}
+	const host = config.host ?? "127.0.0.1";
+	const store = config.store ?? new MemoryStateStore();
+	const token = randomUUID();
+	const server = await startHttpServer(createDaemonApp({
+		getState: () => state,
+		token
+	}), {
+		port: config.port ?? 5099,
+		hostname: host
+	});
+	const actualPort = server.port;
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	writeDaemonInfo({
+		pid: process.pid,
+		host,
+		port: actualPort,
+		startedAt,
+		token
+	});
+	const agents = new AgentRegistry(CONFIG_DIR, log);
+	const bootConfig = await loadDaemonConfig(CONFIG_DIR);
+	if (bootConfig) {
+		const agentNames = Object.keys(bootConfig.agents);
+		for (const name of agentNames) {
+			const def = resolvedToAgentDef(name, bootConfig.agents[name]);
+			agents.registerDefinition(def);
+		}
+		if (agentNames.length > 0) log.info(`Loaded ${agentNames.length} agent(s) from config.yml: ${agentNames.join(", ")}`);
+	}
+	state = {
+		agents,
+		defaultWorkspace: null,
+		config: bootConfig,
+		workflows: /* @__PURE__ */ new Map(),
+		store,
+		server,
+		port: actualPort,
+		host,
+		startedAt
+	};
+	log.info(`Daemon started: pid=${process.pid}`);
+	log.info(`Listening: http://${host}:${actualPort}`);
+	log.info(`MCP: http://${host}:${actualPort}/mcp`);
+	if (bootConfig?.channels && bootConfig.channels.length > 0) await ensureDefaultWorkspace(state);
+	const configAgents = agents.list().filter((h) => !h.ephemeral);
+	if (configAgents.length > 0) {
+		log.info(`Auto-starting ${configAgents.length} agent(s)...`);
+		for (const handle of configAgents) try {
+			await (await ensureAgentLoop(state, handle.name)).start();
+			log.info(`Agent started: ${handle.name}`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log.info(`Failed to start agent ${handle.name}: ${msg}`);
+		}
+	}
+	process.on("SIGINT", () => {
+		log.info("Shutting down...");
+		gracefulShutdown();
+	});
+	process.on("SIGTERM", () => {
+		log.info("Shutting down...");
+		gracefulShutdown();
+	});
+}
+//#endregion
+export { isDaemonRunning as a, writeDaemonInfo as c, AgentHandle as d, DEFAULT_PORT as i, MemoryStateStore as l, startDaemon as n, readDaemonInfo as o, DaemonEventLog as r, removeDaemonInfo as s, daemon_exports as t, AgentRegistry as u };