remoteclaw 0.0.0 → 0.0.1

package/dist/boot/handler.js

@@ -0,0 +1,1455 @@
+import { D as createInternalHookEvent, M as resolveGatewayPort, O as isGatewayStartupEvent, P as resolveStateDir, k as triggerInternalHook, n as defaultRuntime, s as getActivePluginRegistry, t as createSubsystemLogger } from "../subsystem-DE8w_S23.js";
+import { B as listChannelPlugins, C as isDeliverableMessageChannel, D as normalizeMessageChannel, E as listDeliverableMessageChannels, I as isCliProvider, L as normalizeModelRef, O as resolveMessageChannel, S as INTERNAL_MESSAGE_CHANNEL, T as isInternalMessageChannel, V as normalizeChannelId, a as getAgentScopedMediaLocalRoots, at as resolveAgentRuntimeOrThrow, c as chunkMarkdownTextWithMode, dt as normalizeMainKey, et as formatCliCommand, ft as resolveAgentIdFromSessionKey, it as resolveAgentRuntimeEnv, j as loadConfig, l as resolveChunkMode, mt as normalizeAccountId, nt as resolveAgentConfig, o as resolveMarkdownTableMode, ot as resolveAgentWorkspaceDir, rt as resolveAgentRuntimeArgs, s as chunkByParagraph, st as resolveSessionAgentId, tt as listAgentIds, u as resolveTextChunkLimit, ut as normalizeAgentId, w as isGatewayMessageChannel, z as getChannelPlugin } from "../media-DgxPvn2i.js";
+import { A as resolveSessionFilePathOptions, B as resolveChannelMessageToolHints, C as normalizeAccountId$1, D as resolveChannelResetConfig, E as evaluateSessionFreshness, F as resolveMainSessionKey, I as normalizeVerboseLevel, L as ensureAgentWorkspace, M as resolveStorePath, N as resolveAgentMainSessionKey, O as resolveSessionResetPolicy, P as resolveExplicitAgentSessionKey, R as getCliSessionId, S as updateSessionStore, T as resolveSessionKey, V as SILENT_REPLY_TOKEN, _ as parseSessionThreadInfo, a as parseReplyDirectives, b as resolveAndPersistSessionFile, c as AGENT_LANE_NESTED, d as ChannelBridge, f as getGlobalHookRunner, g as resolveGatewayCredentialsFromConfig, h as registerAgentRunContext, i as shouldSuppressReasoningPayload, j as resolveSessionTranscriptPath, k as resolveSessionResetType, l as resolveSendPolicy, m as emitAgentEvent, n as hasNonzeroUsage, o as resolveOutboundTarget, p as clearAgentRunContext, r as isRenderablePayload, s as resolveSessionDeliveryTarget, t as deriveSessionTotalTokens, u as applyVerboseOverride, v as appendAssistantMessageToSessionTranscript, x as loadSessionStore, y as resolveMirroredTranscriptText, z as setCliSessionId } from "../usage-CCU9qNC5.js";
+import "../accounts-uVavganx.js";
+import { t as generateSecureUuid } from "../secure-random-B8v4P_PH.js";
+import "../fetch-CduIccDV.js";
+import "../retry-D7zwz3HY.js";
+import "../targets-DJ_OVcyq.js";
+import { n as markdownToSignalTextChunks, t as sendMessageSignal } from "../send-DZ80jwFi.js";
+import "../store-DlqiXmDO.js";
+import "../outbound-attachment-D5FMlKjS.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import fs$1 from "node:fs";
+import crypto from "node:crypto";
+
+//#region src/cli/outbound-send-mapping.ts
+function createOutboundSendDepsFromCliSource(deps) {
+	return {
+		sendWhatsApp: deps.sendMessageWhatsApp,
+		sendTelegram: deps.sendMessageTelegram,
+		sendDiscord: deps.sendMessageDiscord,
+		sendSlack: deps.sendMessageSlack,
+		sendSignal: deps.sendMessageSignal,
+		sendIMessage: deps.sendMessageIMessage
+	};
+}
+
+//#endregion
+//#region src/cli/deps.ts
+function createDefaultDeps() {
+	return {
+		sendMessageWhatsApp: async (...args) => {
+			const { sendMessageWhatsApp } = await import("../web-zotCHj-B.js");
+			return await sendMessageWhatsApp(...args);
+		},
+		sendMessageTelegram: async (...args) => {
+			const { sendMessageTelegram } = await import("../send-BxQ1YFYH.js");
+			return await sendMessageTelegram(...args);
+		},
+		sendMessageDiscord: async (...args) => {
+			const { sendMessageDiscord } = await import("../send-C9pLn8Zz.js");
+			return await sendMessageDiscord(...args);
+		},
+		sendMessageSlack: async (...args) => {
+			const { sendMessageSlack } = await import("../send-Brtl2skD.js");
+			return await sendMessageSlack(...args);
+		},
+		sendMessageSignal: async (...args) => {
+			const { sendMessageSignal } = await import("../send-C7xFV4Ul.js");
+			return await sendMessageSignal(...args);
+		},
+		sendMessageIMessage: async (...args) => {
+			const { sendMessageIMessage } = await import("../send-BaaCgoKI.js");
+			return await sendMessageIMessage(...args);
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/outbound-send-deps.ts
+function createOutboundSendDeps(deps) {
+	return createOutboundSendDepsFromCliSource(deps);
+}
+
+//#endregion
+//#region src/infra/outbound/agent-delivery.ts
+function resolveAgentDeliveryPlan(params) {
+	const requestedRaw = typeof params.requestedChannel === "string" ? params.requestedChannel.trim() : "";
+	const requestedChannel = (requestedRaw ? normalizeMessageChannel(requestedRaw) : void 0) || "last";
+	const explicitTo = typeof params.explicitTo === "string" && params.explicitTo.trim() ? params.explicitTo.trim() : void 0;
+	const normalizedTurnSource = params.turnSourceChannel ? normalizeMessageChannel(params.turnSourceChannel) : void 0;
+	const turnSourceChannel = normalizedTurnSource && isDeliverableMessageChannel(normalizedTurnSource) ? normalizedTurnSource : void 0;
+	const turnSourceTo = typeof params.turnSourceTo === "string" && params.turnSourceTo.trim() ? params.turnSourceTo.trim() : void 0;
+	const turnSourceAccountId = normalizeAccountId$1(params.turnSourceAccountId);
+	const turnSourceThreadId = params.turnSourceThreadId != null && params.turnSourceThreadId !== "" ? params.turnSourceThreadId : void 0;
+	const baseDelivery = resolveSessionDeliveryTarget({
+		entry: params.sessionEntry,
+		requestedChannel: requestedChannel === INTERNAL_MESSAGE_CHANNEL ? "last" : requestedChannel,
+		explicitTo,
+		explicitThreadId: params.explicitThreadId,
+		turnSourceChannel,
+		turnSourceTo,
+		turnSourceAccountId,
+		turnSourceThreadId
+	});
+	const resolvedChannel = (() => {
+		if (requestedChannel === INTERNAL_MESSAGE_CHANNEL) return INTERNAL_MESSAGE_CHANNEL;
+		if (requestedChannel === "last") {
+			if (baseDelivery.channel && baseDelivery.channel !== INTERNAL_MESSAGE_CHANNEL) return baseDelivery.channel;
+			return INTERNAL_MESSAGE_CHANNEL;
+		}
+		if (isGatewayMessageChannel(requestedChannel)) return requestedChannel;
+		if (baseDelivery.channel && baseDelivery.channel !== INTERNAL_MESSAGE_CHANNEL) return baseDelivery.channel;
+		return INTERNAL_MESSAGE_CHANNEL;
+	})();
+	const deliveryTargetMode = explicitTo ? "explicit" : isDeliverableMessageChannel(resolvedChannel) ? "implicit" : void 0;
+	const resolvedAccountId = normalizeAccountId$1(params.accountId) ?? (deliveryTargetMode === "implicit" ? baseDelivery.accountId : void 0);
+	let resolvedTo = explicitTo;
+	if (!resolvedTo && isDeliverableMessageChannel(resolvedChannel) && resolvedChannel === baseDelivery.lastChannel) resolvedTo = baseDelivery.lastTo;
+	return {
+		baseDelivery,
+		resolvedChannel,
+		resolvedTo,
+		resolvedAccountId,
+		resolvedThreadId: baseDelivery.threadId,
+		deliveryTargetMode
+	};
+}
+function resolveAgentOutboundTarget(params) {
+	const targetMode = params.targetMode ?? params.plan.deliveryTargetMode ?? (params.plan.resolvedTo ? "explicit" : "implicit");
+	if (!isDeliverableMessageChannel(params.plan.resolvedChannel)) return {
+		resolvedTarget: null,
+		resolvedTo: params.plan.resolvedTo,
+		targetMode
+	};
+	if (params.validateExplicitTarget !== true && params.plan.resolvedTo) return {
+		resolvedTarget: null,
+		resolvedTo: params.plan.resolvedTo,
+		targetMode
+	};
+	const resolvedTarget = resolveOutboundTarget({
+		channel: params.plan.resolvedChannel,
+		to: params.plan.resolvedTo,
+		cfg: params.cfg,
+		accountId: params.plan.resolvedAccountId,
+		mode: targetMode
+	});
+	return {
+		resolvedTarget,
+		resolvedTo: resolvedTarget.ok ? resolvedTarget.to : params.plan.resolvedTo,
+		targetMode
+	};
+}
+
+//#endregion
+//#region src/infra/outbound/channel-selection.ts
+const getMessageChannels = () => listDeliverableMessageChannels();
+function isKnownChannel(value) {
+	return getMessageChannels().includes(value);
+}
+function isAccountEnabled(account) {
+	if (!account || typeof account !== "object") return true;
+	return account.enabled !== false;
+}
+async function isPluginConfigured(plugin, cfg) {
+	const accountIds = plugin.config.listAccountIds(cfg);
+	if (accountIds.length === 0) return false;
+	for (const accountId of accountIds) {
+		const account = plugin.config.resolveAccount(cfg, accountId);
+		if (!(plugin.config.isEnabled ? plugin.config.isEnabled(account, cfg) : isAccountEnabled(account))) continue;
+		if (!plugin.config.isConfigured) return true;
+		if (await plugin.config.isConfigured(account, cfg)) return true;
+	}
+	return false;
+}
+async function listConfiguredMessageChannels(cfg) {
+	const channels = [];
+	for (const plugin of listChannelPlugins()) {
+		if (!isKnownChannel(plugin.id)) continue;
+		if (await isPluginConfigured(plugin, cfg)) channels.push(plugin.id);
+	}
+	return channels;
+}
+async function resolveMessageChannelSelection(params) {
+	const normalized = normalizeMessageChannel(params.channel);
+	if (normalized) {
+		if (!isKnownChannel(normalized)) throw new Error(`Unknown channel: ${String(normalized)}`);
+		return {
+			channel: normalized,
+			configured: await listConfiguredMessageChannels(params.cfg)
+		};
+	}
+	const configured = await listConfiguredMessageChannels(params.cfg);
+	if (configured.length === 1) return {
+		channel: configured[0],
+		configured
+	};
+	if (configured.length === 0) throw new Error("Channel is required (no configured channels detected).");
+	throw new Error(`Channel is required when multiple channels are configured: ${configured.join(", ")}`);
+}
+
+//#endregion
+//#region src/channels/plugins/media-limits.ts
+const MB = 1024 * 1024;
+function resolveChannelMediaMaxBytes(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const channelLimit = params.resolveChannelLimitMb({
+		cfg: params.cfg,
+		accountId
+	});
+	if (channelLimit) return channelLimit * MB;
+	if (params.cfg.agents?.defaults?.mediaMaxMb) return params.cfg.agents.defaults.mediaMaxMb * MB;
+}
+
+//#endregion
+//#region src/channels/plugins/registry-loader.ts
+function createChannelRegistryLoader(resolveValue) {
+	const cache = /* @__PURE__ */ new Map();
+	let lastRegistry = null;
+	return async (id) => {
+		const registry = getActivePluginRegistry();
+		if (registry !== lastRegistry) {
+			cache.clear();
+			lastRegistry = registry;
+		}
+		const cached = cache.get(id);
+		if (cached) return cached;
+		const pluginEntry = registry?.channels.find((entry) => entry.plugin.id === id);
+		if (!pluginEntry) return;
+		const resolved = resolveValue(pluginEntry);
+		if (resolved) cache.set(id, resolved);
+		return resolved;
+	};
+}
+
+//#endregion
+//#region src/channels/plugins/outbound/load.ts
+const loadOutboundAdapterFromRegistry = createChannelRegistryLoader((entry) => entry.plugin.outbound);
+async function loadChannelOutboundAdapter(id) {
+	return loadOutboundAdapterFromRegistry(id);
+}
+
+//#endregion
+//#region src/infra/outbound/abort.ts
+/**
+* Utility for checking AbortSignal state and throwing a standard AbortError.
+*/
+/**
+* Throws an AbortError if the given signal has been aborted.
+* Use at async checkpoints to support cancellation.
+*/
+function throwIfAborted(abortSignal) {
+	if (abortSignal?.aborted) {
+		const err = /* @__PURE__ */ new Error("Operation aborted");
+		err.name = "AbortError";
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/infra/outbound/delivery-queue.ts
+const QUEUE_DIRNAME = "delivery-queue";
+const FAILED_DIRNAME = "failed";
+function resolveQueueDir(stateDir) {
+	const base = stateDir ?? resolveStateDir();
+	return path.join(base, QUEUE_DIRNAME);
+}
+function resolveFailedDir(stateDir) {
+	return path.join(resolveQueueDir(stateDir), FAILED_DIRNAME);
+}
+/** Ensure the queue directory (and failed/ subdirectory) exist. */
+async function ensureQueueDir(stateDir) {
+	const queueDir = resolveQueueDir(stateDir);
+	await fs$1.promises.mkdir(queueDir, {
+		recursive: true,
+		mode: 448
+	});
+	await fs$1.promises.mkdir(resolveFailedDir(stateDir), {
+		recursive: true,
+		mode: 448
+	});
+	return queueDir;
+}
+async function enqueueDelivery(params, stateDir) {
+	const queueDir = await ensureQueueDir(stateDir);
+	const id = generateSecureUuid();
+	const entry = {
+		id,
+		enqueuedAt: Date.now(),
+		channel: params.channel,
+		to: params.to,
+		accountId: params.accountId,
+		payloads: params.payloads,
+		threadId: params.threadId,
+		replyToId: params.replyToId,
+		bestEffort: params.bestEffort,
+		gifPlayback: params.gifPlayback,
+		silent: params.silent,
+		mirror: params.mirror,
+		retryCount: 0
+	};
+	const filePath = path.join(queueDir, `${id}.json`);
+	const tmp = `${filePath}.${process.pid}.tmp`;
+	const json = JSON.stringify(entry, null, 2);
+	await fs$1.promises.writeFile(tmp, json, {
+		encoding: "utf-8",
+		mode: 384
+	});
+	await fs$1.promises.rename(tmp, filePath);
+	return id;
+}
+/** Remove a successfully delivered entry from the queue. */
+async function ackDelivery(id, stateDir) {
+	const filePath = path.join(resolveQueueDir(stateDir), `${id}.json`);
+	try {
+		await fs$1.promises.unlink(filePath);
+	} catch (err) {
+		if ((err && typeof err === "object" && "code" in err ? String(err.code) : null) !== "ENOENT") throw err;
+	}
+}
+/** Update a queue entry after a failed delivery attempt. */
+async function failDelivery(id, error, stateDir) {
+	const filePath = path.join(resolveQueueDir(stateDir), `${id}.json`);
+	const raw = await fs$1.promises.readFile(filePath, "utf-8");
+	const entry = JSON.parse(raw);
+	entry.retryCount += 1;
+	entry.lastError = error;
+	const tmp = `${filePath}.${process.pid}.tmp`;
+	await fs$1.promises.writeFile(tmp, JSON.stringify(entry, null, 2), {
+		encoding: "utf-8",
+		mode: 384
+	});
+	await fs$1.promises.rename(tmp, filePath);
+}
+
+//#endregion
+//#region src/infra/outbound/payloads.ts
+function mergeMediaUrls(...lists) {
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const list of lists) {
+		if (!list) continue;
+		for (const entry of list) {
+			const trimmed = entry?.trim();
+			if (!trimmed) continue;
+			if (seen.has(trimmed)) continue;
+			seen.add(trimmed);
+			merged.push(trimmed);
+		}
+	}
+	return merged;
+}
+function normalizeReplyPayloadsForDelivery(payloads) {
+	return payloads.flatMap((payload) => {
+		if (shouldSuppressReasoningPayload(payload)) return [];
+		const parsed = parseReplyDirectives(payload.text ?? "");
+		const explicitMediaUrls = payload.mediaUrls ?? parsed.mediaUrls;
+		const explicitMediaUrl = payload.mediaUrl ?? parsed.mediaUrl;
+		const mergedMedia = mergeMediaUrls(explicitMediaUrls, explicitMediaUrl ? [explicitMediaUrl] : void 0);
+		const resolvedMediaUrl = (explicitMediaUrls?.length ?? 0) > 1 ? void 0 : explicitMediaUrl;
+		const next = {
+			...payload,
+			text: parsed.text ?? "",
+			mediaUrls: mergedMedia.length ? mergedMedia : void 0,
+			mediaUrl: resolvedMediaUrl,
+			replyToId: payload.replyToId ?? parsed.replyToId,
+			replyToTag: payload.replyToTag || parsed.replyToTag,
+			replyToCurrent: payload.replyToCurrent || parsed.replyToCurrent,
+			audioAsVoice: Boolean(payload.audioAsVoice || parsed.audioAsVoice)
+		};
+		if (parsed.isSilent && mergedMedia.length === 0) return [];
+		if (!isRenderablePayload(next)) return [];
+		return [next];
+	});
+}
+function normalizeOutboundPayloads(payloads) {
+	return normalizeReplyPayloadsForDelivery(payloads).map((payload) => {
+		const channelData = payload.channelData;
+		const normalized = {
+			text: payload.text ?? "",
+			mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : [])
+		};
+		if (channelData && Object.keys(channelData).length > 0) normalized.channelData = channelData;
+		return normalized;
+	}).filter((payload) => payload.text || payload.mediaUrls.length > 0 || Boolean(payload.channelData && Object.keys(payload.channelData).length > 0));
+}
+function normalizeOutboundPayloadsForJson(payloads) {
+	return normalizeReplyPayloadsForDelivery(payloads).map((payload) => ({
+		text: payload.text ?? "",
+		mediaUrl: payload.mediaUrl ?? null,
+		mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : void 0),
+		channelData: payload.channelData
+	}));
+}
+function formatOutboundPayloadLog(payload) {
+	const lines = [];
+	if (payload.text) lines.push(payload.text.trimEnd());
+	for (const url of payload.mediaUrls) lines.push(`MEDIA:${url}`);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/infra/outbound/deliver.ts
+async function createChannelHandler(params) {
+	const outbound = await loadChannelOutboundAdapter(params.channel);
+	const handler = createPluginHandler({
+		...params,
+		outbound
+	});
+	if (!handler) throw new Error(`Outbound not configured for channel: ${params.channel}`);
+	return handler;
+}
+function createPluginHandler(params) {
+	const outbound = params.outbound;
+	if (!outbound?.sendText || !outbound?.sendMedia) return null;
+	const baseCtx = createChannelOutboundContextBase(params);
+	const sendText = outbound.sendText;
+	const sendMedia = outbound.sendMedia;
+	const chunker = outbound.chunker ?? null;
+	const chunkerMode = outbound.chunkerMode;
+	const resolveCtx = (overrides) => ({
+		...baseCtx,
+		replyToId: overrides?.replyToId ?? baseCtx.replyToId,
+		threadId: overrides?.threadId ?? baseCtx.threadId
+	});
+	return {
+		chunker,
+		chunkerMode,
+		textChunkLimit: outbound.textChunkLimit,
+		sendPayload: outbound.sendPayload ? async (payload, overrides) => outbound.sendPayload({
+			...resolveCtx(overrides),
+			text: payload.text ?? "",
+			mediaUrl: payload.mediaUrl,
+			payload
+		}) : void 0,
+		sendText: async (text, overrides) => sendText({
+			...resolveCtx(overrides),
+			text
+		}),
+		sendMedia: async (caption, mediaUrl, overrides) => sendMedia({
+			...resolveCtx(overrides),
+			text: caption,
+			mediaUrl
+		})
+	};
+}
+function createChannelOutboundContextBase(params) {
+	return {
+		cfg: params.cfg,
+		to: params.to,
+		accountId: params.accountId,
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		identity: params.identity,
+		gifPlayback: params.gifPlayback,
+		deps: params.deps,
+		silent: params.silent,
+		mediaLocalRoots: params.mediaLocalRoots
+	};
+}
+const isAbortError = (err) => err instanceof Error && err.name === "AbortError";
+async function deliverOutboundPayloads(params) {
+	const { channel, to, payloads } = params;
+	const queueId = params.skipQueue ? null : await enqueueDelivery({
+		channel,
+		to,
+		accountId: params.accountId,
+		payloads,
+		threadId: params.threadId,
+		replyToId: params.replyToId,
+		bestEffort: params.bestEffort,
+		gifPlayback: params.gifPlayback,
+		silent: params.silent,
+		mirror: params.mirror
+	}).catch(() => null);
+	let hadPartialFailure = false;
+	const wrappedParams = params.onError ? {
+		...params,
+		onError: (err, payload) => {
+			hadPartialFailure = true;
+			params.onError(err, payload);
+		}
+	} : params;
+	try {
+		const results = await deliverOutboundPayloadsCore(wrappedParams);
+		if (queueId) if (hadPartialFailure) await failDelivery(queueId, "partial delivery failure (bestEffort)").catch(() => {});
+		else await ackDelivery(queueId).catch(() => {});
+		return results;
+	} catch (err) {
+		if (queueId) if (isAbortError(err)) await ackDelivery(queueId).catch(() => {});
+		else await failDelivery(queueId, err instanceof Error ? err.message : String(err)).catch(() => {});
+		throw err;
+	}
+}
+/** Core delivery logic (extracted for queue wrapper). */
+async function deliverOutboundPayloadsCore(params) {
+	const { cfg, channel, to, payloads } = params;
+	const accountId = params.accountId;
+	const deps = params.deps;
+	const abortSignal = params.abortSignal;
+	const sendSignal = params.deps?.sendSignal ?? sendMessageSignal;
+	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, params.agentId ?? params.mirror?.agentId);
+	const results = [];
+	const handler = await createChannelHandler({
+		cfg,
+		channel,
+		to,
+		deps,
+		accountId,
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		identity: params.identity,
+		gifPlayback: params.gifPlayback,
+		silent: params.silent,
+		mediaLocalRoots
+	});
+	const textLimit = handler.chunker ? resolveTextChunkLimit(cfg, channel, accountId, { fallbackLimit: handler.textChunkLimit }) : void 0;
+	const chunkMode = handler.chunker ? resolveChunkMode(cfg, channel, accountId) : "length";
+	const isSignalChannel = channel === "signal";
+	const signalTableMode = isSignalChannel ? resolveMarkdownTableMode({
+		cfg,
+		channel: "signal",
+		accountId
+	}) : "code";
+	const signalMaxBytes = isSignalChannel ? resolveChannelMediaMaxBytes({
+		cfg,
+		resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+		accountId
+	}) : void 0;
+	const sendTextChunks = async (text, overrides) => {
+		throwIfAborted(abortSignal);
+		if (!handler.chunker || textLimit === void 0) {
+			results.push(await handler.sendText(text, overrides));
+			return;
+		}
+		if (chunkMode === "newline") {
+			const blockChunks = (handler.chunkerMode ?? "text") === "markdown" ? chunkMarkdownTextWithMode(text, textLimit, "newline") : chunkByParagraph(text, textLimit);
+			if (!blockChunks.length && text) blockChunks.push(text);
+			for (const blockChunk of blockChunks) {
+				const chunks = handler.chunker(blockChunk, textLimit);
+				if (!chunks.length && blockChunk) chunks.push(blockChunk);
+				for (const chunk of chunks) {
+					throwIfAborted(abortSignal);
+					results.push(await handler.sendText(chunk, overrides));
+				}
+			}
+			return;
+		}
+		const chunks = handler.chunker(text, textLimit);
+		for (const chunk of chunks) {
+			throwIfAborted(abortSignal);
+			results.push(await handler.sendText(chunk, overrides));
+		}
+	};
+	const sendSignalText = async (text, styles) => {
+		throwIfAborted(abortSignal);
+		return {
+			channel: "signal",
+			...await sendSignal(to, text, {
+				maxBytes: signalMaxBytes,
+				accountId: accountId ?? void 0,
+				textMode: "plain",
+				textStyles: styles
+			})
+		};
+	};
+	const sendSignalTextChunks = async (text) => {
+		throwIfAborted(abortSignal);
+		let signalChunks = textLimit === void 0 ? markdownToSignalTextChunks(text, Number.POSITIVE_INFINITY, { tableMode: signalTableMode }) : markdownToSignalTextChunks(text, textLimit, { tableMode: signalTableMode });
+		if (signalChunks.length === 0 && text) signalChunks = [{
+			text,
+			styles: []
+		}];
+		for (const chunk of signalChunks) {
+			throwIfAborted(abortSignal);
+			results.push(await sendSignalText(chunk.text, chunk.styles));
+		}
+	};
+	const sendSignalMedia = async (caption, mediaUrl) => {
+		throwIfAborted(abortSignal);
+		const formatted = markdownToSignalTextChunks(caption, Number.POSITIVE_INFINITY, { tableMode: signalTableMode })[0] ?? {
+			text: caption,
+			styles: []
+		};
+		return {
+			channel: "signal",
+			...await sendSignal(to, formatted.text, {
+				mediaUrl,
+				maxBytes: signalMaxBytes,
+				accountId: accountId ?? void 0,
+				textMode: "plain",
+				textStyles: formatted.styles,
+				mediaLocalRoots
+			})
+		};
+	};
+	const normalizeWhatsAppPayload = (payload) => {
+		const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+		const normalizedText = (typeof payload.text === "string" ? payload.text : "").replace(/^(?:[ \t]*\r?\n)+/, "");
+		if (!normalizedText.trim()) {
+			if (!hasMedia) return null;
+			return {
+				...payload,
+				text: ""
+			};
+		}
+		return {
+			...payload,
+			text: normalizedText
+		};
+	};
+	const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads).flatMap((payload) => {
+		if (channel !== "whatsapp") return [payload];
+		const normalized = normalizeWhatsAppPayload(payload);
+		return normalized ? [normalized] : [];
+	});
+	const hookRunner = getGlobalHookRunner();
+	const sessionKeyForInternalHooks = params.mirror?.sessionKey ?? params.sessionKey;
+	for (const payload of normalizedPayloads) {
+		const payloadSummary = {
+			text: payload.text ?? "",
+			mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
+			channelData: payload.channelData
+		};
+		const emitMessageSent = (params) => {
+			if (hookRunner?.hasHooks("message_sent")) hookRunner.runMessageSent({
+				to,
+				content: params.content,
+				success: params.success,
+				...params.error ? { error: params.error } : {}
+			}, {
+				channelId: channel,
+				accountId: accountId ?? void 0,
+				conversationId: to
+			}).catch(() => {});
+			if (!sessionKeyForInternalHooks) return;
+			triggerInternalHook(createInternalHookEvent("message", "sent", sessionKeyForInternalHooks, {
+				to,
+				content: params.content,
+				success: params.success,
+				...params.error ? { error: params.error } : {},
+				channelId: channel,
+				accountId: accountId ?? void 0,
+				conversationId: to,
+				messageId: params.messageId
+			})).catch(() => {});
+		};
+		try {
+			throwIfAborted(abortSignal);
+			let effectivePayload = payload;
+			if (hookRunner?.hasHooks("message_sending")) try {
+				const sendingResult = await hookRunner.runMessageSending({
+					to,
+					content: payloadSummary.text,
+					metadata: {
+						channel,
+						accountId,
+						mediaUrls: payloadSummary.mediaUrls
+					}
+				}, {
+					channelId: channel,
+					accountId: accountId ?? void 0
+				});
+				if (sendingResult?.cancel) continue;
+				if (sendingResult?.content != null) {
+					effectivePayload = {
+						...payload,
+						text: sendingResult.content
+					};
+					payloadSummary.text = sendingResult.content;
+				}
+			} catch {}
+			params.onPayload?.(payloadSummary);
+			const sendOverrides = {
+				replyToId: effectivePayload.replyToId ?? params.replyToId ?? void 0,
+				threadId: params.threadId ?? void 0
+			};
+			if (handler.sendPayload && effectivePayload.channelData) {
+				const delivery = await handler.sendPayload(effectivePayload, sendOverrides);
+				results.push(delivery);
+				emitMessageSent({
+					success: true,
+					content: payloadSummary.text,
+					messageId: delivery.messageId
+				});
+				continue;
+			}
+			if (payloadSummary.mediaUrls.length === 0) {
+				const beforeCount = results.length;
+				if (isSignalChannel) await sendSignalTextChunks(payloadSummary.text);
+				else await sendTextChunks(payloadSummary.text, sendOverrides);
+				const messageId = results.at(-1)?.messageId;
+				emitMessageSent({
+					success: results.length > beforeCount,
+					content: payloadSummary.text,
+					messageId
+				});
+				continue;
+			}
+			let first = true;
+			let lastMessageId;
+			for (const url of payloadSummary.mediaUrls) {
+				throwIfAborted(abortSignal);
+				const caption = first ? payloadSummary.text : "";
+				first = false;
+				if (isSignalChannel) {
+					const delivery = await sendSignalMedia(caption, url);
+					results.push(delivery);
+					lastMessageId = delivery.messageId;
+				} else {
+					const delivery = await handler.sendMedia(caption, url, sendOverrides);
+					results.push(delivery);
+					lastMessageId = delivery.messageId;
+				}
+			}
+			emitMessageSent({
+				success: true,
+				content: payloadSummary.text,
+				messageId: lastMessageId
+			});
+		} catch (err) {
+			emitMessageSent({
+				success: false,
+				content: payloadSummary.text,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			if (!params.bestEffort) throw err;
+			params.onError?.(err, payloadSummary);
+		}
+	}
+	if (params.mirror && results.length > 0) {
+		const mirrorText = resolveMirroredTranscriptText({
+			text: params.mirror.text,
+			mediaUrls: params.mirror.mediaUrls
+		});
+		if (mirrorText) await appendAssistantMessageToSessionTranscript({
+			agentId: params.mirror.agentId,
+			sessionKey: params.mirror.sessionKey,
+			text: mirrorText
+		});
+	}
+	return results;
+}
+
+//#endregion
+//#region src/infra/outbound/envelope.ts
+const isOutboundPayloadJson = (payload) => "mediaUrl" in payload;
+function buildOutboundResultEnvelope(params) {
+	const hasPayloads = params.payloads !== void 0;
+	const payloads = params.payloads === void 0 ? void 0 : params.payloads.length === 0 ? [] : isOutboundPayloadJson(params.payloads[0]) ? [...params.payloads] : normalizeOutboundPayloadsForJson(params.payloads);
+	if (params.flattenDelivery !== false && params.delivery && !params.meta && !hasPayloads) return params.delivery;
+	return {
+		...hasPayloads ? { payloads } : {},
+		...params.meta ? { meta: params.meta } : {},
+		...params.delivery ? { delivery: params.delivery } : {}
+	};
+}
+
+//#endregion
+//#region src/commands/agent/delivery.ts
+const NESTED_LOG_PREFIX = "[agent:nested]";
+function formatNestedLogPrefix(opts) {
+	const parts = [NESTED_LOG_PREFIX];
+	const session = opts.sessionKey ?? opts.sessionId;
+	if (session) parts.push(`session=${session}`);
+	if (opts.runId) parts.push(`run=${opts.runId}`);
+	const channel = opts.messageChannel ?? opts.channel;
+	if (channel) parts.push(`channel=${channel}`);
+	if (opts.to) parts.push(`to=${opts.to}`);
+	if (opts.accountId) parts.push(`account=${opts.accountId}`);
+	return parts.join(" ");
+}
+function logNestedOutput(runtime, opts, output) {
+	const prefix = formatNestedLogPrefix(opts);
+	for (const line of output.split(/\r?\n/)) {
+		if (!line) continue;
+		runtime.log(`${prefix} ${line}`);
+	}
+}
+async function deliverAgentCommandResult(params) {
+	const { cfg, deps, runtime, opts, sessionEntry, payloads, result } = params;
+	const resultMeta = {
+		durationMs: result.run.durationMs,
+		aborted: result.run.aborted,
+		agentMeta: {
+			sessionId: result.run.sessionId,
+			usage: result.run.usage
+		}
+	};
+	const deliver = opts.deliver === true;
+	const bestEffortDeliver = opts.bestEffortDeliver === true;
+	const turnSourceChannel = opts.runContext?.messageChannel ?? opts.messageChannel;
+	const turnSourceTo = opts.runContext?.currentChannelId ?? opts.to;
+	const turnSourceAccountId = opts.runContext?.accountId ?? opts.accountId;
+	const turnSourceThreadId = opts.runContext?.currentThreadTs ?? opts.threadId;
+	const deliveryPlan = resolveAgentDeliveryPlan({
+		sessionEntry,
+		requestedChannel: opts.replyChannel ?? opts.channel,
+		explicitTo: opts.replyTo ?? opts.to,
+		explicitThreadId: opts.threadId,
+		accountId: opts.replyAccountId ?? opts.accountId,
+		wantsDelivery: deliver,
+		turnSourceChannel,
+		turnSourceTo,
+		turnSourceAccountId,
+		turnSourceThreadId
+	});
+	let deliveryChannel = deliveryPlan.resolvedChannel;
+	const explicitChannelHint = (opts.replyChannel ?? opts.channel)?.trim();
+	if (deliver && isInternalMessageChannel(deliveryChannel) && !explicitChannelHint) try {
+		deliveryChannel = (await resolveMessageChannelSelection({ cfg })).channel;
+	} catch {}
+	const effectiveDeliveryPlan = deliveryChannel === deliveryPlan.resolvedChannel ? deliveryPlan : {
+		...deliveryPlan,
+		resolvedChannel: deliveryChannel
+	};
+	const deliveryPlugin = !isInternalMessageChannel(deliveryChannel) ? getChannelPlugin(normalizeChannelId(deliveryChannel) ?? deliveryChannel) : void 0;
+	const isDeliveryChannelKnown = isInternalMessageChannel(deliveryChannel) || Boolean(deliveryPlugin);
+	const targetMode = opts.deliveryTargetMode ?? effectiveDeliveryPlan.deliveryTargetMode ?? (opts.to ? "explicit" : "implicit");
+	const resolvedAccountId = effectiveDeliveryPlan.resolvedAccountId;
+	const resolved = deliver && isDeliveryChannelKnown && deliveryChannel ? resolveAgentOutboundTarget({
+		cfg,
+		plan: effectiveDeliveryPlan,
+		targetMode,
+		validateExplicitTarget: true
+	}) : {
+		resolvedTarget: null,
+		resolvedTo: effectiveDeliveryPlan.resolvedTo,
+		targetMode
+	};
+	const resolvedTarget = resolved.resolvedTarget;
+	const deliveryTarget = resolved.resolvedTo;
+	const resolvedThreadId = deliveryPlan.resolvedThreadId ?? opts.threadId;
+	const resolvedReplyToId = deliveryChannel === "slack" && resolvedThreadId != null ? String(resolvedThreadId) : void 0;
+	const resolvedThreadTarget = deliveryChannel === "slack" ? void 0 : resolvedThreadId;
+	const logDeliveryError = (err) => {
+		const message = `Delivery failed (${deliveryChannel}${deliveryTarget ? ` to ${deliveryTarget}` : ""}): ${String(err)}`;
+		runtime.error?.(message);
+		if (!runtime.error) runtime.log(message);
+	};
+	if (deliver) {
+		if (isInternalMessageChannel(deliveryChannel)) {
+			const err = /* @__PURE__ */ new Error("delivery channel is required: pass --channel/--reply-channel or use a main session with a previous channel");
+			if (!bestEffortDeliver) throw err;
+			logDeliveryError(err);
+		} else if (!isDeliveryChannelKnown) {
+			const err = /* @__PURE__ */ new Error(`Unknown channel: ${deliveryChannel}`);
+			if (!bestEffortDeliver) throw err;
+			logDeliveryError(err);
+		} else if (resolvedTarget && !resolvedTarget.ok) {
+			if (!bestEffortDeliver) throw resolvedTarget.error;
+			logDeliveryError(resolvedTarget.error);
+		}
+	}
+	const normalizedPayloads = normalizeOutboundPayloadsForJson(payloads ?? []);
+	if (opts.json) {
+		runtime.log(JSON.stringify(buildOutboundResultEnvelope({
+			payloads: normalizedPayloads,
+			meta: resultMeta
+		}), null, 2));
+		if (!deliver) return {
+			payloads: normalizedPayloads,
+			meta: resultMeta
+		};
+	}
+	if (!payloads || payloads.length === 0) {
+		runtime.log("No reply from agent.");
+		return {
+			payloads: [],
+			meta: resultMeta
+		};
+	}
+	const deliveryPayloads = normalizeOutboundPayloads(payloads);
+	const logPayload = (payload) => {
+		if (opts.json) return;
+		const output = formatOutboundPayloadLog(payload);
+		if (!output) return;
+		if (opts.lane === AGENT_LANE_NESTED) {
+			logNestedOutput(runtime, opts, output);
+			return;
+		}
+		runtime.log(output);
+	};
+	if (!deliver) for (const payload of deliveryPayloads) logPayload(payload);
+	if (deliver && deliveryChannel && !isInternalMessageChannel(deliveryChannel)) {
+		if (deliveryTarget) {
+			const deliveryAgentId = opts.agentId ?? (opts.sessionKey ? resolveSessionAgentId({
+				sessionKey: opts.sessionKey,
+				config: cfg
+			}) : void 0);
+			await deliverOutboundPayloads({
+				cfg,
+				channel: deliveryChannel,
+				to: deliveryTarget,
+				accountId: resolvedAccountId,
+				payloads: deliveryPayloads,
+				agentId: deliveryAgentId,
+				replyToId: resolvedReplyToId ?? null,
+				threadId: resolvedThreadTarget ?? null,
+				bestEffort: bestEffortDeliver,
+				onError: (err) => logDeliveryError(err),
+				onPayload: logPayload,
+				deps: createOutboundSendDeps(deps)
+			});
+		}
+	}
+	return {
+		payloads: normalizedPayloads,
+		meta: resultMeta
+	};
+}
+
+//#endregion
+//#region src/commands/agent/run-context.ts
+function resolveAgentRunContext(opts) {
+	const merged = opts.runContext ? { ...opts.runContext } : {};
+	const normalizedChannel = resolveMessageChannel(merged.messageChannel ?? opts.messageChannel, opts.replyChannel ?? opts.channel);
+	if (normalizedChannel) merged.messageChannel = normalizedChannel;
+	const normalizedAccountId = normalizeAccountId$1(merged.accountId ?? opts.accountId);
+	if (normalizedAccountId) merged.accountId = normalizedAccountId;
+	const groupId = (merged.groupId ?? opts.groupId)?.toString().trim();
+	if (groupId) merged.groupId = groupId;
+	const groupChannel = (merged.groupChannel ?? opts.groupChannel)?.toString().trim();
+	if (groupChannel) merged.groupChannel = groupChannel;
+	const groupSpace = (merged.groupSpace ?? opts.groupSpace)?.toString().trim();
+	if (groupSpace) merged.groupSpace = groupSpace;
+	if (merged.currentThreadTs == null && opts.threadId != null && opts.threadId !== "" && opts.threadId !== null) merged.currentThreadTs = String(opts.threadId);
+	if (!merged.currentChannelId && opts.to) {
+		const trimmedTo = opts.to.trim();
+		if (trimmedTo) merged.currentChannelId = trimmedTo;
+	}
+	return merged;
+}
+
+//#endregion
+//#region src/commands/agent/session-store.ts
+async function updateSessionStoreAfterAgentRun(params) {
+	const { cfg, sessionId, sessionKey, storePath, sessionStore, defaultProvider, defaultModel, fallbackProvider, fallbackModel, result } = params;
+	const runUsage = result.run.usage;
+	const usage = runUsage ? {
+		input: runUsage.inputTokens,
+		output: runUsage.outputTokens,
+		cacheRead: runUsage.cacheReadTokens,
+		cacheWrite: runUsage.cacheWriteTokens
+	} : void 0;
+	const modelUsed = fallbackModel ?? defaultModel;
+	const providerUsed = fallbackProvider ?? defaultProvider;
+	const contextTokens = params.contextTokensOverride ?? 2e5;
+	const next = {
+		...sessionStore[sessionKey] ?? {
+			sessionId,
+			updatedAt: Date.now()
+		},
+		sessionId,
+		updatedAt: Date.now(),
+		contextTokens
+	};
+	next.modelProvider = providerUsed;
+	next.model = modelUsed;
+	if (isCliProvider(providerUsed, cfg)) {
+		const cliSessionId = result.run.sessionId?.trim();
+		if (cliSessionId) setCliSessionId(next, providerUsed, cliSessionId);
+	}
+	next.abortedLastRun = result.run.aborted ?? false;
+	if (hasNonzeroUsage(usage)) {
+		const input = usage.input ?? 0;
+		const output = usage.output ?? 0;
+		const totalTokens = deriveSessionTotalTokens({
+			usage,
+			contextTokens
+		}) ?? input;
+		next.inputTokens = input;
+		next.outputTokens = output;
+		next.totalTokens = totalTokens;
+		next.totalTokensFresh = true;
+		next.cacheRead = usage.cacheRead ?? 0;
+		next.cacheWrite = usage.cacheWrite ?? 0;
+	}
+	sessionStore[sessionKey] = next;
+	await updateSessionStore(storePath, (store) => {
+		store[sessionKey] = next;
+	});
+}
+
+//#endregion
+//#region src/commands/agent/session.ts
+function resolveSessionKeyForRequest(opts) {
+	const sessionCfg = opts.cfg.session;
+	const scope = sessionCfg?.scope ?? "per-sender";
+	const mainKey = normalizeMainKey(sessionCfg?.mainKey);
+	const explicitSessionKey = opts.sessionKey?.trim() || resolveExplicitAgentSessionKey({
+		cfg: opts.cfg,
+		agentId: opts.agentId
+	});
+	const storeAgentId = resolveAgentIdFromSessionKey(explicitSessionKey);
+	const storePath = resolveStorePath(sessionCfg?.store, { agentId: storeAgentId });
+	const sessionStore = loadSessionStore(storePath);
+	const ctx = opts.to?.trim() ? { From: opts.to } : void 0;
+	let sessionKey = explicitSessionKey ?? (ctx ? resolveSessionKey(scope, ctx, mainKey) : void 0);
+	if (!explicitSessionKey && opts.sessionId && (!sessionKey || sessionStore[sessionKey]?.sessionId !== opts.sessionId)) {
+		const foundKey = Object.keys(sessionStore).find((key) => sessionStore[key]?.sessionId === opts.sessionId);
+		if (foundKey) sessionKey = foundKey;
+	}
+	if (opts.sessionId && !explicitSessionKey && (!sessionKey || sessionStore[sessionKey]?.sessionId !== opts.sessionId)) {
+		const allAgentIds = listAgentIds(opts.cfg);
+		for (const agentId of allAgentIds) {
+			if (agentId === storeAgentId) continue;
+			const altStorePath = resolveStorePath(sessionCfg?.store, { agentId });
+			const altStore = loadSessionStore(altStorePath);
+			const foundKey = Object.keys(altStore).find((key) => altStore[key]?.sessionId === opts.sessionId);
+			if (foundKey) return {
+				sessionKey: foundKey,
+				sessionStore: altStore,
+				storePath: altStorePath
+			};
+		}
+	}
+	return {
+		sessionKey,
+		sessionStore,
+		storePath
+	};
+}
+function resolveSession(opts) {
+	const sessionCfg = opts.cfg.session;
+	const { sessionKey, sessionStore, storePath } = resolveSessionKeyForRequest({
+		cfg: opts.cfg,
+		to: opts.to,
+		sessionId: opts.sessionId,
+		sessionKey: opts.sessionKey,
+		agentId: opts.agentId
+	});
+	const now = Date.now();
+	const sessionEntry = sessionKey ? sessionStore[sessionKey] : void 0;
+	const resetPolicy = resolveSessionResetPolicy({
+		sessionCfg,
+		resetType: resolveSessionResetType({ sessionKey }),
+		resetOverride: resolveChannelResetConfig({
+			sessionCfg,
+			channel: sessionEntry?.lastChannel ?? sessionEntry?.channel
+		})
+	});
+	const fresh = sessionEntry ? evaluateSessionFreshness({
+		updatedAt: sessionEntry.updatedAt,
+		now,
+		policy: resetPolicy
+	}).fresh : false;
+	return {
+		sessionId: opts.sessionId?.trim() || (fresh ? sessionEntry?.sessionId : void 0) || crypto.randomUUID(),
+		sessionKey,
+		sessionEntry,
+		sessionStore,
+		storePath,
+		isNewSession: !fresh && !opts.sessionId,
+		persistedVerbose: fresh && sessionEntry?.verboseLevel ? normalizeVerboseLevel(sessionEntry.verboseLevel) : void 0
+	};
+}
+
+//#endregion
+//#region src/commands/agent.ts
+async function persistSessionEntry(params) {
+	params.sessionStore[params.sessionKey] = params.entry;
+	await updateSessionStore(params.storePath, (store) => {
+		store[params.sessionKey] = params.entry;
+	});
+}
+/**
+* Create a SessionMap-compatible adapter that bridges the agent command
+* session store to the ChannelBridge's SessionMap interface.
+*
+* `get()` returns the CLI session ID from the session entry.
+* `set()` is a no-op — session updates are handled by the caller after the run.
+*/
+function createSessionMapAdapter(params) {
+	return {
+		async get() {
+			return params.getSessionId();
+		},
+		async set() {},
+		async delete() {}
+	};
+}
+/** Resolve gateway URL from config for local gateway. */
+function resolveGatewayUrlFromConfig(cfg) {
+	return `ws://127.0.0.1:${resolveGatewayPort(cfg)}`;
+}
+/** Resolve gateway auth token from config. */
+function resolveGatewayTokenFromConfig(cfg) {
+	return resolveGatewayCredentialsFromConfig({
+		cfg,
+		env: process.env
+	}).token ?? "";
+}
+/** Build a ChannelMessage from the CLI command context. */
+function buildCliChannelMessage(params) {
+	return {
+		id: params.runId,
+		text: params.text,
+		from: params.accountId ?? "cli",
+		channelId: params.channelId ?? "",
+		provider: params.messageChannel ?? "cli",
+		timestamp: params.timestamp,
+		replyToId: params.threadId,
+		messageToolHints: params.messageToolHints?.length ? params.messageToolHints : void 0,
+		senderIsOwner: true
+	};
+}
+async function agentCommand(opts, runtime = defaultRuntime, deps = createDefaultDeps()) {
+	const body = (opts.message ?? "").trim();
+	if (!body) throw new Error("Message (--message) is required");
+	if (!opts.to && !opts.sessionId && !opts.sessionKey && !opts.agentId) throw new Error("Pass --to <E.164>, --session-id, or --agent to choose a session");
+	const cfg = loadConfig();
+	const agentIdOverrideRaw = opts.agentId?.trim();
+	const agentIdOverride = agentIdOverrideRaw ? normalizeAgentId(agentIdOverrideRaw) : void 0;
+	if (agentIdOverride) {
+		if (!listAgentIds(cfg).includes(agentIdOverride)) throw new Error(`Unknown agent id "${agentIdOverrideRaw}". Use "${formatCliCommand("remoteclaw agents list")}" to see configured agents.`);
+	}
+	if (agentIdOverride && opts.sessionKey) {
+		const sessionAgentId = resolveAgentIdFromSessionKey(opts.sessionKey);
+		if (sessionAgentId !== agentIdOverride) throw new Error(`Agent id "${agentIdOverrideRaw}" does not match session key agent "${sessionAgentId}".`);
+	}
+	const agentCfg = cfg.agents?.defaults;
+	const verboseOverride = normalizeVerboseLevel(opts.verbose);
+	if (opts.verbose && !verboseOverride) throw new Error("Invalid verbose level. Use \"on\", \"full\", or \"off\".");
+	if (opts.timeout !== void 0) {
+		const timeoutSecondsRaw = Number.parseInt(String(opts.timeout), 10);
+		if (Number.isNaN(timeoutSecondsRaw) || timeoutSecondsRaw < 0) throw new Error("--timeout must be a non-negative integer (seconds; 0 means no timeout)");
+	}
+	const { sessionId, sessionKey, sessionEntry: resolvedSessionEntry, sessionStore, storePath, isNewSession: _isNewSession, persistedVerbose } = resolveSession({
+		cfg,
+		to: opts.to,
+		sessionId: opts.sessionId,
+		sessionKey: opts.sessionKey,
+		agentId: agentIdOverride
+	});
+	const sessionAgentId = agentIdOverride ?? resolveSessionAgentId({
+		sessionKey: sessionKey ?? opts.sessionKey?.trim(),
+		config: cfg
+	});
+	const workspaceDir = await ensureAgentWorkspace(resolveAgentWorkspaceDir(cfg, sessionAgentId));
+	let sessionEntry = resolvedSessionEntry;
+	const runId = opts.runId?.trim() || sessionId;
+	try {
+		if (opts.deliver === true) {
+			if (resolveSendPolicy({
+				cfg,
+				entry: sessionEntry,
+				sessionKey,
+				channel: sessionEntry?.channel,
+				chatType: sessionEntry?.chatType
+			}) === "deny") throw new Error("send blocked by session policy");
+		}
+		const resolvedVerboseLevel = verboseOverride ?? persistedVerbose ?? agentCfg?.verboseDefault;
+		if (sessionKey) registerAgentRunContext(runId, {
+			sessionKey,
+			verboseLevel: resolvedVerboseLevel
+		});
+		if (sessionStore && sessionKey) {
+			const next = {
+				...sessionStore[sessionKey] ?? sessionEntry ?? {
+					sessionId,
+					updatedAt: Date.now()
+				},
+				sessionId,
+				updatedAt: Date.now()
+			};
+			applyVerboseOverride(next, verboseOverride);
+			await persistSessionEntry({
+				sessionStore,
+				sessionKey,
+				storePath,
+				entry: next
+			});
+			sessionEntry = next;
+		}
+		const { provider: defaultProvider, model: defaultModel } = normalizeModelRef("unknown", "unknown");
+		let provider = defaultProvider;
+		let model = defaultModel;
+		const storedProviderOverride = sessionEntry?.providerOverride?.trim();
+		const storedModelOverride = sessionEntry?.modelOverride?.trim();
+		if (storedModelOverride) {
+			const normalizedStored = normalizeModelRef(storedProviderOverride || defaultProvider, storedModelOverride);
+			provider = normalizedStored.provider;
+			model = normalizedStored.model;
+		}
+		const sessionPathOpts = resolveSessionFilePathOptions({
+			agentId: sessionAgentId,
+			storePath
+		});
+		if (sessionStore && sessionKey) {
+			const threadIdFromSessionKey = parseSessionThreadInfo(sessionKey).threadId;
+			const fallbackSessionFile = !sessionEntry?.sessionFile ? resolveSessionTranscriptPath(sessionId, sessionAgentId, opts.threadId ?? threadIdFromSessionKey) : void 0;
+			sessionEntry = (await resolveAndPersistSessionFile({
+				sessionId,
+				sessionKey,
+				sessionStore,
+				storePath,
+				sessionEntry,
+				agentId: sessionPathOpts?.agentId,
+				sessionsDir: sessionPathOpts?.sessionsDir,
+				fallbackSessionFile
+			})).sessionEntry;
+		}
+		const startedAt = Date.now();
+		let result;
+		const fallbackProvider = provider;
+		const fallbackModel = model;
+		try {
+			const runContext = resolveAgentRunContext(opts);
+			const messageChannel = resolveMessageChannel(runContext.messageChannel, opts.replyChannel ?? opts.channel);
+			const sessionMap = createSessionMapAdapter({ getSessionId: () => getCliSessionId(sessionEntry, provider) });
+			const bridge = new ChannelBridge({
+				provider: resolveAgentRuntimeOrThrow(cfg, sessionAgentId),
+				sessionMap,
+				gatewayUrl: resolveGatewayUrlFromConfig(cfg),
+				gatewayToken: resolveGatewayTokenFromConfig(cfg),
+				workspaceDir,
+				runtimeArgs: resolveAgentRuntimeArgs(cfg, sessionAgentId),
+				runtimeEnv: resolveAgentRuntimeEnv(cfg, sessionAgentId)
+			});
+			const messageToolHints = resolveChannelMessageToolHints({
+				cfg,
+				channel: messageChannel,
+				accountId: runContext.accountId ?? opts.accountId
+			});
+			const message = buildCliChannelMessage({
+				runId,
+				text: body,
+				accountId: runContext.accountId ?? opts.accountId,
+				channelId: opts.to,
+				messageChannel,
+				threadId: opts.threadId != null ? String(opts.threadId) : void 0,
+				timestamp: Date.now(),
+				messageToolHints
+			});
+			result = await bridge.handle(message, void 0, opts.abortSignal);
+			emitAgentEvent({
+				runId,
+				stream: "lifecycle",
+				data: {
+					phase: "end",
+					startedAt,
+					endedAt: Date.now(),
+					aborted: result.run.aborted ?? false
+				}
+			});
+		} catch (err) {
+			emitAgentEvent({
+				runId,
+				stream: "lifecycle",
+				data: {
+					phase: "error",
+					startedAt,
+					endedAt: Date.now(),
+					error: String(err)
+				}
+			});
+			throw err;
+		}
+		if (sessionStore && sessionKey) await updateSessionStoreAfterAgentRun({
+			cfg,
+			contextTokensOverride: agentCfg?.contextTokens,
+			sessionId,
+			sessionKey,
+			storePath,
+			sessionStore,
+			defaultProvider: provider,
+			defaultModel: model,
+			fallbackProvider,
+			fallbackModel,
+			result
+		});
+		const payloads = result.payloads ?? [];
+		return await deliverAgentCommandResult({
+			cfg,
+			deps,
+			runtime,
+			opts,
+			sessionEntry,
+			result,
+			payloads
+		});
+	} finally {
+		clearAgentRunContext(runId);
+	}
+}
+
+//#endregion
+//#region src/gateway/boot.ts
+function generateBootSessionId() {
+	return `boot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").replace("Z", "")}-${crypto.randomUUID().slice(0, 8)}`;
+}
+const log$1 = createSubsystemLogger("gateway/boot");
+function buildBootPrompt(content) {
+	return [
+		"You are running a boot check. Follow the boot instructions exactly.",
+		"",
+		"Boot instructions:",
+		content,
+		"",
+		"If the instructions ask you to send a message, use the message tool (action=send with channel + target).",
+		"Use the `target` field (not `to`) for message tool destinations.",
+		`After sending with the message tool, reply with ONLY: ${SILENT_REPLY_TOKEN}.`,
+		`If nothing needs attention, reply with ONLY: ${SILENT_REPLY_TOKEN}.`
+	].join("\n");
+}
+async function resolveBootPrompt(boot, workspaceDir) {
+	if (!boot) return { status: "not-configured" };
+	if (boot.prompt !== void 0) {
+		const trimmed = boot.prompt.trim();
+		if (!trimmed) return { status: "empty" };
+		return {
+			status: "ok",
+			content: trimmed
+		};
+	}
+	if (boot.file !== void 0) {
+		const filePath = path.isAbsolute(boot.file) ? boot.file : path.join(workspaceDir, boot.file);
+		try {
+			const trimmed = (await fs.readFile(filePath, "utf-8")).trim();
+			if (!trimmed) return { status: "empty" };
+			return {
+				status: "ok",
+				content: trimmed
+			};
+		} catch (err) {
+			return {
+				status: "read-error",
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	return { status: "not-configured" };
+}
+function snapshotMainSessionMapping(params) {
+	const agentId = resolveAgentIdFromSessionKey(params.sessionKey);
+	const storePath = resolveStorePath(params.cfg.session?.store, { agentId });
+	try {
+		const entry = loadSessionStore(storePath, { skipCache: true })[params.sessionKey];
+		if (!entry) return {
+			storePath,
+			sessionKey: params.sessionKey,
+			canRestore: true,
+			hadEntry: false
+		};
+		return {
+			storePath,
+			sessionKey: params.sessionKey,
+			canRestore: true,
+			hadEntry: true,
+			entry: structuredClone(entry)
+		};
+	} catch (err) {
+		log$1.debug("boot: could not snapshot main session mapping", {
+			sessionKey: params.sessionKey,
+			error: String(err)
+		});
+		return {
+			storePath,
+			sessionKey: params.sessionKey,
+			canRestore: false,
+			hadEntry: false
+		};
+	}
+}
+async function restoreMainSessionMapping(snapshot) {
+	if (!snapshot.canRestore) return;
+	try {
+		await updateSessionStore(snapshot.storePath, (store) => {
+			if (snapshot.hadEntry && snapshot.entry) {
+				store[snapshot.sessionKey] = snapshot.entry;
+				return;
+			}
+			delete store[snapshot.sessionKey];
+		}, { activeSessionKey: snapshot.sessionKey });
+		return;
+	} catch (err) {
+		return err instanceof Error ? err.message : String(err);
+	}
+}
+async function runBootOnce(params) {
+	const bootRuntime = {
+		log: () => {},
+		error: (message) => log$1.error(String(message)),
+		exit: defaultRuntime.exit
+	};
+	const resolved = await resolveBootPrompt(params.boot, params.workspaceDir);
+	if (resolved.status === "not-configured") return {
+		status: "skipped",
+		reason: "not-configured"
+	};
+	if (resolved.status === "empty") return {
+		status: "skipped",
+		reason: "empty"
+	};
+	if (resolved.status === "read-error") {
+		log$1.error(`boot: failed to read boot file: ${resolved.error}`);
+		return {
+			status: "failed",
+			reason: resolved.error ?? "read error"
+		};
+	}
+	const sessionKey = params.agentId ? resolveAgentMainSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId
+	}) : resolveMainSessionKey(params.cfg);
+	const message = buildBootPrompt(resolved.content ?? "");
+	const sessionId = generateBootSessionId();
+	const mappingSnapshot = snapshotMainSessionMapping({
+		cfg: params.cfg,
+		sessionKey
+	});
+	let agentFailure;
+	try {
+		await agentCommand({
+			message,
+			sessionKey,
+			sessionId,
+			deliver: false
+		}, bootRuntime, params.deps);
+	} catch (err) {
+		agentFailure = err instanceof Error ? err.message : String(err);
+		log$1.error(`boot: agent run failed: ${agentFailure}`);
+	}
+	const mappingRestoreFailure = await restoreMainSessionMapping(mappingSnapshot);
+	if (mappingRestoreFailure) log$1.error(`boot: failed to restore main session mapping: ${mappingRestoreFailure}`);
+	if (!agentFailure && !mappingRestoreFailure) return { status: "ran" };
+	return {
+		status: "failed",
+		reason: [agentFailure ? `agent run failed: ${agentFailure}` : void 0, mappingRestoreFailure ? `mapping restore failed: ${mappingRestoreFailure}` : void 0].filter((part) => Boolean(part)).join("; ")
+	};
+}
+
+//#endregion
+//#region src/hooks/bundled/boot/handler.ts
+const log = createSubsystemLogger("hooks/boot");
+function resolveBootConfig(cfg, agentId) {
+	const agentCfg = resolveAgentConfig(cfg, agentId);
+	if (agentCfg?.boot) return agentCfg.boot;
+	return cfg.agents?.defaults?.boot;
+}
+const runBootChecklist = async (event) => {
+	if (!isGatewayStartupEvent(event)) return;
+	if (!event.context.cfg) return;
+	const cfg = event.context.cfg;
+	const deps = event.context.deps ?? createDefaultDeps();
+	const agentIds = listAgentIds(cfg);
+	for (const agentId of agentIds) {
+		const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+		const result = await runBootOnce({
+			cfg,
+			deps,
+			boot: resolveBootConfig(cfg, agentId),
+			workspaceDir,
+			agentId
+		});
+		if (result.status === "failed") {
+			log.warn("boot failed for agent startup run", {
+				agentId,
+				workspaceDir,
+				reason: result.reason
+			});
+			continue;
+		}
+		if (result.status === "skipped") log.debug("boot skipped for agent startup run", {
+			agentId,
+			workspaceDir,
+			reason: result.reason
+		});
+	}
+};
+
+//#endregion
+export { runBootChecklist as default };