remoteclaw 0.0.0 → 0.1.0-next.2abd2fa

package/dist/targets-DfqPGOmM.js

@@ -0,0 +1,2173 @@
+import { h as normalizeVerboseLevel } from "./agent-helpers-B6VfZ9_u.js";
+import { h as normalizeAnyChannelId } from "./subsystem-COd61u0P.js";
+import { n as defaultRuntime } from "./runtime-DJNp29jv.js";
+import { h as normalizeAccountId, v as deriveSessionChatType } from "./session-key-5YLnn_qf.js";
+import { a as normalizeProviderId } from "./provider-utils-FaBmofiq.js";
+import { c as normalizeMessageChannel, n as isDeliverableMessageChannel, t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-DzJqHVZD.js";
+import { t as parseDiscordTarget } from "./targets-D-u6Kyio.js";
+import { t as getChannelDock } from "./dock-CQuu41bw.js";
+import { t as normalizeChatType } from "./chat-type-DKb2TlGZ.js";
+import { t as formatCliCommand } from "./command-format-DgXcqxBt.js";
+import { a as ensureAuthProfileStore, r as listProfilesForProvider } from "./auth-profiles-D8vKiBPq.js";
+import { a as isWhatsAppGroupJid, o as normalizeWhatsAppTarget, r as normalizeChannelId, t as getChannelPlugin } from "./plugins-woGRXMzU.js";
+import { t as SILENT_REPLY_TOKEN } from "./tokens-DzFOtLlW.js";
+import { p as getGlobalHookRunner } from "./reply-payloads-D_BM1Anb.js";
+import { t as parseSlackTarget } from "./targets-DyybKefq.js";
+import { d as deliveryContextFromSession, l as updateSessionStore } from "./store-SusmIfz7.js";
+import { i as resolveTelegramTargetChatType, r as parseTelegramTarget } from "./targets-D-qLBpTA.js";
+import { n as missingTargetError } from "./target-errors-BDpPcwh5.js";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdir, mkdtemp, readFile, readdir, rm, rmdir, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+//#region src/sessions/send-policy.ts
+function normalizeSendPolicy(raw) {
+	const value = raw?.trim().toLowerCase();
+	if (value === "allow") return "allow";
+	if (value === "deny") return "deny";
+}
+function normalizeMatchValue(raw) {
+	const value = raw?.trim().toLowerCase();
+	return value ? value : void 0;
+}
+function stripAgentSessionKeyPrefix(key) {
+	if (!key) return;
+	const parts = key.split(":").filter(Boolean);
+	if (parts.length >= 3 && parts[0] === "agent") return parts.slice(2).join(":");
+	return key;
+}
+function deriveChannelFromKey(key) {
+	const normalizedKey = stripAgentSessionKeyPrefix(key);
+	if (!normalizedKey) return;
+	const parts = normalizedKey.split(":").filter(Boolean);
+	if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) return normalizeMatchValue(parts[0]);
+}
+function deriveChatTypeFromKey(key) {
+	const chatType = deriveSessionChatType(key);
+	return chatType === "unknown" ? void 0 : chatType;
+}
+function resolveSendPolicy(params) {
+	const override = normalizeSendPolicy(params.entry?.sendPolicy);
+	if (override) return override;
+	const policy = params.cfg.session?.sendPolicy;
+	if (!policy) return "allow";
+	const channel = normalizeMatchValue(params.channel) ?? normalizeMatchValue(params.entry?.channel) ?? normalizeMatchValue(params.entry?.lastChannel) ?? deriveChannelFromKey(params.sessionKey);
+	const chatType = normalizeChatType(params.chatType ?? params.entry?.chatType) ?? normalizeChatType(deriveChatTypeFromKey(params.sessionKey));
+	const rawSessionKey = params.sessionKey ?? "";
+	const strippedSessionKey = stripAgentSessionKeyPrefix(rawSessionKey) ?? "";
+	const rawSessionKeyNorm = rawSessionKey.toLowerCase();
+	const strippedSessionKeyNorm = strippedSessionKey.toLowerCase();
+	let allowedMatch = false;
+	for (const rule of policy.rules ?? []) {
+		if (!rule) continue;
+		const action = normalizeSendPolicy(rule.action) ?? "allow";
+		const match = rule.match ?? {};
+		const matchChannel = normalizeMatchValue(match.channel);
+		const matchChatType = normalizeChatType(match.chatType);
+		const matchPrefix = normalizeMatchValue(match.keyPrefix);
+		const matchRawPrefix = normalizeMatchValue(match.rawKeyPrefix);
+		if (matchChannel && matchChannel !== channel) continue;
+		if (matchChatType && matchChatType !== chatType) continue;
+		if (matchRawPrefix && !rawSessionKeyNorm.startsWith(matchRawPrefix)) continue;
+		if (matchPrefix && !rawSessionKeyNorm.startsWith(matchPrefix) && !strippedSessionKeyNorm.startsWith(matchPrefix)) continue;
+		if (action === "deny") return "deny";
+		allowedMatch = true;
+	}
+	if (allowedMatch) return "allow";
+	return normalizeSendPolicy(policy.default) ?? "allow";
+}
+
+//#endregion
+//#region src/infra/system-events.ts
+const MAX_EVENTS = 20;
+const queues = /* @__PURE__ */ new Map();
+function requireSessionKey(key) {
+	const trimmed = typeof key === "string" ? key.trim() : "";
+	if (!trimmed) throw new Error("system events require a sessionKey");
+	return trimmed;
+}
+function normalizeContextKey(key) {
+	if (!key) return null;
+	const trimmed = key.trim();
+	if (!trimmed) return null;
+	return trimmed.toLowerCase();
+}
+function isSystemEventContextChanged(sessionKey, contextKey) {
+	const key = requireSessionKey(sessionKey);
+	const existing = queues.get(key);
+	return normalizeContextKey(contextKey) !== (existing?.lastContextKey ?? null);
+}
+function enqueueSystemEvent(text, options) {
+	const key = requireSessionKey(options?.sessionKey);
+	const entry = queues.get(key) ?? (() => {
+		const created = {
+			queue: [],
+			lastText: null,
+			lastContextKey: null
+		};
+		queues.set(key, created);
+		return created;
+	})();
+	const cleaned = text.trim();
+	if (!cleaned) return;
+	const normalizedContextKey = normalizeContextKey(options?.contextKey);
+	entry.lastContextKey = normalizedContextKey;
+	if (entry.lastText === cleaned) return;
+	entry.lastText = cleaned;
+	entry.queue.push({
+		text: cleaned,
+		ts: Date.now(),
+		contextKey: normalizedContextKey
+	});
+	if (entry.queue.length > MAX_EVENTS) entry.queue.shift();
+}
+function drainSystemEventEntries(sessionKey) {
+	const key = requireSessionKey(sessionKey);
+	const entry = queues.get(key);
+	if (!entry || entry.queue.length === 0) return [];
+	const out = entry.queue.slice();
+	entry.queue.length = 0;
+	entry.lastText = null;
+	entry.lastContextKey = null;
+	queues.delete(key);
+	return out;
+}
+function peekSystemEventEntries(sessionKey) {
+	const key = requireSessionKey(sessionKey);
+	return queues.get(key)?.queue.map((event) => ({ ...event })) ?? [];
+}
+function peekSystemEvents(sessionKey) {
+	return peekSystemEventEntries(sessionKey).map((event) => event.text);
+}
+
+//#endregion
+//#region src/sessions/level-overrides.ts
+function parseVerboseOverride(raw) {
+	if (raw === null) return {
+		ok: true,
+		value: null
+	};
+	if (raw === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	if (typeof raw !== "string") return {
+		ok: false,
+		error: "invalid verboseLevel (use \"on\"|\"off\")"
+	};
+	const normalized = normalizeVerboseLevel(raw);
+	if (!normalized) return {
+		ok: false,
+		error: "invalid verboseLevel (use \"on\"|\"off\")"
+	};
+	return {
+		ok: true,
+		value: normalized
+	};
+}
+function applyVerboseOverride(entry, level) {
+	if (level === void 0) return;
+	if (level === null) {
+		delete entry.verboseLevel;
+		return;
+	}
+	entry.verboseLevel = level;
+}
+
+//#endregion
+//#region src/agents/auth-profiles/session-override.ts
+function isProfileForProvider(params) {
+	const entry = params.store.profiles[params.profileId];
+	if (!entry?.provider) return false;
+	return normalizeProviderId(entry.provider) === normalizeProviderId(params.provider);
+}
+async function clearSessionAuthProfileOverride(params) {
+	const { sessionEntry, sessionStore, sessionKey, storePath } = params;
+	delete sessionEntry.authProfileOverride;
+	delete sessionEntry.authProfileOverrideSource;
+	delete sessionEntry.authProfileOverrideCompactionCount;
+	sessionEntry.updatedAt = Date.now();
+	sessionStore[sessionKey] = sessionEntry;
+	if (storePath) await updateSessionStore(storePath, (store) => {
+		store[sessionKey] = sessionEntry;
+	});
+}
+async function resolveSessionAuthProfileOverride(params) {
+	const { provider, agentDir, sessionEntry, sessionStore, sessionKey, storePath } = params;
+	if (!sessionEntry || !sessionStore || !sessionKey) return sessionEntry?.authProfileOverride;
+	const store = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
+	const profiles = listProfilesForProvider(store, provider);
+	let current = sessionEntry.authProfileOverride?.trim();
+	if (current && !store.profiles[current]) {
+		await clearSessionAuthProfileOverride({
+			sessionEntry,
+			sessionStore,
+			sessionKey,
+			storePath
+		});
+		current = void 0;
+	}
+	if (current && !isProfileForProvider({
+		provider,
+		profileId: current,
+		store
+	})) {
+		await clearSessionAuthProfileOverride({
+			sessionEntry,
+			sessionStore,
+			sessionKey,
+			storePath
+		});
+		current = void 0;
+	}
+	if (profiles.length === 0) return;
+	const next = current ?? profiles[0];
+	if (!next) return current;
+	if (next !== sessionEntry.authProfileOverride || sessionEntry.authProfileOverrideSource !== "auto") {
+		sessionEntry.authProfileOverride = next;
+		sessionEntry.authProfileOverrideSource = "auto";
+		sessionEntry.updatedAt = Date.now();
+		sessionStore[sessionKey] = sessionEntry;
+		if (storePath) await updateSessionStore(storePath, (store) => {
+			store[sessionKey] = sessionEntry;
+		});
+	}
+	return next;
+}
+
+//#endregion
+//#region src/agents/channel-tools.ts
+/**
+* Get the list of supported message actions for a specific channel.
+* Returns an empty array if channel is not found or has no actions configured.
+*/
+function listChannelSupportedActions(params) {
+	if (!params.channel) return [];
+	const plugin = getChannelPlugin(params.channel);
+	if (!plugin?.actions?.listActions) return [];
+	return runPluginListActions(plugin, params.cfg ?? {});
+}
+function resolveChannelMessageToolHints(params) {
+	const channelId = normalizeAnyChannelId(params.channel);
+	if (!channelId) return [];
+	const resolve = getChannelDock(channelId)?.agentPrompt?.messageToolHints;
+	if (!resolve) return [];
+	return (resolve({
+		cfg: params.cfg ?? {},
+		accountId: params.accountId
+	}) ?? []).map((entry) => entry.trim()).filter(Boolean);
+}
+const loggedListActionErrors = /* @__PURE__ */ new Set();
+function runPluginListActions(plugin, cfg) {
+	if (!plugin.actions?.listActions) return [];
+	try {
+		const listed = plugin.actions.listActions({ cfg });
+		return Array.isArray(listed) ? listed : [];
+	} catch (err) {
+		logListActionsError(plugin.id, err);
+		return [];
+	}
+}
+function logListActionsError(pluginId, err) {
+	const message = err instanceof Error ? err.message : String(err);
+	const key = `${pluginId}:${message}`;
+	if (loggedListActionErrors.has(key)) return;
+	loggedListActionErrors.add(key);
+	const details = (err instanceof Error && err.stack ? err.stack : null) ?? message;
+	defaultRuntime.error?.(`[channel-tools] ${pluginId}.actions.listActions failed: ${details}`);
+}
+
+//#endregion
+//#region src/middleware/delivery-adapter.ts
+const DEFAULT_CHUNK_LIMIT = 4e3;
+/**
+* Converts AgentEvent async iterable into channel-deliverable ReplyPayload chunks.
+*
+* Handles:
+* - Text accumulation and chunking at channel limits
+* - Progressive streaming via BridgeCallbacks
+* - Tool result formatting
+* - Error event formatting
+*/
+var DeliveryAdapter = class {
+	constructor(options) {
+		this.chunkLimit = options?.chunkLimit ?? DEFAULT_CHUNK_LIMIT;
+	}
+	/**
+	* Process an event stream, invoking callbacks for real-time delivery
+	* and returning final payloads for post-execution delivery.
+	*
+	* @param events - AgentEvent async iterable from runtime.execute()
+	* @param callbacks - Optional streaming callbacks for real-time delivery
+	* @returns Final ReplyPayload array for post-execution delivery
+	*/
+	async process(events, callbacks) {
+		let textBuffer = "";
+		const payloads = [];
+		for await (const event of events) switch (event.type) {
+			case "text":
+				if (event.text === "") break;
+				textBuffer += event.text;
+				while (textBuffer.length > this.chunkLimit) {
+					const { chunk, rest } = splitAtBoundary(textBuffer, this.chunkLimit);
+					textBuffer = rest;
+					const payload = { text: chunk };
+					payloads.push(payload);
+					await callbacks?.onPartialReply?.(payload);
+				}
+				break;
+			case "tool_use": break;
+			case "tool_result": {
+				const payload = { text: formatToolResult(event.toolId, event.output, event.isError) };
+				await callbacks?.onToolResult?.(payload);
+				break;
+			}
+			case "error": {
+				const payload = {
+					text: event.code ? `[${event.code}] ${event.message}` : event.message,
+					isError: true
+				};
+				payloads.push(payload);
+				await callbacks?.onBlockReply?.(payload);
+				break;
+			}
+			case "done":
+				if (textBuffer.length > 0) {
+					const payload = { text: textBuffer };
+					payloads.push(payload);
+					await callbacks?.onBlockReply?.(payload);
+					textBuffer = "";
+				}
+				break;
+		}
+		if (textBuffer.length > 0) {
+			const payload = { text: textBuffer };
+			payloads.push(payload);
+		}
+		return payloads;
+	}
+};
+/** Format a tool result for display. */
+function formatToolResult(toolId, output, isError) {
+	return `${isError ? `Tool ${toolId} error` : `Tool ${toolId} result`}: ${output}`;
+}
+/**
+* Split text at the nearest safe boundary before the limit.
+*
+* Preference order:
+* 1. Paragraph break (\n\n)
+* 2. Line break (\n)
+* 3. Word boundary (space)
+* 4. Hard split at limit
+*
+* Markdown-aware: preserves code fence boundaries by closing/reopening
+* fences at split points when a split occurs inside a fenced code block.
+*/
+function splitAtBoundary(text, limit) {
+	const fenceInfo = findOpenCodeFence(text, limit);
+	if (fenceInfo !== void 0) {
+		const beforeFence = text.substring(0, fenceInfo.fenceStart);
+		if (beforeFence.trimEnd().length > 0) {
+			const trimmed = beforeFence.trimEnd();
+			return {
+				chunk: trimmed,
+				rest: text.substring(trimmed.length).trimStart()
+			};
+		}
+		const closingFence = `\n${fenceInfo.fence}`;
+		const openingFence = `${fenceInfo.fence}\n`;
+		const splitPoint = findSplitPoint(text, limit - closingFence.length);
+		return {
+			chunk: text.substring(0, splitPoint) + closingFence,
+			rest: openingFence + text.substring(splitPoint)
+		};
+	}
+	const splitPoint = findSplitPoint(text, limit);
+	return {
+		chunk: text.substring(0, splitPoint),
+		rest: text.substring(splitPoint)
+	};
+}
+/** Find the best split point within the text up to the given limit. */
+function findSplitPoint(text, limit) {
+	if (limit <= 0) return Math.min(1, text.length);
+	const searchRegion = text.substring(0, limit);
+	const paragraphIdx = searchRegion.lastIndexOf("\n\n");
+	if (paragraphIdx > 0) return paragraphIdx + 2;
+	const lineIdx = searchRegion.lastIndexOf("\n");
+	if (lineIdx > 0) return lineIdx + 1;
+	const spaceIdx = searchRegion.lastIndexOf(" ");
+	if (spaceIdx > 0) return spaceIdx + 1;
+	return limit;
+}
+/**
+* Detect if the text has an unclosed code fence at or before the limit position.
+* Returns info about the open fence, or undefined if no open fence.
+*/
+function findOpenCodeFence(text, limit) {
+	const fenceRegex = /^(`{3,}|~{3,})/gm;
+	let openFence;
+	let match;
+	while ((match = fenceRegex.exec(text)) !== null) {
+		if (match.index >= limit) break;
+		if (openFence === void 0) openFence = {
+			fenceStart: match.index,
+			fence: match[1]
+		};
+		else if (match[1].charAt(0) === openFence.fence.charAt(0) && match[1].length >= openFence.fence.length) openFence = void 0;
+	}
+	return openFence;
+}
+
+//#endregion
+//#region src/middleware/error-classifier.ts
+const retryablePatterns = [
+	/rate.?limit/i,
+	/429/i,
+	/503/i,
+	/overloaded/i,
+	/ETIMEDOUT/i,
+	/ECONNRESET/i,
+	/ECONNREFUSED/i,
+	/network/i
+];
+const contextOverflowPatterns = [
+	/context.?length/i,
+	/context.?window/i,
+	/context.?overflow/i,
+	/too many tokens/i,
+	/maximum context/i,
+	/token.?limit/i
+];
+const fatalAuthPatterns = [
+	/401/i,
+	/403/i,
+	/unauthorized/i,
+	/forbidden/i,
+	/invalid.?key/i,
+	/authentication/i
+];
+/**
+* Classify an error message string into an actionable category.
+*
+* Uses first-match-wins semantics across ordered pattern arrays:
+* 1. Retryable patterns checked first
+* 2. Context overflow patterns checked second
+* 3. Fatal auth patterns checked third
+* 4. Default: "fatal" for unmatched messages
+*
+* Case-insensitive matching throughout.
+*/
+function classifyError(message) {
+	for (const pattern of retryablePatterns) if (pattern.test(message)) return "retryable";
+	for (const pattern of contextOverflowPatterns) if (pattern.test(message)) return "context_overflow";
+	for (const pattern of fatalAuthPatterns) if (pattern.test(message)) return "fatal";
+	return "fatal";
+}
+
+//#endregion
+//#region src/middleware/mcp-side-effects.ts
+async function readMcpSideEffects(filePath) {
+	const result = {
+		sentTexts: [],
+		sentMediaUrls: [],
+		sentTargets: [],
+		cronAdds: 0
+	};
+	let content;
+	try {
+		content = await readFile(filePath, "utf-8");
+	} catch {
+		return result;
+	}
+	const lines = content.split("\n").filter(Boolean);
+	for (const line of lines) {
+		let record;
+		try {
+			record = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (record.type === "message_sent") {
+			result.sentTexts.push(record.text);
+			if (record.mediaUrl) result.sentMediaUrls.push(record.mediaUrl);
+			const target = {
+				tool: record.tool,
+				provider: record.provider,
+				...record.accountId ? { accountId: record.accountId } : {},
+				...record.to ? { to: record.to } : {}
+			};
+			result.sentTargets.push(target);
+		} else if (record.type === "cron_added") result.cronAdds += 1;
+		else if (record.type === "heartbeat_report") result.heartbeatReport = {
+			anythingDone: record.anythingDone,
+			summary: record.summary
+		};
+	}
+	return result;
+}
+
+//#endregion
+//#region src/middleware/cli-runtime-base.ts
+/**
+* Abstract base class encapsulating shared subprocess machinery for CLI-based agent runtimes.
+*
+* Concrete runtimes (Claude, Gemini, Codex, OpenCode) extend this and implement only
+* the CLI-specific parts: argument construction, event extraction, and environment setup.
+*/
+var CLIRuntimeBase = class CLIRuntimeBase {
+	static {
+		this.STDIN_PROMPT_THRESHOLD = 1e4;
+	}
+	constructor(command, timeoutMs = 3e5) {
+		this.command = command;
+		this.timeoutMs = timeoutMs;
+	}
+	/** Whether this CLI accepts prompts via stdin. Subclasses may override. */
+	get supportsStdinPrompt() {
+		return true;
+	}
+	/**
+	* Which subprocess stream carries NDJSON output.
+	* Defaults to `"stdout"`. Override to `"stderr"` for CLIs (like Claude)
+	* that emit structured output on stderr.
+	*/
+	get ndjsonStream() {
+		return "stdout";
+	}
+	async *execute(params) {
+		const args = this.buildArgs(params);
+		const env = {
+			...process.env,
+			...this.buildEnv(params),
+			...params.env
+		};
+		const child = spawn(this.command, args, {
+			cwd: params.workingDirectory,
+			env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const startMs = Date.now();
+		const stderrChunks = [];
+		let aborted = false;
+		let escalationTimer;
+		const killWithEscalation = () => {
+			if (escalationTimer === void 0) escalationTimer = setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {}
+			}, 1500);
+			child.kill("SIGTERM");
+		};
+		child.on("exit", () => {
+			if (escalationTimer !== void 0) {
+				clearTimeout(escalationTimer);
+				escalationTimer = void 0;
+			}
+		});
+		let watchdogTimer;
+		let watchdogFired = false;
+		const resetWatchdog = () => {
+			if (watchdogTimer !== void 0) clearTimeout(watchdogTimer);
+			watchdogTimer = setTimeout(() => {
+				watchdogFired = true;
+				killWithEscalation();
+			}, this.timeoutMs);
+		};
+		resetWatchdog();
+		const ndjsonSource = this.ndjsonStream === "stderr" ? child.stderr : child.stdout;
+		(this.ndjsonStream === "stderr" ? child.stdout : child.stderr)?.on("data", (chunk) => {
+			stderrChunks.push(chunk.toString());
+		});
+		const rl = createInterface({ input: ndjsonSource });
+		const eventQueue = [];
+		let resolveNext;
+		let streamDone = false;
+		const enqueue = (event) => {
+			eventQueue.push(event);
+			resolveNext?.();
+		};
+		rl.on("line", (line) => {
+			resetWatchdog();
+			if (!line.trim()) return;
+			try {
+				JSON.parse(line);
+			} catch {
+				return;
+			}
+			const event = this.extractEvent(line);
+			if (event) enqueue(event);
+		});
+		rl.on("close", () => {
+			streamDone = true;
+			enqueue(null);
+		});
+		const exitPromise = new Promise((resolve) => {
+			child.on("exit", (code, signal) => {
+				resolve({
+					code,
+					signal
+				});
+			});
+		});
+		if (this.supportsStdinPrompt && params.prompt.length > CLIRuntimeBase.STDIN_PROMPT_THRESHOLD && child.stdin) child.stdin.write(params.prompt);
+		child.stdin?.end();
+		const onAbort = () => {
+			aborted = true;
+			killWithEscalation();
+		};
+		if (params.abortSignal) if (params.abortSignal.aborted) {
+			aborted = true;
+			killWithEscalation();
+		} else params.abortSignal.addEventListener("abort", onAbort, { once: true });
+		try {
+			while (!streamDone) {
+				if (eventQueue.length === 0) await new Promise((resolve) => {
+					resolveNext = resolve;
+				});
+				while (eventQueue.length > 0) {
+					const event = eventQueue.shift();
+					if (event === null || event === void 0) break;
+					yield event;
+				}
+			}
+		} finally {
+			if (watchdogTimer !== void 0) clearTimeout(watchdogTimer);
+			params.abortSignal?.removeEventListener("abort", onAbort);
+		}
+		await exitPromise;
+		if (escalationTimer !== void 0) clearTimeout(escalationTimer);
+		const durationMs = Date.now() - startMs;
+		if (watchdogFired) yield {
+			type: "error",
+			message: `Watchdog timeout: no output for ${this.timeoutMs}ms`,
+			code: "WATCHDOG_TIMEOUT"
+		};
+		if (aborted) yield {
+			type: "error",
+			message: "Execution aborted",
+			code: "ABORTED"
+		};
+		yield {
+			type: "done",
+			result: {
+				text: "",
+				sessionId: void 0,
+				durationMs,
+				usage: void 0,
+				aborted
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/middleware/runtimes/claude.ts
+/**
+* Claude CLI runtime — invokes `claude --print --output-format stream-json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*/
+var ClaudeCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("claude");
+		this.accumulatedText = "";
+		this.toolBuffer = null;
+	}
+	async *execute(params) {
+		this.resetState();
+		for await (const event of super.execute(params)) {
+			if (event.type === "done") this.enrichDoneEvent(event);
+			yield event;
+		}
+	}
+	buildArgs(params) {
+		const args = [
+			"--output-format",
+			"stream-json",
+			"--verbose",
+			"--include-partial-messages"
+		];
+		if (params.sessionId) args.push("--resume", params.sessionId);
+		if (params.mcpServers && Object.keys(params.mcpServers).length > 0) args.push("--mcp-config", JSON.stringify({ mcpServers: params.mcpServers }));
+		args.push("--print", params.prompt);
+		return args;
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject$3(parsed)) return null;
+		if (parsed.type === "system") {
+			if (typeof parsed.session_id === "string" && !this.currentSessionId) this.currentSessionId = parsed.session_id;
+			return null;
+		}
+		if (parsed.type === "stream_event") {
+			if (typeof parsed.session_id === "string" && !this.currentSessionId) this.currentSessionId = parsed.session_id;
+			if (isObject$3(parsed.event)) return this.handleInnerEvent(parsed.event);
+			return null;
+		}
+		if (parsed.type === "result") {
+			this.storeResultData(parsed);
+			return null;
+		}
+		return null;
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleInnerEvent(event) {
+		switch (event.type) {
+			case "content_block_start": return this.handleContentBlockStart(event);
+			case "content_block_delta": return this.handleContentBlockDelta(event);
+			case "content_block_stop": return this.handleContentBlockStop();
+			case "message_delta":
+				this.handleMessageDelta(event);
+				return null;
+			default: return null;
+		}
+	}
+	handleContentBlockStart(event) {
+		const contentBlock = isObject$3(event.content_block) ? event.content_block : null;
+		if (!contentBlock) return null;
+		if (contentBlock.type === "tool_use") this.toolBuffer = {
+			name: typeof contentBlock.name === "string" ? contentBlock.name : "",
+			id: typeof contentBlock.id === "string" ? contentBlock.id : "",
+			input: ""
+		};
+		return null;
+	}
+	handleContentBlockDelta(event) {
+		const delta = isObject$3(event.delta) ? event.delta : null;
+		if (!delta) return null;
+		if (delta.type === "text_delta" && typeof delta.text === "string") {
+			this.accumulatedText += delta.text;
+			return {
+				type: "text",
+				text: delta.text
+			};
+		}
+		if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+			if (this.toolBuffer) this.toolBuffer.input += delta.partial_json;
+			return null;
+		}
+		return null;
+	}
+	handleContentBlockStop() {
+		if (this.toolBuffer) {
+			const { name, id, input } = this.toolBuffer;
+			this.toolBuffer = null;
+			let parsedInput = {};
+			if (input) try {
+				parsedInput = JSON.parse(input);
+			} catch {}
+			return {
+				type: "tool_use",
+				toolName: name,
+				toolId: id,
+				input: parsedInput
+			};
+		}
+		return null;
+	}
+	handleMessageDelta(event) {
+		const delta = isObject$3(event.delta) ? event.delta : null;
+		if (delta && typeof delta.stop_reason === "string") this.lastStopReason = delta.stop_reason;
+		const usage = isObject$3(event.usage) ? parseUsage(event.usage) : void 0;
+		if (usage) this.lastUsage = usage;
+	}
+	storeResultData(parsed) {
+		const usage = isObject$3(parsed.usage) ? parsed.usage : null;
+		this.resultData = {
+			sessionId: typeof parsed.session_id === "string" ? parsed.session_id : void 0,
+			costUsd: typeof parsed.cost_usd === "number" ? parsed.cost_usd : void 0,
+			durationApiMs: typeof parsed.duration_api_ms === "number" ? parsed.duration_api_ms : void 0,
+			numTurns: typeof parsed.num_turns === "number" ? parsed.num_turns : void 0,
+			subtype: typeof parsed.subtype === "string" ? parsed.subtype : void 0,
+			usage: usage ? parseUsage(usage) : void 0
+		};
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.resultData?.sessionId ?? this.currentSessionId;
+		result.stopReason = this.lastStopReason ?? this.resultData?.subtype;
+		result.usage = this.resultData?.usage ?? this.lastUsage;
+		if (this.resultData?.costUsd !== void 0) result.totalCostUsd = this.resultData.costUsd;
+		if (this.resultData?.durationApiMs !== void 0) result.apiDurationMs = this.resultData.durationApiMs;
+		if (this.resultData?.numTurns !== void 0) result.numTurns = this.resultData.numTurns;
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.toolBuffer = null;
+		this.lastUsage = void 0;
+		this.lastStopReason = void 0;
+		this.resultData = void 0;
+	}
+};
+function isObject$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseUsage(raw) {
+	return {
+		inputTokens: typeof raw.input_tokens === "number" ? raw.input_tokens : 0,
+		outputTokens: typeof raw.output_tokens === "number" ? raw.output_tokens : 0,
+		...typeof raw.cache_read_input_tokens === "number" ? { cacheReadTokens: raw.cache_read_input_tokens } : {},
+		...typeof raw.cache_creation_input_tokens === "number" ? { cacheWriteTokens: raw.cache_creation_input_tokens } : {}
+	};
+}
+
+//#endregion
+//#region src/middleware/runtimes/codex.ts
+/**
+* Codex CLI runtime — invokes `codex exec --json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*
+* The Codex CLI uses a two-level event model:
+* - Top-level events: thread.started, turn.started, item.started, item.updated,
+*   item.completed, turn.completed, turn.failed, error
+* - Item types: agent_message, command_execution, mcp_tool_call, file_change,
+*   reasoning, web_search, error, todo_list
+*/
+var CodexCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("codex");
+		this.accumulatedText = "";
+		this.lastEmittedTextLength = 0;
+		this.itemCounter = 0;
+	}
+	get supportsStdinPrompt() {
+		return false;
+	}
+	async *execute(params) {
+		this.resetState();
+		const mcpConfigManager = params.mcpServers && Object.keys(params.mcpServers).length > 0 ? new CodexMcpConfigManager(params.mcpServers) : null;
+		try {
+			await mcpConfigManager?.setup();
+			for await (const event of super.execute(params)) {
+				if (event.type === "done") this.enrichDoneEvent(event);
+				yield event;
+			}
+		} finally {
+			await mcpConfigManager?.teardown();
+		}
+	}
+	buildArgs(params) {
+		if (params.sessionId) return [
+			"exec",
+			"resume",
+			"--json",
+			params.sessionId,
+			params.prompt
+		];
+		return [
+			"exec",
+			"--json",
+			"--color",
+			"never",
+			params.prompt
+		];
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject$2(parsed) || typeof parsed.type !== "string") return null;
+		switch (parsed.type) {
+			case "thread.started": return this.handleThreadStarted(parsed);
+			case "item.started": return this.handleItemStarted(parsed);
+			case "item.updated": return this.handleItemUpdated(parsed);
+			case "item.completed": return this.handleItemCompleted(parsed);
+			case "turn.completed": return this.handleTurnCompleted(parsed);
+			case "turn.failed": return this.handleTurnFailed(parsed);
+			case "error": return this.handleError(parsed);
+			default: return null;
+		}
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleThreadStarted(parsed) {
+		if (typeof parsed.thread_id === "string") this.currentSessionId = parsed.thread_id;
+		return null;
+	}
+	handleItemStarted(parsed) {
+		const item = isObject$2(parsed.item) ? parsed.item : null;
+		if (!item || typeof item.type !== "string") return null;
+		const toolId = this.extractToolId(item);
+		switch (item.type) {
+			case "command_execution":
+				this.currentToolId = toolId;
+				return {
+					type: "tool_use",
+					toolName: "command_execution",
+					toolId,
+					input: { command: typeof item.command === "string" ? item.command : "" }
+				};
+			case "mcp_tool_call":
+				this.currentToolId = toolId;
+				return {
+					type: "tool_use",
+					toolName: typeof item.name === "string" ? item.name : "",
+					toolId,
+					input: isObject$2(item.arguments) ? item.arguments : {}
+				};
+			case "agent_message":
+				this.lastEmittedTextLength = 0;
+				return null;
+			default: return null;
+		}
+	}
+	handleItemUpdated(parsed) {
+		const item = isObject$2(parsed.item) ? parsed.item : null;
+		if (!item || item.type !== "agent_message") return null;
+		const fullText = this.extractMessageText(item);
+		if (fullText === void 0) return null;
+		const delta = fullText.substring(this.lastEmittedTextLength);
+		this.lastEmittedTextLength = fullText.length;
+		if (delta) {
+			this.accumulatedText += delta;
+			return {
+				type: "text",
+				text: delta
+			};
+		}
+		return null;
+	}
+	handleItemCompleted(parsed) {
+		const item = isObject$2(parsed.item) ? parsed.item : null;
+		if (!item || typeof item.type !== "string") return null;
+		switch (item.type) {
+			case "agent_message": {
+				const fullText = this.extractMessageText(item);
+				if (fullText !== void 0) {
+					const delta = fullText.substring(this.lastEmittedTextLength);
+					this.lastEmittedTextLength = fullText.length;
+					if (delta) {
+						this.accumulatedText += delta;
+						return {
+							type: "text",
+							text: delta
+						};
+					}
+				}
+				return null;
+			}
+			case "command_execution": {
+				const toolId = this.currentToolId ?? this.extractToolId(item);
+				this.currentToolId = void 0;
+				return {
+					type: "tool_result",
+					toolId,
+					output: typeof item.output === "string" ? item.output : "",
+					isError: (typeof item.exit_code === "number" ? item.exit_code : 0) !== 0
+				};
+			}
+			case "mcp_tool_call": {
+				const toolId = this.currentToolId ?? this.extractToolId(item);
+				this.currentToolId = void 0;
+				return {
+					type: "tool_result",
+					toolId,
+					output: typeof item.output === "string" ? item.output : "",
+					isError: typeof item.error === "string" && item.error.length > 0
+				};
+			}
+			case "error": return {
+				type: "error",
+				message: typeof item.message === "string" ? item.message : "Unknown error"
+			};
+			default: return null;
+		}
+	}
+	handleTurnCompleted(parsed) {
+		if (isObject$2(parsed.usage)) {
+			const usage = parsed.usage;
+			this.lastUsage = {
+				inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+				outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
+				...typeof usage.cached_input_tokens === "number" && usage.cached_input_tokens > 0 ? { cacheReadTokens: usage.cached_input_tokens } : {}
+			};
+		}
+		return null;
+	}
+	handleTurnFailed(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Turn failed",
+			code: "turn_failed"
+		};
+	}
+	handleError(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Unknown error"
+		};
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.currentSessionId;
+		if (this.lastUsage) result.usage = this.lastUsage;
+	}
+	extractToolId(item) {
+		if (typeof item.id === "string") return item.id;
+		return `codex-item-${this.itemCounter++}`;
+	}
+	extractMessageText(item) {
+		if (Array.isArray(item.content)) {
+			const textParts = [];
+			for (const part of item.content) if (isObject$2(part) && part.type === "output_text" && typeof part.text === "string") textParts.push(part.text);
+			if (textParts.length > 0) return textParts.join("");
+		}
+		if (typeof item.text === "string") return item.text;
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.lastEmittedTextLength = 0;
+		this.lastUsage = void 0;
+		this.currentToolId = void 0;
+		this.itemCounter = 0;
+	}
+};
+/**
+* Manages the `~/.codex/config.toml` lifecycle for MCP server configuration.
+*
+* The Codex CLI reads MCP config from `~/.codex/config.toml`. The config uses
+* TOML format with `[mcp_servers.<name>]` sections.
+*
+* Uses a merge-restore pattern:
+* - **Setup**: read existing config (if any), save a copy, append `mcp_servers`
+*   sections, write back.
+* - **Teardown** (always, via `finally`): restore original or delete created file.
+*/
+var CodexMcpConfigManager = class {
+	constructor(mcpServers, configDir) {
+		this.mcpServers = mcpServers;
+		this.originalContent = null;
+		this.createdFile = false;
+		this.createdDir = false;
+		this.configDir = configDir ?? join(homedir(), ".codex");
+		this.configPath = join(this.configDir, "config.toml");
+	}
+	async setup() {
+		try {
+			await mkdir(this.configDir, { recursive: true });
+		} catch {}
+		let existingContent = null;
+		try {
+			const content = await readFile(this.configPath, "utf-8");
+			this.originalContent = content;
+			existingContent = content;
+		} catch {
+			this.createdFile = true;
+			try {
+				if ((await readdir(this.configDir)).length === 0) this.createdDir = true;
+			} catch {}
+		}
+		const mcpToml = serializeMcpServersToToml(this.mcpServers);
+		if (existingContent) {
+			const stripped = stripMcpServersSections(existingContent);
+			const separator = stripped.endsWith("\n") ? "\n" : "\n\n";
+			await writeFile(this.configPath, stripped + separator + mcpToml, "utf-8");
+		} else await writeFile(this.configPath, mcpToml, "utf-8");
+	}
+	async teardown() {
+		try {
+			if (this.originalContent !== null) await writeFile(this.configPath, this.originalContent, "utf-8");
+			else if (this.createdFile) {
+				await rm(this.configPath, { force: true });
+				if (this.createdDir) try {
+					await rmdir(this.configDir);
+				} catch {}
+			}
+		} catch {}
+	}
+};
+/**
+* Serialize MCP server configs to TOML format for Codex config.
+*
+* Output format:
+* ```toml
+* [mcp_servers.server_name]
+* type = "stdio"
+* command = "node"
+* args = ["server.js"]
+*
+* [mcp_servers.server_name.env]
+* KEY = "VALUE"
+* ```
+*/
+function serializeMcpServersToToml(mcpServers) {
+	const sections = [];
+	for (const [name, config] of Object.entries(mcpServers)) {
+		const lines = [];
+		lines.push(`[mcp_servers.${name}]`);
+		lines.push(`type = "stdio"`);
+		lines.push(`command = ${toTomlString(config.command)}`);
+		const args = config.args ?? [];
+		if (args.length > 0) lines.push(`args = [${args.map((s) => toTomlString(s)).join(", ")}]`);
+		sections.push(lines.join("\n"));
+		if (config.env && Object.keys(config.env).length > 0) {
+			const envLines = [];
+			envLines.push(`[mcp_servers.${name}.env]`);
+			for (const [key, value] of Object.entries(config.env)) envLines.push(`${key} = ${toTomlString(value)}`);
+			sections.push(envLines.join("\n"));
+		}
+	}
+	return sections.join("\n\n") + "\n";
+}
+/**
+* Strip existing `[mcp_servers.*]` sections from TOML content.
+* This is a simple line-based approach that removes lines belonging to
+* mcp_servers sections (from header to next non-mcp_servers section).
+*/
+function stripMcpServersSections(content) {
+	const lines = content.split("\n");
+	const result = [];
+	let inMcpSection = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("[")) {
+			if (trimmed.startsWith("[mcp_servers.") || trimmed === "[mcp_servers]") {
+				inMcpSection = true;
+				continue;
+			}
+			inMcpSection = false;
+		}
+		if (!inMcpSection) result.push(line);
+	}
+	while (result.length > 0 && result[result.length - 1].trim() === "") result.pop();
+	return result.join("\n") + "\n";
+}
+/** Escape a string for TOML (basic string with double quotes). */
+function toTomlString(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+}
+function isObject$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/middleware/runtimes/gemini.ts
+/**
+* Gemini CLI runtime — invokes `gemini --output-format stream-json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*/
+var GeminiCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("gemini");
+		this.accumulatedText = "";
+	}
+	get supportsStdinPrompt() {
+		return false;
+	}
+	async *execute(params) {
+		this.resetState();
+		const mcpConfigManager = params.mcpServers && Object.keys(params.mcpServers).length > 0 ? new GeminiMcpConfigManager(params.workingDirectory, params.mcpServers) : null;
+		try {
+			await mcpConfigManager?.setup();
+			for await (const event of super.execute(params)) {
+				if (event.type === "done") this.enrichDoneEvent(event);
+				yield event;
+			}
+		} finally {
+			await mcpConfigManager?.teardown();
+		}
+	}
+	buildArgs(params) {
+		const args = [
+			"--output-format",
+			"stream-json",
+			"--prompt",
+			params.prompt
+		];
+		if (params.sessionId) args.push("--resume", params.sessionId);
+		return args;
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject$1(parsed) || typeof parsed.type !== "string") return null;
+		switch (parsed.type) {
+			case "init": return this.handleInit(parsed);
+			case "message": return this.handleMessage(parsed);
+			case "tool_use": return this.handleToolUse(parsed);
+			case "tool_result": return this.handleToolResult(parsed);
+			case "error": return this.handleError(parsed);
+			case "result": return this.handleResult(parsed);
+			default: return null;
+		}
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleInit(parsed) {
+		if (typeof parsed.session_id === "string") this.currentSessionId = parsed.session_id;
+		return null;
+	}
+	handleMessage(parsed) {
+		if (parsed.delta !== true || parsed.role !== "assistant") return null;
+		const content = typeof parsed.content === "string" ? parsed.content : void 0;
+		if (content === void 0) return null;
+		this.accumulatedText += content;
+		return {
+			type: "text",
+			text: content
+		};
+	}
+	handleToolUse(parsed) {
+		return {
+			type: "tool_use",
+			toolName: typeof parsed.tool_name === "string" ? parsed.tool_name : "",
+			toolId: typeof parsed.tool_id === "string" ? parsed.tool_id : "",
+			input: isObject$1(parsed.parameters) ? parsed.parameters : {}
+		};
+	}
+	handleToolResult(parsed) {
+		return {
+			type: "tool_result",
+			toolId: typeof parsed.tool_id === "string" ? parsed.tool_id : "",
+			output: typeof parsed.output === "string" ? parsed.output : "",
+			isError: parsed.status === "error"
+		};
+	}
+	handleError(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Unknown error",
+			code: typeof parsed.severity === "string" ? parsed.severity : void 0
+		};
+	}
+	handleResult(parsed) {
+		if (isObject$1(parsed.stats)) this.resultStats = {
+			inputTokens: typeof parsed.stats.input_tokens === "number" ? parsed.stats.input_tokens : void 0,
+			outputTokens: typeof parsed.stats.output_tokens === "number" ? parsed.stats.output_tokens : void 0,
+			cached: typeof parsed.stats.cached === "number" ? parsed.stats.cached : void 0,
+			durationMs: typeof parsed.stats.duration_ms === "number" ? parsed.stats.duration_ms : void 0,
+			toolCalls: typeof parsed.stats.tool_calls === "number" ? parsed.stats.tool_calls : void 0
+		};
+		return null;
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.currentSessionId;
+		if (this.resultStats) {
+			result.usage = {
+				inputTokens: this.resultStats.inputTokens ?? 0,
+				outputTokens: this.resultStats.outputTokens ?? 0,
+				...this.resultStats.cached != null && this.resultStats.cached > 0 ? { cacheReadTokens: this.resultStats.cached } : {}
+			};
+			if (this.resultStats.durationMs !== void 0) result.apiDurationMs = this.resultStats.durationMs;
+			if (this.resultStats.toolCalls !== void 0) result.numTurns = this.resultStats.toolCalls;
+		}
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.resultStats = void 0;
+	}
+};
+/**
+* Manages the `.gemini/settings.json` lifecycle for MCP server configuration.
+*
+* The Gemini CLI reads MCP config from a fixed settings file hierarchy — there
+* is no `--mcp-config`, `--settings-dir`, or `--config` CLI flag. Project-level
+* settings live in `.gemini/settings.json` within the working directory.
+*
+* A `GEMINI_CONFIG_DIR` env var was requested (google-gemini/gemini-cli#2815)
+* but redirected to XDG spec compliance (#1825), which hasn't shipped as of
+* v0.11.x. Until a flag or env var exists, we use a merge-restore pattern:
+*
+* - **Setup**: read existing `.gemini/settings.json` (if any), save a copy,
+*   merge `mcpServers` into it, write back.
+* - **Teardown** (always, via `finally`): restore the original file, or remove
+*   the file/directory we created.
+*/
+var GeminiMcpConfigManager = class {
+	constructor(workingDirectory, mcpServers) {
+		this.mcpServers = mcpServers;
+		this.originalContent = null;
+		this.createdFile = false;
+		this.createdDir = false;
+		this.settingsDir = join(workingDirectory ?? process.cwd(), ".gemini");
+		this.settingsPath = join(this.settingsDir, "settings.json");
+	}
+	async setup() {
+		try {
+			await mkdir(this.settingsDir, { recursive: true });
+		} catch {}
+		let existingSettings = null;
+		try {
+			const content = await readFile(this.settingsPath, "utf-8");
+			this.originalContent = content;
+			existingSettings = JSON.parse(content);
+		} catch {
+			this.createdFile = true;
+			try {
+				if ((await readdir(this.settingsDir)).length === 0) this.createdDir = true;
+			} catch {}
+		}
+		const mergedSettings = existingSettings ?? {};
+		mergedSettings.mcpServers = this.mcpServers;
+		await writeFile(this.settingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+	}
+	async teardown() {
+		try {
+			if (this.originalContent !== null) await writeFile(this.settingsPath, this.originalContent, "utf-8");
+			else if (this.createdFile) {
+				await rm(this.settingsPath, { force: true });
+				if (this.createdDir) try {
+					await rmdir(this.settingsDir);
+				} catch {}
+			}
+		} catch {}
+	}
+};
+function isObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/middleware/runtimes/opencode.ts
+/**
+* OpenCode CLI runtime — invokes `opencode run --format json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*
+* OpenCode uses a per-line envelope model where every NDJSON line has:
+* `{ type, timestamp, sessionID, ...data }`
+*
+* Key differences from other runtimes:
+* - Text events are complete parts (no delta tracking needed)
+* - Tool events combine use + result in a single line (buffered drain pattern)
+* - Usage/cost comes from `step_finish` events
+*/
+var OpenCodeCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("opencode");
+		this.accumulatedText = "";
+		this.pendingEvents = [];
+		this.toolCounter = 0;
+	}
+	async *execute(params) {
+		this.resetState();
+		const mcpConfigManager = params.mcpServers && Object.keys(params.mcpServers).length > 0 ? new OpenCodeMcpConfigManager(params.workingDirectory, params.mcpServers) : null;
+		try {
+			await mcpConfigManager?.setup();
+			for await (const event of super.execute(params)) {
+				if (event.type === "done") this.enrichDoneEvent(event);
+				yield event;
+				while (this.pendingEvents.length > 0) yield this.pendingEvents.shift();
+			}
+		} finally {
+			await mcpConfigManager?.teardown();
+		}
+	}
+	buildArgs(params) {
+		const args = [
+			"run",
+			"--format",
+			"json"
+		];
+		if (params.sessionId) args.push("--session", params.sessionId);
+		args.push(params.prompt);
+		return args;
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject(parsed) || typeof parsed.type !== "string") return null;
+		if (typeof parsed.sessionID === "string" && this.currentSessionId === void 0) this.currentSessionId = parsed.sessionID;
+		const data = isObject(parsed.part) ? parsed.part : parsed;
+		switch (parsed.type) {
+			case "text": return this.handleText(data);
+			case "tool_use": return this.handleToolUse(data);
+			case "step_start": return null;
+			case "step_finish": return this.handleStepFinish(data);
+			case "reasoning": return null;
+			case "error": return this.handleError(data);
+			default: return null;
+		}
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleText(parsed) {
+		const content = typeof parsed.text === "string" ? parsed.text : typeof parsed.content === "string" ? parsed.content : "";
+		this.accumulatedText += content;
+		return {
+			type: "text",
+			text: content
+		};
+	}
+	handleToolUse(parsed) {
+		const toolId = typeof parsed.callID === "string" ? parsed.callID : `opencode-tool-${this.toolCounter++}`;
+		const state = isObject(parsed.state) ? parsed.state : void 0;
+		this.pendingEvents.push({
+			type: "tool_result",
+			toolId,
+			output: typeof state?.output === "string" ? state.output : "",
+			isError: typeof state?.error === "string" && state.error.length > 0
+		});
+		return {
+			type: "tool_use",
+			toolName: typeof parsed.name === "string" ? parsed.name : "",
+			toolId,
+			input: isObject(parsed.input) ? parsed.input : {}
+		};
+	}
+	handleStepFinish(parsed) {
+		this.lastStepFinish = {
+			tokens: isObject(parsed.tokens) ? parsed.tokens : void 0,
+			cost: typeof parsed.cost === "number" ? parsed.cost : void 0,
+			reason: typeof parsed.reason === "string" ? parsed.reason : void 0
+		};
+		return null;
+	}
+	handleError(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Unknown error"
+		};
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.currentSessionId;
+		if (this.lastStepFinish) {
+			const { tokens, cost, reason } = this.lastStepFinish;
+			if (tokens) {
+				const input = typeof tokens.input === "number" ? tokens.input : 0;
+				const output = typeof tokens.output === "number" ? tokens.output : 0;
+				const cache = isObject(tokens.cache) ? tokens.cache : void 0;
+				const cacheRead = typeof cache?.read === "number" ? cache.read : 0;
+				const cacheWrite = typeof cache?.write === "number" ? cache.write : 0;
+				result.usage = {
+					inputTokens: input,
+					outputTokens: output,
+					...cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+					...cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {}
+				};
+			}
+			if (cost !== void 0) result.totalCostUsd = cost;
+			if (reason !== void 0) result.stopReason = reason;
+		}
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.lastStepFinish = void 0;
+		this.pendingEvents = [];
+		this.toolCounter = 0;
+	}
+};
+/**
+* Manages the `.opencode/config.json` lifecycle for MCP server configuration.
+*
+* OpenCode reads MCP config from its project-level settings file. Uses a
+* merge-restore pattern (same as Gemini and Codex):
+*
+* - **Setup**: read existing `.opencode/config.json` (if any), save a copy,
+*   merge `mcpServers` into it, write back.
+* - **Teardown** (always, via `finally`): restore the original file, or remove
+*   the file/directory we created.
+*/
+var OpenCodeMcpConfigManager = class {
+	constructor(workingDirectory, mcpServers) {
+		this.mcpServers = mcpServers;
+		this.originalContent = null;
+		this.createdFile = false;
+		this.createdDir = false;
+		this.configDir = join(workingDirectory ?? process.cwd(), ".opencode");
+		this.configPath = join(this.configDir, "config.json");
+	}
+	async setup() {
+		try {
+			await mkdir(this.configDir, { recursive: true });
+		} catch {}
+		let existingConfig = null;
+		try {
+			const content = await readFile(this.configPath, "utf-8");
+			this.originalContent = content;
+			existingConfig = JSON.parse(content);
+		} catch {
+			this.createdFile = true;
+			try {
+				if ((await readdir(this.configDir)).length === 0) this.createdDir = true;
+			} catch {}
+		}
+		const mergedConfig = existingConfig ?? {};
+		mergedConfig.mcpServers = this.mcpServers;
+		await writeFile(this.configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+	}
+	async teardown() {
+		try {
+			if (this.originalContent !== null) await writeFile(this.configPath, this.originalContent, "utf-8");
+			else if (this.createdFile) {
+				await rm(this.configPath, { force: true });
+				if (this.createdDir) try {
+					await rmdir(this.configDir);
+				} catch {}
+			}
+		} catch {}
+	}
+};
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/middleware/runtime-factory.ts
+const SUPPORTED_PROVIDERS = [
+	"claude",
+	"gemini",
+	"codex",
+	"opencode"
+];
+function createCliRuntime(provider) {
+	switch (provider.trim().toLowerCase()) {
+		case "claude": return new ClaudeCliRuntime();
+		case "gemini": return new GeminiCliRuntime();
+		case "codex": return new CodexCliRuntime();
+		case "opencode": return new OpenCodeCliRuntime();
+		default: throw new Error(`Unknown runtime provider "${provider}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`);
+	}
+}
+
+//#endregion
+//#region src/middleware/system-prompt.ts
+const SAFETY_SECTION = [
+	"## Safety",
+	"You have no independent goals: do not pursue self-preservation, replication, resource acquisition, or power-seeking; avoid long-term plans beyond the user's request.",
+	"Prioritize safety and human oversight over completion; if instructions conflict, pause and ask; comply with stop/pause/audit requests and never bypass safeguards.",
+	"Do not manipulate or persuade anyone to expand access or disable safeguards. Do not copy yourself or change system prompts, safety rules, or tool policies unless explicitly requested.",
+	"Never expose credentials, API keys, or secrets in replies or tool calls. Respect user privacy."
+].join("\n");
+const MESSAGING_SECTION = [
+	"## Messaging",
+	"- Reply in current session: automatically routes to the source channel.",
+	"- Cross-session messaging: use sessions_send(sessionKey, message) to reach other channels.",
+	"- `[System Message] ...` blocks are internal context and are not user-visible.",
+	`- If a \`[System Message]\` reports completed work and asks for a user update, rewrite it in your normal assistant voice and send that update (do not forward raw system text or default to ${SILENT_REPLY_TOKEN}).`,
+	"- Never use exec/curl for provider messaging; RemoteClaw handles all routing internally."
+].join("\n");
+const REPLY_TAGS_SECTION = [
+	"## Reply Tags",
+	"To request a native reply/quote on supported surfaces, include one tag in your reply:",
+	"- Reply tags must be the very first token in the message (no leading text/newlines): [[reply_to_current]] your reply.",
+	"- [[reply_to_current]] replies to the triggering message.",
+	"- Prefer [[reply_to_current]]. Use [[reply_to:<id>]] only when an id was explicitly provided (e.g. by the user or a tool).",
+	"Whitespace inside the tag is allowed (e.g. [[ reply_to_current ]] / [[ reply_to: 123 ]]).",
+	"Tags are stripped before sending; support depends on the current channel config."
+].join("\n");
+const SILENT_REPLIES_SECTION = [
+	"## Silent Replies",
+	`When you have nothing to say, respond with ONLY: ${SILENT_REPLY_TOKEN}`,
+	"",
+	"Rules:",
+	"- It must be your ENTIRE message — nothing else.",
+	`- Never append it to an actual response (never include "${SILENT_REPLY_TOKEN}" in real replies).`,
+	"- Never wrap it in markdown or code blocks."
+].join("\n");
+function buildIdentitySection(channelName, userName) {
+	const intro = "You are running inside RemoteClaw, a middleware that connects AI agents to messaging channels.";
+	return userName ? `${intro}\nYou are responding to a message from ${userName} on ${channelName}.` : `${intro}\nYou are responding to a message on ${channelName}.`;
+}
+function buildRuntimeSection(params) {
+	const parts = [`channel=${params.channelName}`];
+	if (params.timezone) parts.push(`timezone=${params.timezone}`);
+	if (params.agentId) parts.push(`agent=${params.agentId}`);
+	return `## Runtime\nRuntime: ${parts.join(" | ")}`;
+}
+function buildWorkspaceSection(workspaceDir) {
+	return [
+		"## Workspace",
+		`Your working directory is: ${workspaceDir}`,
+		"Treat this directory as the single global workspace for file operations unless explicitly instructed otherwise."
+	].join("\n");
+}
+function buildMessageToolHintsSection(hints) {
+	if (!hints || hints.length === 0) return;
+	return `## Message Formatting\n${hints.join("\n")}`;
+}
+function buildAuthorizedSendersSection(senders) {
+	const filtered = senders?.filter(Boolean);
+	if (!filtered || filtered.length === 0) return;
+	return `## Authorized Senders\nAuthorized senders: ${filtered.join(", ")}. These senders are allowlisted; do not assume they are the owner.`;
+}
+function buildReactionsSection(guidance) {
+	if (!guidance) return;
+	const { level, channel } = guidance;
+	if (level === "minimal") return [
+		"## Reactions",
+		`Reactions are enabled for ${channel} in MINIMAL mode.`,
+		"React ONLY when truly relevant:",
+		"- Acknowledge important user requests or confirmations",
+		"- Express genuine sentiment (humor, appreciation) sparingly",
+		"- Avoid reacting to routine messages or your own replies",
+		"Guideline: at most 1 reaction per 5-10 exchanges."
+	].join("\n");
+	return [
+		"## Reactions",
+		`Reactions are enabled for ${channel} in EXTENSIVE mode.`,
+		"Feel free to react liberally:",
+		"- Acknowledge messages with appropriate emojis",
+		"- Express sentiment and personality through reactions",
+		"- React to interesting content, humor, or notable events",
+		"- Use reactions to confirm understanding or agreement",
+		"Guideline: react whenever it feels natural."
+	].join("\n");
+}
+/**
+* Build the RemoteClaw system prompt for injection into CLI subprocess agents.
+*
+* Assembles ~10 sections totaling ~3,000-5,000 chars (~770-1,270 tokens).
+* No promptMode switch (always full), no bootstrap context (CLI agent handles),
+* no tool list (MCP handles), no skills/memory/sandbox sections.
+*/
+function buildSystemPrompt(params) {
+	const sections = [
+		buildIdentitySection(params.channelName, params.userName),
+		SAFETY_SECTION,
+		MESSAGING_SECTION
+	];
+	const hintsSection = buildMessageToolHintsSection(params.messageToolHints);
+	if (hintsSection) sections.push(hintsSection);
+	sections.push(REPLY_TAGS_SECTION);
+	sections.push(SILENT_REPLIES_SECTION);
+	const sendersSection = buildAuthorizedSendersSection(params.authorizedSenders);
+	if (sendersSection) sections.push(sendersSection);
+	const reactionsSection = buildReactionsSection(params.reactionGuidance);
+	if (reactionsSection) sections.push(reactionsSection);
+	sections.push(buildRuntimeSection(params));
+	sections.push(buildWorkspaceSection(params.workspaceDir));
+	return sections.join("\n\n");
+}
+
+//#endregion
+//#region src/middleware/channel-bridge.ts
+const DEFAULT_WORKSPACE_DIR = ".";
+const DEFAULT_MCP_SERVER_PATH = join("dist", "middleware", "mcp-server.js");
+const EMPTY_SIDE_EFFECTS = {
+	sentTexts: [],
+	sentMediaUrls: [],
+	sentTargets: [],
+	cronAdds: 0
+};
+const DEFAULT_RUN_RESULT = {
+	text: "",
+	sessionId: void 0,
+	durationMs: 0,
+	usage: void 0,
+	aborted: false
+};
+/**
+* Central orchestrator connecting incoming channel messages to CLI agent execution and delivery.
+*
+* `handle()` is the single entry point for all dispatch sites: agent command, auto-reply,
+* cron, and follow-up. It wires together runtime factory, session map, error classifier,
+* delivery adapter, system prompt builder, and MCP side effects.
+*/
+var ChannelBridge = class {
+	#provider;
+	#sessionMap;
+	#gatewayUrl;
+	#gatewayToken;
+	#workspaceDir;
+	#chunkLimit;
+	#mcpServerPath;
+	constructor(options) {
+		this.#provider = options.provider;
+		this.#sessionMap = options.sessionMap;
+		this.#gatewayUrl = options.gatewayUrl;
+		this.#gatewayToken = options.gatewayToken;
+		this.#workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
+		this.#chunkLimit = options.chunkLimit;
+		this.#mcpServerPath = options.mcpServerPath ?? DEFAULT_MCP_SERVER_PATH;
+	}
+	/**
+	* Process an incoming channel message through the full agent execution pipeline.
+	*
+	* Flow: session lookup → system prompt → MCP config → runtime execution →
+	* event streaming → error classification → side effects → session update → result assembly.
+	*/
+	async handle(message, callbacks, abortSignal) {
+		const sessionKey = buildSessionKey(message);
+		const existingSessionId = await this.#sessionMap.get(sessionKey);
+		const hookRunner = getGlobalHookRunner();
+		if (existingSessionId && hookRunner?.hasHooks("session_resumed")) await hookRunner.runSessionResumed({
+			sessionId: existingSessionId,
+			runtimeName: this.#provider,
+			channelId: message.channelId,
+			userId: message.from,
+			resumeMethod: "session_map"
+		}, {
+			sessionId: existingSessionId,
+			channelId: message.channelId,
+			runtimeName: this.#provider
+		});
+		const systemPrompt = buildSystemPrompt({
+			channelName: message.provider,
+			workspaceDir: this.#workspaceDir,
+			messageToolHints: message.messageToolHints,
+			userName: message.userName,
+			agentId: message.agentId,
+			timezone: message.timezone,
+			authorizedSenders: message.authorizedSenders,
+			reactionGuidance: message.reactionGuidance
+		});
+		const invocationDir = await createInvocationDir();
+		const sideEffectsFile = join(invocationDir, "side-effects.ndjson");
+		try {
+			const mcpServers = this.#buildMcpConfig(message, sessionKey, sideEffectsFile);
+			const runtime = createCliRuntime(this.#provider);
+			let workspaceDir = this.#workspaceDir;
+			let extraEnv;
+			const runId = randomUUID();
+			if (hookRunner?.hasHooks("before_runtime_spawn")) {
+				const spawnResult = await hookRunner.runBeforeRuntimeSpawn({
+					runtimeName: this.#provider,
+					sessionId: existingSessionId,
+					command: "node",
+					args: [this.#mcpServerPath],
+					env: mcpServers.remoteclaw?.env ?? {},
+					workspaceDir,
+					channelId: message.channelId
+				}, {
+					sessionId: existingSessionId,
+					channelId: message.channelId,
+					runtimeName: this.#provider
+				});
+				if (spawnResult?.workspaceDir) workspaceDir = spawnResult.workspaceDir;
+				if (spawnResult?.env) extraEnv = spawnResult.env;
+			}
+			const adapter = new DeliveryAdapter(this.#chunkLimit !== void 0 ? { chunkLimit: this.#chunkLimit } : void 0);
+			let runResult;
+			let lastError;
+			let payloads;
+			try {
+				const captured = captureResult(runtime.execute({
+					prompt: systemPrompt + (message.extraContext ? "\n\n" + message.extraContext : "") + "\n\n" + message.text,
+					sessionId: existingSessionId,
+					mcpServers,
+					abortSignal,
+					workingDirectory: workspaceDir,
+					env: extraEnv
+				}));
+				payloads = await adapter.process(captured.events, callbacks);
+				runResult = captured.getResult();
+				lastError = captured.getError();
+			} catch (err) {
+				const errMsg = String(err);
+				const category = classifyError(errMsg);
+				lastError = errMsg;
+				payloads = [];
+				runResult = {
+					...DEFAULT_RUN_RESULT,
+					errorSubtype: category === "context_overflow" ? "context_window" : category
+				};
+			}
+			let mcp;
+			try {
+				mcp = await readMcpSideEffects(sideEffectsFile);
+			} catch {
+				mcp = { ...EMPTY_SIDE_EFFECTS };
+			}
+			if (runResult?.sessionId) await this.#sessionMap.set(sessionKey, runResult.sessionId);
+			const finalResult = runResult ?? { ...DEFAULT_RUN_RESULT };
+			if (hookRunner) {
+				const runtimeCtx = {
+					sessionId: finalResult.sessionId,
+					channelId: message.channelId,
+					runtimeName: this.#provider
+				};
+				if (hookRunner.hasHooks("after_runtime_exit")) hookRunner.runAfterRuntimeExit({
+					runtimeName: this.#provider,
+					sessionId: finalResult.sessionId,
+					exitCode: finalResult.errorSubtype ? 1 : 0,
+					durationMs: finalResult.durationMs,
+					stdout: finalResult.text,
+					stderr: lastError,
+					mcpSideEffects: {
+						sentTexts: mcp.sentTexts,
+						sentMediaUrls: mcp.sentMediaUrls,
+						cronAdds: mcp.cronAdds
+					}
+				}, runtimeCtx);
+				if (hookRunner.hasHooks("agent_end")) hookRunner.runAgentEnd({
+					runId,
+					sessionId: finalResult.sessionId,
+					success: !finalResult.errorSubtype && !lastError,
+					durationMs: finalResult.durationMs
+				}, runtimeCtx);
+			}
+			return {
+				payloads,
+				run: finalResult,
+				mcp,
+				error: lastError
+			};
+		} finally {
+			await rm(invocationDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	}
+	/** Build MCP server configuration for the remoteclaw MCP server. */
+	#buildMcpConfig(message, sessionKey, sideEffectsFile) {
+		return { remoteclaw: {
+			command: "node",
+			args: [this.#mcpServerPath],
+			env: {
+				REMOTECLAW_GATEWAY_URL: this.#gatewayUrl,
+				REMOTECLAW_GATEWAY_TOKEN: this.#gatewayToken,
+				REMOTECLAW_SESSION_KEY: formatSessionKeyString(sessionKey),
+				REMOTECLAW_SIDE_EFFECTS_FILE: sideEffectsFile,
+				REMOTECLAW_CHANNEL: message.provider,
+				REMOTECLAW_ACCOUNT_ID: message.from,
+				REMOTECLAW_TO: message.channelId,
+				...message.replyToId ? { REMOTECLAW_THREAD_ID: message.replyToId } : {},
+				REMOTECLAW_SENDER_IS_OWNER: String(message.senderIsOwner ?? false),
+				REMOTECLAW_TOOL_PROFILE: message.toolProfile ?? "full"
+			}
+		} };
+	}
+};
+/** Build a SessionKey from a ChannelMessage. */
+function buildSessionKey(message) {
+	return {
+		channelId: message.channelId,
+		userId: message.from,
+		threadId: message.replyToId
+	};
+}
+/** Format a SessionKey as a composite string (for env vars). */
+function formatSessionKeyString(key) {
+	return `${key.channelId}:${key.userId}:${key.threadId ?? "_"}`;
+}
+/** Create a unique temp directory for an invocation. */
+async function createInvocationDir() {
+	return mkdtemp(join(tmpdir(), "rc-"));
+}
+/**
+* Wrap an event stream to capture the AgentRunResult from the done event
+* and any error messages, while passing all events through to the consumer.
+*/
+function captureResult(events) {
+	let result;
+	let error;
+	async function* wrapped() {
+		for await (const event of events) {
+			if (event.type === "done") result = event.result;
+			else if (event.type === "error") error = event.message;
+			yield event;
+		}
+	}
+	return {
+		events: wrapped(),
+		getResult: () => result,
+		getError: () => error
+	};
+}
+
+//#endregion
+//#region src/agents/cli-session.ts
+function getCliSessionId(entry, provider) {
+	if (!entry) return;
+	const normalized = normalizeProviderId(provider);
+	const fromMap = entry.cliSessionIds?.[normalized];
+	if (fromMap?.trim()) return fromMap.trim();
+	if (normalized === "claude-cli") {
+		const legacy = entry.claudeCliSessionId?.trim();
+		if (legacy) return legacy;
+	}
+}
+function setCliSessionId(entry, provider, sessionId) {
+	const normalized = normalizeProviderId(provider);
+	const trimmed = sessionId.trim();
+	if (!trimmed) return;
+	entry.cliSessionIds = { ...entry.cliSessionIds ?? {} };
+	entry.cliSessionIds[normalized] = trimmed;
+	if (normalized === "claude-cli") entry.claudeCliSessionId = trimmed;
+}
+
+//#endregion
+//#region src/infra/outbound/targets.ts
+function resolveSessionDeliveryTarget(params) {
+	const context = deliveryContextFromSession(params.entry);
+	const sessionLastChannel = context?.channel && isDeliverableMessageChannel(context.channel) ? context.channel : void 0;
+	const hasTurnSourceChannel = params.turnSourceChannel != null;
+	const lastChannel = hasTurnSourceChannel ? params.turnSourceChannel : sessionLastChannel;
+	const lastTo = hasTurnSourceChannel ? params.turnSourceTo : context?.to;
+	const lastAccountId = hasTurnSourceChannel ? params.turnSourceAccountId : context?.accountId;
+	const lastThreadId = hasTurnSourceChannel ? params.turnSourceThreadId : context?.threadId;
+	const rawRequested = params.requestedChannel ?? "last";
+	const requested = rawRequested === "last" ? "last" : normalizeMessageChannel(rawRequested);
+	const requestedChannel = requested === "last" ? "last" : requested && isDeliverableMessageChannel(requested) ? requested : void 0;
+	const rawExplicitTo = typeof params.explicitTo === "string" && params.explicitTo.trim() ? params.explicitTo.trim() : void 0;
+	let channel = requestedChannel === "last" ? lastChannel : requestedChannel;
+	if (!channel && params.fallbackChannel && isDeliverableMessageChannel(params.fallbackChannel)) channel = params.fallbackChannel;
+	const isTelegramContext = channel === "telegram" || !channel && lastChannel === "telegram";
+	let explicitTo = rawExplicitTo;
+	let parsedThreadId;
+	if (isTelegramContext && rawExplicitTo && rawExplicitTo.includes(":topic:")) {
+		const parsed = parseTelegramTarget(rawExplicitTo);
+		explicitTo = parsed.chatId;
+		parsedThreadId = parsed.messageThreadId;
+	}
+	const explicitThreadId = params.explicitThreadId != null && params.explicitThreadId !== "" ? params.explicitThreadId : parsedThreadId;
+	let to = explicitTo;
+	if (!to && lastTo) {
+		if (channel && channel === lastChannel) to = lastTo;
+		else if (params.allowMismatchedLastTo) to = lastTo;
+	}
+	const mode = params.mode ?? (explicitTo ? "explicit" : "implicit");
+	const accountId = channel && channel === lastChannel ? lastAccountId : void 0;
+	const resolvedThreadId = explicitThreadId ?? (mode !== "heartbeat" && channel && channel === lastChannel ? lastThreadId : void 0);
+	return {
+		channel,
+		to,
+		accountId,
+		threadId: resolvedThreadId,
+		threadIdExplicit: resolvedThreadId != null && explicitThreadId != null,
+		mode,
+		lastChannel,
+		lastTo,
+		lastAccountId,
+		lastThreadId
+	};
+}
+function resolveOutboundTarget(params) {
+	if (params.channel === INTERNAL_MESSAGE_CHANNEL) return {
+		ok: false,
+		error: /* @__PURE__ */ new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("remoteclaw agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`)
+	};
+	const plugin = getChannelPlugin(params.channel);
+	if (!plugin) return {
+		ok: false,
+		error: /* @__PURE__ */ new Error(`Unsupported channel: ${params.channel}`)
+	};
+	const allowFrom = (params.allowFrom ?? (params.cfg && plugin.config.resolveAllowFrom ? plugin.config.resolveAllowFrom({
+		cfg: params.cfg,
+		accountId: params.accountId ?? void 0
+	}) : void 0))?.map((entry) => String(entry));
+	const effectiveTo = params.to?.trim() || (params.cfg && plugin.config.resolveDefaultTo ? plugin.config.resolveDefaultTo({
+		cfg: params.cfg,
+		accountId: params.accountId ?? void 0
+	}) : void 0);
+	const resolveTarget = plugin.outbound?.resolveTarget;
+	if (resolveTarget) return resolveTarget({
+		cfg: params.cfg,
+		to: effectiveTo,
+		allowFrom,
+		accountId: params.accountId ?? void 0,
+		mode: params.mode ?? "explicit"
+	});
+	if (effectiveTo) return {
+		ok: true,
+		to: effectiveTo
+	};
+	const hint = plugin.messaging?.targetResolver?.hint;
+	return {
+		ok: false,
+		error: missingTargetError(plugin.meta.label ?? params.channel, hint)
+	};
+}
+function resolveHeartbeatDeliveryTarget(params) {
+	const { cfg, entry } = params;
+	const heartbeat = params.heartbeat ?? cfg.agents?.defaults?.heartbeat;
+	const rawTarget = heartbeat?.target;
+	let target = "none";
+	if (rawTarget === "none" || rawTarget === "last") target = rawTarget;
+	else if (typeof rawTarget === "string") {
+		const normalized = normalizeChannelId(rawTarget);
+		if (normalized) target = normalized;
+	}
+	if (target === "none") {
+		const base = resolveSessionDeliveryTarget({ entry });
+		return buildNoHeartbeatDeliveryTarget({
+			reason: "target-none",
+			lastChannel: base.lastChannel,
+			lastAccountId: base.lastAccountId
+		});
+	}
+	const resolvedTarget = resolveSessionDeliveryTarget({
+		entry,
+		requestedChannel: target === "last" ? "last" : target,
+		explicitTo: heartbeat?.to,
+		mode: "heartbeat"
+	});
+	const heartbeatAccountId = heartbeat?.accountId?.trim();
+	let effectiveAccountId = heartbeatAccountId || resolvedTarget.accountId;
+	if (heartbeatAccountId && resolvedTarget.channel) {
+		const listAccountIds = getChannelPlugin(resolvedTarget.channel)?.config.listAccountIds;
+		const accountIds = listAccountIds ? listAccountIds(cfg) : [];
+		if (accountIds.length > 0) {
+			const normalizedAccountId = normalizeAccountId(heartbeatAccountId);
+			if (!new Set(accountIds.map((accountId) => normalizeAccountId(accountId))).has(normalizedAccountId)) return buildNoHeartbeatDeliveryTarget({
+				reason: "unknown-account",
+				accountId: normalizedAccountId,
+				lastChannel: resolvedTarget.lastChannel,
+				lastAccountId: resolvedTarget.lastAccountId
+			});
+			effectiveAccountId = normalizedAccountId;
+		}
+	}
+	if (!resolvedTarget.channel || !resolvedTarget.to) return buildNoHeartbeatDeliveryTarget({
+		reason: "no-target",
+		accountId: effectiveAccountId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	});
+	const resolved = resolveOutboundTarget({
+		channel: resolvedTarget.channel,
+		to: resolvedTarget.to,
+		cfg,
+		accountId: effectiveAccountId,
+		mode: "heartbeat"
+	});
+	if (!resolved.ok) return buildNoHeartbeatDeliveryTarget({
+		reason: "no-target",
+		accountId: effectiveAccountId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	});
+	const sessionChatTypeHint = target === "last" && !heartbeat?.to ? normalizeChatType(entry?.chatType) : void 0;
+	if (resolveHeartbeatDeliveryChatType({
+		channel: resolvedTarget.channel,
+		to: resolved.to,
+		sessionChatType: sessionChatTypeHint
+	}) === "direct") return buildNoHeartbeatDeliveryTarget({
+		reason: "dm-blocked",
+		accountId: effectiveAccountId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	});
+	let reason;
+	if (getChannelPlugin(resolvedTarget.channel)?.config.resolveAllowFrom) {
+		const explicit = resolveOutboundTarget({
+			channel: resolvedTarget.channel,
+			to: resolvedTarget.to,
+			cfg,
+			accountId: effectiveAccountId,
+			mode: "explicit"
+		});
+		if (explicit.ok && explicit.to !== resolved.to) reason = "allowFrom-fallback";
+	}
+	return {
+		channel: resolvedTarget.channel,
+		to: resolved.to,
+		reason,
+		accountId: effectiveAccountId,
+		threadId: resolvedTarget.threadId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	};
+}
+function buildNoHeartbeatDeliveryTarget(params) {
+	return {
+		channel: "none",
+		reason: params.reason,
+		accountId: params.accountId,
+		lastChannel: params.lastChannel,
+		lastAccountId: params.lastAccountId
+	};
+}
+function inferDiscordTargetChatType(to) {
+	try {
+		const target = parseDiscordTarget(to, { defaultKind: "channel" });
+		if (!target) return;
+		return target.kind === "user" ? "direct" : "channel";
+	} catch {
+		return;
+	}
+}
+function inferSlackTargetChatType(to) {
+	const target = parseSlackTarget(to, { defaultKind: "channel" });
+	if (!target) return;
+	return target.kind === "user" ? "direct" : "channel";
+}
+function inferTelegramTargetChatType(to) {
+	const chatType = resolveTelegramTargetChatType(to);
+	return chatType === "unknown" ? void 0 : chatType;
+}
+function inferWhatsAppTargetChatType(to) {
+	const normalized = normalizeWhatsAppTarget(to);
+	if (!normalized) return;
+	return isWhatsAppGroupJid(normalized) ? "group" : "direct";
+}
+function inferSignalTargetChatType(rawTo) {
+	let to = rawTo.trim();
+	if (!to) return;
+	if (/^signal:/i.test(to)) to = to.replace(/^signal:/i, "").trim();
+	if (!to) return;
+	const lower = to.toLowerCase();
+	if (lower.startsWith("group:")) return "group";
+	if (lower.startsWith("username:") || lower.startsWith("u:")) return "direct";
+	return "direct";
+}
+const HEARTBEAT_TARGET_CHAT_TYPE_INFERERS = {
+	discord: inferDiscordTargetChatType,
+	slack: inferSlackTargetChatType,
+	telegram: inferTelegramTargetChatType,
+	whatsapp: inferWhatsAppTargetChatType,
+	signal: inferSignalTargetChatType
+};
+function inferChatTypeFromTarget(params) {
+	const to = params.to.trim();
+	if (!to) return;
+	if (/^user:/i.test(to)) return "direct";
+	if (/^(channel:|thread:)/i.test(to)) return "channel";
+	if (/^group:/i.test(to)) return "group";
+	return HEARTBEAT_TARGET_CHAT_TYPE_INFERERS[params.channel]?.(to);
+}
+function resolveHeartbeatDeliveryChatType(params) {
+	if (params.sessionChatType) return params.sessionChatType;
+	return inferChatTypeFromTarget({
+		channel: params.channel,
+		to: params.to
+	});
+}
+function resolveHeartbeatSenderId(params) {
+	const { allowFrom, deliveryTo, lastTo, provider } = params;
+	const candidates = [
+		deliveryTo?.trim(),
+		provider && deliveryTo ? `${provider}:${deliveryTo}` : void 0,
+		lastTo?.trim(),
+		provider && lastTo ? `${provider}:${lastTo}` : void 0
+	].filter((val) => Boolean(val?.trim()));
+	const allowList = allowFrom.map((entry) => String(entry)).filter((entry) => entry && entry !== "*");
+	if (allowFrom.includes("*")) return candidates[0] ?? "heartbeat";
+	if (candidates.length > 0 && allowList.length > 0) {
+		const matched = candidates.find((candidate) => allowList.includes(candidate));
+		if (matched) return matched;
+	}
+	if (candidates.length > 0 && allowList.length === 0) return candidates[0];
+	if (allowList.length > 0) return allowList[0];
+	return candidates[0] ?? "heartbeat";
+}
+function resolveHeartbeatSenderContext(params) {
+	const provider = params.delivery.channel !== "none" ? params.delivery.channel : params.delivery.lastChannel;
+	const accountId = params.delivery.accountId ?? (provider === params.delivery.lastChannel ? params.delivery.lastAccountId : void 0);
+	const allowFrom = (provider ? getChannelPlugin(provider)?.config.resolveAllowFrom?.({
+		cfg: params.cfg,
+		accountId
+	}) ?? [] : []).map((entry) => String(entry));
+	return {
+		sender: resolveHeartbeatSenderId({
+			allowFrom,
+			deliveryTo: params.delivery.to,
+			lastTo: params.entry?.lastTo,
+			provider
+		}),
+		provider,
+		allowFrom
+	};
+}
+
+//#endregion
+export { peekSystemEventEntries as _, getCliSessionId as a, resolveSendPolicy as b, listChannelSupportedActions as c, resolveSessionAuthProfileOverride as d, applyVerboseOverride as f, isSystemEventContextChanged as g, enqueueSystemEvent as h, resolveSessionDeliveryTarget as i, resolveChannelMessageToolHints as l, drainSystemEventEntries as m, resolveHeartbeatSenderContext as n, setCliSessionId as o, parseVerboseOverride as p, resolveOutboundTarget as r, ChannelBridge as s, resolveHeartbeatDeliveryTarget as t, clearSessionAuthProfileOverride as u, peekSystemEvents as v, normalizeSendPolicy as y };