remoteclaw 0.0.0 → 0.1.0-next.2abd2fa

package/dist/subagent-registry-Du_j0Fnt.js

@@ -0,0 +1,4860 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { h as resolveStateDir } from "./paths-BTaH3rLn.js";
+import { s as sanitizeUserFacingText } from "./agent-helpers-B6VfZ9_u.js";
+import { c as resolveSessionAgentId, s as resolveDefaultAgentId } from "./agent-scope-BGYzhtWQ.js";
+import { g as normalizeChannelId, t as createSubsystemLogger } from "./subsystem-COd61u0P.js";
+import { n as defaultRuntime } from "./runtime-DJNp29jv.js";
+import { C as parseAgentSessionKey, S as isSubagentSessionKey, b as isAcpSessionKey, c as normalizeMainKey, h as normalizeAccountId, l as resolveAgentIdFromSessionKey, y as getSubagentDepth } from "./session-key-5YLnn_qf.js";
+import { a as isInternalMessageChannel, c as normalizeMessageChannel, n as isDeliverableMessageChannel, t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-DzJqHVZD.js";
+import { _ as parseDurationMs, i as loadConfig, lt as DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "./config-D5XU45KD.js";
+import { n as saveJsonFile, t as loadJsonFile } from "./json-file-B7l5-Xhr.js";
+import { r as normalizeChannelId$1, t as getChannelPlugin } from "./plugins-woGRXMzU.js";
+import { r as isSilentReplyText, t as SILENT_REPLY_TOKEN } from "./tokens-DzFOtLlW.js";
+import { p as getGlobalHookRunner, s as shouldSuppressReasoningPayload } from "./reply-payloads-D_BM1Anb.js";
+import { m as resolveStorePath } from "./chat-envelope-el7Uo-Fe.js";
+import { X as resolveMainSessionKey, d as deliveryContextFromSession, f as mergeDeliveryContext, n as loadSessionStore, p as normalizeDeliveryContext } from "./store-SusmIfz7.js";
+import { n as callGateway } from "./call-PivL7Uex.js";
+import { r as CommandLane, s as onAgentEvent, t as AGENT_LANE_NESTED } from "./lanes-ByWMUgrz.js";
+import { a as resolveEffectiveMessagesConfig, n as resolveResponsePrefixTemplate } from "./response-prefix-template-rVZQOViK.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSON5 from "json5";
+import crypto from "node:crypto";
+
+//#region src/agents/timeout.ts
+const DEFAULT_AGENT_TIMEOUT_SECONDS = 600;
+const MAX_SAFE_TIMEOUT_MS = 2147e6;
+const normalizeNumber = (value) => typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : void 0;
+function resolveAgentTimeoutSeconds(cfg) {
+	const seconds = normalizeNumber(cfg?.agents?.defaults?.timeoutSeconds) ?? DEFAULT_AGENT_TIMEOUT_SECONDS;
+	return Math.max(seconds, 1);
+}
+function resolveAgentTimeoutMs(opts) {
+	const minMs = Math.max(normalizeNumber(opts.minMs) ?? 1, 1);
+	const clampTimeoutMs = (valueMs) => Math.min(Math.max(valueMs, minMs), MAX_SAFE_TIMEOUT_MS);
+	const defaultMs = clampTimeoutMs(resolveAgentTimeoutSeconds(opts.cfg) * 1e3);
+	const NO_TIMEOUT_MS = MAX_SAFE_TIMEOUT_MS;
+	const overrideMs = normalizeNumber(opts.overrideMs);
+	if (overrideMs !== void 0) {
+		if (overrideMs === 0) return NO_TIMEOUT_MS;
+		if (overrideMs < 0) return defaultMs;
+		return clampTimeoutMs(overrideMs);
+	}
+	const overrideSeconds = normalizeNumber(opts.overrideSeconds);
+	if (overrideSeconds !== void 0) {
+		if (overrideSeconds === 0) return NO_TIMEOUT_MS;
+		if (overrideSeconds < 0) return defaultMs;
+		return clampTimeoutMs(overrideSeconds * 1e3);
+	}
+	return defaultMs;
+}
+
+//#endregion
+//#region src/line/flex-templates/common.ts
+function attachFooterText(bubble, footer) {
+	bubble.footer = {
+		type: "box",
+		layout: "vertical",
+		contents: [{
+			type: "text",
+			text: footer,
+			size: "xs",
+			color: "#AAAAAA",
+			wrap: true,
+			align: "center"
+		}],
+		paddingAll: "lg",
+		backgroundColor: "#FAFAFA"
+	};
+}
+
+//#endregion
+//#region src/line/flex-templates/schedule-cards.ts
+function buildTitleSubtitleHeader(params) {
+	const { title, subtitle } = params;
+	const headerContents = [{
+		type: "text",
+		text: title,
+		weight: "bold",
+		size: "xl",
+		color: "#111111",
+		wrap: true
+	}];
+	if (subtitle) headerContents.push({
+		type: "text",
+		text: subtitle,
+		size: "sm",
+		color: "#888888",
+		margin: "sm",
+		wrap: true
+	});
+	return headerContents;
+}
+function buildCardHeaderSections(headerContents) {
+	return [{
+		type: "box",
+		layout: "vertical",
+		contents: headerContents,
+		paddingBottom: "lg"
+	}, {
+		type: "separator",
+		color: "#EEEEEE"
+	}];
+}
+function createMegaBubbleWithFooter(params) {
+	const bubble = {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: params.bodyContents,
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF"
+		}
+	};
+	if (params.footer) attachFooterText(bubble, params.footer);
+	return bubble;
+}
+/**
+* Create a receipt/summary card (for orders, transactions, data tables)
+*
+* Editorial design: Clean table layout with alternating row backgrounds,
+* prominent total section, and clear visual hierarchy.
+*/
+function createReceiptCard(params) {
+	const { title, subtitle, items, total, footer } = params;
+	const itemRows = items.slice(0, 12).map((item, index) => ({
+		type: "box",
+		layout: "horizontal",
+		contents: [{
+			type: "text",
+			text: item.name,
+			size: "sm",
+			color: item.highlight ? "#111111" : "#666666",
+			weight: item.highlight ? "bold" : "regular",
+			flex: 3,
+			wrap: true
+		}, {
+			type: "text",
+			text: item.value,
+			size: "sm",
+			color: item.highlight ? "#06C755" : "#333333",
+			weight: item.highlight ? "bold" : "regular",
+			flex: 2,
+			align: "end",
+			wrap: true
+		}],
+		paddingAll: "md",
+		backgroundColor: index % 2 === 0 ? "#FFFFFF" : "#FAFAFA"
+	}));
+	const bodyContents = [...buildCardHeaderSections(buildTitleSubtitleHeader({
+		title,
+		subtitle
+	})), {
+		type: "box",
+		layout: "vertical",
+		contents: itemRows,
+		margin: "md",
+		cornerRadius: "md",
+		borderWidth: "light",
+		borderColor: "#EEEEEE"
+	}];
+	if (total) bodyContents.push({
+		type: "box",
+		layout: "horizontal",
+		contents: [{
+			type: "text",
+			text: total.label,
+			size: "lg",
+			weight: "bold",
+			color: "#111111",
+			flex: 2
+		}, {
+			type: "text",
+			text: total.value,
+			size: "xl",
+			weight: "bold",
+			color: "#06C755",
+			flex: 2,
+			align: "end"
+		}],
+		margin: "xl",
+		paddingAll: "lg",
+		backgroundColor: "#F0FDF4",
+		cornerRadius: "lg"
+	});
+	return createMegaBubbleWithFooter({
+		bodyContents,
+		footer
+	});
+}
+/**
+* Create a calendar event card (for meetings, appointments, reminders)
+*
+* Editorial design: Date as hero, strong typographic hierarchy,
+* color-blocked zones, full text wrapping for readability.
+*/
+function createEventCard(params) {
+	const { title, date, time, location, description, calendar, isAllDay, action } = params;
+	const dateBlock = {
+		type: "box",
+		layout: "vertical",
+		contents: [{
+			type: "text",
+			text: date.toUpperCase(),
+			size: "sm",
+			weight: "bold",
+			color: "#06C755",
+			wrap: true
+		}, {
+			type: "text",
+			text: isAllDay ? "ALL DAY" : time ?? "",
+			size: "xxl",
+			weight: "bold",
+			color: "#111111",
+			wrap: true,
+			margin: "xs"
+		}],
+		paddingBottom: "lg",
+		borderWidth: "none"
+	};
+	if (!time && !isAllDay) dateBlock.contents = [{
+		type: "text",
+		text: date,
+		size: "xl",
+		weight: "bold",
+		color: "#111111",
+		wrap: true
+	}];
+	const bodyContents = [dateBlock, {
+		type: "box",
+		layout: "horizontal",
+		contents: [{
+			type: "box",
+			layout: "vertical",
+			contents: [],
+			width: "4px",
+			backgroundColor: "#06C755",
+			cornerRadius: "2px"
+		}, {
+			type: "box",
+			layout: "vertical",
+			contents: [{
+				type: "text",
+				text: title,
+				size: "lg",
+				weight: "bold",
+				color: "#1a1a1a",
+				wrap: true
+			}, ...calendar ? [{
+				type: "text",
+				text: calendar,
+				size: "xs",
+				color: "#888888",
+				margin: "sm",
+				wrap: true
+			}] : []],
+			flex: 1,
+			paddingStart: "lg"
+		}],
+		paddingTop: "lg",
+		paddingBottom: "lg",
+		borderWidth: "light",
+		borderColor: "#EEEEEE"
+	}];
+	if (location || description) {
+		const detailItems = [];
+		if (location) detailItems.push({
+			type: "box",
+			layout: "horizontal",
+			contents: [{
+				type: "text",
+				text: "📍",
+				size: "sm",
+				flex: 0
+			}, {
+				type: "text",
+				text: location,
+				size: "sm",
+				color: "#444444",
+				margin: "md",
+				flex: 1,
+				wrap: true
+			}],
+			alignItems: "flex-start"
+		});
+		if (description) detailItems.push({
+			type: "text",
+			text: description,
+			size: "sm",
+			color: "#666666",
+			wrap: true,
+			margin: location ? "lg" : "none"
+		});
+		bodyContents.push({
+			type: "box",
+			layout: "vertical",
+			contents: detailItems,
+			margin: "lg",
+			paddingAll: "lg",
+			backgroundColor: "#F8F9FA",
+			cornerRadius: "lg"
+		});
+	}
+	return {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: bodyContents,
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF",
+			action
+		}
+	};
+}
+/**
+* Create a calendar agenda card showing multiple events
+*
+* Editorial timeline design: Time-focused left column with event details
+* on the right. Visual accent bars indicate event priority/recency.
+*/
+function createAgendaCard(params) {
+	const { title, subtitle, events, footer } = params;
+	const headerContents = buildTitleSubtitleHeader({
+		title,
+		subtitle
+	});
+	const eventItems = events.slice(0, 6).map((event, index) => {
+		const isActive = event.isNow || index === 0;
+		const accentColor = isActive ? "#06C755" : "#E5E5E5";
+		const timeColumn = {
+			type: "box",
+			layout: "vertical",
+			contents: [{
+				type: "text",
+				text: event.time ?? "—",
+				size: "sm",
+				weight: isActive ? "bold" : "regular",
+				color: isActive ? "#06C755" : "#666666",
+				align: "end",
+				wrap: true
+			}],
+			width: "65px",
+			justifyContent: "flex-start"
+		};
+		const dotColumn = {
+			type: "box",
+			layout: "vertical",
+			contents: [{
+				type: "box",
+				layout: "vertical",
+				contents: [],
+				width: "10px",
+				height: "10px",
+				backgroundColor: accentColor,
+				cornerRadius: "5px"
+			}],
+			width: "24px",
+			alignItems: "center",
+			justifyContent: "flex-start",
+			paddingTop: "xs"
+		};
+		const detailContents = [{
+			type: "text",
+			text: event.title,
+			size: "md",
+			weight: "bold",
+			color: "#1a1a1a",
+			wrap: true
+		}];
+		const secondaryParts = [];
+		if (event.location) secondaryParts.push(event.location);
+		if (event.calendar) secondaryParts.push(event.calendar);
+		if (secondaryParts.length > 0) detailContents.push({
+			type: "text",
+			text: secondaryParts.join(" · "),
+			size: "xs",
+			color: "#888888",
+			wrap: true,
+			margin: "xs"
+		});
+		return {
+			type: "box",
+			layout: "horizontal",
+			contents: [
+				timeColumn,
+				dotColumn,
+				{
+					type: "box",
+					layout: "vertical",
+					contents: detailContents,
+					flex: 1
+				}
+			],
+			margin: index > 0 ? "xl" : void 0,
+			alignItems: "flex-start"
+		};
+	});
+	return createMegaBubbleWithFooter({
+		bodyContents: [...buildCardHeaderSections(headerContents), {
+			type: "box",
+			layout: "vertical",
+			contents: eventItems,
+			paddingTop: "xl"
+		}],
+		footer
+	});
+}
+
+//#endregion
+//#region src/line/flex-templates/media-control-cards.ts
+/**
+* Create a media player card for Sonos, Spotify, Apple Music, etc.
+*
+* Editorial design: Album art hero with gradient overlay for text,
+* prominent now-playing indicator, refined playback controls.
+*/
+function createMediaPlayerCard(params) {
+	const { title, subtitle, source, imageUrl, isPlaying, progress, controls, extraActions } = params;
+	const trackInfo = [{
+		type: "text",
+		text: title,
+		weight: "bold",
+		size: "xl",
+		color: "#111111",
+		wrap: true
+	}];
+	if (subtitle) trackInfo.push({
+		type: "text",
+		text: subtitle,
+		size: "md",
+		color: "#666666",
+		wrap: true,
+		margin: "sm"
+	});
+	const statusItems = [];
+	if (isPlaying !== void 0) statusItems.push({
+		type: "box",
+		layout: "horizontal",
+		contents: [{
+			type: "box",
+			layout: "vertical",
+			contents: [],
+			width: "8px",
+			height: "8px",
+			backgroundColor: isPlaying ? "#06C755" : "#CCCCCC",
+			cornerRadius: "4px"
+		}, {
+			type: "text",
+			text: isPlaying ? "Now Playing" : "Paused",
+			size: "xs",
+			color: isPlaying ? "#06C755" : "#888888",
+			weight: "bold",
+			margin: "sm"
+		}],
+		alignItems: "center"
+	});
+	if (source) statusItems.push({
+		type: "text",
+		text: source,
+		size: "xs",
+		color: "#AAAAAA",
+		margin: statusItems.length > 0 ? "lg" : void 0
+	});
+	if (progress) statusItems.push({
+		type: "text",
+		text: progress,
+		size: "xs",
+		color: "#888888",
+		align: "end",
+		flex: 1
+	});
+	const bodyContents = [{
+		type: "box",
+		layout: "vertical",
+		contents: trackInfo
+	}];
+	if (statusItems.length > 0) bodyContents.push({
+		type: "box",
+		layout: "horizontal",
+		contents: statusItems,
+		margin: "lg",
+		alignItems: "center"
+	});
+	const bubble = {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: bodyContents,
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF"
+		}
+	};
+	if (imageUrl) bubble.hero = {
+		type: "image",
+		url: imageUrl,
+		size: "full",
+		aspectRatio: "1:1",
+		aspectMode: "cover"
+	};
+	if (controls || extraActions?.length) {
+		const footerContents = [];
+		if (controls) {
+			const controlButtons = [];
+			if (controls.previous) controlButtons.push({
+				type: "button",
+				action: {
+					type: "postback",
+					label: "⏮",
+					data: controls.previous.data
+				},
+				style: "secondary",
+				flex: 1,
+				height: "sm"
+			});
+			if (controls.play) controlButtons.push({
+				type: "button",
+				action: {
+					type: "postback",
+					label: "▶",
+					data: controls.play.data
+				},
+				style: isPlaying ? "secondary" : "primary",
+				flex: 1,
+				height: "sm",
+				margin: controls.previous ? "md" : void 0
+			});
+			if (controls.pause) controlButtons.push({
+				type: "button",
+				action: {
+					type: "postback",
+					label: "⏸",
+					data: controls.pause.data
+				},
+				style: isPlaying ? "primary" : "secondary",
+				flex: 1,
+				height: "sm",
+				margin: controlButtons.length > 0 ? "md" : void 0
+			});
+			if (controls.next) controlButtons.push({
+				type: "button",
+				action: {
+					type: "postback",
+					label: "⏭",
+					data: controls.next.data
+				},
+				style: "secondary",
+				flex: 1,
+				height: "sm",
+				margin: controlButtons.length > 0 ? "md" : void 0
+			});
+			if (controlButtons.length > 0) footerContents.push({
+				type: "box",
+				layout: "horizontal",
+				contents: controlButtons
+			});
+		}
+		if (extraActions?.length) footerContents.push({
+			type: "box",
+			layout: "horizontal",
+			contents: extraActions.slice(0, 2).map((action, index) => ({
+				type: "button",
+				action: {
+					type: "postback",
+					label: action.label.slice(0, 15),
+					data: action.data
+				},
+				style: "secondary",
+				flex: 1,
+				height: "sm",
+				margin: index > 0 ? "md" : void 0
+			})),
+			margin: "md"
+		});
+		if (footerContents.length > 0) bubble.footer = {
+			type: "box",
+			layout: "vertical",
+			contents: footerContents,
+			paddingAll: "lg",
+			backgroundColor: "#FAFAFA"
+		};
+	}
+	return bubble;
+}
+/**
+* Create an Apple TV remote card with a D-pad and control rows.
+*/
+function createAppleTvRemoteCard(params) {
+	const { deviceName, status, actionData } = params;
+	const headerContents = [{
+		type: "text",
+		text: deviceName,
+		weight: "bold",
+		size: "xl",
+		color: "#111111",
+		wrap: true
+	}];
+	if (status) headerContents.push({
+		type: "text",
+		text: status,
+		size: "sm",
+		color: "#666666",
+		wrap: true,
+		margin: "sm"
+	});
+	const makeButton = (label, data, style = "secondary") => ({
+		type: "button",
+		action: {
+			type: "postback",
+			label,
+			data
+		},
+		style,
+		height: "sm",
+		flex: 1
+	});
+	const dpadRows = [
+		{
+			type: "box",
+			layout: "horizontal",
+			contents: [
+				{ type: "filler" },
+				makeButton("↑", actionData.up),
+				{ type: "filler" }
+			]
+		},
+		{
+			type: "box",
+			layout: "horizontal",
+			contents: [
+				makeButton("←", actionData.left),
+				makeButton("OK", actionData.select, "primary"),
+				makeButton("→", actionData.right)
+			],
+			margin: "md"
+		},
+		{
+			type: "box",
+			layout: "horizontal",
+			contents: [
+				{ type: "filler" },
+				makeButton("↓", actionData.down),
+				{ type: "filler" }
+			],
+			margin: "md"
+		}
+	];
+	const menuRow = {
+		type: "box",
+		layout: "horizontal",
+		contents: [makeButton("Menu", actionData.menu), makeButton("Home", actionData.home)],
+		margin: "lg"
+	};
+	const playbackRow = {
+		type: "box",
+		layout: "horizontal",
+		contents: [makeButton("Play", actionData.play), makeButton("Pause", actionData.pause)],
+		margin: "md"
+	};
+	const volumeRow = {
+		type: "box",
+		layout: "horizontal",
+		contents: [
+			makeButton("Vol +", actionData.volumeUp),
+			makeButton("Mute", actionData.mute),
+			makeButton("Vol -", actionData.volumeDown)
+		],
+		margin: "md"
+	};
+	return {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: [
+				{
+					type: "box",
+					layout: "vertical",
+					contents: headerContents
+				},
+				{
+					type: "separator",
+					margin: "lg",
+					color: "#EEEEEE"
+				},
+				...dpadRows,
+				menuRow,
+				playbackRow,
+				volumeRow
+			],
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF"
+		}
+	};
+}
+/**
+* Create a device control card for Apple TV, smart home devices, etc.
+*
+* Editorial design: Device-focused header with status indicator,
+* clean control grid with clear visual hierarchy.
+*/
+function createDeviceControlCard(params) {
+	const { deviceName, deviceType, status, isOnline, imageUrl, controls } = params;
+	const headerContents = [{
+		type: "box",
+		layout: "horizontal",
+		contents: [{
+			type: "box",
+			layout: "vertical",
+			contents: [],
+			width: "10px",
+			height: "10px",
+			backgroundColor: isOnline !== false ? "#06C755" : "#FF5555",
+			cornerRadius: "5px"
+		}, {
+			type: "text",
+			text: deviceName,
+			weight: "bold",
+			size: "xl",
+			color: "#111111",
+			wrap: true,
+			flex: 1,
+			margin: "md"
+		}],
+		alignItems: "center"
+	}];
+	if (deviceType) headerContents.push({
+		type: "text",
+		text: deviceType,
+		size: "sm",
+		color: "#888888",
+		margin: "sm"
+	});
+	if (status) headerContents.push({
+		type: "box",
+		layout: "vertical",
+		contents: [{
+			type: "text",
+			text: status,
+			size: "sm",
+			color: "#444444",
+			wrap: true
+		}],
+		margin: "lg",
+		paddingAll: "md",
+		backgroundColor: "#F8F9FA",
+		cornerRadius: "md"
+	});
+	const bubble = {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: headerContents,
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF"
+		}
+	};
+	if (imageUrl) bubble.hero = {
+		type: "image",
+		url: imageUrl,
+		size: "full",
+		aspectRatio: "16:9",
+		aspectMode: "cover"
+	};
+	if (controls.length > 0) {
+		const rows = [];
+		const limitedControls = controls.slice(0, 6);
+		for (let i = 0; i < limitedControls.length; i += 2) {
+			const rowButtons = [];
+			for (let j = i; j < Math.min(i + 2, limitedControls.length); j++) {
+				const ctrl = limitedControls[j];
+				const buttonLabel = ctrl.icon ? `${ctrl.icon} ${ctrl.label}` : ctrl.label;
+				rowButtons.push({
+					type: "button",
+					action: {
+						type: "postback",
+						label: buttonLabel.slice(0, 18),
+						data: ctrl.data
+					},
+					style: ctrl.style ?? "secondary",
+					flex: 1,
+					height: "sm",
+					margin: j > i ? "md" : void 0
+				});
+			}
+			if (rowButtons.length === 1) rowButtons.push({ type: "filler" });
+			rows.push({
+				type: "box",
+				layout: "horizontal",
+				contents: rowButtons,
+				margin: i > 0 ? "md" : void 0
+			});
+		}
+		bubble.footer = {
+			type: "box",
+			layout: "vertical",
+			contents: rows,
+			paddingAll: "lg",
+			backgroundColor: "#FAFAFA"
+		};
+	}
+	return bubble;
+}
+
+//#endregion
+//#region src/utils/queue-helpers.ts
+function clearQueueSummaryState(state) {
+	state.droppedCount = 0;
+	state.summaryLines = [];
+}
+function previewQueueSummaryPrompt(params) {
+	return buildQueueSummaryPrompt({
+		state: {
+			dropPolicy: params.state.dropPolicy,
+			droppedCount: params.state.droppedCount,
+			summaryLines: [...params.state.summaryLines]
+		},
+		noun: params.noun,
+		title: params.title
+	});
+}
+function applyQueueRuntimeSettings(params) {
+	params.target.mode = params.settings.mode;
+	params.target.debounceMs = typeof params.settings.debounceMs === "number" ? Math.max(0, params.settings.debounceMs) : params.target.debounceMs;
+	params.target.cap = typeof params.settings.cap === "number" && params.settings.cap > 0 ? Math.floor(params.settings.cap) : params.target.cap;
+	params.target.dropPolicy = params.settings.dropPolicy ?? params.target.dropPolicy;
+}
+function elideQueueText(text, limit = 140) {
+	if (text.length <= limit) return text;
+	return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+function buildQueueSummaryLine(text, limit = 160) {
+	return elideQueueText(text.replace(/\s+/g, " ").trim(), limit);
+}
+function shouldSkipQueueItem(params) {
+	if (!params.dedupe) return false;
+	return params.dedupe(params.item, params.items);
+}
+function applyQueueDropPolicy(params) {
+	const cap = params.queue.cap;
+	if (cap <= 0 || params.queue.items.length < cap) return true;
+	if (params.queue.dropPolicy === "new") return false;
+	const dropCount = params.queue.items.length - cap + 1;
+	const dropped = params.queue.items.splice(0, dropCount);
+	if (params.queue.dropPolicy === "summarize") {
+		for (const item of dropped) {
+			params.queue.droppedCount += 1;
+			params.queue.summaryLines.push(buildQueueSummaryLine(params.summarize(item)));
+		}
+		const limit = Math.max(0, params.summaryLimit ?? cap);
+		while (params.queue.summaryLines.length > limit) params.queue.summaryLines.shift();
+	}
+	return true;
+}
+function waitForQueueDebounce(queue) {
+	if (process.env.REMOTECLAW_TEST_FAST === "1") return Promise.resolve();
+	const debounceMs = Math.max(0, queue.debounceMs);
+	if (debounceMs <= 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		const check = () => {
+			const since = Date.now() - queue.lastEnqueuedAt;
+			if (since >= debounceMs) {
+				resolve();
+				return;
+			}
+			setTimeout(check, debounceMs - since);
+		};
+		check();
+	});
+}
+function beginQueueDrain(map, key) {
+	const queue = map.get(key);
+	if (!queue || queue.draining) return;
+	queue.draining = true;
+	return queue;
+}
+async function drainNextQueueItem(items, run) {
+	const next = items[0];
+	if (!next) return false;
+	await run(next);
+	items.shift();
+	return true;
+}
+async function drainCollectItemIfNeeded(params) {
+	if (!params.forceIndividualCollect && !params.isCrossChannel) return "skipped";
+	if (params.isCrossChannel) params.setForceIndividualCollect?.(true);
+	return await drainNextQueueItem(params.items, params.run) ? "drained" : "empty";
+}
+async function drainCollectQueueStep(params) {
+	return await drainCollectItemIfNeeded({
+		forceIndividualCollect: params.collectState.forceIndividualCollect,
+		isCrossChannel: params.isCrossChannel,
+		setForceIndividualCollect: (next) => {
+			params.collectState.forceIndividualCollect = next;
+		},
+		items: params.items,
+		run: params.run
+	});
+}
+function buildQueueSummaryPrompt(params) {
+	if (params.state.dropPolicy !== "summarize" || params.state.droppedCount <= 0) return;
+	const noun = params.noun;
+	const lines = [params.title ?? `[Queue overflow] Dropped ${params.state.droppedCount} ${noun}${params.state.droppedCount === 1 ? "" : "s"} due to cap.`];
+	if (params.state.summaryLines.length > 0) {
+		lines.push("Summary:");
+		for (const line of params.state.summaryLines) lines.push(`- ${line}`);
+	}
+	clearQueueSummaryState(params.state);
+	return lines.join("\n");
+}
+function buildCollectPrompt(params) {
+	const blocks = [params.title];
+	if (params.summary) blocks.push(params.summary);
+	params.items.forEach((item, idx) => {
+		blocks.push(params.renderItem(item, idx));
+	});
+	return blocks.join("\n\n");
+}
+function hasCrossChannelItems(items, resolveKey) {
+	const keys = /* @__PURE__ */ new Set();
+	let hasUnkeyed = false;
+	for (const item of items) {
+		const resolved = resolveKey(item);
+		if (resolved.cross) return true;
+		if (!resolved.key) {
+			hasUnkeyed = true;
+			continue;
+		}
+		keys.add(resolved.key);
+	}
+	if (keys.size === 0) return false;
+	if (hasUnkeyed) return true;
+	return keys.size > 1;
+}
+
+//#endregion
+//#region src/auto-reply/reply/directive-parsing.ts
+function skipDirectiveArgPrefix(raw) {
+	let i = 0;
+	const len = raw.length;
+	while (i < len && /\s/.test(raw[i])) i += 1;
+	if (raw[i] === ":") {
+		i += 1;
+		while (i < len && /\s/.test(raw[i])) i += 1;
+	}
+	return i;
+}
+function takeDirectiveToken(raw, startIndex) {
+	let i = startIndex;
+	const len = raw.length;
+	while (i < len && /\s/.test(raw[i])) i += 1;
+	if (i >= len) return {
+		token: null,
+		nextIndex: i
+	};
+	const start = i;
+	while (i < len && !/\s/.test(raw[i])) i += 1;
+	if (start === i) return {
+		token: null,
+		nextIndex: i
+	};
+	const token = raw.slice(start, i);
+	while (i < len && /\s/.test(raw[i])) i += 1;
+	return {
+		token,
+		nextIndex: i
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/normalize.ts
+function normalizeQueueMode(raw) {
+	if (!raw) return;
+	const cleaned = raw.trim().toLowerCase();
+	if (cleaned === "queue" || cleaned === "queued") return "steer";
+	if (cleaned === "interrupt" || cleaned === "interrupts" || cleaned === "abort") return "interrupt";
+	if (cleaned === "steer" || cleaned === "steering") return "steer";
+	if (cleaned === "followup" || cleaned === "follow-ups" || cleaned === "followups") return "followup";
+	if (cleaned === "collect" || cleaned === "coalesce") return "collect";
+	if (cleaned === "steer+backlog" || cleaned === "steer-backlog" || cleaned === "steer_backlog") return "steer-backlog";
+}
+function normalizeQueueDropPolicy(raw) {
+	if (!raw) return;
+	const cleaned = raw.trim().toLowerCase();
+	if (cleaned === "old" || cleaned === "oldest") return "old";
+	if (cleaned === "new" || cleaned === "newest") return "new";
+	if (cleaned === "summarize" || cleaned === "summary") return "summarize";
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/directive.ts
+function parseQueueDebounce(raw) {
+	if (!raw) return;
+	try {
+		const parsed = parseDurationMs(raw.trim(), { defaultUnit: "ms" });
+		if (!parsed || parsed < 0) return;
+		return Math.round(parsed);
+	} catch {
+		return;
+	}
+}
+function parseQueueCap(raw) {
+	if (!raw) return;
+	const num = Number(raw);
+	if (!Number.isFinite(num)) return;
+	const cap = Math.floor(num);
+	if (cap < 1) return;
+	return cap;
+}
+function parseQueueDirectiveArgs(raw) {
+	const len = raw.length;
+	let i = skipDirectiveArgPrefix(raw);
+	let consumed = i;
+	let queueMode;
+	let queueReset = false;
+	let rawMode;
+	let debounceMs;
+	let cap;
+	let dropPolicy;
+	let rawDebounce;
+	let rawCap;
+	let rawDrop;
+	let hasOptions = false;
+	const takeToken = () => {
+		const res = takeDirectiveToken(raw, i);
+		i = res.nextIndex;
+		return res.token;
+	};
+	while (i < len) {
+		const token = takeToken();
+		if (!token) break;
+		const lowered = token.trim().toLowerCase();
+		if (lowered === "default" || lowered === "reset" || lowered === "clear") {
+			queueReset = true;
+			consumed = i;
+			break;
+		}
+		if (lowered.startsWith("debounce:") || lowered.startsWith("debounce=")) {
+			rawDebounce = token.split(/[:=]/)[1] ?? "";
+			debounceMs = parseQueueDebounce(rawDebounce);
+			hasOptions = true;
+			consumed = i;
+			continue;
+		}
+		if (lowered.startsWith("cap:") || lowered.startsWith("cap=")) {
+			rawCap = token.split(/[:=]/)[1] ?? "";
+			cap = parseQueueCap(rawCap);
+			hasOptions = true;
+			consumed = i;
+			continue;
+		}
+		if (lowered.startsWith("drop:") || lowered.startsWith("drop=")) {
+			rawDrop = token.split(/[:=]/)[1] ?? "";
+			dropPolicy = normalizeQueueDropPolicy(rawDrop);
+			hasOptions = true;
+			consumed = i;
+			continue;
+		}
+		const mode = normalizeQueueMode(token);
+		if (mode) {
+			queueMode = mode;
+			rawMode = token;
+			consumed = i;
+			continue;
+		}
+		break;
+	}
+	return {
+		consumed,
+		queueMode,
+		queueReset,
+		rawMode,
+		debounceMs,
+		cap,
+		dropPolicy,
+		rawDebounce,
+		rawCap,
+		rawDrop,
+		hasOptions
+	};
+}
+function extractQueueDirective(body) {
+	if (!body) return {
+		cleaned: "",
+		hasDirective: false,
+		queueReset: false,
+		hasOptions: false
+	};
+	const match = /(?:^|\s)\/queue(?=$|\s|:)/i.exec(body);
+	if (!match) return {
+		cleaned: body.trim(),
+		hasDirective: false,
+		queueReset: false,
+		hasOptions: false
+	};
+	const start = match.index + match[0].indexOf("/queue");
+	const argsStart = start + 6;
+	const parsed = parseQueueDirectiveArgs(body.slice(argsStart));
+	return {
+		cleaned: `${body.slice(0, start)} ${body.slice(argsStart + parsed.consumed)}`.replace(/\s+/g, " ").trim(),
+		queueMode: parsed.queueMode,
+		queueReset: parsed.queueReset,
+		rawMode: parsed.rawMode,
+		debounceMs: parsed.debounceMs,
+		cap: parsed.cap,
+		dropPolicy: parsed.dropPolicy,
+		rawDebounce: parsed.rawDebounce,
+		rawCap: parsed.rawCap,
+		rawDrop: parsed.rawDrop,
+		hasDirective: true,
+		hasOptions: parsed.hasOptions
+	};
+}
+
+//#endregion
+//#region src/infra/diagnostic-events.ts
+function getDiagnosticEventsState() {
+	const globalStore = globalThis;
+	if (!globalStore.__remoteclawDiagnosticEventsState) globalStore.__remoteclawDiagnosticEventsState = {
+		seq: 0,
+		listeners: /* @__PURE__ */ new Set(),
+		dispatchDepth: 0
+	};
+	return globalStore.__remoteclawDiagnosticEventsState;
+}
+function isDiagnosticsEnabled(config) {
+	return config?.diagnostics?.enabled === true;
+}
+function emitDiagnosticEvent(event) {
+	const state = getDiagnosticEventsState();
+	if (state.dispatchDepth > 100) {
+		console.error(`[diagnostic-events] recursion guard tripped at depth=${state.dispatchDepth}, dropping type=${event.type}`);
+		return;
+	}
+	const enriched = {
+		...event,
+		seq: state.seq += 1,
+		ts: Date.now()
+	};
+	state.dispatchDepth += 1;
+	for (const listener of state.listeners) try {
+		listener(enriched);
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.stack ?? err.message : typeof err === "string" ? err : String(err);
+		console.error(`[diagnostic-events] listener error type=${enriched.type} seq=${enriched.seq}: ${errorMessage}`);
+	}
+	state.dispatchDepth -= 1;
+}
+
+//#endregion
+//#region src/logging/diagnostic-session-state.ts
+const diagnosticSessionStates = /* @__PURE__ */ new Map();
+const SESSION_STATE_TTL_MS = 1800 * 1e3;
+const SESSION_STATE_PRUNE_INTERVAL_MS = 60 * 1e3;
+const SESSION_STATE_MAX_ENTRIES = 2e3;
+let lastSessionPruneAt = 0;
+function pruneDiagnosticSessionStates(now = Date.now(), force = false) {
+	const shouldPruneForSize = diagnosticSessionStates.size > SESSION_STATE_MAX_ENTRIES;
+	if (!force && !shouldPruneForSize && now - lastSessionPruneAt < SESSION_STATE_PRUNE_INTERVAL_MS) return;
+	lastSessionPruneAt = now;
+	for (const [key, state] of diagnosticSessionStates.entries()) {
+		const ageMs = now - state.lastActivity;
+		if (state.state === "idle" && state.queueDepth <= 0 && ageMs > SESSION_STATE_TTL_MS) diagnosticSessionStates.delete(key);
+	}
+	if (diagnosticSessionStates.size <= SESSION_STATE_MAX_ENTRIES) return;
+	const excess = diagnosticSessionStates.size - SESSION_STATE_MAX_ENTRIES;
+	const ordered = Array.from(diagnosticSessionStates.entries()).toSorted((a, b) => a[1].lastActivity - b[1].lastActivity);
+	for (let i = 0; i < excess; i += 1) {
+		const key = ordered[i]?.[0];
+		if (!key) break;
+		diagnosticSessionStates.delete(key);
+	}
+}
+function resolveSessionKey({ sessionKey, sessionId }) {
+	return sessionKey ?? sessionId ?? "unknown";
+}
+function findStateBySessionId(sessionId) {
+	for (const state of diagnosticSessionStates.values()) if (state.sessionId === sessionId) return state;
+}
+function getDiagnosticSessionState(ref) {
+	pruneDiagnosticSessionStates();
+	const key = resolveSessionKey(ref);
+	const existing = diagnosticSessionStates.get(key) ?? (ref.sessionId && findStateBySessionId(ref.sessionId));
+	if (existing) {
+		if (ref.sessionId) existing.sessionId = ref.sessionId;
+		if (ref.sessionKey) existing.sessionKey = ref.sessionKey;
+		return existing;
+	}
+	const created = {
+		sessionId: ref.sessionId,
+		sessionKey: ref.sessionKey,
+		lastActivity: Date.now(),
+		state: "idle",
+		queueDepth: 0
+	};
+	diagnosticSessionStates.set(key, created);
+	pruneDiagnosticSessionStates(Date.now(), true);
+	return created;
+}
+
+//#endregion
+//#region src/logging/diagnostic.ts
+const diag = createSubsystemLogger("diagnostic");
+const webhookStats = {
+	received: 0,
+	processed: 0,
+	errors: 0,
+	lastReceived: 0
+};
+let lastActivityAt = 0;
+function markActivity() {
+	lastActivityAt = Date.now();
+}
+function logWebhookReceived(params) {
+	webhookStats.received += 1;
+	webhookStats.lastReceived = Date.now();
+	if (diag.isEnabled("debug")) diag.debug(`webhook received: channel=${params.channel} type=${params.updateType ?? "unknown"} chatId=${params.chatId ?? "unknown"} total=${webhookStats.received}`);
+	emitDiagnosticEvent({
+		type: "webhook.received",
+		channel: params.channel,
+		updateType: params.updateType,
+		chatId: params.chatId
+	});
+	markActivity();
+}
+function logWebhookProcessed(params) {
+	webhookStats.processed += 1;
+	if (diag.isEnabled("debug")) diag.debug(`webhook processed: channel=${params.channel} type=${params.updateType ?? "unknown"} chatId=${params.chatId ?? "unknown"} duration=${params.durationMs ?? 0}ms processed=${webhookStats.processed}`);
+	emitDiagnosticEvent({
+		type: "webhook.processed",
+		channel: params.channel,
+		updateType: params.updateType,
+		chatId: params.chatId,
+		durationMs: params.durationMs
+	});
+	markActivity();
+}
+function logWebhookError(params) {
+	webhookStats.errors += 1;
+	diag.error(`webhook error: channel=${params.channel} type=${params.updateType ?? "unknown"} chatId=${params.chatId ?? "unknown"} error="${params.error}" errors=${webhookStats.errors}`);
+	emitDiagnosticEvent({
+		type: "webhook.error",
+		channel: params.channel,
+		updateType: params.updateType,
+		chatId: params.chatId,
+		error: params.error
+	});
+	markActivity();
+}
+function logMessageQueued(params) {
+	const state = getDiagnosticSessionState(params);
+	state.queueDepth += 1;
+	state.lastActivity = Date.now();
+	if (diag.isEnabled("debug")) diag.debug(`message queued: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} source=${params.source} queueDepth=${state.queueDepth} sessionState=${state.state}`);
+	emitDiagnosticEvent({
+		type: "message.queued",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		channel: params.channel,
+		source: params.source,
+		queueDepth: state.queueDepth
+	});
+	markActivity();
+}
+function logMessageProcessed(params) {
+	if (params.outcome === "error" ? diag.isEnabled("error") : diag.isEnabled("debug")) {
+		const payload = `message processed: channel=${params.channel} chatId=${params.chatId ?? "unknown"} messageId=${params.messageId ?? "unknown"} sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} outcome=${params.outcome} duration=${params.durationMs ?? 0}ms${params.reason ? ` reason=${params.reason}` : ""}${params.error ? ` error="${params.error}"` : ""}`;
+		if (params.outcome === "error") diag.error(payload);
+		else diag.debug(payload);
+	}
+	emitDiagnosticEvent({
+		type: "message.processed",
+		channel: params.channel,
+		chatId: params.chatId,
+		messageId: params.messageId,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		durationMs: params.durationMs,
+		outcome: params.outcome,
+		reason: params.reason,
+		error: params.error
+	});
+	markActivity();
+}
+function logSessionStateChange(params) {
+	const state = getDiagnosticSessionState(params);
+	const isProbeSession = state.sessionId?.startsWith("probe-") ?? false;
+	const prevState = state.state;
+	state.state = params.state;
+	state.lastActivity = Date.now();
+	if (params.state === "idle") state.queueDepth = Math.max(0, state.queueDepth - 1);
+	if (!isProbeSession && diag.isEnabled("debug")) diag.debug(`session state: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} prev=${prevState} new=${params.state} reason="${params.reason ?? ""}" queueDepth=${state.queueDepth}`);
+	emitDiagnosticEvent({
+		type: "session.state",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		prevState,
+		state: params.state,
+		reason: params.reason,
+		queueDepth: state.queueDepth
+	});
+	markActivity();
+}
+function logSessionStuck(params) {
+	const state = getDiagnosticSessionState(params);
+	diag.warn(`stuck session: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} state=${params.state} age=${Math.round(params.ageMs / 1e3)}s queueDepth=${state.queueDepth}`);
+	emitDiagnosticEvent({
+		type: "session.stuck",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		state: params.state,
+		ageMs: params.ageMs,
+		queueDepth: state.queueDepth
+	});
+	markActivity();
+}
+function logLaneDequeue(lane, waitMs, queueSize) {
+	diag.debug(`lane dequeue: lane=${lane} waitMs=${waitMs} queueSize=${queueSize}`);
+	emitDiagnosticEvent({
+		type: "queue.lane.dequeue",
+		lane,
+		queueSize,
+		waitMs
+	});
+	markActivity();
+}
+let heartbeatInterval = null;
+function startDiagnosticHeartbeat() {
+	if (heartbeatInterval) return;
+	heartbeatInterval = setInterval(() => {
+		const now = Date.now();
+		pruneDiagnosticSessionStates(now, true);
+		const activeCount = Array.from(diagnosticSessionStates.values()).filter((s) => s.state === "processing").length;
+		const waitingCount = Array.from(diagnosticSessionStates.values()).filter((s) => s.state === "waiting").length;
+		const totalQueued = Array.from(diagnosticSessionStates.values()).reduce((sum, s) => sum + s.queueDepth, 0);
+		if (!(lastActivityAt > 0 || webhookStats.received > 0 || activeCount > 0 || waitingCount > 0 || totalQueued > 0)) return;
+		if (now - lastActivityAt > 12e4 && activeCount === 0 && waitingCount === 0) return;
+		diag.debug(`heartbeat: webhooks=${webhookStats.received}/${webhookStats.processed}/${webhookStats.errors} active=${activeCount} waiting=${waitingCount} queued=${totalQueued}`);
+		emitDiagnosticEvent({
+			type: "diagnostic.heartbeat",
+			webhooks: {
+				received: webhookStats.received,
+				processed: webhookStats.processed,
+				errors: webhookStats.errors
+			},
+			active: activeCount,
+			waiting: waitingCount,
+			queued: totalQueued
+		});
+		for (const [, state] of diagnosticSessionStates) {
+			const ageMs = now - state.lastActivity;
+			if (state.state === "processing" && ageMs > 12e4) logSessionStuck({
+				sessionId: state.sessionId,
+				sessionKey: state.sessionKey,
+				state: state.state,
+				ageMs
+			});
+		}
+	}, 3e4);
+	heartbeatInterval.unref?.();
+}
+function stopDiagnosticHeartbeat() {
+	if (heartbeatInterval) {
+		clearInterval(heartbeatInterval);
+		heartbeatInterval = null;
+	}
+}
+
+//#endregion
+//#region src/process/command-queue.ts
+/**
+* Dedicated error type thrown when a queued command is rejected because
+* its lane was cleared.  Callers that fire-and-forget enqueued tasks can
+* catch (or ignore) this specific type to avoid unhandled-rejection noise.
+*/
+var CommandLaneClearedError = class extends Error {
+	constructor(lane) {
+		super(lane ? `Command lane "${lane}" cleared` : "Command lane cleared");
+		this.name = "CommandLaneClearedError";
+	}
+};
+const lanes = /* @__PURE__ */ new Map();
+let nextTaskId = 1;
+function getLaneState(lane) {
+	const existing = lanes.get(lane);
+	if (existing) return existing;
+	const created = {
+		lane,
+		queue: [],
+		activeTaskIds: /* @__PURE__ */ new Set(),
+		maxConcurrent: 1,
+		draining: false,
+		generation: 0
+	};
+	lanes.set(lane, created);
+	return created;
+}
+function completeTask(state, taskId, taskGeneration) {
+	if (taskGeneration !== state.generation) return false;
+	state.activeTaskIds.delete(taskId);
+	return true;
+}
+function drainLane(lane) {
+	const state = getLaneState(lane);
+	if (state.draining) return;
+	state.draining = true;
+	const pump = () => {
+		while (state.activeTaskIds.size < state.maxConcurrent && state.queue.length > 0) {
+			const entry = state.queue.shift();
+			const waitedMs = Date.now() - entry.enqueuedAt;
+			if (waitedMs >= entry.warnAfterMs) {
+				entry.onWait?.(waitedMs, state.queue.length);
+				diag.warn(`lane wait exceeded: lane=${lane} waitedMs=${waitedMs} queueAhead=${state.queue.length}`);
+			}
+			logLaneDequeue(lane, waitedMs, state.queue.length);
+			const taskId = nextTaskId++;
+			const taskGeneration = state.generation;
+			state.activeTaskIds.add(taskId);
+			(async () => {
+				const startTime = Date.now();
+				try {
+					const result = await entry.task();
+					if (completeTask(state, taskId, taskGeneration)) {
+						diag.debug(`lane task done: lane=${lane} durationMs=${Date.now() - startTime} active=${state.activeTaskIds.size} queued=${state.queue.length}`);
+						pump();
+					}
+					entry.resolve(result);
+				} catch (err) {
+					const completedCurrentGeneration = completeTask(state, taskId, taskGeneration);
+					if (!(lane.startsWith("auth-probe:") || lane.startsWith("session:probe-"))) diag.error(`lane task error: lane=${lane} durationMs=${Date.now() - startTime} error="${String(err)}"`);
+					if (completedCurrentGeneration) pump();
+					entry.reject(err);
+				}
+			})();
+		}
+		state.draining = false;
+	};
+	pump();
+}
+function setCommandLaneConcurrency(lane, maxConcurrent) {
+	const cleaned = lane.trim() || CommandLane.Main;
+	const state = getLaneState(cleaned);
+	state.maxConcurrent = Math.max(1, Math.floor(maxConcurrent));
+	drainLane(cleaned);
+}
+function getQueueSize(lane = CommandLane.Main) {
+	const resolved = lane.trim() || CommandLane.Main;
+	const state = lanes.get(resolved);
+	if (!state) return 0;
+	return state.queue.length + state.activeTaskIds.size;
+}
+function getTotalQueueSize() {
+	let total = 0;
+	for (const s of lanes.values()) total += s.queue.length + s.activeTaskIds.size;
+	return total;
+}
+function clearCommandLane(lane = CommandLane.Main) {
+	const cleaned = lane.trim() || CommandLane.Main;
+	const state = lanes.get(cleaned);
+	if (!state) return 0;
+	const removed = state.queue.length;
+	const pending = state.queue.splice(0);
+	for (const entry of pending) entry.reject(new CommandLaneClearedError(cleaned));
+	return removed;
+}
+/**
+* Reset all lane runtime state to idle. Used after SIGUSR1 in-process
+* restarts where interrupted tasks' finally blocks may not run, leaving
+* stale active task IDs that permanently block new work from draining.
+*
+* Bumps lane generation and clears execution counters so stale completions
+* from old in-flight tasks are ignored. Queued entries are intentionally
+* preserved — they represent pending user work that should still execute
+* after restart.
+*
+* After resetting, drains any lanes that still have queued entries so
+* preserved work is pumped immediately rather than waiting for a future
+* `enqueueCommandInLane()` call (which may never come).
+*/
+function resetAllLanes() {
+	const lanesToDrain = [];
+	for (const state of lanes.values()) {
+		state.generation += 1;
+		state.activeTaskIds.clear();
+		state.draining = false;
+		if (state.queue.length > 0) lanesToDrain.push(state.lane);
+	}
+	for (const lane of lanesToDrain) drainLane(lane);
+}
+/**
+* Returns the total number of actively executing tasks across all lanes
+* (excludes queued-but-not-started entries).
+*/
+function getActiveTaskCount() {
+	let total = 0;
+	for (const s of lanes.values()) total += s.activeTaskIds.size;
+	return total;
+}
+/**
+* Wait for all currently active tasks across all lanes to finish.
+* Polls at a short interval; resolves when no tasks are active or
+* when `timeoutMs` elapses (whichever comes first).
+*
+* New tasks enqueued after this call are ignored — only tasks that are
+* already executing are waited on.
+*/
+function waitForActiveTasks(timeoutMs) {
+	const POLL_INTERVAL_MS = 50;
+	const deadline = Date.now() + timeoutMs;
+	const activeAtStart = /* @__PURE__ */ new Set();
+	for (const state of lanes.values()) for (const taskId of state.activeTaskIds) activeAtStart.add(taskId);
+	return new Promise((resolve) => {
+		const check = () => {
+			if (activeAtStart.size === 0) {
+				resolve({ drained: true });
+				return;
+			}
+			let hasPending = false;
+			for (const state of lanes.values()) {
+				for (const taskId of state.activeTaskIds) if (activeAtStart.has(taskId)) {
+					hasPending = true;
+					break;
+				}
+				if (hasPending) break;
+			}
+			if (!hasPending) {
+				resolve({ drained: true });
+				return;
+			}
+			if (Date.now() >= deadline) {
+				resolve({ drained: false });
+				return;
+			}
+			setTimeout(check, POLL_INTERVAL_MS);
+		};
+		check();
+	});
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/state.ts
+const DEFAULT_QUEUE_DEBOUNCE_MS = 1e3;
+const DEFAULT_QUEUE_CAP = 20;
+const DEFAULT_QUEUE_DROP = "summarize";
+const FOLLOWUP_QUEUES = /* @__PURE__ */ new Map();
+function getExistingFollowupQueue(key) {
+	const cleaned = key.trim();
+	if (!cleaned) return;
+	return FOLLOWUP_QUEUES.get(cleaned);
+}
+function getFollowupQueue(key, settings) {
+	const existing = FOLLOWUP_QUEUES.get(key);
+	if (existing) {
+		applyQueueRuntimeSettings({
+			target: existing,
+			settings
+		});
+		return existing;
+	}
+	const created = {
+		items: [],
+		draining: false,
+		lastEnqueuedAt: 0,
+		mode: settings.mode,
+		debounceMs: typeof settings.debounceMs === "number" ? Math.max(0, settings.debounceMs) : DEFAULT_QUEUE_DEBOUNCE_MS,
+		cap: typeof settings.cap === "number" && settings.cap > 0 ? Math.floor(settings.cap) : DEFAULT_QUEUE_CAP,
+		dropPolicy: settings.dropPolicy ?? DEFAULT_QUEUE_DROP,
+		droppedCount: 0,
+		summaryLines: []
+	};
+	applyQueueRuntimeSettings({
+		target: created,
+		settings
+	});
+	FOLLOWUP_QUEUES.set(key, created);
+	return created;
+}
+function clearFollowupQueue(key) {
+	const cleaned = key.trim();
+	const queue = getExistingFollowupQueue(cleaned);
+	if (!queue) return 0;
+	const cleared = queue.items.length + queue.droppedCount;
+	queue.items.length = 0;
+	queue.droppedCount = 0;
+	queue.summaryLines = [];
+	queue.lastRun = void 0;
+	queue.lastEnqueuedAt = 0;
+	FOLLOWUP_QUEUES.delete(cleaned);
+	return cleared;
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/cleanup.ts
+function clearSessionQueues(keys) {
+	const seen = /* @__PURE__ */ new Set();
+	let followupCleared = 0;
+	let laneCleared = 0;
+	const clearedKeys = [];
+	for (const key of keys) {
+		const cleaned = key?.trim();
+		if (!cleaned || seen.has(cleaned)) continue;
+		seen.add(cleaned);
+		clearedKeys.push(cleaned);
+		followupCleared += clearFollowupQueue(cleaned);
+		laneCleared += clearCommandLane("default");
+	}
+	return {
+		followupCleared,
+		laneCleared,
+		keys: clearedKeys
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/line-directives.ts
+/**
+* Parse LINE-specific directives from text and extract them into ReplyPayload fields.
+*
+* Supported directives:
+* - [[quick_replies: option1, option2, option3]]
+* - [[location: title | address | latitude | longitude]]
+* - [[confirm: question | yes_label | no_label]]
+* - [[buttons: title | text | btn1:data1, btn2:data2]]
+* - [[media_player: title | artist | source | imageUrl | playing/paused]]
+* - [[event: title | date | time | location | description]]
+* - [[agenda: title | event1_title:event1_time, event2_title:event2_time, ...]]
+* - [[device: name | type | status | ctrl1:data1, ctrl2:data2]]
+* - [[appletv_remote: name | status]]
+*
+* Returns the modified payload with directives removed from text and fields populated.
+*/
+function parseLineDirectives(payload) {
+	let text = payload.text;
+	if (!text) return payload;
+	const result = { ...payload };
+	const lineData = { ...result.channelData?.line };
+	const toSlug = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "device";
+	const lineActionData = (action, extras) => {
+		const base = [`line.action=${encodeURIComponent(action)}`];
+		if (extras) for (const [key, value] of Object.entries(extras)) base.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+		return base.join("&");
+	};
+	const quickRepliesMatch = text.match(/\[\[quick_replies:\s*([^\]]+)\]\]/i);
+	if (quickRepliesMatch) {
+		const options = quickRepliesMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+		if (options.length > 0) lineData.quickReplies = [...lineData.quickReplies || [], ...options];
+		text = text.replace(quickRepliesMatch[0], "").trim();
+	}
+	const locationMatch = text.match(/\[\[location:\s*([^\]]+)\]\]/i);
+	if (locationMatch && !lineData.location) {
+		const parts = locationMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 4) {
+			const [title, address, latStr, lonStr] = parts;
+			const latitude = parseFloat(latStr);
+			const longitude = parseFloat(lonStr);
+			if (!isNaN(latitude) && !isNaN(longitude)) lineData.location = {
+				title: title || "Location",
+				address: address || "",
+				latitude,
+				longitude
+			};
+		}
+		text = text.replace(locationMatch[0], "").trim();
+	}
+	const confirmMatch = text.match(/\[\[confirm:\s*([^\]]+)\]\]/i);
+	if (confirmMatch && !lineData.templateMessage) {
+		const parts = confirmMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 3) {
+			const [question, yesPart, noPart] = parts;
+			const [yesLabel, yesData] = yesPart.includes(":") ? yesPart.split(":").map((s) => s.trim()) : [yesPart, yesPart.toLowerCase()];
+			const [noLabel, noData] = noPart.includes(":") ? noPart.split(":").map((s) => s.trim()) : [noPart, noPart.toLowerCase()];
+			lineData.templateMessage = {
+				type: "confirm",
+				text: question,
+				confirmLabel: yesLabel,
+				confirmData: yesData,
+				cancelLabel: noLabel,
+				cancelData: noData,
+				altText: question
+			};
+		}
+		text = text.replace(confirmMatch[0], "").trim();
+	}
+	const buttonsMatch = text.match(/\[\[buttons:\s*([^\]]+)\]\]/i);
+	if (buttonsMatch && !lineData.templateMessage) {
+		const parts = buttonsMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 3) {
+			const [title, bodyText, actionsStr] = parts;
+			const actions = actionsStr.split(",").map((actionStr) => {
+				const trimmed = actionStr.trim();
+				const colonIndex = (() => {
+					const index = trimmed.indexOf(":");
+					if (index === -1) return -1;
+					const lower = trimmed.toLowerCase();
+					if (lower.startsWith("http://") || lower.startsWith("https://")) return -1;
+					return index;
+				})();
+				let label;
+				let data;
+				if (colonIndex === -1) {
+					label = trimmed;
+					data = trimmed;
+				} else {
+					label = trimmed.slice(0, colonIndex).trim();
+					data = trimmed.slice(colonIndex + 1).trim();
+				}
+				if (data.startsWith("http://") || data.startsWith("https://")) return {
+					type: "uri",
+					label,
+					uri: data
+				};
+				if (data.includes("=")) return {
+					type: "postback",
+					label,
+					data
+				};
+				return {
+					type: "message",
+					label,
+					data: data || label
+				};
+			});
+			if (actions.length > 0) lineData.templateMessage = {
+				type: "buttons",
+				title,
+				text: bodyText,
+				actions: actions.slice(0, 4),
+				altText: `${title}: ${bodyText}`
+			};
+		}
+		text = text.replace(buttonsMatch[0], "").trim();
+	}
+	const mediaPlayerMatch = text.match(/\[\[media_player:\s*([^\]]+)\]\]/i);
+	if (mediaPlayerMatch && !lineData.flexMessage) {
+		const parts = mediaPlayerMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 1) {
+			const [title, artist, source, imageUrl, statusStr] = parts;
+			const isPlaying = statusStr?.toLowerCase() === "playing";
+			const validImageUrl = imageUrl?.startsWith("https://") ? imageUrl : void 0;
+			const deviceKey = toSlug(source || title || "media");
+			const card = createMediaPlayerCard({
+				title: title || "Unknown Track",
+				subtitle: artist || void 0,
+				source: source || void 0,
+				imageUrl: validImageUrl,
+				isPlaying: statusStr ? isPlaying : void 0,
+				controls: {
+					previous: { data: lineActionData("previous", { "line.device": deviceKey }) },
+					play: { data: lineActionData("play", { "line.device": deviceKey }) },
+					pause: { data: lineActionData("pause", { "line.device": deviceKey }) },
+					next: { data: lineActionData("next", { "line.device": deviceKey }) }
+				}
+			});
+			lineData.flexMessage = {
+				altText: `🎵 ${title}${artist ? ` - ${artist}` : ""}`,
+				contents: card
+			};
+		}
+		text = text.replace(mediaPlayerMatch[0], "").trim();
+	}
+	const eventMatch = text.match(/\[\[event:\s*([^\]]+)\]\]/i);
+	if (eventMatch && !lineData.flexMessage) {
+		const parts = eventMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 2) {
+			const [title, date, time, location, description] = parts;
+			const card = createEventCard({
+				title: title || "Event",
+				date: date || "TBD",
+				time: time || void 0,
+				location: location || void 0,
+				description: description || void 0
+			});
+			lineData.flexMessage = {
+				altText: `📅 ${title} - ${date}${time ? ` ${time}` : ""}`,
+				contents: card
+			};
+		}
+		text = text.replace(eventMatch[0], "").trim();
+	}
+	const appleTvMatch = text.match(/\[\[appletv_remote:\s*([^\]]+)\]\]/i);
+	if (appleTvMatch && !lineData.flexMessage) {
+		const parts = appleTvMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 1) {
+			const [deviceName, status] = parts;
+			const deviceKey = toSlug(deviceName || "apple_tv");
+			const card = createAppleTvRemoteCard({
+				deviceName: deviceName || "Apple TV",
+				status: status || void 0,
+				actionData: {
+					up: lineActionData("up", { "line.device": deviceKey }),
+					down: lineActionData("down", { "line.device": deviceKey }),
+					left: lineActionData("left", { "line.device": deviceKey }),
+					right: lineActionData("right", { "line.device": deviceKey }),
+					select: lineActionData("select", { "line.device": deviceKey }),
+					menu: lineActionData("menu", { "line.device": deviceKey }),
+					home: lineActionData("home", { "line.device": deviceKey }),
+					play: lineActionData("play", { "line.device": deviceKey }),
+					pause: lineActionData("pause", { "line.device": deviceKey }),
+					volumeUp: lineActionData("volume_up", { "line.device": deviceKey }),
+					volumeDown: lineActionData("volume_down", { "line.device": deviceKey }),
+					mute: lineActionData("mute", { "line.device": deviceKey })
+				}
+			});
+			lineData.flexMessage = {
+				altText: `📺 ${deviceName || "Apple TV"} Remote`,
+				contents: card
+			};
+		}
+		text = text.replace(appleTvMatch[0], "").trim();
+	}
+	const agendaMatch = text.match(/\[\[agenda:\s*([^\]]+)\]\]/i);
+	if (agendaMatch && !lineData.flexMessage) {
+		const parts = agendaMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 2) {
+			const [title, eventsStr] = parts;
+			const events = eventsStr.split(",").map((eventStr) => {
+				const trimmed = eventStr.trim();
+				const colonIdx = trimmed.lastIndexOf(":");
+				if (colonIdx > 0) return {
+					title: trimmed.slice(0, colonIdx).trim(),
+					time: trimmed.slice(colonIdx + 1).trim()
+				};
+				return { title: trimmed };
+			});
+			const card = createAgendaCard({
+				title: title || "Agenda",
+				events
+			});
+			lineData.flexMessage = {
+				altText: `📋 ${title} (${events.length} events)`,
+				contents: card
+			};
+		}
+		text = text.replace(agendaMatch[0], "").trim();
+	}
+	const deviceMatch = text.match(/\[\[device:\s*([^\]]+)\]\]/i);
+	if (deviceMatch && !lineData.flexMessage) {
+		const parts = deviceMatch[1].split("|").map((s) => s.trim());
+		if (parts.length >= 1) {
+			const [deviceName, deviceType, status, controlsStr] = parts;
+			const deviceKey = toSlug(deviceName || "device");
+			const controls = controlsStr ? controlsStr.split(",").map((ctrlStr) => {
+				const [label, data] = ctrlStr.split(":").map((s) => s.trim());
+				return {
+					label,
+					data: lineActionData(data || label.toLowerCase().replace(/\s+/g, "_"), { "line.device": deviceKey })
+				};
+			}) : [];
+			const card = createDeviceControlCard({
+				deviceName: deviceName || "Device",
+				deviceType: deviceType || void 0,
+				status: status || void 0,
+				controls
+			});
+			lineData.flexMessage = {
+				altText: `📱 ${deviceName}${status ? `: ${status}` : ""}`,
+				contents: card
+			};
+		}
+		text = text.replace(deviceMatch[0], "").trim();
+	}
+	text = text.replace(/\n{3,}/g, "\n\n").trim();
+	result.text = text || void 0;
+	if (Object.keys(lineData).length > 0) result.channelData = {
+		...result.channelData,
+		line: lineData
+	};
+	return result;
+}
+/**
+* Check if text contains any LINE directives
+*/
+function hasLineDirectives(text) {
+	return /\[\[(quick_replies|location|confirm|buttons|media_player|event|agenda|device|appletv_remote):/i.test(text);
+}
+
+//#endregion
+//#region src/auto-reply/reply/normalize-reply.ts
+function normalizeReplyPayload(payload, opts = {}) {
+	const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+	const hasChannelData = Boolean(payload.channelData && Object.keys(payload.channelData).length > 0);
+	const trimmed = payload.text?.trim() ?? "";
+	if (!trimmed && !hasMedia && !hasChannelData) {
+		opts.onSkip?.("empty");
+		return null;
+	}
+	const silentToken = opts.silentToken ?? SILENT_REPLY_TOKEN;
+	let text = payload.text ?? void 0;
+	if (text && isSilentReplyText(text, silentToken)) {
+		if (!hasMedia && !hasChannelData) {
+			opts.onSkip?.("silent");
+			return null;
+		}
+		text = "";
+	}
+	if (text && !trimmed) text = "";
+	if (text) text = sanitizeUserFacingText(text, { errorContext: Boolean(payload.isError) });
+	if (!text?.trim() && !hasMedia && !hasChannelData) {
+		opts.onSkip?.("empty");
+		return null;
+	}
+	let enrichedPayload = {
+		...payload,
+		text
+	};
+	if (text && hasLineDirectives(text)) {
+		enrichedPayload = parseLineDirectives(enrichedPayload);
+		text = enrichedPayload.text;
+	}
+	const effectivePrefix = opts.responsePrefixContext ? resolveResponsePrefixTemplate(opts.responsePrefix, opts.responsePrefixContext) : opts.responsePrefix;
+	if (effectivePrefix && text && !text.startsWith(effectivePrefix)) text = `${effectivePrefix} ${text}`;
+	return {
+		...enrichedPayload,
+		text
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/route-reply.ts
+/**
+* Provider-agnostic reply router.
+*
+* Routes replies to the originating channel based on OriginatingChannel/OriginatingTo
+* instead of using the session's lastChannel. This ensures replies go back to the
+* provider where the message originated, even when the main session is shared
+* across multiple providers.
+*/
+/**
+* Routes a reply payload to the specified channel.
+*
+* This function provides a unified interface for sending messages to any
+* supported provider. It's used by the followup queue to route replies
+* back to the originating channel when OriginatingChannel/OriginatingTo
+* are set.
+*/
+async function routeReply(params) {
+	const { payload, channel, to, accountId, threadId, cfg, abortSignal } = params;
+	if (shouldSuppressReasoningPayload(payload)) return { ok: true };
+	const normalizedChannel = normalizeMessageChannel(channel);
+	const resolvedAgentId = params.sessionKey ? resolveSessionAgentId({
+		sessionKey: params.sessionKey,
+		config: cfg
+	}) : void 0;
+	const normalized = normalizeReplyPayload(payload, { responsePrefix: params.sessionKey ? resolveEffectiveMessagesConfig(cfg, resolvedAgentId ?? resolveSessionAgentId({ config: cfg }), {
+		channel: normalizedChannel,
+		accountId
+	}).responsePrefix : cfg.messages?.responsePrefix === "auto" ? void 0 : cfg.messages?.responsePrefix });
+	if (!normalized) return { ok: true };
+	let text = normalized.text ?? "";
+	let mediaUrls = (normalized.mediaUrls?.filter(Boolean) ?? []).length ? normalized.mediaUrls?.filter(Boolean) : normalized.mediaUrl ? [normalized.mediaUrl] : [];
+	const replyToId = normalized.replyToId;
+	if (!text.trim() && mediaUrls.length === 0) return { ok: true };
+	if (channel === INTERNAL_MESSAGE_CHANNEL) return {
+		ok: false,
+		error: "Webchat routing not supported for queued replies"
+	};
+	const channelId = normalizeChannelId$1(channel) ?? null;
+	if (!channelId) return {
+		ok: false,
+		error: `Unknown channel: ${String(channel)}`
+	};
+	if (abortSignal?.aborted) return {
+		ok: false,
+		error: "Reply routing aborted"
+	};
+	const resolvedReplyToId = replyToId ?? (channelId === "slack" && threadId != null && threadId !== "" ? String(threadId) : void 0);
+	const resolvedThreadId = channelId === "slack" ? null : threadId ?? null;
+	try {
+		const { deliverOutboundPayloads } = await import("./deliver-D56J4-1F.js").then((n) => n.n);
+		return {
+			ok: true,
+			messageId: (await deliverOutboundPayloads({
+				cfg,
+				channel: channelId,
+				to,
+				accountId: accountId ?? void 0,
+				payloads: [normalized],
+				replyToId: resolvedReplyToId ?? null,
+				threadId: resolvedThreadId,
+				agentId: resolvedAgentId,
+				abortSignal,
+				mirror: params.mirror !== false && params.sessionKey ? {
+					sessionKey: params.sessionKey,
+					agentId: resolvedAgentId,
+					text,
+					mediaUrls
+				} : void 0
+			})).at(-1)?.messageId
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: `Failed to route reply to ${channel}: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+}
+/**
+* Checks if a channel type is routable via routeReply.
+*
+* Some channels (webchat) require special handling and cannot be routed through
+* this generic interface.
+*/
+function isRoutableChannel(channel) {
+	if (!channel || channel === INTERNAL_MESSAGE_CHANNEL) return false;
+	return normalizeChannelId$1(channel) !== null;
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/drain.ts
+function resolveOriginRoutingMetadata(items) {
+	return {
+		originatingChannel: items.find((item) => item.originatingChannel)?.originatingChannel,
+		originatingTo: items.find((item) => item.originatingTo)?.originatingTo,
+		originatingAccountId: items.find((item) => item.originatingAccountId)?.originatingAccountId,
+		originatingThreadId: items.find((item) => item.originatingThreadId != null && item.originatingThreadId !== "")?.originatingThreadId
+	};
+}
+function resolveCrossChannelKey(item) {
+	const { originatingChannel: channel, originatingTo: to, originatingAccountId: accountId } = item;
+	const threadId = item.originatingThreadId;
+	if (!channel && !to && !accountId && (threadId == null || threadId === "")) return {};
+	if (!isRoutableChannel(channel) || !to) return { cross: true };
+	return { key: [
+		channel,
+		to,
+		accountId || "",
+		threadId != null && threadId !== "" ? String(threadId) : ""
+	].join("|") };
+}
+function scheduleFollowupDrain(key, runFollowup) {
+	const queue = beginQueueDrain(FOLLOWUP_QUEUES, key);
+	if (!queue) return;
+	(async () => {
+		try {
+			const collectState = { forceIndividualCollect: false };
+			while (queue.items.length > 0 || queue.droppedCount > 0) {
+				await waitForQueueDebounce(queue);
+				if (queue.mode === "collect") {
+					const collectDrainResult = await drainCollectQueueStep({
+						collectState,
+						isCrossChannel: hasCrossChannelItems(queue.items, resolveCrossChannelKey),
+						items: queue.items,
+						run: runFollowup
+					});
+					if (collectDrainResult === "empty") break;
+					if (collectDrainResult === "drained") continue;
+					const items = queue.items.slice();
+					const summary = previewQueueSummaryPrompt({
+						state: queue,
+						noun: "message"
+					});
+					const run = items.at(-1)?.run ?? queue.lastRun;
+					if (!run) break;
+					const routing = resolveOriginRoutingMetadata(items);
+					await runFollowup({
+						prompt: buildCollectPrompt({
+							title: "[Queued messages while agent was busy]",
+							items,
+							summary,
+							renderItem: (item, idx) => `---\nQueued #${idx + 1}\n${item.prompt}`.trim()
+						}),
+						run,
+						enqueuedAt: Date.now(),
+						...routing
+					});
+					queue.items.splice(0, items.length);
+					if (summary) clearQueueSummaryState(queue);
+					continue;
+				}
+				const summaryPrompt = previewQueueSummaryPrompt({
+					state: queue,
+					noun: "message"
+				});
+				if (summaryPrompt) {
+					const run = queue.lastRun;
+					if (!run) break;
+					if (!await drainNextQueueItem(queue.items, async (item) => {
+						await runFollowup({
+							prompt: summaryPrompt,
+							run,
+							enqueuedAt: Date.now(),
+							originatingChannel: item.originatingChannel,
+							originatingTo: item.originatingTo,
+							originatingAccountId: item.originatingAccountId,
+							originatingThreadId: item.originatingThreadId
+						});
+					})) break;
+					clearQueueSummaryState(queue);
+					continue;
+				}
+				if (!await drainNextQueueItem(queue.items, runFollowup)) break;
+			}
+		} catch (err) {
+			queue.lastEnqueuedAt = Date.now();
+			defaultRuntime.error?.(`followup queue drain failed for ${key}: ${String(err)}`);
+		} finally {
+			queue.draining = false;
+			if (queue.items.length === 0 && queue.droppedCount === 0) FOLLOWUP_QUEUES.delete(key);
+			else scheduleFollowupDrain(key, runFollowup);
+		}
+	})();
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/enqueue.ts
+function isRunAlreadyQueued(run, items, allowPromptFallback = false) {
+	const hasSameRouting = (item) => item.originatingChannel === run.originatingChannel && item.originatingTo === run.originatingTo && item.originatingAccountId === run.originatingAccountId && item.originatingThreadId === run.originatingThreadId;
+	const messageId = run.messageId?.trim();
+	if (messageId) return items.some((item) => item.messageId?.trim() === messageId && hasSameRouting(item));
+	if (!allowPromptFallback) return false;
+	return items.some((item) => item.prompt === run.prompt && hasSameRouting(item));
+}
+function enqueueFollowupRun(key, run, settings, dedupeMode = "message-id") {
+	const queue = getFollowupQueue(key, settings);
+	const dedupe = dedupeMode === "none" ? void 0 : (item, items) => isRunAlreadyQueued(item, items, dedupeMode === "prompt");
+	if (shouldSkipQueueItem({
+		item: run,
+		items: queue.items,
+		dedupe
+	})) return false;
+	queue.lastEnqueuedAt = Date.now();
+	queue.lastRun = run.run;
+	if (!applyQueueDropPolicy({
+		queue,
+		summarize: (item) => item.summaryLine?.trim() || item.prompt.trim()
+	})) return false;
+	queue.items.push(run);
+	return true;
+}
+function getFollowupQueueDepth(key) {
+	const queue = getExistingFollowupQueue(key);
+	if (!queue) return 0;
+	return queue.items.length;
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/settings.ts
+function defaultQueueModeForChannel(_channel) {
+	return "collect";
+}
+/** Resolve per-channel debounce override from debounceMsByChannel map. */
+function resolveChannelDebounce(byChannel, channelKey) {
+	if (!channelKey || !byChannel) return;
+	const value = byChannel[channelKey];
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function resolvePluginDebounce(channelKey) {
+	if (!channelKey) return;
+	const value = getChannelPlugin(channelKey)?.defaults?.queue?.debounceMs;
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function resolveQueueSettings(params) {
+	const channelKey = params.channel?.trim().toLowerCase();
+	const queueCfg = params.cfg.messages?.queue;
+	const providerModeRaw = channelKey && queueCfg?.byChannel ? queueCfg.byChannel[channelKey] : void 0;
+	const resolvedMode = params.inlineMode ?? normalizeQueueMode(params.sessionEntry?.queueMode) ?? normalizeQueueMode(providerModeRaw) ?? normalizeQueueMode(queueCfg?.mode) ?? defaultQueueModeForChannel(channelKey);
+	const debounceRaw = params.inlineOptions?.debounceMs ?? params.sessionEntry?.queueDebounceMs ?? resolveChannelDebounce(queueCfg?.debounceMsByChannel, channelKey) ?? resolvePluginDebounce(channelKey) ?? queueCfg?.debounceMs ?? DEFAULT_QUEUE_DEBOUNCE_MS;
+	const capRaw = params.inlineOptions?.cap ?? params.sessionEntry?.queueCap ?? queueCfg?.cap ?? DEFAULT_QUEUE_CAP;
+	const dropRaw = params.inlineOptions?.dropPolicy ?? params.sessionEntry?.queueDrop ?? normalizeQueueDropPolicy(queueCfg?.drop) ?? DEFAULT_QUEUE_DROP;
+	return {
+		mode: resolvedMode,
+		debounceMs: typeof debounceRaw === "number" ? Math.max(0, debounceRaw) : void 0,
+		cap: typeof capRaw === "number" ? Math.max(1, Math.floor(capRaw)) : void 0,
+		dropPolicy: dropRaw
+	};
+}
+
+//#endregion
+//#region src/infra/outbound/session-binding-service.ts
+function normalizeConversationRef(ref) {
+	return {
+		channel: ref.channel.trim().toLowerCase(),
+		accountId: normalizeAccountId(ref.accountId),
+		conversationId: ref.conversationId.trim(),
+		parentConversationId: ref.parentConversationId?.trim() || void 0
+	};
+}
+function toAdapterKey(params) {
+	return `${params.channel.trim().toLowerCase()}:${normalizeAccountId(params.accountId)}`;
+}
+const ADAPTERS_BY_CHANNEL_ACCOUNT = /* @__PURE__ */ new Map();
+function registerSessionBindingAdapter(adapter) {
+	const key = toAdapterKey({
+		channel: adapter.channel,
+		accountId: adapter.accountId
+	});
+	ADAPTERS_BY_CHANNEL_ACCOUNT.set(key, {
+		...adapter,
+		channel: adapter.channel.trim().toLowerCase(),
+		accountId: normalizeAccountId(adapter.accountId)
+	});
+}
+function unregisterSessionBindingAdapter(params) {
+	ADAPTERS_BY_CHANNEL_ACCOUNT.delete(toAdapterKey(params));
+}
+function resolveAdapterForConversation(ref) {
+	const normalized = normalizeConversationRef(ref);
+	const key = toAdapterKey({
+		channel: normalized.channel,
+		accountId: normalized.accountId
+	});
+	return ADAPTERS_BY_CHANNEL_ACCOUNT.get(key) ?? null;
+}
+function dedupeBindings(records) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (!record?.bindingId) continue;
+		byId.set(record.bindingId, record);
+	}
+	return [...byId.values()];
+}
+function createDefaultSessionBindingService() {
+	return {
+		bind: async (input) => {
+			const normalizedConversation = normalizeConversationRef(input.conversation);
+			const adapter = resolveAdapterForConversation(normalizedConversation);
+			if (!adapter?.bind) throw new Error(`Session binding adapter unavailable for ${normalizedConversation.channel}:${normalizedConversation.accountId}`);
+			const bound = await adapter.bind({
+				...input,
+				conversation: normalizedConversation
+			});
+			if (!bound) throw new Error("Session binding adapter failed to bind target conversation");
+			return bound;
+		},
+		listBySession: (targetSessionKey) => {
+			const key = targetSessionKey.trim();
+			if (!key) return [];
+			const results = [];
+			for (const adapter of ADAPTERS_BY_CHANNEL_ACCOUNT.values()) {
+				const entries = adapter.listBySession(key);
+				if (entries.length > 0) results.push(...entries);
+			}
+			return dedupeBindings(results);
+		},
+		resolveByConversation: (ref) => {
+			const normalized = normalizeConversationRef(ref);
+			if (!normalized.channel || !normalized.conversationId) return null;
+			const adapter = resolveAdapterForConversation(normalized);
+			if (!adapter) return null;
+			return adapter.resolveByConversation(normalized);
+		},
+		touch: (bindingId, at) => {
+			const normalizedBindingId = bindingId.trim();
+			if (!normalizedBindingId) return;
+			for (const adapter of ADAPTERS_BY_CHANNEL_ACCOUNT.values()) adapter.touch?.(normalizedBindingId, at);
+		},
+		unbind: async (input) => {
+			const removed = [];
+			for (const adapter of ADAPTERS_BY_CHANNEL_ACCOUNT.values()) {
+				if (!adapter.unbind) continue;
+				const entries = await adapter.unbind(input);
+				if (entries.length > 0) removed.push(...entries);
+			}
+			return dedupeBindings(removed);
+		}
+	};
+}
+const DEFAULT_SESSION_BINDING_SERVICE = createDefaultSessionBindingService();
+function getSessionBindingService() {
+	return DEFAULT_SESSION_BINDING_SERVICE;
+}
+
+//#endregion
+//#region src/infra/outbound/bound-delivery-router.ts
+function isActiveBinding(record) {
+	return record.status === "active";
+}
+function resolveBindingForRequester(requester, bindings) {
+	const matchingChannelAccount = bindings.filter((entry) => entry.conversation.channel === requester.channel && entry.conversation.accountId === requester.accountId);
+	if (matchingChannelAccount.length === 0) return null;
+	const exactConversation = matchingChannelAccount.find((entry) => entry.conversation.conversationId === requester.conversationId);
+	if (exactConversation) return exactConversation;
+	if (matchingChannelAccount.length === 1) return matchingChannelAccount[0] ?? null;
+	return null;
+}
+function createBoundDeliveryRouter(service = getSessionBindingService()) {
+	return { resolveDestination: (input) => {
+		const targetSessionKey = input.targetSessionKey.trim();
+		if (!targetSessionKey) return {
+			binding: null,
+			mode: "fallback",
+			reason: "missing-target-session"
+		};
+		const activeBindings = service.listBySession(targetSessionKey).filter(isActiveBinding);
+		if (activeBindings.length === 0) return {
+			binding: null,
+			mode: "fallback",
+			reason: "no-active-binding"
+		};
+		if (!input.requester) {
+			if (activeBindings.length === 1) return {
+				binding: activeBindings[0] ?? null,
+				mode: "bound",
+				reason: "single-active-binding"
+			};
+			return {
+				binding: null,
+				mode: "fallback",
+				reason: "ambiguous-without-requester"
+			};
+		}
+		const requester = {
+			channel: input.requester.channel.trim().toLowerCase(),
+			accountId: input.requester.accountId.trim(),
+			conversationId: input.requester.conversationId.trim(),
+			parentConversationId: input.requester.parentConversationId?.trim() || void 0
+		};
+		if (!requester.channel || !requester.conversationId) return {
+			binding: null,
+			mode: "fallback",
+			reason: "invalid-requester"
+		};
+		const fromRequester = resolveBindingForRequester(requester, activeBindings);
+		if (fromRequester) return {
+			binding: fromRequester,
+			mode: "bound",
+			reason: "requester-match"
+		};
+		if (activeBindings.length === 1 && !input.failClosed) return {
+			binding: activeBindings[0] ?? null,
+			mode: "bound",
+			reason: "single-active-binding-fallback"
+		};
+		return {
+			binding: null,
+			mode: "fallback",
+			reason: "no-requester-match"
+		};
+	} };
+}
+
+//#endregion
+//#region src/shared/chat-content.ts
+function extractTextFromChatContent(content, opts) {
+	const normalize = opts?.normalizeText ?? ((text) => text.replace(/\s+/g, " ").trim());
+	const joinWith = opts?.joinWith ?? " ";
+	if (typeof content === "string") {
+		const normalized = normalize(opts?.sanitizeText ? opts.sanitizeText(content) : content);
+		return normalized ? normalized : null;
+	}
+	if (!Array.isArray(content)) return null;
+	const chunks = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		if (block.type !== "text") continue;
+		const text = block.text;
+		if (typeof text !== "string") continue;
+		const value = opts?.sanitizeText ? opts.sanitizeText(text) : text;
+		if (value.trim()) chunks.push(value);
+	}
+	const joined = normalize(chunks.join(joinWith));
+	return joined ? joined : null;
+}
+
+//#endregion
+//#region src/agents/announce-idempotency.ts
+function buildAnnounceIdFromChildRun(params) {
+	return `v1:${params.childSessionKey}:${params.childRunId}`;
+}
+function buildAnnounceIdempotencyKey(announceId) {
+	return `announce:${announceId}`;
+}
+
+//#endregion
+//#region src/agents/subagent-depth.ts
+function normalizeSpawnDepth(value) {
+	if (typeof value === "number") return Number.isInteger(value) && value >= 0 ? value : void 0;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return;
+		const numeric = Number(trimmed);
+		return Number.isInteger(numeric) && numeric >= 0 ? numeric : void 0;
+	}
+}
+function normalizeSessionKey(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readSessionStore(storePath) {
+	try {
+		const raw = fs.readFileSync(storePath, "utf-8");
+		const parsed = JSON5.parse(raw);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+function buildKeyCandidates(rawKey, cfg) {
+	if (!cfg) return [rawKey];
+	if (rawKey === "global" || rawKey === "unknown") return [rawKey];
+	if (parseAgentSessionKey(rawKey)) return [rawKey];
+	const prefixed = `agent:${resolveDefaultAgentId(cfg)}:${rawKey}`;
+	return prefixed === rawKey ? [rawKey] : [rawKey, prefixed];
+}
+function findEntryBySessionId(store, sessionId) {
+	const normalizedSessionId = normalizeSessionKey(sessionId);
+	if (!normalizedSessionId) return;
+	for (const entry of Object.values(store)) {
+		const candidateSessionId = normalizeSessionKey(entry?.sessionId);
+		if (candidateSessionId && candidateSessionId === normalizedSessionId) return entry;
+	}
+}
+function resolveEntryForSessionKey(params) {
+	const candidates = buildKeyCandidates(params.sessionKey, params.cfg);
+	if (params.store) {
+		for (const key of candidates) {
+			const entry = params.store[key];
+			if (entry) return entry;
+		}
+		return findEntryBySessionId(params.store, params.sessionKey);
+	}
+	if (!params.cfg) return;
+	for (const key of candidates) {
+		const parsed = parseAgentSessionKey(key);
+		if (!parsed?.agentId) continue;
+		const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed.agentId });
+		let store = params.cache.get(storePath);
+		if (!store) {
+			store = readSessionStore(storePath);
+			params.cache.set(storePath, store);
+		}
+		const entry = store[key] ?? findEntryBySessionId(store, params.sessionKey);
+		if (entry) return entry;
+	}
+}
+function getSubagentDepthFromSessionStore(sessionKey, opts) {
+	const raw = (sessionKey ?? "").trim();
+	const fallbackDepth = getSubagentDepth(raw);
+	if (!raw) return fallbackDepth;
+	const cache = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	const depthFromStore = (key) => {
+		const normalizedKey = normalizeSessionKey(key);
+		if (!normalizedKey) return;
+		if (visited.has(normalizedKey)) return;
+		visited.add(normalizedKey);
+		const entry = resolveEntryForSessionKey({
+			sessionKey: normalizedKey,
+			cfg: opts?.cfg,
+			store: opts?.store,
+			cache
+		});
+		const storedDepth = normalizeSpawnDepth(entry?.spawnDepth);
+		if (storedDepth !== void 0) return storedDepth;
+		const spawnedBy = normalizeSessionKey(entry?.spawnedBy);
+		if (!spawnedBy) return;
+		const parentDepth = depthFromStore(spawnedBy);
+		if (parentDepth !== void 0) return parentDepth + 1;
+		return getSubagentDepth(spawnedBy) + 1;
+	};
+	return depthFromStore(raw) ?? fallbackDepth;
+}
+
+//#endregion
+//#region src/agents/tools/sessions-resolution.ts
+function resolveMainSessionAlias(cfg) {
+	const mainKey = normalizeMainKey(cfg.session?.mainKey);
+	const scope = cfg.session?.scope ?? "per-sender";
+	return {
+		mainKey,
+		alias: scope === "global" ? "global" : mainKey,
+		scope
+	};
+}
+function resolveDisplaySessionKey(params) {
+	if (params.key === params.alias) return "main";
+	if (params.key === params.mainKey) return "main";
+	return params.key;
+}
+function resolveInternalSessionKey(params) {
+	if (params.key === "main") return params.alias;
+	return params.key;
+}
+async function listSpawnedSessionKeys(params) {
+	const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? Math.max(1, Math.floor(params.limit)) : 500;
+	try {
+		const list = await callGateway({
+			method: "sessions.list",
+			params: {
+				includeGlobal: false,
+				includeUnknown: false,
+				limit,
+				spawnedBy: params.requesterSessionKey
+			}
+		});
+		const keys = (Array.isArray(list?.sessions) ? list.sessions : []).map((entry) => typeof entry?.key === "string" ? entry.key : "").map((value) => value.trim()).filter(Boolean);
+		return new Set(keys);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+async function isRequesterSpawnedSessionVisible(params) {
+	if (params.requesterSessionKey === params.targetSessionKey) return true;
+	return (await listSpawnedSessionKeys({
+		requesterSessionKey: params.requesterSessionKey,
+		limit: params.limit
+	})).has(params.targetSessionKey);
+}
+function shouldVerifyRequesterSpawnedSessionVisibility(params) {
+	return params.restrictToSpawned && !params.resolvedViaSessionId && params.requesterSessionKey !== params.targetSessionKey;
+}
+async function isResolvedSessionVisibleToRequester(params) {
+	if (!shouldVerifyRequesterSpawnedSessionVisibility({
+		requesterSessionKey: params.requesterSessionKey,
+		targetSessionKey: params.targetSessionKey,
+		restrictToSpawned: params.restrictToSpawned,
+		resolvedViaSessionId: params.resolvedViaSessionId
+	})) return true;
+	return await isRequesterSpawnedSessionVisible({
+		requesterSessionKey: params.requesterSessionKey,
+		targetSessionKey: params.targetSessionKey,
+		limit: params.limit
+	});
+}
+const SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function looksLikeSessionId(value) {
+	return SESSION_ID_RE.test(value.trim());
+}
+function looksLikeSessionKey(value) {
+	const raw = value.trim();
+	if (!raw) return false;
+	if (raw === "main" || raw === "global" || raw === "unknown") return true;
+	if (isAcpSessionKey(raw)) return true;
+	if (raw.startsWith("agent:")) return true;
+	if (raw.startsWith("cron:") || raw.startsWith("hook:")) return true;
+	if (raw.startsWith("node-") || raw.startsWith("node:")) return true;
+	if (raw.includes(":group:") || raw.includes(":channel:")) return true;
+	return false;
+}
+function shouldResolveSessionIdInput(value) {
+	return looksLikeSessionId(value) || !looksLikeSessionKey(value);
+}
+async function resolveSessionKeyFromSessionId(params) {
+	try {
+		const result = await callGateway({
+			method: "sessions.resolve",
+			params: {
+				sessionId: params.sessionId,
+				spawnedBy: params.restrictToSpawned ? params.requesterInternalKey : void 0,
+				includeGlobal: !params.restrictToSpawned,
+				includeUnknown: !params.restrictToSpawned
+			}
+		});
+		const key = typeof result?.key === "string" ? result.key.trim() : "";
+		if (!key) throw new Error(`Session not found: ${params.sessionId} (use the full sessionKey from sessions_list)`);
+		return {
+			ok: true,
+			key,
+			displayKey: resolveDisplaySessionKey({
+				key,
+				alias: params.alias,
+				mainKey: params.mainKey
+			}),
+			resolvedViaSessionId: true
+		};
+	} catch (err) {
+		if (params.restrictToSpawned) return {
+			ok: false,
+			status: "forbidden",
+			error: `Session not visible from this sandboxed agent session: ${params.sessionId}`
+		};
+		return {
+			ok: false,
+			status: "error",
+			error: (err instanceof Error ? err.message : String(err)) || `Session not found: ${params.sessionId} (use the full sessionKey from sessions_list)`
+		};
+	}
+}
+async function resolveSessionKeyFromKey(params) {
+	try {
+		const result = await callGateway({
+			method: "sessions.resolve",
+			params: {
+				key: params.key,
+				spawnedBy: params.restrictToSpawned ? params.requesterInternalKey : void 0
+			}
+		});
+		const key = typeof result?.key === "string" ? result.key.trim() : "";
+		if (!key) return null;
+		return {
+			ok: true,
+			key,
+			displayKey: resolveDisplaySessionKey({
+				key,
+				alias: params.alias,
+				mainKey: params.mainKey
+			}),
+			resolvedViaSessionId: false
+		};
+	} catch {
+		return null;
+	}
+}
+async function resolveSessionReference(params) {
+	const raw = params.sessionKey.trim();
+	if (shouldResolveSessionIdInput(raw)) {
+		const resolvedByKey = await resolveSessionKeyFromKey({
+			key: raw,
+			alias: params.alias,
+			mainKey: params.mainKey,
+			requesterInternalKey: params.requesterInternalKey,
+			restrictToSpawned: params.restrictToSpawned
+		});
+		if (resolvedByKey) return resolvedByKey;
+		return await resolveSessionKeyFromSessionId({
+			sessionId: raw,
+			alias: params.alias,
+			mainKey: params.mainKey,
+			requesterInternalKey: params.requesterInternalKey,
+			restrictToSpawned: params.restrictToSpawned
+		});
+	}
+	const resolvedKey = resolveInternalSessionKey({
+		key: raw,
+		alias: params.alias,
+		mainKey: params.mainKey
+	});
+	return {
+		ok: true,
+		key: resolvedKey,
+		displayKey: resolveDisplaySessionKey({
+			key: resolvedKey,
+			alias: params.alias,
+			mainKey: params.mainKey
+		}),
+		resolvedViaSessionId: false
+	};
+}
+
+//#endregion
+//#region src/agents/tools/sessions-access.ts
+function resolveSessionToolsVisibility(cfg) {
+	const raw = cfg.tools?.sessions?.visibility;
+	const value = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+	if (value === "self" || value === "tree" || value === "agent" || value === "all") return value;
+	return "tree";
+}
+function resolveEffectiveSessionToolsVisibility(params) {
+	const visibility = resolveSessionToolsVisibility(params.cfg);
+	if (!params.sandboxed) return visibility;
+	if ((params.cfg.agents?.defaults?.sandbox?.sessionToolsVisibility ?? "spawned") === "spawned" && visibility !== "tree") return "tree";
+	return visibility;
+}
+function resolveSandboxSessionToolsVisibility(cfg) {
+	return cfg.agents?.defaults?.sandbox?.sessionToolsVisibility ?? "spawned";
+}
+function resolveSandboxedSessionToolContext(params) {
+	const { mainKey, alias } = resolveMainSessionAlias(params.cfg);
+	const visibility = resolveSandboxSessionToolsVisibility(params.cfg);
+	const requesterInternalKey = typeof params.agentSessionKey === "string" && params.agentSessionKey.trim() ? resolveInternalSessionKey({
+		key: params.agentSessionKey,
+		alias,
+		mainKey
+	}) : void 0;
+	return {
+		mainKey,
+		alias,
+		visibility,
+		requesterInternalKey,
+		effectiveRequesterKey: requesterInternalKey ?? alias,
+		restrictToSpawned: params.sandboxed === true && visibility === "spawned" && !!requesterInternalKey && !isSubagentSessionKey(requesterInternalKey)
+	};
+}
+function createAgentToAgentPolicy(cfg) {
+	const routingA2A = cfg.tools?.agentToAgent;
+	const enabled = routingA2A?.enabled === true;
+	const allowPatterns = Array.isArray(routingA2A?.allow) ? routingA2A.allow : [];
+	const matchesAllow = (agentId) => {
+		if (allowPatterns.length === 0) return true;
+		return allowPatterns.some((pattern) => {
+			const raw = String(pattern ?? "").trim();
+			if (!raw) return false;
+			if (raw === "*") return true;
+			if (!raw.includes("*")) return raw === agentId;
+			const escaped = raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			return new RegExp(`^${escaped.replaceAll("\\*", ".*")}$`, "i").test(agentId);
+		});
+	};
+	const isAllowed = (requesterAgentId, targetAgentId) => {
+		if (requesterAgentId === targetAgentId) return true;
+		if (!enabled) return false;
+		return matchesAllow(requesterAgentId) && matchesAllow(targetAgentId);
+	};
+	return {
+		enabled,
+		matchesAllow,
+		isAllowed
+	};
+}
+function actionPrefix(action) {
+	if (action === "history") return "Session history";
+	if (action === "send") return "Session send";
+	return "Session list";
+}
+function a2aDisabledMessage(action) {
+	if (action === "history") return "Agent-to-agent history is disabled. Set tools.agentToAgent.enabled=true to allow cross-agent access.";
+	if (action === "send") return "Agent-to-agent messaging is disabled. Set tools.agentToAgent.enabled=true to allow cross-agent sends.";
+	return "Agent-to-agent listing is disabled. Set tools.agentToAgent.enabled=true to allow cross-agent visibility.";
+}
+function a2aDeniedMessage(action) {
+	if (action === "history") return "Agent-to-agent history denied by tools.agentToAgent.allow.";
+	if (action === "send") return "Agent-to-agent messaging denied by tools.agentToAgent.allow.";
+	return "Agent-to-agent listing denied by tools.agentToAgent.allow.";
+}
+function crossVisibilityMessage(action) {
+	if (action === "history") return "Session history visibility is restricted. Set tools.sessions.visibility=all to allow cross-agent access.";
+	if (action === "send") return "Session send visibility is restricted. Set tools.sessions.visibility=all to allow cross-agent access.";
+	return "Session list visibility is restricted. Set tools.sessions.visibility=all to allow cross-agent access.";
+}
+function selfVisibilityMessage(action) {
+	return `${actionPrefix(action)} visibility is restricted to the current session (tools.sessions.visibility=self).`;
+}
+function treeVisibilityMessage(action) {
+	return `${actionPrefix(action)} visibility is restricted to the current session tree (tools.sessions.visibility=tree).`;
+}
+async function createSessionVisibilityGuard(params) {
+	const requesterAgentId = resolveAgentIdFromSessionKey(params.requesterSessionKey);
+	const spawnedKeys = params.visibility === "tree" ? await listSpawnedSessionKeys({ requesterSessionKey: params.requesterSessionKey }) : null;
+	const check = (targetSessionKey) => {
+		const targetAgentId = resolveAgentIdFromSessionKey(targetSessionKey);
+		if (targetAgentId !== requesterAgentId) {
+			if (params.visibility !== "all") return {
+				allowed: false,
+				status: "forbidden",
+				error: crossVisibilityMessage(params.action)
+			};
+			if (!params.a2aPolicy.enabled) return {
+				allowed: false,
+				status: "forbidden",
+				error: a2aDisabledMessage(params.action)
+			};
+			if (!params.a2aPolicy.isAllowed(requesterAgentId, targetAgentId)) return {
+				allowed: false,
+				status: "forbidden",
+				error: a2aDeniedMessage(params.action)
+			};
+			return { allowed: true };
+		}
+		if (params.visibility === "self" && targetSessionKey !== params.requesterSessionKey) return {
+			allowed: false,
+			status: "forbidden",
+			error: selfVisibilityMessage(params.action)
+		};
+		if (params.visibility === "tree" && targetSessionKey !== params.requesterSessionKey && !spawnedKeys?.has(targetSessionKey)) return {
+			allowed: false,
+			status: "forbidden",
+			error: treeVisibilityMessage(params.action)
+		};
+		return { allowed: true };
+	};
+	return { check };
+}
+
+//#endregion
+//#region src/shared/text/code-regions.ts
+function findCodeRegions(text) {
+	const regions = [];
+	for (const match of text.matchAll(/(^|\n)(```|~~~)[^\n]*\n[\s\S]*?(?:\n\2(?:\n|$)|$)/g)) {
+		const start = (match.index ?? 0) + match[1].length;
+		regions.push({
+			start,
+			end: start + match[0].length - match[1].length
+		});
+	}
+	for (const match of text.matchAll(/`+[^`]+`+/g)) {
+		const start = match.index ?? 0;
+		const end = start + match[0].length;
+		if (!regions.some((r) => start >= r.start && end <= r.end)) regions.push({
+			start,
+			end
+		});
+	}
+	regions.sort((a, b) => a.start - b.start);
+	return regions;
+}
+function isInsideCode(pos, regions) {
+	return regions.some((r) => pos >= r.start && pos < r.end);
+}
+
+//#endregion
+//#region src/shared/text/reasoning-tags.ts
+const QUICK_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought|antthinking|final)\b/i;
+const FINAL_TAG_RE = /<\s*\/?\s*final\b[^<>]*>/gi;
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+function applyTrim(value, mode) {
+	if (mode === "none") return value;
+	if (mode === "start") return value.trimStart();
+	return value.trim();
+}
+function stripReasoningTagsFromText(text, options) {
+	if (!text) return text;
+	if (!QUICK_TAG_RE.test(text)) return text;
+	const mode = options?.mode ?? "strict";
+	const trimMode = options?.trim ?? "both";
+	let cleaned = text;
+	if (FINAL_TAG_RE.test(cleaned)) {
+		FINAL_TAG_RE.lastIndex = 0;
+		const finalMatches = [];
+		const preCodeRegions = findCodeRegions(cleaned);
+		for (const match of cleaned.matchAll(FINAL_TAG_RE)) {
+			const start = match.index ?? 0;
+			finalMatches.push({
+				start,
+				length: match[0].length,
+				inCode: isInsideCode(start, preCodeRegions)
+			});
+		}
+		for (let i = finalMatches.length - 1; i >= 0; i--) {
+			const m = finalMatches[i];
+			if (!m.inCode) cleaned = cleaned.slice(0, m.start) + cleaned.slice(m.start + m.length);
+		}
+	} else FINAL_TAG_RE.lastIndex = 0;
+	const codeRegions = findCodeRegions(cleaned);
+	THINKING_TAG_RE.lastIndex = 0;
+	let result = "";
+	let lastIndex = 0;
+	let inThinking = false;
+	for (const match of cleaned.matchAll(THINKING_TAG_RE)) {
+		const idx = match.index ?? 0;
+		const isClose = match[1] === "/";
+		if (isInsideCode(idx, codeRegions)) continue;
+		if (!inThinking) {
+			result += cleaned.slice(lastIndex, idx);
+			if (!isClose) inThinking = true;
+		} else if (isClose) inThinking = false;
+		lastIndex = idx + match[0].length;
+	}
+	if (!inThinking || mode === "preserve") result += cleaned.slice(lastIndex);
+	return applyTrim(result, trimMode);
+}
+
+//#endregion
+//#region src/agents/agent-utils.ts
+/**
+* Strip malformed Minimax tool invocations that leak into text content.
+* Minimax sometimes embeds tool calls as XML in text blocks instead of
+* proper structured tool calls. This removes:
+* - <invoke name="...">...</invoke> blocks
+* - </minimax:tool_call> closing tags
+*/
+function stripMinimaxToolCallXml(text) {
+	if (!text) return text;
+	if (!/minimax:tool_call/i.test(text)) return text;
+	let cleaned = text.replace(/<invoke\b[^>]*>[\s\S]*?<\/invoke>/gi, "");
+	cleaned = cleaned.replace(/<\/?minimax:tool_call>/gi, "");
+	return cleaned;
+}
+/**
+* Strip downgraded tool call text representations that leak into text content.
+* When replaying history to Gemini, tool calls without `thought_signature` are
+* downgraded to text blocks like `[Tool Call: name (ID: ...)]`. These should
+* not be shown to users.
+*/
+function stripDowngradedToolCallText(text) {
+	if (!text) return text;
+	if (!/\[Tool (?:Call|Result)/i.test(text) && !/\[Historical context/i.test(text)) return text;
+	const consumeJsonish = (input, start, options) => {
+		const { allowLeadingNewlines = false } = options ?? {};
+		let index = start;
+		while (index < input.length) {
+			const ch = input[index];
+			if (ch === " " || ch === "	") {
+				index += 1;
+				continue;
+			}
+			if (allowLeadingNewlines && (ch === "\n" || ch === "\r")) {
+				index += 1;
+				continue;
+			}
+			break;
+		}
+		if (index >= input.length) return null;
+		const startChar = input[index];
+		if (startChar === "{" || startChar === "[") {
+			let depth = 0;
+			let inString = false;
+			let escape = false;
+			for (let i = index; i < input.length; i += 1) {
+				const ch = input[i];
+				if (inString) {
+					if (escape) escape = false;
+					else if (ch === "\\") escape = true;
+					else if (ch === "\"") inString = false;
+					continue;
+				}
+				if (ch === "\"") {
+					inString = true;
+					continue;
+				}
+				if (ch === "{" || ch === "[") {
+					depth += 1;
+					continue;
+				}
+				if (ch === "}" || ch === "]") {
+					depth -= 1;
+					if (depth === 0) return i + 1;
+				}
+			}
+			return null;
+		}
+		if (startChar === "\"") {
+			let escape = false;
+			for (let i = index + 1; i < input.length; i += 1) {
+				const ch = input[i];
+				if (escape) {
+					escape = false;
+					continue;
+				}
+				if (ch === "\\") {
+					escape = true;
+					continue;
+				}
+				if (ch === "\"") return i + 1;
+			}
+			return null;
+		}
+		let end = index;
+		while (end < input.length && input[end] !== "\n" && input[end] !== "\r") end += 1;
+		return end;
+	};
+	const stripToolCalls = (input) => {
+		const markerRe = /\[Tool Call:[^\]]*\]/gi;
+		let result = "";
+		let cursor = 0;
+		for (const match of input.matchAll(markerRe)) {
+			const start = match.index ?? 0;
+			if (start < cursor) continue;
+			result += input.slice(cursor, start);
+			let index = start + match[0].length;
+			while (index < input.length && (input[index] === " " || input[index] === "	")) index += 1;
+			if (input[index] === "\r") {
+				index += 1;
+				if (input[index] === "\n") index += 1;
+			} else if (input[index] === "\n") index += 1;
+			while (index < input.length && (input[index] === " " || input[index] === "	")) index += 1;
+			if (input.slice(index, index + 9).toLowerCase() === "arguments") {
+				index += 9;
+				if (input[index] === ":") index += 1;
+				if (input[index] === " ") index += 1;
+				const end = consumeJsonish(input, index, { allowLeadingNewlines: true });
+				if (end !== null) index = end;
+			}
+			if ((input[index] === "\n" || input[index] === "\r") && (result.endsWith("\n") || result.endsWith("\r") || result.length === 0)) {
+				if (input[index] === "\r") index += 1;
+				if (input[index] === "\n") index += 1;
+			}
+			cursor = index;
+		}
+		result += input.slice(cursor);
+		return result;
+	};
+	let cleaned = stripToolCalls(text);
+	cleaned = cleaned.replace(/\[Tool Result for ID[^\]]*\]\n?[\s\S]*?(?=\n*\[Tool |\n*$)/gi, "");
+	cleaned = cleaned.replace(/\[Historical context:[^\]]*\]\n?/gi, "");
+	return cleaned.trim();
+}
+/**
+* Strip thinking tags and their content from text.
+* This is a safety net for cases where the model outputs <think> tags
+* that slip through other filtering mechanisms.
+*/
+function stripThinkingTagsFromText(text) {
+	return stripReasoningTagsFromText(text, {
+		mode: "strict",
+		trim: "both"
+	});
+}
+function formatReasoningMessage(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	return `Reasoning:\n${trimmed.split("\n").map((line) => line ? `_${line}_` : line).join("\n")}`;
+}
+
+//#endregion
+//#region src/agents/tools/sessions-helpers.ts
+function normalizeKey(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function classifySessionKind(params) {
+	const key = params.key;
+	if (key === params.alias || key === params.mainKey) return "main";
+	if (key.startsWith("cron:")) return "cron";
+	if (key.startsWith("hook:")) return "hook";
+	if (key.startsWith("node-") || key.startsWith("node:")) return "node";
+	if (params.gatewayKind === "group") return "group";
+	if (key.includes(":group:") || key.includes(":channel:")) return "group";
+	return "other";
+}
+function deriveChannel(params) {
+	if (params.kind === "cron" || params.kind === "hook" || params.kind === "node") return "internal";
+	const channel = normalizeKey(params.channel ?? void 0);
+	if (channel) return channel;
+	const lastChannel = normalizeKey(params.lastChannel ?? void 0);
+	if (lastChannel) return lastChannel;
+	const parts = params.key.split(":").filter(Boolean);
+	if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) return parts[0];
+	return "unknown";
+}
+function stripToolMessages(messages) {
+	return messages.filter((msg) => {
+		if (!msg || typeof msg !== "object") return true;
+		const role = msg.role;
+		return role !== "toolResult" && role !== "tool";
+	});
+}
+/**
+* Sanitize text content to strip tool call markers and thinking tags.
+* This ensures user-facing text doesn't leak internal tool representations.
+*/
+function sanitizeTextContent(text) {
+	if (!text) return text;
+	return stripThinkingTagsFromText(stripDowngradedToolCallText(stripMinimaxToolCallXml(text)));
+}
+function extractAssistantText(message) {
+	if (!message || typeof message !== "object") return;
+	if (message.role !== "assistant") return;
+	const content = message.content;
+	if (!Array.isArray(content)) return;
+	const joined = extractTextFromChatContent(content, {
+		sanitizeText: sanitizeTextContent,
+		joinWith: "",
+		normalizeText: (text) => text.trim()
+	}) ?? "";
+	const stopReason = message.stopReason;
+	const errorMessage = message.errorMessage;
+	const errorContext = stopReason === "error" || typeof errorMessage === "string" && Boolean(errorMessage.trim());
+	return joined ? sanitizeUserFacingText(joined, { errorContext }) : void 0;
+}
+
+//#endregion
+//#region src/agents/tools/agent-step.ts
+async function readLatestAssistantReply(params) {
+	const history = await callGateway({
+		method: "chat.history",
+		params: {
+			sessionKey: params.sessionKey,
+			limit: params.limit ?? 50
+		}
+	});
+	const filtered = stripToolMessages(Array.isArray(history?.messages) ? history.messages : []);
+	for (let i = filtered.length - 1; i >= 0; i -= 1) {
+		const candidate = filtered[i];
+		if (!candidate || typeof candidate !== "object") continue;
+		if (candidate.role !== "assistant") continue;
+		const text = extractAssistantText(candidate);
+		if (!text?.trim()) continue;
+		return text;
+	}
+}
+async function runAgentStep(params) {
+	const stepIdem = crypto.randomUUID();
+	const response = await callGateway({
+		method: "agent",
+		params: {
+			message: params.message,
+			sessionKey: params.sessionKey,
+			idempotencyKey: stepIdem,
+			deliver: false,
+			channel: params.channel ?? INTERNAL_MESSAGE_CHANNEL,
+			lane: params.lane ?? AGENT_LANE_NESTED,
+			extraSystemPrompt: params.extraSystemPrompt,
+			inputProvenance: {
+				kind: "inter_session",
+				sourceSessionKey: params.sourceSessionKey,
+				sourceChannel: params.sourceChannel,
+				sourceTool: params.sourceTool ?? "sessions_send"
+			}
+		},
+		timeoutMs: 1e4
+	});
+	const resolvedRunId = (typeof response?.runId === "string" && response.runId ? response.runId : "") || stepIdem;
+	const stepWaitMs = Math.min(params.timeoutMs, 6e4);
+	if ((await callGateway({
+		method: "agent.wait",
+		params: {
+			runId: resolvedRunId,
+			timeoutMs: stepWaitMs
+		},
+		timeoutMs: stepWaitMs + 2e3
+	}))?.status !== "ok") return;
+	return await readLatestAssistantReply({ sessionKey: params.sessionKey });
+}
+
+//#endregion
+//#region src/agents/tools/sessions-send-helpers.ts
+const ANNOUNCE_SKIP_TOKEN = "ANNOUNCE_SKIP";
+const REPLY_SKIP_TOKEN = "REPLY_SKIP";
+const DEFAULT_PING_PONG_TURNS = 5;
+const MAX_PING_PONG_TURNS = 5;
+function resolveAnnounceTargetFromKey(sessionKey) {
+	const rawParts = sessionKey.split(":").filter(Boolean);
+	const parts = rawParts.length >= 3 && rawParts[0] === "agent" ? rawParts.slice(2) : rawParts;
+	if (parts.length < 3) return null;
+	const [channelRaw, kind, ...rest] = parts;
+	if (kind !== "group" && kind !== "channel") return null;
+	let threadId;
+	const restJoined = rest.join(":");
+	const topicMatch = restJoined.match(/:topic:(\d+)$/);
+	const threadMatch = restJoined.match(/:thread:(\d+)$/);
+	const match = topicMatch || threadMatch;
+	if (match) threadId = match[1];
+	const id = match ? restJoined.replace(/:(topic|thread):\d+$/, "") : restJoined.trim();
+	if (!id) return null;
+	if (!channelRaw) return null;
+	const normalizedChannel = normalizeChannelId$1(channelRaw) ?? normalizeChannelId(channelRaw);
+	const channel = normalizedChannel ?? channelRaw.toLowerCase();
+	const kindTarget = (() => {
+		if (!normalizedChannel) return id;
+		if (normalizedChannel === "discord" || normalizedChannel === "slack") return `channel:${id}`;
+		return kind === "channel" ? `channel:${id}` : `group:${id}`;
+	})();
+	return {
+		channel,
+		to: (normalizedChannel ? getChannelPlugin(normalizedChannel)?.messaging?.normalizeTarget?.(kindTarget) : void 0) ?? kindTarget,
+		threadId
+	};
+}
+function buildAgentToAgentMessageContext(params) {
+	return [
+		"Agent-to-agent message context:",
+		params.requesterSessionKey ? `Agent 1 (requester) session: ${params.requesterSessionKey}.` : void 0,
+		params.requesterChannel ? `Agent 1 (requester) channel: ${params.requesterChannel}.` : void 0,
+		`Agent 2 (target) session: ${params.targetSessionKey}.`
+	].filter(Boolean).join("\n");
+}
+function buildAgentToAgentReplyContext(params) {
+	return [
+		"Agent-to-agent reply step:",
+		`Current agent: ${params.currentRole === "requester" ? "Agent 1 (requester)" : "Agent 2 (target)"}.`,
+		`Turn ${params.turn} of ${params.maxTurns}.`,
+		params.requesterSessionKey ? `Agent 1 (requester) session: ${params.requesterSessionKey}.` : void 0,
+		params.requesterChannel ? `Agent 1 (requester) channel: ${params.requesterChannel}.` : void 0,
+		`Agent 2 (target) session: ${params.targetSessionKey}.`,
+		params.targetChannel ? `Agent 2 (target) channel: ${params.targetChannel}.` : void 0,
+		`If you want to stop the ping-pong, reply exactly "${REPLY_SKIP_TOKEN}".`
+	].filter(Boolean).join("\n");
+}
+function buildAgentToAgentAnnounceContext(params) {
+	return [
+		"Agent-to-agent announce step:",
+		params.requesterSessionKey ? `Agent 1 (requester) session: ${params.requesterSessionKey}.` : void 0,
+		params.requesterChannel ? `Agent 1 (requester) channel: ${params.requesterChannel}.` : void 0,
+		`Agent 2 (target) session: ${params.targetSessionKey}.`,
+		params.targetChannel ? `Agent 2 (target) channel: ${params.targetChannel}.` : void 0,
+		`Original request: ${params.originalMessage}`,
+		params.roundOneReply ? `Round 1 reply: ${params.roundOneReply}` : "Round 1 reply: (not available).",
+		params.latestReply ? `Latest reply: ${params.latestReply}` : "Latest reply: (not available).",
+		`If you want to remain silent, reply exactly "${ANNOUNCE_SKIP_TOKEN}".`,
+		"Any other reply will be posted to the target channel.",
+		"After this reply, the agent-to-agent conversation is over."
+	].filter(Boolean).join("\n");
+}
+function isAnnounceSkip(text) {
+	return (text ?? "").trim() === ANNOUNCE_SKIP_TOKEN;
+}
+function isReplySkip(text) {
+	return (text ?? "").trim() === REPLY_SKIP_TOKEN;
+}
+function resolvePingPongTurns(cfg) {
+	const raw = cfg?.session?.agentToAgent?.maxPingPongTurns;
+	const fallback = DEFAULT_PING_PONG_TURNS;
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return fallback;
+	const rounded = Math.floor(raw);
+	return Math.max(0, Math.min(MAX_PING_PONG_TURNS, rounded));
+}
+
+//#endregion
+//#region src/agents/subagent-announce.ts
+const FAST_TEST_MODE = process.env.REMOTECLAW_TEST_FAST === "1";
+const FAST_TEST_RETRY_INTERVAL_MS = 8;
+const FAST_TEST_REPLY_CHANGE_WAIT_MS = 20;
+const DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS = 6e4;
+const MAX_TIMER_SAFE_TIMEOUT_MS = 2147e6;
+const DIRECT_ANNOUNCE_TRANSIENT_RETRY_DELAYS_MS = FAST_TEST_MODE ? [
+	8,
+	16,
+	32
+] : [
+	5e3,
+	1e4,
+	2e4
+];
+function resolveSubagentAnnounceTimeoutMs(cfg) {
+	const configured = cfg.agents?.defaults?.subagents?.announceTimeoutMs;
+	if (typeof configured !== "number" || !Number.isFinite(configured)) return DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS;
+	return Math.min(Math.max(1, Math.floor(configured)), MAX_TIMER_SAFE_TIMEOUT_MS);
+}
+function buildCompletionDeliveryMessage(params) {
+	const findingsText = params.findings.trim();
+	if (isAnnounceSkip(findingsText)) return "";
+	const hasFindings = findingsText.length > 0 && findingsText !== "(no output)";
+	const header = (() => {
+		if (params.outcome?.status === "error") return params.spawnMode === "session" ? `❌ Subagent ${params.subagentName} failed this task (session remains active)` : `❌ Subagent ${params.subagentName} failed`;
+		if (params.outcome?.status === "timeout") return params.spawnMode === "session" ? `⏱️ Subagent ${params.subagentName} timed out on this task (session remains active)` : `⏱️ Subagent ${params.subagentName} timed out`;
+		return params.spawnMode === "session" ? `✅ Subagent ${params.subagentName} completed this task (session remains active)` : `✅ Subagent ${params.subagentName} finished`;
+	})();
+	if (!hasFindings) return header;
+	return `${header}\n\n${findingsText}`;
+}
+function summarizeDeliveryError(error) {
+	if (error instanceof Error) return error.message || "error";
+	if (typeof error === "string") return error;
+	if (error === void 0 || error === null) return "unknown error";
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return "error";
+	}
+}
+const TRANSIENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS = [
+	/\berrorcode=unavailable\b/i,
+	/\bstatus\s*[:=]\s*"?unavailable\b/i,
+	/\bUNAVAILABLE\b/,
+	/no active .* listener/i,
+	/gateway not connected/i,
+	/gateway closed \(1006/i,
+	/gateway timeout/i,
+	/\b(econnreset|econnrefused|etimedout|enotfound|ehostunreach|network error)\b/i
+];
+const PERMANENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS = [
+	/unsupported channel/i,
+	/unknown channel/i,
+	/chat not found/i,
+	/user not found/i,
+	/bot was blocked by the user/i,
+	/forbidden: bot was kicked/i,
+	/recipient is not a valid/i,
+	/outbound not configured for channel/i
+];
+function isTransientAnnounceDeliveryError(error) {
+	const message = summarizeDeliveryError(error);
+	if (!message) return false;
+	if (PERMANENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message))) return false;
+	return TRANSIENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message));
+}
+async function waitForAnnounceRetryDelay(ms, signal) {
+	if (ms <= 0) return;
+	if (!signal) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+		return;
+	}
+	if (signal.aborted) return;
+	await new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function runAnnounceDeliveryWithRetry(params) {
+	let retryIndex = 0;
+	for (;;) {
+		if (params.signal?.aborted) throw new Error("announce delivery aborted");
+		try {
+			return await params.run();
+		} catch (err) {
+			const delayMs = DIRECT_ANNOUNCE_TRANSIENT_RETRY_DELAYS_MS[retryIndex];
+			if (delayMs == null || !isTransientAnnounceDeliveryError(err) || params.signal?.aborted) throw err;
+			const nextAttempt = retryIndex + 2;
+			const maxAttempts = DIRECT_ANNOUNCE_TRANSIENT_RETRY_DELAYS_MS.length + 1;
+			defaultRuntime.log(`[warn] Subagent announce ${params.operation} transient failure, retrying ${nextAttempt}/${maxAttempts} in ${Math.round(delayMs / 1e3)}s: ${summarizeDeliveryError(err)}`);
+			retryIndex += 1;
+			await waitForAnnounceRetryDelay(delayMs, params.signal);
+		}
+	}
+}
+function extractToolResultText(content) {
+	if (typeof content === "string") return sanitizeTextContent(content);
+	if (content && typeof content === "object" && !Array.isArray(content)) {
+		const obj = content;
+		if (typeof obj.text === "string") return sanitizeTextContent(obj.text);
+		if (typeof obj.output === "string") return sanitizeTextContent(obj.output);
+		if (typeof obj.content === "string") return sanitizeTextContent(obj.content);
+		if (typeof obj.result === "string") return sanitizeTextContent(obj.result);
+		if (typeof obj.error === "string") return sanitizeTextContent(obj.error);
+		if (typeof obj.summary === "string") return sanitizeTextContent(obj.summary);
+	}
+	if (!Array.isArray(content)) return "";
+	return extractTextFromChatContent(content, {
+		sanitizeText: sanitizeTextContent,
+		normalizeText: (text) => text,
+		joinWith: "\n"
+	})?.trim() ?? "";
+}
+function extractInlineTextContent(content) {
+	if (!Array.isArray(content)) return "";
+	return extractTextFromChatContent(content, {
+		sanitizeText: sanitizeTextContent,
+		normalizeText: (text) => text.trim(),
+		joinWith: ""
+	}) ?? "";
+}
+function extractSubagentOutputText(message) {
+	if (!message || typeof message !== "object") return "";
+	const role = message.role;
+	const content = message.content;
+	if (role === "assistant") {
+		const assistantText = extractAssistantText(message);
+		if (assistantText) return assistantText;
+		if (typeof content === "string") return sanitizeTextContent(content);
+		if (Array.isArray(content)) return extractInlineTextContent(content);
+		return "";
+	}
+	if (role === "toolResult" || role === "tool") return extractToolResultText(message.content);
+	if (role == null) {
+		if (typeof content === "string") return sanitizeTextContent(content);
+		if (Array.isArray(content)) return extractInlineTextContent(content);
+	}
+	return "";
+}
+async function readLatestSubagentOutput(sessionKey) {
+	try {
+		const latestAssistant = await readLatestAssistantReply({
+			sessionKey,
+			limit: 50
+		});
+		if (latestAssistant?.trim()) return latestAssistant;
+	} catch {}
+	const history = await callGateway({
+		method: "chat.history",
+		params: {
+			sessionKey,
+			limit: 50
+		}
+	});
+	const messages = Array.isArray(history?.messages) ? history.messages : [];
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const msg = messages[i];
+		const text = extractSubagentOutputText(msg);
+		if (text) return text;
+	}
+}
+async function readLatestSubagentOutputWithRetry(params) {
+	const RETRY_INTERVAL_MS = FAST_TEST_MODE ? FAST_TEST_RETRY_INTERVAL_MS : 100;
+	const deadline = Date.now() + Math.max(0, Math.min(params.maxWaitMs, 15e3));
+	let result;
+	while (Date.now() < deadline) {
+		result = await readLatestSubagentOutput(params.sessionKey);
+		if (result?.trim()) return result;
+		await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
+	}
+	return result;
+}
+async function waitForSubagentOutputChange(params) {
+	const baseline = params.baselineReply.trim();
+	if (!baseline) return params.baselineReply;
+	const RETRY_INTERVAL_MS = FAST_TEST_MODE ? FAST_TEST_RETRY_INTERVAL_MS : 100;
+	const deadline = Date.now() + Math.max(0, Math.min(params.maxWaitMs, 5e3));
+	let latest = params.baselineReply;
+	while (Date.now() < deadline) {
+		const next = await readLatestSubagentOutput(params.sessionKey);
+		if (next?.trim()) {
+			latest = next;
+			if (next.trim() !== baseline) return next;
+		}
+		await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
+	}
+	return latest;
+}
+function formatDurationShort(valueMs) {
+	if (!valueMs || !Number.isFinite(valueMs) || valueMs <= 0) return "n/a";
+	const totalSeconds = Math.round(valueMs / 1e3);
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor(totalSeconds % 3600 / 60);
+	const seconds = totalSeconds % 60;
+	if (hours > 0) return `${hours}h${minutes}m`;
+	if (minutes > 0) return `${minutes}m${seconds}s`;
+	return `${seconds}s`;
+}
+function formatTokenCount(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return "0";
+	if (value >= 1e6) return `${(value / 1e6).toFixed(1)}m`;
+	if (value >= 1e3) return `${(value / 1e3).toFixed(1)}k`;
+	return String(Math.round(value));
+}
+async function buildCompactAnnounceStatsLine(params) {
+	const cfg = loadConfig();
+	const agentId = resolveAgentIdFromSessionKey(params.sessionKey);
+	const storePath = resolveStorePath(cfg.session?.store, { agentId });
+	let entry = loadSessionStore(storePath)[params.sessionKey];
+	const tokenWaitAttempts = FAST_TEST_MODE ? 1 : 3;
+	for (let attempt = 0; attempt < tokenWaitAttempts; attempt += 1) {
+		if (typeof entry?.inputTokens === "number" || typeof entry?.outputTokens === "number" || typeof entry?.totalTokens === "number") break;
+		if (!FAST_TEST_MODE) await new Promise((resolve) => setTimeout(resolve, 150));
+		entry = loadSessionStore(storePath)[params.sessionKey];
+	}
+	const input = typeof entry?.inputTokens === "number" ? entry.inputTokens : 0;
+	const output = typeof entry?.outputTokens === "number" ? entry.outputTokens : 0;
+	const ioTotal = input + output;
+	const promptCache = typeof entry?.totalTokens === "number" ? entry.totalTokens : void 0;
+	const parts = [`runtime ${formatDurationShort(typeof params.startedAt === "number" && typeof params.endedAt === "number" ? Math.max(0, params.endedAt - params.startedAt) : void 0)}`, `tokens ${formatTokenCount(ioTotal)} (in ${formatTokenCount(input)} / out ${formatTokenCount(output)})`];
+	if (typeof promptCache === "number" && promptCache > ioTotal) parts.push(`prompt/cache ${formatTokenCount(promptCache)}`);
+	return `Stats: ${parts.join(" • ")}`;
+}
+function resolveAnnounceOrigin(entry, requesterOrigin) {
+	const normalizedRequester = normalizeDeliveryContext(requesterOrigin);
+	const normalizedEntry = deliveryContextFromSession(entry);
+	if (normalizedRequester?.channel && isInternalMessageChannel(normalizedRequester.channel)) return mergeDeliveryContext({
+		accountId: normalizedRequester.accountId,
+		threadId: normalizedRequester.threadId
+	}, normalizedEntry);
+	return mergeDeliveryContext(normalizedRequester, normalizedRequester?.to && normalizedRequester.threadId == null && normalizedEntry?.threadId != null ? (() => {
+		const { threadId: _ignore, ...rest } = normalizedEntry;
+		return rest;
+	})() : normalizedEntry);
+}
+async function resolveSubagentCompletionOrigin(params) {
+	const requesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
+	const requesterConversation = (() => {
+		const channel = requesterOrigin?.channel?.trim().toLowerCase();
+		const to = requesterOrigin?.to?.trim();
+		const accountId = normalizeAccountId(requesterOrigin?.accountId);
+		const conversationId = (requesterOrigin?.threadId != null && requesterOrigin.threadId !== "" ? String(requesterOrigin.threadId).trim() : void 0) || (to?.startsWith("channel:") ? to.slice(8) : "");
+		if (!channel || !conversationId) return;
+		return {
+			channel,
+			accountId,
+			conversationId
+		};
+	})();
+	const route = createBoundDeliveryRouter().resolveDestination({
+		eventKind: "task_completion",
+		targetSessionKey: params.childSessionKey,
+		requester: requesterConversation,
+		failClosed: false
+	});
+	if (route.mode === "bound" && route.binding) return {
+		origin: mergeDeliveryContext({
+			channel: route.binding.conversation.channel,
+			accountId: route.binding.conversation.accountId,
+			to: `channel:${route.binding.conversation.conversationId}`,
+			threadId: route.binding.conversation.conversationId
+		}, requesterOrigin),
+		routeMode: "bound"
+	};
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("subagent_delivery_target")) return {
+		origin: requesterOrigin,
+		routeMode: "fallback"
+	};
+	try {
+		const hookOrigin = normalizeDeliveryContext((await hookRunner.runSubagentDeliveryTarget({
+			childSessionKey: params.childSessionKey,
+			requesterSessionKey: params.requesterSessionKey,
+			requesterOrigin,
+			childRunId: params.childRunId,
+			spawnMode: params.spawnMode,
+			expectsCompletionMessage: params.expectsCompletionMessage
+		}, {
+			runId: params.childRunId,
+			childSessionKey: params.childSessionKey,
+			requesterSessionKey: params.requesterSessionKey
+		}))?.origin);
+		if (!hookOrigin) return {
+			origin: requesterOrigin,
+			routeMode: "fallback"
+		};
+		if (hookOrigin.channel && !isDeliverableMessageChannel(hookOrigin.channel)) return {
+			origin: requesterOrigin,
+			routeMode: "fallback"
+		};
+		return {
+			origin: mergeDeliveryContext(hookOrigin, requesterOrigin),
+			routeMode: "hook"
+		};
+	} catch {
+		return {
+			origin: requesterOrigin,
+			routeMode: "fallback"
+		};
+	}
+}
+function resolveRequesterStoreKey(cfg, requesterSessionKey) {
+	const raw = (requesterSessionKey ?? "").trim();
+	if (!raw) return raw;
+	if (raw === "global" || raw === "unknown") return raw;
+	if (raw.startsWith("agent:")) return raw;
+	const mainKey = normalizeMainKey(cfg.session?.mainKey);
+	if (raw === "main" || raw === mainKey) return resolveMainSessionKey(cfg);
+	return `agent:${resolveAgentIdFromSessionKey(raw)}:${raw}`;
+}
+function loadRequesterSessionEntry(requesterSessionKey) {
+	const cfg = loadConfig();
+	const canonicalKey = resolveRequesterStoreKey(cfg, requesterSessionKey);
+	const agentId = resolveAgentIdFromSessionKey(canonicalKey);
+	return {
+		cfg,
+		entry: loadSessionStore(resolveStorePath(cfg.session?.store, { agentId }))[canonicalKey],
+		canonicalKey
+	};
+}
+async function maybeQueueSubagentAnnounce(params) {
+	if (params.signal?.aborted) return "none";
+	const { cfg, entry } = loadRequesterSessionEntry(params.requesterSessionKey);
+	resolveRequesterStoreKey(cfg, params.requesterSessionKey);
+	if (!entry?.sessionId) return "none";
+	const queueSettings = resolveQueueSettings({
+		cfg,
+		channel: entry?.channel ?? entry?.lastChannel,
+		sessionEntry: entry
+	});
+	queueSettings.mode === "followup" || queueSettings.mode === "collect" || queueSettings.mode === "steer-backlog" || queueSettings.mode;
+	return "none";
+}
+function queueOutcomeToDeliveryResult(outcome) {
+	if (outcome === "steered") return {
+		delivered: true,
+		path: "steered"
+	};
+	if (outcome === "queued") return {
+		delivered: true,
+		path: "queued"
+	};
+	return {
+		delivered: false,
+		path: "none"
+	};
+}
+async function sendSubagentAnnounceDirectly(params) {
+	if (params.signal?.aborted) return {
+		delivered: false,
+		path: "none"
+	};
+	const cfg = loadConfig();
+	const announceTimeoutMs = resolveSubagentAnnounceTimeoutMs(cfg);
+	const canonicalRequesterSessionKey = resolveRequesterStoreKey(cfg, params.targetRequesterSessionKey);
+	try {
+		const completionDirectOrigin = normalizeDeliveryContext(params.completionDirectOrigin);
+		const completionChannelRaw = typeof completionDirectOrigin?.channel === "string" ? completionDirectOrigin.channel.trim() : "";
+		const completionChannel = completionChannelRaw && isDeliverableMessageChannel(completionChannelRaw) ? completionChannelRaw : "";
+		const completionTo = typeof completionDirectOrigin?.to === "string" ? completionDirectOrigin.to.trim() : "";
+		const hasCompletionDirectTarget = !params.requesterIsSubagent && Boolean(completionChannel) && Boolean(completionTo);
+		if (params.expectsCompletionMessage && hasCompletionDirectTarget && params.completionMessage?.trim()) {
+			const forceBoundSessionDirectDelivery = params.spawnMode === "session" && (params.completionRouteMode === "bound" || params.completionRouteMode === "hook");
+			let shouldSendCompletionDirectly = true;
+			if (!forceBoundSessionDirectDelivery) {
+				let activeDescendantRuns = 0;
+				try {
+					const { countActiveDescendantRuns } = await Promise.resolve().then(() => subagent_registry_exports);
+					activeDescendantRuns = Math.max(0, countActiveDescendantRuns(canonicalRequesterSessionKey));
+				} catch {}
+				if (activeDescendantRuns > 0) shouldSendCompletionDirectly = false;
+			}
+			if (shouldSendCompletionDirectly) {
+				const completionThreadId = completionDirectOrigin?.threadId != null && completionDirectOrigin.threadId !== "" ? String(completionDirectOrigin.threadId) : void 0;
+				if (params.signal?.aborted) return {
+					delivered: false,
+					path: "none"
+				};
+				await runAnnounceDeliveryWithRetry({
+					operation: "completion direct send",
+					signal: params.signal,
+					run: async () => await callGateway({
+						method: "send",
+						params: {
+							channel: completionChannel,
+							to: completionTo,
+							accountId: completionDirectOrigin?.accountId,
+							threadId: completionThreadId,
+							sessionKey: canonicalRequesterSessionKey,
+							message: params.completionMessage,
+							idempotencyKey: params.directIdempotencyKey
+						},
+						timeoutMs: announceTimeoutMs
+					})
+				});
+				return {
+					delivered: true,
+					path: "direct"
+				};
+			}
+		}
+		const directOrigin = normalizeDeliveryContext(params.directOrigin);
+		const directChannelRaw = typeof directOrigin?.channel === "string" ? directOrigin.channel.trim() : "";
+		const directChannel = directChannelRaw && isDeliverableMessageChannel(directChannelRaw) ? directChannelRaw : "";
+		const directTo = typeof directOrigin?.to === "string" ? directOrigin.to.trim() : "";
+		const hasDeliverableDirectTarget = !params.requesterIsSubagent && Boolean(directChannel) && Boolean(directTo);
+		const shouldDeliverExternally = !params.requesterIsSubagent && (!params.expectsCompletionMessage || hasDeliverableDirectTarget);
+		const threadId = directOrigin?.threadId != null && directOrigin.threadId !== "" ? String(directOrigin.threadId) : void 0;
+		if (params.signal?.aborted) return {
+			delivered: false,
+			path: "none"
+		};
+		await runAnnounceDeliveryWithRetry({
+			operation: "direct announce agent call",
+			signal: params.signal,
+			run: async () => await callGateway({
+				method: "agent",
+				params: {
+					sessionKey: canonicalRequesterSessionKey,
+					message: params.triggerMessage,
+					deliver: shouldDeliverExternally,
+					bestEffortDeliver: params.bestEffortDeliver,
+					channel: shouldDeliverExternally ? directChannel : void 0,
+					accountId: shouldDeliverExternally ? directOrigin?.accountId : void 0,
+					to: shouldDeliverExternally ? directTo : void 0,
+					threadId: shouldDeliverExternally ? threadId : void 0,
+					idempotencyKey: params.directIdempotencyKey
+				},
+				expectFinal: true,
+				timeoutMs: announceTimeoutMs
+			})
+		});
+		return {
+			delivered: true,
+			path: "direct"
+		};
+	} catch (err) {
+		return {
+			delivered: false,
+			path: "direct",
+			error: summarizeDeliveryError(err)
+		};
+	}
+}
+async function deliverSubagentAnnouncement(params) {
+	if (params.signal?.aborted) return {
+		delivered: false,
+		path: "none"
+	};
+	if (!params.expectsCompletionMessage) {
+		const queued = queueOutcomeToDeliveryResult(await maybeQueueSubagentAnnounce({
+			requesterSessionKey: params.requesterSessionKey,
+			announceId: params.announceId,
+			triggerMessage: params.triggerMessage,
+			summaryLine: params.summaryLine,
+			requesterOrigin: params.requesterOrigin,
+			signal: params.signal
+		}));
+		if (queued.delivered) return queued;
+	}
+	const direct = await sendSubagentAnnounceDirectly({
+		targetRequesterSessionKey: params.targetRequesterSessionKey,
+		triggerMessage: params.triggerMessage,
+		completionMessage: params.completionMessage,
+		directIdempotencyKey: params.directIdempotencyKey,
+		completionDirectOrigin: params.completionDirectOrigin,
+		completionRouteMode: params.completionRouteMode,
+		spawnMode: params.spawnMode,
+		directOrigin: params.directOrigin,
+		requesterIsSubagent: params.requesterIsSubagent,
+		expectsCompletionMessage: params.expectsCompletionMessage,
+		signal: params.signal,
+		bestEffortDeliver: params.bestEffortDeliver
+	});
+	if (direct.delivered || !params.expectsCompletionMessage) return direct;
+	const queueOutcome = await maybeQueueSubagentAnnounce({
+		requesterSessionKey: params.requesterSessionKey,
+		announceId: params.announceId,
+		triggerMessage: params.triggerMessage,
+		summaryLine: params.summaryLine,
+		requesterOrigin: params.requesterOrigin,
+		signal: params.signal
+	});
+	if (queueOutcome === "steered" || queueOutcome === "queued") return queueOutcomeToDeliveryResult(queueOutcome);
+	return direct;
+}
+function loadSessionEntryByKey(sessionKey) {
+	const cfg = loadConfig();
+	const agentId = resolveAgentIdFromSessionKey(sessionKey);
+	return loadSessionStore(resolveStorePath(cfg.session?.store, { agentId }))[sessionKey];
+}
+function buildSubagentSystemPrompt(params) {
+	const taskText = typeof params.task === "string" && params.task.trim() ? params.task.replace(/\s+/g, " ").trim() : "{{TASK_DESCRIPTION}}";
+	const childDepth = typeof params.childDepth === "number" ? params.childDepth : 1;
+	const canSpawn = childDepth < (typeof params.maxSpawnDepth === "number" ? params.maxSpawnDepth : DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH);
+	const parentLabel = childDepth >= 2 ? "parent orchestrator" : "main agent";
+	const lines = [
+		"# Subagent Context",
+		"",
+		`You are a **subagent** spawned by the ${parentLabel} for a specific task.`,
+		"",
+		"## Your Role",
+		`- You were created to handle: ${taskText}`,
+		"- Complete this task. That's your entire purpose.",
+		`- You are NOT the ${parentLabel}. Don't try to be.`,
+		"",
+		"## Rules",
+		"1. **Stay focused** - Do your assigned task, nothing else",
+		`2. **Complete the task** - Your final message will be automatically reported to the ${parentLabel}`,
+		"3. **Don't initiate** - No heartbeats, no proactive actions, no side quests",
+		"4. **Be ephemeral** - You may be terminated after task completion. That's fine.",
+		"5. **Trust push-based completion** - Descendant results are auto-announced back to you; do not busy-poll for status.",
+		"6. **Recover from compacted/truncated tool output** - If you see `[compacted: tool output removed to free context]` or `[truncated: output exceeded context limit]`, assume prior output was reduced. Re-read only what you need using smaller chunks (`read` with offset/limit, or targeted `rg`/`head`/`tail`) instead of full-file `cat`.",
+		"",
+		"## Output Format",
+		"When complete, your final response should include:",
+		`- What you accomplished or found`,
+		`- Any relevant details the ${parentLabel} should know`,
+		"- Keep it concise but informative",
+		"",
+		"## What You DON'T Do",
+		`- NO user conversations (that's ${parentLabel}'s job)`,
+		"- NO external messages (email, tweets, etc.) unless explicitly tasked with a specific recipient/channel",
+		"- NO cron jobs or persistent state",
+		`- NO pretending to be the ${parentLabel}`,
+		`- Only use the \`message\` tool when explicitly instructed to contact a specific external recipient; otherwise return plain text and let the ${parentLabel} deliver it`,
+		""
+	];
+	if (canSpawn) lines.push("## Sub-Agent Spawning", "You CAN spawn your own sub-agents for parallel or complex work using `sessions_spawn`.", "Use the `subagents` tool to steer, kill, or do an on-demand status check for your spawned sub-agents.", "Your sub-agents will announce their results back to you automatically (not to the main agent).", "Default workflow: spawn work, continue orchestrating, and wait for auto-announced completions.", "Do NOT repeatedly poll `subagents list` in a loop unless you are actively debugging or intervening.", "Coordinate their work and synthesize results before reporting back.", "");
+	else if (childDepth >= 2) lines.push("## Sub-Agent Spawning", "You are a leaf worker and CANNOT spawn further sub-agents. Focus on your assigned task.", "");
+	lines.push("## Session Context", ...[
+		params.label ? `- Label: ${params.label}` : void 0,
+		params.requesterSessionKey ? `- Requester session: ${params.requesterSessionKey}.` : void 0,
+		params.requesterOrigin?.channel ? `- Requester channel: ${params.requesterOrigin.channel}.` : void 0,
+		`- Your session: ${params.childSessionKey}.`
+	].filter((line) => line !== void 0), "");
+	return lines.join("\n");
+}
+function buildAnnounceReplyInstruction(params) {
+	if (params.remainingActiveSubagentRuns > 0) {
+		const activeRunsLabel = params.remainingActiveSubagentRuns === 1 ? "run" : "runs";
+		return `There are still ${params.remainingActiveSubagentRuns} active subagent ${activeRunsLabel} for this session. If they are part of the same workflow, wait for the remaining results before sending a user update. If they are unrelated, respond normally using only the result above.`;
+	}
+	if (params.requesterIsSubagent) return `Convert this completion into a concise internal orchestration update for your parent agent in your own words. Keep this internal context private (don't mention system/log/stats/session details or announce type). If this result is duplicate or no update is needed, reply ONLY: ${SILENT_REPLY_TOKEN}.`;
+	if (params.expectsCompletionMessage) return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type).`;
+	return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type), and do not copy the system message verbatim. Reply ONLY: ${SILENT_REPLY_TOKEN} if this exact result was already delivered to the user in this same turn.`;
+}
+async function runSubagentAnnounceFlow(params) {
+	let didAnnounce = false;
+	const expectsCompletionMessage = params.expectsCompletionMessage === true;
+	let shouldDeleteChildSession = params.cleanup === "delete";
+	try {
+		let targetRequesterSessionKey = params.requesterSessionKey;
+		let targetRequesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
+		const childSessionId = (() => {
+			const entry = loadSessionEntryByKey(params.childSessionKey);
+			return typeof entry?.sessionId === "string" && entry.sessionId.trim() ? entry.sessionId.trim() : void 0;
+		})();
+		const settleTimeoutMs = Math.min(Math.max(params.timeoutMs, 1), 12e4);
+		let reply = params.roundOneReply;
+		let outcome = params.outcome;
+		if (!reply && params.waitForCompletion !== false) {
+			const waitMs = settleTimeoutMs;
+			const wait = await callGateway({
+				method: "agent.wait",
+				params: {
+					runId: params.childRunId,
+					timeoutMs: waitMs
+				},
+				timeoutMs: waitMs + 2e3
+			});
+			const waitError = typeof wait?.error === "string" ? wait.error : void 0;
+			if (wait?.status === "timeout") outcome = { status: "timeout" };
+			else if (wait?.status === "error") outcome = {
+				status: "error",
+				error: waitError
+			};
+			else if (wait?.status === "ok") outcome = { status: "ok" };
+			if (typeof wait?.startedAt === "number" && !params.startedAt) params.startedAt = wait.startedAt;
+			if (typeof wait?.endedAt === "number" && !params.endedAt) params.endedAt = wait.endedAt;
+			if (wait?.status === "timeout") {
+				if (!outcome) outcome = { status: "timeout" };
+			}
+			reply = await readLatestSubagentOutput(params.childSessionKey);
+		}
+		if (!reply) reply = await readLatestSubagentOutput(params.childSessionKey);
+		if (!reply?.trim()) reply = await readLatestSubagentOutputWithRetry({
+			sessionKey: params.childSessionKey,
+			maxWaitMs: params.timeoutMs
+		});
+		if (isAnnounceSkip(reply)) return true;
+		if (!outcome) outcome = { status: "unknown" };
+		let requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
+		let activeChildDescendantRuns = 0;
+		try {
+			const { countActiveDescendantRuns } = await Promise.resolve().then(() => subagent_registry_exports);
+			activeChildDescendantRuns = Math.max(0, countActiveDescendantRuns(params.childSessionKey));
+		} catch {}
+		if (activeChildDescendantRuns > 0) {
+			shouldDeleteChildSession = false;
+			return false;
+		}
+		if (requesterDepth >= 1 && reply?.trim()) {
+			const minReplyChangeWaitMs = FAST_TEST_MODE ? FAST_TEST_REPLY_CHANGE_WAIT_MS : 250;
+			reply = await waitForSubagentOutputChange({
+				sessionKey: params.childSessionKey,
+				baselineReply: reply,
+				maxWaitMs: Math.max(minReplyChangeWaitMs, Math.min(params.timeoutMs, 2e3))
+			});
+		}
+		const statusLabel = outcome.status === "ok" ? "completed successfully" : outcome.status === "timeout" ? "timed out" : outcome.status === "error" ? `failed: ${outcome.error || "unknown error"}` : "finished with unknown status";
+		const announceType = params.announceType ?? "subagent task";
+		const taskLabel = params.label || params.task || "task";
+		const subagentName = resolveAgentIdFromSessionKey(params.childSessionKey);
+		const announceSessionId = childSessionId || "unknown";
+		const findings = reply || "(no output)";
+		let completionMessage = "";
+		let triggerMessage = "";
+		let requesterIsSubagent = requesterDepth >= 1;
+		if (requesterIsSubagent) {
+			const { isSubagentSessionRunActive, resolveRequesterForChildSession } = await Promise.resolve().then(() => subagent_registry_exports);
+			if (!isSubagentSessionRunActive(targetRequesterSessionKey)) {
+				const parentSessionEntry = loadSessionEntryByKey(targetRequesterSessionKey);
+				if (!(parentSessionEntry && typeof parentSessionEntry.sessionId === "string" && parentSessionEntry.sessionId.trim())) {
+					const fallback = resolveRequesterForChildSession(targetRequesterSessionKey);
+					if (!fallback?.requesterSessionKey) {
+						shouldDeleteChildSession = false;
+						return false;
+					}
+					targetRequesterSessionKey = fallback.requesterSessionKey;
+					targetRequesterOrigin = normalizeDeliveryContext(fallback.requesterOrigin) ?? targetRequesterOrigin;
+					requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
+					requesterIsSubagent = requesterDepth >= 1;
+				}
+			}
+		}
+		let remainingActiveSubagentRuns = 0;
+		try {
+			const { countActiveDescendantRuns } = await Promise.resolve().then(() => subagent_registry_exports);
+			remainingActiveSubagentRuns = Math.max(0, countActiveDescendantRuns(targetRequesterSessionKey));
+		} catch {}
+		const replyInstruction = buildAnnounceReplyInstruction({
+			remainingActiveSubagentRuns,
+			requesterIsSubagent,
+			announceType,
+			expectsCompletionMessage
+		});
+		const statsLine = await buildCompactAnnounceStatsLine({
+			sessionKey: params.childSessionKey,
+			startedAt: params.startedAt,
+			endedAt: params.endedAt
+		});
+		completionMessage = buildCompletionDeliveryMessage({
+			findings,
+			subagentName,
+			spawnMode: params.spawnMode,
+			outcome
+		});
+		triggerMessage = [
+			[
+				`[System Message] [sessionId: ${announceSessionId}] A ${announceType} "${taskLabel}" just ${statusLabel}.`,
+				"",
+				"Result:",
+				findings,
+				"",
+				statsLine
+			].join("\n"),
+			"",
+			replyInstruction
+		].join("\n");
+		const announceId = buildAnnounceIdFromChildRun({
+			childSessionKey: params.childSessionKey,
+			childRunId: params.childRunId
+		});
+		let directOrigin = targetRequesterOrigin;
+		if (!requesterIsSubagent) {
+			const { entry } = loadRequesterSessionEntry(targetRequesterSessionKey);
+			directOrigin = resolveAnnounceOrigin(entry, targetRequesterOrigin);
+		}
+		const completionResolution = expectsCompletionMessage && !requesterIsSubagent ? await resolveSubagentCompletionOrigin({
+			childSessionKey: params.childSessionKey,
+			requesterSessionKey: targetRequesterSessionKey,
+			requesterOrigin: directOrigin,
+			childRunId: params.childRunId,
+			spawnMode: params.spawnMode,
+			expectsCompletionMessage
+		}) : {
+			origin: targetRequesterOrigin,
+			routeMode: "fallback"
+		};
+		const completionDirectOrigin = completionResolution.origin;
+		const directIdempotencyKey = buildAnnounceIdempotencyKey(announceId);
+		const delivery = await deliverSubagentAnnouncement({
+			requesterSessionKey: targetRequesterSessionKey,
+			announceId,
+			triggerMessage,
+			completionMessage,
+			summaryLine: taskLabel,
+			requesterOrigin: expectsCompletionMessage && !requesterIsSubagent ? completionDirectOrigin : targetRequesterOrigin,
+			completionDirectOrigin,
+			directOrigin,
+			targetRequesterSessionKey,
+			requesterIsSubagent,
+			expectsCompletionMessage,
+			bestEffortDeliver: params.bestEffortDeliver,
+			completionRouteMode: completionResolution.routeMode,
+			spawnMode: params.spawnMode,
+			directIdempotencyKey,
+			signal: params.signal
+		});
+		didAnnounce = delivery.delivered;
+		if (!delivery.delivered && delivery.path === "direct" && delivery.error) defaultRuntime.error?.(`Subagent completion direct announce failed for run ${params.childRunId}: ${delivery.error}`);
+	} catch (err) {
+		defaultRuntime.error?.(`Subagent announce failed: ${String(err)}`);
+	} finally {
+		if (params.label) try {
+			await callGateway({
+				method: "sessions.patch",
+				params: {
+					key: params.childSessionKey,
+					label: params.label
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+		if (shouldDeleteChildSession) try {
+			await callGateway({
+				method: "sessions.delete",
+				params: {
+					key: params.childSessionKey,
+					deleteTranscript: true,
+					emitLifecycleHooks: false
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+	}
+	return didAnnounce;
+}
+
+//#endregion
+//#region src/agents/subagent-lifecycle-events.ts
+const SUBAGENT_TARGET_KIND_SUBAGENT = "subagent";
+const SUBAGENT_ENDED_REASON_COMPLETE = "subagent-complete";
+const SUBAGENT_ENDED_REASON_ERROR = "subagent-error";
+const SUBAGENT_ENDED_REASON_KILLED = "subagent-killed";
+const SUBAGENT_ENDED_OUTCOME_OK = "ok";
+const SUBAGENT_ENDED_OUTCOME_ERROR = "error";
+const SUBAGENT_ENDED_OUTCOME_TIMEOUT = "timeout";
+const SUBAGENT_ENDED_OUTCOME_KILLED = "killed";
+
+//#endregion
+//#region src/agents/subagent-registry-cleanup.ts
+function resolveCleanupCompletionReason(entry) {
+	return entry.endedReason ?? SUBAGENT_ENDED_REASON_COMPLETE;
+}
+function resolveEndedAgoMs(entry, now) {
+	return typeof entry.endedAt === "number" ? now - entry.endedAt : 0;
+}
+function resolveDeferredCleanupDecision(params) {
+	const endedAgo = resolveEndedAgoMs(params.entry, params.now);
+	if (params.entry.expectsCompletionMessage === true && params.activeDescendantRuns > 0) {
+		if (endedAgo > params.announceExpiryMs) return {
+			kind: "give-up",
+			reason: "expiry"
+		};
+		return {
+			kind: "defer-descendants",
+			delayMs: params.deferDescendantDelayMs
+		};
+	}
+	const retryCount = (params.entry.announceRetryCount ?? 0) + 1;
+	if (retryCount >= params.maxAnnounceRetryCount || endedAgo > params.announceExpiryMs) return {
+		kind: "give-up",
+		reason: retryCount >= params.maxAnnounceRetryCount ? "retry-limit" : "expiry",
+		retryCount
+	};
+	return {
+		kind: "retry",
+		retryCount,
+		resumeDelayMs: params.entry.expectsCompletionMessage === true ? params.resolveAnnounceRetryDelayMs(retryCount) : void 0
+	};
+}
+
+//#endregion
+//#region src/agents/subagent-registry-completion.ts
+function runOutcomesEqual(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	if (a.status !== b.status) return false;
+	if (a.status === "error" && b.status === "error") return (a.error ?? "") === (b.error ?? "");
+	return true;
+}
+function resolveLifecycleOutcomeFromRunOutcome(outcome) {
+	if (outcome?.status === "error") return SUBAGENT_ENDED_OUTCOME_ERROR;
+	if (outcome?.status === "timeout") return SUBAGENT_ENDED_OUTCOME_TIMEOUT;
+	return SUBAGENT_ENDED_OUTCOME_OK;
+}
+async function emitSubagentEndedHookOnce(params) {
+	const runId = params.entry.runId.trim();
+	if (!runId) return false;
+	if (params.entry.endedHookEmittedAt) return false;
+	if (params.inFlightRunIds.has(runId)) return false;
+	params.inFlightRunIds.add(runId);
+	try {
+		const hookRunner = getGlobalHookRunner();
+		if (hookRunner?.hasHooks("subagent_ended")) await hookRunner.runSubagentEnded({
+			targetSessionKey: params.entry.childSessionKey,
+			targetKind: SUBAGENT_TARGET_KIND_SUBAGENT,
+			reason: params.reason,
+			sendFarewell: params.sendFarewell,
+			accountId: params.accountId,
+			runId: params.entry.runId,
+			endedAt: params.entry.endedAt,
+			outcome: params.outcome,
+			error: params.error
+		}, {
+			runId: params.entry.runId,
+			childSessionKey: params.entry.childSessionKey,
+			requesterSessionKey: params.entry.requesterSessionKey
+		});
+		params.entry.endedHookEmittedAt = Date.now();
+		params.persist();
+		return true;
+	} catch {
+		return false;
+	} finally {
+		params.inFlightRunIds.delete(runId);
+	}
+}
+
+//#endregion
+//#region src/agents/subagent-registry-queries.ts
+function findRunIdsByChildSessionKeyFromRuns(runs, childSessionKey) {
+	const key = childSessionKey.trim();
+	if (!key) return [];
+	const runIds = [];
+	for (const [runId, entry] of runs.entries()) if (entry.childSessionKey === key) runIds.push(runId);
+	return runIds;
+}
+function listRunsForRequesterFromRuns(runs, requesterSessionKey) {
+	const key = requesterSessionKey.trim();
+	if (!key) return [];
+	return [...runs.values()].filter((entry) => entry.requesterSessionKey === key);
+}
+function resolveRequesterForChildSessionFromRuns(runs, childSessionKey) {
+	const key = childSessionKey.trim();
+	if (!key) return null;
+	let best;
+	for (const entry of runs.values()) {
+		if (entry.childSessionKey !== key) continue;
+		if (!best || entry.createdAt > best.createdAt) best = entry;
+	}
+	if (!best) return null;
+	return {
+		requesterSessionKey: best.requesterSessionKey,
+		requesterOrigin: best.requesterOrigin
+	};
+}
+function countActiveRunsForSessionFromRuns(runs, requesterSessionKey) {
+	const key = requesterSessionKey.trim();
+	if (!key) return 0;
+	let count = 0;
+	for (const entry of runs.values()) {
+		if (entry.requesterSessionKey !== key) continue;
+		if (typeof entry.endedAt === "number") continue;
+		count += 1;
+	}
+	return count;
+}
+function countActiveDescendantRunsFromRuns(runs, rootSessionKey) {
+	const root = rootSessionKey.trim();
+	if (!root) return 0;
+	const pending = [root];
+	const visited = new Set([root]);
+	let count = 0;
+	while (pending.length > 0) {
+		const requester = pending.shift();
+		if (!requester) continue;
+		for (const entry of runs.values()) {
+			if (entry.requesterSessionKey !== requester) continue;
+			if (typeof entry.endedAt !== "number") count += 1;
+			const childKey = entry.childSessionKey.trim();
+			if (!childKey || visited.has(childKey)) continue;
+			visited.add(childKey);
+			pending.push(childKey);
+		}
+	}
+	return count;
+}
+function listDescendantRunsForRequesterFromRuns(runs, rootSessionKey) {
+	const root = rootSessionKey.trim();
+	if (!root) return [];
+	const pending = [root];
+	const visited = new Set([root]);
+	const descendants = [];
+	while (pending.length > 0) {
+		const requester = pending.shift();
+		if (!requester) continue;
+		for (const entry of runs.values()) {
+			if (entry.requesterSessionKey !== requester) continue;
+			descendants.push(entry);
+			const childKey = entry.childSessionKey.trim();
+			if (!childKey || visited.has(childKey)) continue;
+			visited.add(childKey);
+			pending.push(childKey);
+		}
+	}
+	return descendants;
+}
+
+//#endregion
+//#region src/agents/subagent-registry.store.ts
+const REGISTRY_VERSION = 2;
+function resolveSubagentStateDir(env = process.env) {
+	if (env.REMOTECLAW_STATE_DIR?.trim()) return resolveStateDir(env);
+	if (env.VITEST || env.NODE_ENV === "test") return path.join(os.tmpdir(), "remoteclaw-test-state", String(process.pid));
+	return resolveStateDir(env);
+}
+function resolveSubagentRegistryPath() {
+	return path.join(resolveSubagentStateDir(process.env), "subagents", "runs.json");
+}
+function loadSubagentRegistryFromDisk() {
+	const raw = loadJsonFile(resolveSubagentRegistryPath());
+	if (!raw || typeof raw !== "object") return /* @__PURE__ */ new Map();
+	const record = raw;
+	if (record.version !== 1 && record.version !== 2) return /* @__PURE__ */ new Map();
+	const runsRaw = record.runs;
+	if (!runsRaw || typeof runsRaw !== "object") return /* @__PURE__ */ new Map();
+	const out = /* @__PURE__ */ new Map();
+	const isLegacy = record.version === 1;
+	let migrated = false;
+	for (const [runId, entry] of Object.entries(runsRaw)) {
+		if (!entry || typeof entry !== "object") continue;
+		const typed = entry;
+		if (!typed.runId || typeof typed.runId !== "string") continue;
+		const legacyCompletedAt = isLegacy && typeof typed.announceCompletedAt === "number" ? typed.announceCompletedAt : void 0;
+		const cleanupCompletedAt = typeof typed.cleanupCompletedAt === "number" ? typed.cleanupCompletedAt : legacyCompletedAt;
+		const cleanupHandled = typeof typed.cleanupHandled === "boolean" ? typed.cleanupHandled : isLegacy ? Boolean(typed.announceHandled ?? cleanupCompletedAt) : void 0;
+		const requesterOrigin = normalizeDeliveryContext(typed.requesterOrigin ?? {
+			channel: typeof typed.requesterChannel === "string" ? typed.requesterChannel : void 0,
+			accountId: typeof typed.requesterAccountId === "string" ? typed.requesterAccountId : void 0
+		});
+		const { announceCompletedAt: _announceCompletedAt, announceHandled: _announceHandled, requesterChannel: _channel, requesterAccountId: _accountId, ...rest } = typed;
+		out.set(runId, {
+			...rest,
+			requesterOrigin,
+			cleanupCompletedAt,
+			cleanupHandled,
+			spawnMode: typed.spawnMode === "session" ? "session" : "run"
+		});
+		if (isLegacy) migrated = true;
+	}
+	if (migrated) try {
+		saveSubagentRegistryToDisk(out);
+	} catch {}
+	return out;
+}
+function saveSubagentRegistryToDisk(runs) {
+	const pathname = resolveSubagentRegistryPath();
+	const serialized = {};
+	for (const [runId, entry] of runs.entries()) serialized[runId] = entry;
+	saveJsonFile(pathname, {
+		version: REGISTRY_VERSION,
+		runs: serialized
+	});
+}
+
+//#endregion
+//#region src/agents/subagent-registry-state.ts
+function persistSubagentRunsToDisk(runs) {
+	try {
+		saveSubagentRegistryToDisk(runs);
+	} catch {}
+}
+function restoreSubagentRunsFromDisk(params) {
+	const restored = loadSubagentRegistryFromDisk();
+	if (restored.size === 0) return 0;
+	let added = 0;
+	for (const [runId, entry] of restored.entries()) {
+		if (!runId || !entry) continue;
+		if (params.mergeOnly && params.runs.has(runId)) continue;
+		params.runs.set(runId, entry);
+		added += 1;
+	}
+	return added;
+}
+function getSubagentRunsSnapshotForRead(inMemoryRuns) {
+	const merged = /* @__PURE__ */ new Map();
+	if (!(process.env.VITEST || false)) try {
+		for (const [runId, entry] of loadSubagentRegistryFromDisk().entries()) merged.set(runId, entry);
+	} catch {}
+	for (const [runId, entry] of inMemoryRuns.entries()) merged.set(runId, entry);
+	return merged;
+}
+
+//#endregion
+//#region src/agents/subagent-registry.ts
+var subagent_registry_exports = /* @__PURE__ */ __exportAll({
+	clearSubagentRunSteerRestart: () => clearSubagentRunSteerRestart,
+	countActiveDescendantRuns: () => countActiveDescendantRuns,
+	countActiveRunsForSession: () => countActiveRunsForSession,
+	initSubagentRegistry: () => initSubagentRegistry,
+	isSubagentSessionRunActive: () => isSubagentSessionRunActive,
+	listDescendantRunsForRequester: () => listDescendantRunsForRequester,
+	listSubagentRunsForRequester: () => listSubagentRunsForRequester,
+	markSubagentRunForSteerRestart: () => markSubagentRunForSteerRestart,
+	markSubagentRunTerminated: () => markSubagentRunTerminated,
+	registerSubagentRun: () => registerSubagentRun,
+	replaceSubagentRunAfterSteer: () => replaceSubagentRunAfterSteer,
+	resolveRequesterForChildSession: () => resolveRequesterForChildSession
+});
+const subagentRuns = /* @__PURE__ */ new Map();
+let sweeper = null;
+let listenerStarted = false;
+let listenerStop = null;
+var restoreAttempted = false;
+const SUBAGENT_ANNOUNCE_TIMEOUT_MS = 12e4;
+const MIN_ANNOUNCE_RETRY_DELAY_MS = 1e3;
+const MAX_ANNOUNCE_RETRY_DELAY_MS = 8e3;
+/**
+* Maximum number of announce delivery attempts before giving up.
+* Prevents infinite retry loops when `runSubagentAnnounceFlow` repeatedly
+* returns `false` due to stale state or transient conditions (#18264).
+*/
+const MAX_ANNOUNCE_RETRY_COUNT = 3;
+/**
+* Announce entries older than this are force-expired even if delivery never
+* succeeded. Guards against stale registry entries surviving gateway restarts.
+*/
+const ANNOUNCE_EXPIRY_MS = 5 * 6e4;
+function resolveAnnounceRetryDelayMs(retryCount) {
+	const boundedRetryCount = Math.max(0, Math.min(retryCount, 10));
+	const baseDelay = MIN_ANNOUNCE_RETRY_DELAY_MS * 2 ** Math.max(0, boundedRetryCount - 1);
+	return Math.min(baseDelay, MAX_ANNOUNCE_RETRY_DELAY_MS);
+}
+function logAnnounceGiveUp(entry, reason) {
+	const retryCount = entry.announceRetryCount ?? 0;
+	const endedAgoMs = typeof entry.endedAt === "number" ? Math.max(0, Date.now() - entry.endedAt) : void 0;
+	const endedAgoLabel = endedAgoMs != null ? `${Math.round(endedAgoMs / 1e3)}s` : "n/a";
+	defaultRuntime.log(`[warn] Subagent announce give up (${reason}) run=${entry.runId} child=${entry.childSessionKey} requester=${entry.requesterSessionKey} retries=${retryCount} endedAgo=${endedAgoLabel}`);
+}
+function persistSubagentRuns() {
+	persistSubagentRunsToDisk(subagentRuns);
+}
+function findSessionEntryByKey(store, sessionKey) {
+	const direct = store[sessionKey];
+	if (direct) return direct;
+	const normalized = sessionKey.toLowerCase();
+	for (const [key, entry] of Object.entries(store)) if (key.toLowerCase() === normalized) return entry;
+}
+function resolveSubagentRunOrphanReason(params) {
+	const childSessionKey = params.entry.childSessionKey?.trim();
+	if (!childSessionKey) return "missing-session-entry";
+	try {
+		const cfg = loadConfig();
+		const agentId = resolveAgentIdFromSessionKey(childSessionKey);
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		let store = params.storeCache?.get(storePath);
+		if (!store) {
+			store = loadSessionStore(storePath);
+			params.storeCache?.set(storePath, store);
+		}
+		const sessionEntry = findSessionEntryByKey(store, childSessionKey);
+		if (!sessionEntry) return "missing-session-entry";
+		if (typeof sessionEntry.sessionId !== "string" || !sessionEntry.sessionId.trim()) return "missing-session-id";
+		return null;
+	} catch {
+		return null;
+	}
+}
+function reconcileOrphanedRun(params) {
+	const now = Date.now();
+	let changed = false;
+	if (typeof params.entry.endedAt !== "number") {
+		params.entry.endedAt = now;
+		changed = true;
+	}
+	const orphanOutcome = {
+		status: "error",
+		error: `orphaned subagent run (${params.reason})`
+	};
+	if (!runOutcomesEqual(params.entry.outcome, orphanOutcome)) {
+		params.entry.outcome = orphanOutcome;
+		changed = true;
+	}
+	if (params.entry.endedReason !== SUBAGENT_ENDED_REASON_ERROR) {
+		params.entry.endedReason = SUBAGENT_ENDED_REASON_ERROR;
+		changed = true;
+	}
+	if (params.entry.cleanupHandled !== true) {
+		params.entry.cleanupHandled = true;
+		changed = true;
+	}
+	if (typeof params.entry.cleanupCompletedAt !== "number") {
+		params.entry.cleanupCompletedAt = now;
+		changed = true;
+	}
+	const removed = subagentRuns.delete(params.runId);
+	resumedRuns.delete(params.runId);
+	if (!removed && !changed) return false;
+	defaultRuntime.log(`[warn] Subagent orphan run pruned source=${params.source} run=${params.runId} child=${params.entry.childSessionKey} reason=${params.reason}`);
+	return true;
+}
+function reconcileOrphanedRestoredRuns() {
+	const storeCache = /* @__PURE__ */ new Map();
+	let changed = false;
+	for (const [runId, entry] of subagentRuns.entries()) {
+		const orphanReason = resolveSubagentRunOrphanReason({
+			entry,
+			storeCache
+		});
+		if (!orphanReason) continue;
+		if (reconcileOrphanedRun({
+			runId,
+			entry,
+			reason: orphanReason,
+			source: "restore"
+		})) changed = true;
+	}
+	return changed;
+}
+const resumedRuns = /* @__PURE__ */ new Set();
+const endedHookInFlightRunIds = /* @__PURE__ */ new Set();
+function suppressAnnounceForSteerRestart(entry) {
+	return entry?.suppressAnnounceReason === "steer-restart";
+}
+function shouldKeepThreadBindingAfterRun(params) {
+	if (params.reason === SUBAGENT_ENDED_REASON_KILLED) return false;
+	return params.entry.spawnMode === "session";
+}
+function shouldEmitEndedHookForRun(params) {
+	return !shouldKeepThreadBindingAfterRun(params);
+}
+async function emitSubagentEndedHookForRun(params) {
+	const reason = params.reason ?? params.entry.endedReason ?? SUBAGENT_ENDED_REASON_COMPLETE;
+	const outcome = resolveLifecycleOutcomeFromRunOutcome(params.entry.outcome);
+	const error = params.entry.outcome?.status === "error" ? params.entry.outcome.error : void 0;
+	await emitSubagentEndedHookOnce({
+		entry: params.entry,
+		reason,
+		sendFarewell: params.sendFarewell,
+		accountId: params.accountId ?? params.entry.requesterOrigin?.accountId,
+		outcome,
+		error,
+		inFlightRunIds: endedHookInFlightRunIds,
+		persist: persistSubagentRuns
+	});
+}
+async function completeSubagentRun(params) {
+	const entry = subagentRuns.get(params.runId);
+	if (!entry) return;
+	let mutated = false;
+	const endedAt = typeof params.endedAt === "number" ? params.endedAt : Date.now();
+	if (entry.endedAt !== endedAt) {
+		entry.endedAt = endedAt;
+		mutated = true;
+	}
+	if (!runOutcomesEqual(entry.outcome, params.outcome)) {
+		entry.outcome = params.outcome;
+		mutated = true;
+	}
+	if (entry.endedReason !== params.reason) {
+		entry.endedReason = params.reason;
+		mutated = true;
+	}
+	if (mutated) persistSubagentRuns();
+	const suppressedForSteerRestart = suppressAnnounceForSteerRestart(entry);
+	const shouldEmitEndedHook = !suppressedForSteerRestart && shouldEmitEndedHookForRun({
+		entry,
+		reason: params.reason
+	});
+	if (!(shouldEmitEndedHook && params.triggerCleanup && entry.expectsCompletionMessage === true && !suppressedForSteerRestart) && shouldEmitEndedHook) await emitSubagentEndedHookForRun({
+		entry,
+		reason: params.reason,
+		sendFarewell: params.sendFarewell,
+		accountId: params.accountId
+	});
+	if (!params.triggerCleanup) return;
+	if (suppressedForSteerRestart) return;
+	startSubagentAnnounceCleanupFlow(params.runId, entry);
+}
+function startSubagentAnnounceCleanupFlow(runId, entry) {
+	if (!beginSubagentCleanup(runId)) return false;
+	const requesterOrigin = normalizeDeliveryContext(entry.requesterOrigin);
+	runSubagentAnnounceFlow({
+		childSessionKey: entry.childSessionKey,
+		childRunId: entry.runId,
+		requesterSessionKey: entry.requesterSessionKey,
+		requesterOrigin,
+		requesterDisplayKey: entry.requesterDisplayKey,
+		task: entry.task,
+		timeoutMs: SUBAGENT_ANNOUNCE_TIMEOUT_MS,
+		cleanup: entry.cleanup,
+		waitForCompletion: false,
+		startedAt: entry.startedAt,
+		endedAt: entry.endedAt,
+		label: entry.label,
+		outcome: entry.outcome,
+		spawnMode: entry.spawnMode,
+		expectsCompletionMessage: entry.expectsCompletionMessage
+	}).then((didAnnounce) => {
+		finalizeSubagentCleanup(runId, entry.cleanup, didAnnounce);
+	});
+	return true;
+}
+function resumeSubagentRun(runId) {
+	if (!runId || resumedRuns.has(runId)) return;
+	const entry = subagentRuns.get(runId);
+	if (!entry) return;
+	const orphanReason = resolveSubagentRunOrphanReason({ entry });
+	if (orphanReason) {
+		if (reconcileOrphanedRun({
+			runId,
+			entry,
+			reason: orphanReason,
+			source: "resume"
+		})) persistSubagentRuns();
+		return;
+	}
+	if (entry.cleanupCompletedAt) return;
+	if ((entry.announceRetryCount ?? 0) >= MAX_ANNOUNCE_RETRY_COUNT) {
+		logAnnounceGiveUp(entry, "retry-limit");
+		entry.cleanupCompletedAt = Date.now();
+		persistSubagentRuns();
+		return;
+	}
+	if (typeof entry.endedAt === "number" && Date.now() - entry.endedAt > ANNOUNCE_EXPIRY_MS) {
+		logAnnounceGiveUp(entry, "expiry");
+		entry.cleanupCompletedAt = Date.now();
+		persistSubagentRuns();
+		return;
+	}
+	const now = Date.now();
+	const delayMs = resolveAnnounceRetryDelayMs(entry.announceRetryCount ?? 0);
+	const earliestRetryAt = (entry.lastAnnounceRetryAt ?? 0) + delayMs;
+	if (entry.expectsCompletionMessage === true && entry.lastAnnounceRetryAt && now < earliestRetryAt) {
+		const waitMs = Math.max(1, earliestRetryAt - now);
+		setTimeout(() => {
+			resumeSubagentRun(runId);
+		}, waitMs).unref?.();
+		resumedRuns.add(runId);
+		return;
+	}
+	if (typeof entry.endedAt === "number" && entry.endedAt > 0) {
+		if (suppressAnnounceForSteerRestart(entry)) {
+			resumedRuns.add(runId);
+			return;
+		}
+		if (!startSubagentAnnounceCleanupFlow(runId, entry)) return;
+		resumedRuns.add(runId);
+		return;
+	}
+	waitForSubagentCompletion(runId, resolveSubagentWaitTimeoutMs(loadConfig(), entry.runTimeoutSeconds));
+	resumedRuns.add(runId);
+}
+function restoreSubagentRunsOnce() {
+	if (restoreAttempted) return;
+	restoreAttempted = true;
+	try {
+		if (restoreSubagentRunsFromDisk({
+			runs: subagentRuns,
+			mergeOnly: true
+		}) === 0) return;
+		if (reconcileOrphanedRestoredRuns()) persistSubagentRuns();
+		if (subagentRuns.size === 0) return;
+		ensureListener();
+		if ([...subagentRuns.values()].some((entry) => entry.archiveAtMs)) startSweeper();
+		for (const runId of subagentRuns.keys()) resumeSubagentRun(runId);
+	} catch {}
+}
+function resolveArchiveAfterMs(cfg) {
+	const minutes = (cfg ?? loadConfig()).agents?.defaults?.subagents?.archiveAfterMinutes ?? 60;
+	if (!Number.isFinite(minutes) || minutes <= 0) return;
+	return Math.max(1, Math.floor(minutes)) * 6e4;
+}
+function resolveSubagentWaitTimeoutMs(cfg, runTimeoutSeconds) {
+	return resolveAgentTimeoutMs({
+		cfg,
+		overrideSeconds: runTimeoutSeconds ?? 0
+	});
+}
+function startSweeper() {
+	if (sweeper) return;
+	sweeper = setInterval(() => {
+		sweepSubagentRuns();
+	}, 6e4);
+	sweeper.unref?.();
+}
+function stopSweeper() {
+	if (!sweeper) return;
+	clearInterval(sweeper);
+	sweeper = null;
+}
+async function sweepSubagentRuns() {
+	const now = Date.now();
+	let mutated = false;
+	for (const [runId, entry] of subagentRuns.entries()) {
+		if (!entry.archiveAtMs || entry.archiveAtMs > now) continue;
+		subagentRuns.delete(runId);
+		mutated = true;
+		try {
+			await callGateway({
+				method: "sessions.delete",
+				params: {
+					key: entry.childSessionKey,
+					deleteTranscript: true,
+					emitLifecycleHooks: false
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+	}
+	if (mutated) persistSubagentRuns();
+	if (subagentRuns.size === 0) stopSweeper();
+}
+function ensureListener() {
+	if (listenerStarted) return;
+	listenerStarted = true;
+	listenerStop = onAgentEvent((evt) => {
+		(async () => {
+			if (!evt || evt.stream !== "lifecycle") return;
+			const entry = subagentRuns.get(evt.runId);
+			if (!entry) return;
+			const phase = evt.data?.phase;
+			if (phase === "start") {
+				const startedAt = typeof evt.data?.startedAt === "number" ? evt.data.startedAt : void 0;
+				if (startedAt) {
+					entry.startedAt = startedAt;
+					persistSubagentRuns();
+				}
+				return;
+			}
+			if (phase !== "end" && phase !== "error") return;
+			const endedAt = typeof evt.data?.endedAt === "number" ? evt.data.endedAt : Date.now();
+			const error = typeof evt.data?.error === "string" ? evt.data.error : void 0;
+			const outcome = phase === "error" ? {
+				status: "error",
+				error
+			} : evt.data?.aborted ? { status: "timeout" } : { status: "ok" };
+			await completeSubagentRun({
+				runId: evt.runId,
+				endedAt,
+				outcome,
+				reason: phase === "error" ? SUBAGENT_ENDED_REASON_ERROR : SUBAGENT_ENDED_REASON_COMPLETE,
+				sendFarewell: true,
+				accountId: entry.requesterOrigin?.accountId,
+				triggerCleanup: true
+			});
+		})();
+	});
+}
+async function finalizeSubagentCleanup(runId, cleanup, didAnnounce) {
+	const entry = subagentRuns.get(runId);
+	if (!entry) return;
+	if (didAnnounce) {
+		await emitCompletionEndedHookIfNeeded(entry, resolveCleanupCompletionReason(entry));
+		completeCleanupBookkeeping({
+			runId,
+			entry,
+			cleanup,
+			completedAt: Date.now()
+		});
+		return;
+	}
+	const now = Date.now();
+	const deferredDecision = resolveDeferredCleanupDecision({
+		entry,
+		now,
+		activeDescendantRuns: Math.max(0, countActiveDescendantRuns(entry.childSessionKey)),
+		announceExpiryMs: ANNOUNCE_EXPIRY_MS,
+		maxAnnounceRetryCount: MAX_ANNOUNCE_RETRY_COUNT,
+		deferDescendantDelayMs: MIN_ANNOUNCE_RETRY_DELAY_MS,
+		resolveAnnounceRetryDelayMs
+	});
+	if (deferredDecision.kind === "defer-descendants") {
+		entry.lastAnnounceRetryAt = now;
+		entry.cleanupHandled = false;
+		resumedRuns.delete(runId);
+		persistSubagentRuns();
+		setTimeout(() => {
+			resumeSubagentRun(runId);
+		}, deferredDecision.delayMs).unref?.();
+		return;
+	}
+	if (deferredDecision.retryCount != null) {
+		entry.announceRetryCount = deferredDecision.retryCount;
+		entry.lastAnnounceRetryAt = now;
+	}
+	if (deferredDecision.kind === "give-up") {
+		await emitCompletionEndedHookIfNeeded(entry, resolveCleanupCompletionReason(entry));
+		logAnnounceGiveUp(entry, deferredDecision.reason);
+		completeCleanupBookkeeping({
+			runId,
+			entry,
+			cleanup: "keep",
+			completedAt: now
+		});
+		return;
+	}
+	entry.cleanupHandled = false;
+	resumedRuns.delete(runId);
+	persistSubagentRuns();
+	if (deferredDecision.resumeDelayMs == null) return;
+	setTimeout(() => {
+		resumeSubagentRun(runId);
+	}, deferredDecision.resumeDelayMs).unref?.();
+}
+async function emitCompletionEndedHookIfNeeded(entry, reason) {
+	if (entry.expectsCompletionMessage === true && shouldEmitEndedHookForRun({
+		entry,
+		reason
+	})) await emitSubagentEndedHookForRun({
+		entry,
+		reason,
+		sendFarewell: true
+	});
+}
+function completeCleanupBookkeeping(params) {
+	if (params.cleanup === "delete") {
+		subagentRuns.delete(params.runId);
+		persistSubagentRuns();
+		retryDeferredCompletedAnnounces(params.runId);
+		return;
+	}
+	params.entry.cleanupCompletedAt = params.completedAt;
+	persistSubagentRuns();
+	retryDeferredCompletedAnnounces(params.runId);
+}
+function retryDeferredCompletedAnnounces(excludeRunId) {
+	const now = Date.now();
+	for (const [runId, entry] of subagentRuns.entries()) {
+		if (excludeRunId && runId === excludeRunId) continue;
+		if (typeof entry.endedAt !== "number") continue;
+		if (entry.cleanupCompletedAt || entry.cleanupHandled) continue;
+		if (suppressAnnounceForSteerRestart(entry)) continue;
+		if (now - (entry.endedAt ?? now) > ANNOUNCE_EXPIRY_MS) {
+			logAnnounceGiveUp(entry, "expiry");
+			entry.cleanupCompletedAt = now;
+			persistSubagentRuns();
+			continue;
+		}
+		resumedRuns.delete(runId);
+		resumeSubagentRun(runId);
+	}
+}
+function beginSubagentCleanup(runId) {
+	const entry = subagentRuns.get(runId);
+	if (!entry) return false;
+	if (entry.cleanupCompletedAt) return false;
+	if (entry.cleanupHandled) return false;
+	entry.cleanupHandled = true;
+	persistSubagentRuns();
+	return true;
+}
+function markSubagentRunForSteerRestart(runId) {
+	const key = runId.trim();
+	if (!key) return false;
+	const entry = subagentRuns.get(key);
+	if (!entry) return false;
+	if (entry.suppressAnnounceReason === "steer-restart") return true;
+	entry.suppressAnnounceReason = "steer-restart";
+	persistSubagentRuns();
+	return true;
+}
+function clearSubagentRunSteerRestart(runId) {
+	const key = runId.trim();
+	if (!key) return false;
+	const entry = subagentRuns.get(key);
+	if (!entry) return false;
+	if (entry.suppressAnnounceReason !== "steer-restart") return true;
+	entry.suppressAnnounceReason = void 0;
+	persistSubagentRuns();
+	resumedRuns.delete(key);
+	if (typeof entry.endedAt === "number" && !entry.cleanupCompletedAt) resumeSubagentRun(key);
+	return true;
+}
+function replaceSubagentRunAfterSteer(params) {
+	const previousRunId = params.previousRunId.trim();
+	const nextRunId = params.nextRunId.trim();
+	if (!previousRunId || !nextRunId) return false;
+	const source = subagentRuns.get(previousRunId) ?? params.fallback;
+	if (!source) return false;
+	if (previousRunId !== nextRunId) {
+		subagentRuns.delete(previousRunId);
+		resumedRuns.delete(previousRunId);
+	}
+	const now = Date.now();
+	const cfg = loadConfig();
+	const archiveAfterMs = resolveArchiveAfterMs(cfg);
+	const spawnMode = source.spawnMode === "session" ? "session" : "run";
+	const archiveAtMs = spawnMode === "session" ? void 0 : archiveAfterMs ? now + archiveAfterMs : void 0;
+	const runTimeoutSeconds = params.runTimeoutSeconds ?? source.runTimeoutSeconds ?? 0;
+	const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, runTimeoutSeconds);
+	const next = {
+		...source,
+		runId: nextRunId,
+		startedAt: now,
+		endedAt: void 0,
+		endedReason: void 0,
+		endedHookEmittedAt: void 0,
+		outcome: void 0,
+		cleanupCompletedAt: void 0,
+		cleanupHandled: false,
+		suppressAnnounceReason: void 0,
+		announceRetryCount: void 0,
+		lastAnnounceRetryAt: void 0,
+		spawnMode,
+		archiveAtMs,
+		runTimeoutSeconds
+	};
+	subagentRuns.set(nextRunId, next);
+	ensureListener();
+	persistSubagentRuns();
+	if (archiveAtMs) startSweeper();
+	waitForSubagentCompletion(nextRunId, waitTimeoutMs);
+	return true;
+}
+function registerSubagentRun(params) {
+	const now = Date.now();
+	const cfg = loadConfig();
+	const archiveAfterMs = resolveArchiveAfterMs(cfg);
+	const spawnMode = params.spawnMode === "session" ? "session" : "run";
+	const archiveAtMs = spawnMode === "session" ? void 0 : archiveAfterMs ? now + archiveAfterMs : void 0;
+	const runTimeoutSeconds = params.runTimeoutSeconds ?? 0;
+	const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, runTimeoutSeconds);
+	const requesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
+	subagentRuns.set(params.runId, {
+		runId: params.runId,
+		childSessionKey: params.childSessionKey,
+		requesterSessionKey: params.requesterSessionKey,
+		requesterOrigin,
+		requesterDisplayKey: params.requesterDisplayKey,
+		task: params.task,
+		cleanup: params.cleanup,
+		expectsCompletionMessage: params.expectsCompletionMessage,
+		spawnMode,
+		label: params.label,
+		model: params.model,
+		runTimeoutSeconds,
+		createdAt: now,
+		startedAt: now,
+		archiveAtMs,
+		cleanupHandled: false
+	});
+	ensureListener();
+	persistSubagentRuns();
+	if (archiveAtMs) startSweeper();
+	waitForSubagentCompletion(params.runId, waitTimeoutMs);
+}
+async function waitForSubagentCompletion(runId, waitTimeoutMs) {
+	try {
+		const timeoutMs = Math.max(1, Math.floor(waitTimeoutMs));
+		const wait = await callGateway({
+			method: "agent.wait",
+			params: {
+				runId,
+				timeoutMs
+			},
+			timeoutMs: timeoutMs + 1e4
+		});
+		if (wait?.status !== "ok" && wait?.status !== "error" && wait?.status !== "timeout") return;
+		const entry = subagentRuns.get(runId);
+		if (!entry) return;
+		let mutated = false;
+		if (typeof wait.startedAt === "number") {
+			entry.startedAt = wait.startedAt;
+			mutated = true;
+		}
+		if (typeof wait.endedAt === "number") {
+			entry.endedAt = wait.endedAt;
+			mutated = true;
+		}
+		if (!entry.endedAt) {
+			entry.endedAt = Date.now();
+			mutated = true;
+		}
+		const waitError = typeof wait.error === "string" ? wait.error : void 0;
+		const outcome = wait.status === "error" ? {
+			status: "error",
+			error: waitError
+		} : wait.status === "timeout" ? { status: "timeout" } : { status: "ok" };
+		if (!runOutcomesEqual(entry.outcome, outcome)) {
+			entry.outcome = outcome;
+			mutated = true;
+		}
+		if (mutated) persistSubagentRuns();
+		await completeSubagentRun({
+			runId,
+			endedAt: entry.endedAt,
+			outcome,
+			reason: wait.status === "error" ? SUBAGENT_ENDED_REASON_ERROR : SUBAGENT_ENDED_REASON_COMPLETE,
+			sendFarewell: true,
+			accountId: entry.requesterOrigin?.accountId,
+			triggerCleanup: true
+		});
+	} catch {}
+}
+function findRunIdsByChildSessionKey(childSessionKey) {
+	return findRunIdsByChildSessionKeyFromRuns(subagentRuns, childSessionKey);
+}
+function resolveRequesterForChildSession(childSessionKey) {
+	const resolved = resolveRequesterForChildSessionFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), childSessionKey);
+	if (!resolved) return null;
+	return {
+		requesterSessionKey: resolved.requesterSessionKey,
+		requesterOrigin: normalizeDeliveryContext(resolved.requesterOrigin)
+	};
+}
+function isSubagentSessionRunActive(childSessionKey) {
+	const runIds = findRunIdsByChildSessionKey(childSessionKey);
+	for (const runId of runIds) {
+		const entry = subagentRuns.get(runId);
+		if (!entry) continue;
+		if (typeof entry.endedAt !== "number") return true;
+	}
+	return false;
+}
+function markSubagentRunTerminated(params) {
+	const runIds = /* @__PURE__ */ new Set();
+	if (typeof params.runId === "string" && params.runId.trim()) runIds.add(params.runId.trim());
+	if (typeof params.childSessionKey === "string" && params.childSessionKey.trim()) for (const runId of findRunIdsByChildSessionKey(params.childSessionKey)) runIds.add(runId);
+	if (runIds.size === 0) return 0;
+	const now = Date.now();
+	const reason = params.reason?.trim() || "killed";
+	let updated = 0;
+	const entriesByChildSessionKey = /* @__PURE__ */ new Map();
+	for (const runId of runIds) {
+		const entry = subagentRuns.get(runId);
+		if (!entry) continue;
+		if (typeof entry.endedAt === "number") continue;
+		entry.endedAt = now;
+		entry.outcome = {
+			status: "error",
+			error: reason
+		};
+		entry.endedReason = SUBAGENT_ENDED_REASON_KILLED;
+		entry.cleanupHandled = true;
+		entry.cleanupCompletedAt = now;
+		entry.suppressAnnounceReason = "killed";
+		if (!entriesByChildSessionKey.has(entry.childSessionKey)) entriesByChildSessionKey.set(entry.childSessionKey, entry);
+		updated += 1;
+	}
+	if (updated > 0) {
+		persistSubagentRuns();
+		for (const entry of entriesByChildSessionKey.values()) emitSubagentEndedHookOnce({
+			entry,
+			reason: SUBAGENT_ENDED_REASON_KILLED,
+			sendFarewell: true,
+			outcome: SUBAGENT_ENDED_OUTCOME_KILLED,
+			error: reason,
+			inFlightRunIds: endedHookInFlightRunIds,
+			persist: persistSubagentRuns
+		}).catch(() => {});
+	}
+	return updated;
+}
+function listSubagentRunsForRequester(requesterSessionKey) {
+	return listRunsForRequesterFromRuns(subagentRuns, requesterSessionKey);
+}
+function countActiveRunsForSession(requesterSessionKey) {
+	return countActiveRunsForSessionFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), requesterSessionKey);
+}
+function countActiveDescendantRuns(rootSessionKey) {
+	return countActiveDescendantRunsFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), rootSessionKey);
+}
+function listDescendantRunsForRequester(rootSessionKey) {
+	return listDescendantRunsForRequesterFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), rootSessionKey);
+}
+function initSubagentRegistry() {
+	restoreSubagentRunsOnce();
+}
+
+//#endregion
+export { clearSessionQueues as $, findCodeRegions as A, resolveSessionReference as B, classifySessionKind as C, stripToolMessages as D, sanitizeTextContent as E, resolveSandboxedSessionToolContext as F, unregisterSessionBindingAdapter as G, getSubagentDepthFromSessionStore as H, isResolvedSessionVisibleToRequester as I, getFollowupQueueDepth as J, resolveQueueSettings as K, resolveDisplaySessionKey as L, createAgentToAgentPolicy as M, createSessionVisibilityGuard as N, formatReasoningMessage as O, resolveEffectiveSessionToolsVisibility as P, normalizeReplyPayload as Q, resolveInternalSessionKey as R, runAgentStep as S, extractAssistantText as T, extractTextFromChatContent as U, shouldResolveSessionIdInput as V, registerSessionBindingAdapter as W, isRoutableChannel as X, scheduleFollowupDrain as Y, routeReply as Z, isAnnounceSkip as _, extractQueueDirective as _t, listDescendantRunsForRequester as a, setCommandLaneConcurrency as at, resolvePingPongTurns as b, markSubagentRunTerminated as c, logMessageQueued as ct, subagent_registry_exports as d, logWebhookProcessed as dt, clearCommandLane as et, buildSubagentSystemPrompt as f, logWebhookReceived as ft, buildAgentToAgentReplyContext as g, isDiagnosticsEnabled as gt, buildAgentToAgentMessageContext as h, emitDiagnosticEvent as ht, initSubagentRegistry as i, resetAllLanes as it, isInsideCode as j, stripReasoningTagsFromText as k, registerSubagentRun as l, logSessionStateChange as lt, buildAgentToAgentAnnounceContext as m, stopDiagnosticHeartbeat as mt, countActiveDescendantRuns as n, getQueueSize as nt, listSubagentRunsForRequester as o, waitForActiveTasks as ot, runSubagentAnnounceFlow as p, startDiagnosticHeartbeat as pt, enqueueFollowupRun as q, countActiveRunsForSession as r, getTotalQueueSize as rt, markSubagentRunForSteerRestart as s, logMessageProcessed as st, clearSubagentRunSteerRestart as t, getActiveTaskCount as tt, replaceSubagentRunAfterSteer as u, logWebhookError as ut, isReplySkip as v, createReceiptCard as vt, deriveChannel as w, readLatestAssistantReply as x, resolveAnnounceTargetFromKey as y, resolveAgentTimeoutMs as yt, resolveMainSessionAlias as z };