@noxsoft/anima 2.0.2 → 2.0.4

package/dist/subagent-registry-CdSjz14I.js

@@ -0,0 +1,2760 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { g as resolveStateDir } from "./paths-BMuHNFxg.js";
+import { t as createSubsystemLogger, u as defaultRuntime } from "./subsystem-DfKstnEK.js";
+import { _ as isAcpSessionKey, d as resolveAgentIdFromSessionKey, g as getSubagentDepth, u as normalizeMainKey, x as parseAgentSessionKey } from "./session-key-DxcgHezu.js";
+import { c as resolveDefaultAgentId, l as resolveSessionAgentId, n as resolveAgentConfig } from "./agent-scope-CPphqq-U.js";
+import { bt as loadJsonFile, xt as saveJsonFile } from "./model-selection-Cqt6aJ0G.js";
+import { S as resolveAgentTimeoutMs, f as stripHeartbeatToken, g as isEmbeddedPiRunActive, o as onAgentEvent, p as CommandLane, t as AGENT_LANE_NESTED, v as queueEmbeddedPiMessage, x as waitForEmbeddedPiRunEnd, y as resolveEmbeddedSessionLane } from "./lanes-BvSnHq2h.js";
+import { i as loadConfig, m as parseDurationMs } from "./config-DaqbUdkI.js";
+import { d as deliveryContextFromSession, f as deliveryContextKey, i as loadSessionStore, k as resolveMainSessionKey, m as normalizeDeliveryContext, p as mergeDeliveryContext } from "./sessions-B-Cu7JZq.js";
+import { n as SILENT_REPLY_TOKEN, r as isSilentReplyText, t as HEARTBEAT_TOKEN } from "./tokens-3psI_Qk2.js";
+import { l as normalizeMessageChannel, t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-D_jIO87f.js";
+import { r as normalizeChannelId, t as getChannelPlugin } from "./plugins-DhcGAPDB.js";
+import { c as resolveStorePath } from "./paths-BXQQzXGQ.js";
+import { n as callGateway } from "./call-BYDpTVCZ.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/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
+let seq = 0;
+const listeners = /* @__PURE__ */ new Set();
+function isDiagnosticsEnabled(config) {
+	return config?.diagnostics?.enabled === true;
+}
+function emitDiagnosticEvent(event) {
+	const enriched = {
+		...event,
+		seq: seq += 1,
+		ts: Date.now()
+	};
+	for (const listener of listeners) try {
+		listener(enriched);
+	} catch {}
+}
+
+//#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 getDiagnosticSessionState(ref) {
+	pruneDiagnosticSessionStates();
+	const key = resolveSessionKey(ref);
+	const existing = diagnosticSessionStates.get(key);
+	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 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 getFollowupQueue(key, settings) {
+	const existing = FOLLOWUP_QUEUES.get(key);
+	if (existing) {
+		existing.mode = settings.mode;
+		existing.debounceMs = typeof settings.debounceMs === "number" ? Math.max(0, settings.debounceMs) : existing.debounceMs;
+		existing.cap = typeof settings.cap === "number" && settings.cap > 0 ? Math.floor(settings.cap) : existing.cap;
+		existing.dropPolicy = settings.dropPolicy ?? existing.dropPolicy;
+		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: []
+	};
+	FOLLOWUP_QUEUES.set(key, created);
+	return created;
+}
+function clearFollowupQueue(key) {
+	const cleaned = key.trim();
+	if (!cleaned) return 0;
+	const queue = FOLLOWUP_QUEUES.get(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(resolveEmbeddedSessionLane(cleaned));
+	}
+	return {
+		followupCleared,
+		laneCleared,
+		keys: clearedKeys
+	};
+}
+
+//#endregion
+//#region src/utils/queue-helpers.ts
+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) {
+	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 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}`);
+	}
+	params.state.droppedCount = 0;
+	params.state.summaryLines = [];
+	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/agents/identity.ts
+function resolveAgentIdentity(cfg, agentId) {
+	return resolveAgentConfig(cfg, agentId)?.identity;
+}
+function resolveIdentityNamePrefix(cfg, agentId) {
+	const name = resolveAgentIdentity(cfg, agentId)?.name?.trim();
+	if (!name) return;
+	return `[${name}]`;
+}
+/** Returns just the identity name (without brackets) for template context. */
+function resolveIdentityName(cfg, agentId) {
+	return resolveAgentIdentity(cfg, agentId)?.name?.trim() || void 0;
+}
+function resolveMessagePrefix(cfg, agentId, opts) {
+	const configured = opts?.configured ?? cfg.messages?.messagePrefix;
+	if (configured !== void 0) return configured;
+	if (opts?.hasAllowFrom === true) return "";
+	return resolveIdentityNamePrefix(cfg, agentId) ?? opts?.fallback ?? "[anima]";
+}
+/** Helper to extract a channel config value by dynamic key. */
+function getChannelConfig(cfg, channel) {
+	const value = cfg.channels?.[channel];
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function resolveResponsePrefix(cfg, agentId, opts) {
+	if (opts?.channel && opts?.accountId) {
+		const accountPrefix = (getChannelConfig(cfg, opts.channel)?.accounts)?.[opts.accountId]?.responsePrefix;
+		if (accountPrefix !== void 0) {
+			if (accountPrefix === "auto") return resolveIdentityNamePrefix(cfg, agentId);
+			return accountPrefix;
+		}
+	}
+	if (opts?.channel) {
+		const channelPrefix = getChannelConfig(cfg, opts.channel)?.responsePrefix;
+		if (channelPrefix !== void 0) {
+			if (channelPrefix === "auto") return resolveIdentityNamePrefix(cfg, agentId);
+			return channelPrefix;
+		}
+	}
+	const configured = cfg.messages?.responsePrefix;
+	if (configured !== void 0) {
+		if (configured === "auto") return resolveIdentityNamePrefix(cfg, agentId);
+		return configured;
+	}
+}
+function resolveEffectiveMessagesConfig(cfg, agentId, opts) {
+	return {
+		messagePrefix: resolveMessagePrefix(cfg, agentId, {
+			hasAllowFrom: opts?.hasAllowFrom,
+			fallback: opts?.fallbackMessagePrefix
+		}),
+		responsePrefix: resolveResponsePrefix(cfg, agentId, {
+			channel: opts?.channel,
+			accountId: opts?.accountId
+		})
+	};
+}
+function resolveHumanDelayConfig(cfg, agentId) {
+	const defaults = cfg.agents?.defaults?.humanDelay;
+	const overrides = resolveAgentConfig(cfg, agentId)?.humanDelay;
+	if (!defaults && !overrides) return;
+	return {
+		mode: overrides?.mode ?? defaults?.mode,
+		minMs: overrides?.minMs ?? defaults?.minMs,
+		maxMs: overrides?.maxMs ?? defaults?.maxMs
+	};
+}
+
+//#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/response-prefix-template.ts
+const TEMPLATE_VAR_PATTERN = /\{([a-zA-Z][a-zA-Z0-9.]*)\}/g;
+/**
+* Interpolate template variables in a response prefix string.
+*
+* @param template - The template string with `{variable}` placeholders
+* @param context - Context object with values for interpolation
+* @returns The interpolated string, or undefined if template is undefined
+*
+* @example
+* resolveResponsePrefixTemplate("[{model} | think:{thinkingLevel}]", {
+*   model: "gpt-5.2",
+*   thinkingLevel: "high"
+* })
+* // Returns: "[gpt-5.2 | think:high]"
+*/
+function resolveResponsePrefixTemplate(template, context) {
+	if (!template) return;
+	return template.replace(TEMPLATE_VAR_PATTERN, (match, varName) => {
+		switch (varName.toLowerCase()) {
+			case "model": return context.model ?? match;
+			case "modelfull": return context.modelFull ?? match;
+			case "provider": return context.provider ?? match;
+			case "thinkinglevel":
+			case "think": return context.thinkingLevel ?? match;
+			case "identity.name":
+			case "identityname": return context.identityName ?? match;
+			default: return match;
+		}
+	});
+}
+/**
+* Extract short model name from a full model string.
+*
+* Strips:
+* - Provider prefix (e.g., "openai/" from "openai/gpt-5.2")
+* - Date suffixes (e.g., "-20260205" from "claude-opus-4-6-20260205")
+* - Common version suffixes (e.g., "-latest")
+*
+* @example
+* extractShortModelName("openai-codex/gpt-5.2") // "gpt-5.2"
+* extractShortModelName("claude-opus-4-6-20260205") // "claude-opus-4-6"
+* extractShortModelName("gpt-5.2-latest") // "gpt-5.2"
+*/
+function extractShortModelName(fullModel) {
+	const slash = fullModel.lastIndexOf("/");
+	return (slash >= 0 ? fullModel.slice(slash + 1) : fullModel).replace(/-\d{8}$/, "").replace(/-latest$/, "");
+}
+
+//#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 ((opts.stripHeartbeat ?? true) && text?.includes(HEARTBEAT_TOKEN)) {
+		const stripped = stripHeartbeatToken(text, { mode: "message" });
+		if (stripped.didStrip) opts.onHeartbeatStrip?.();
+		if (stripped.shouldSkip && !hasMedia && !hasChannelData) {
+			opts.onSkip?.("heartbeat");
+			return null;
+		}
+		text = stripped.text;
+	}
+	if (text) text = sanitizeUserFacingText$1(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.trim() !== HEARTBEAT_TOKEN && !text.startsWith(effectivePrefix)) text = `${effectivePrefix} ${text}`;
+	return {
+		...enrichedPayload,
+		text
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/route-reply.ts
+/**
+* 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;
+	const normalizedChannel = normalizeMessageChannel(channel);
+	const normalized = normalizeReplyPayload(payload, { responsePrefix: params.sessionKey ? resolveEffectiveMessagesConfig(cfg, resolveSessionAgentId({
+		sessionKey: params.sessionKey,
+		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(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-BBggsviM.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,
+				abortSignal,
+				mirror: params.mirror !== false && params.sessionKey ? {
+					sessionKey: params.sessionKey,
+					agentId: resolveSessionAgentId({
+						sessionKey: params.sessionKey,
+						config: cfg
+					}),
+					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(channel) !== null;
+}
+
+//#endregion
+//#region src/auto-reply/reply/queue/drain.ts
+function previewQueueSummaryPrompt$1(queue) {
+	return buildQueueSummaryPrompt({
+		state: {
+			dropPolicy: queue.dropPolicy,
+			droppedCount: queue.droppedCount,
+			summaryLines: [...queue.summaryLines]
+		},
+		noun: "message"
+	});
+}
+function clearQueueSummaryState$1(queue) {
+	queue.droppedCount = 0;
+	queue.summaryLines = [];
+}
+function scheduleFollowupDrain(key, runFollowup) {
+	const queue = FOLLOWUP_QUEUES.get(key);
+	if (!queue || queue.draining) return;
+	queue.draining = true;
+	(async () => {
+		try {
+			let forceIndividualCollect = false;
+			while (queue.items.length > 0 || queue.droppedCount > 0) {
+				await waitForQueueDebounce(queue);
+				if (queue.mode === "collect") {
+					if (forceIndividualCollect) {
+						const next = queue.items[0];
+						if (!next) break;
+						await runFollowup(next);
+						queue.items.shift();
+						continue;
+					}
+					if (hasCrossChannelItems(queue.items, (item) => {
+						const channel = item.originatingChannel;
+						const to = item.originatingTo;
+						const accountId = item.originatingAccountId;
+						const threadId = item.originatingThreadId;
+						if (!channel && !to && !accountId && threadId == null) return {};
+						if (!isRoutableChannel(channel) || !to) return { cross: true };
+						return { key: [
+							channel,
+							to,
+							accountId || "",
+							threadId != null ? String(threadId) : ""
+						].join("|") };
+					})) {
+						forceIndividualCollect = true;
+						const next = queue.items[0];
+						if (!next) break;
+						await runFollowup(next);
+						queue.items.shift();
+						continue;
+					}
+					const items = queue.items.slice();
+					const summary = previewQueueSummaryPrompt$1(queue);
+					const run = items.at(-1)?.run ?? queue.lastRun;
+					if (!run) break;
+					const originatingChannel = items.find((i) => i.originatingChannel)?.originatingChannel;
+					const originatingTo = items.find((i) => i.originatingTo)?.originatingTo;
+					const originatingAccountId = items.find((i) => i.originatingAccountId)?.originatingAccountId;
+					const originatingThreadId = items.find((i) => i.originatingThreadId != null)?.originatingThreadId;
+					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(),
+						originatingChannel,
+						originatingTo,
+						originatingAccountId,
+						originatingThreadId
+					});
+					queue.items.splice(0, items.length);
+					if (summary) clearQueueSummaryState$1(queue);
+					continue;
+				}
+				const summaryPrompt = previewQueueSummaryPrompt$1(queue);
+				if (summaryPrompt) {
+					const run = queue.lastRun;
+					if (!run) break;
+					if (!queue.items[0]) break;
+					await runFollowup({
+						prompt: summaryPrompt,
+						run,
+						enqueuedAt: Date.now()
+					});
+					queue.items.shift();
+					clearQueueSummaryState$1(queue);
+					continue;
+				}
+				const next = queue.items[0];
+				if (!next) break;
+				await runFollowup(next);
+				queue.items.shift();
+			}
+		} 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 cleaned = key.trim();
+	if (!cleaned) return 0;
+	const queue = FOLLOWUP_QUEUES.get(cleaned);
+	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/agents/subagent-announce-queue.ts
+const ANNOUNCE_QUEUES = /* @__PURE__ */ new Map();
+function previewQueueSummaryPrompt(queue) {
+	return buildQueueSummaryPrompt({
+		state: {
+			dropPolicy: queue.dropPolicy,
+			droppedCount: queue.droppedCount,
+			summaryLines: [...queue.summaryLines]
+		},
+		noun: "announce"
+	});
+}
+function clearQueueSummaryState(queue) {
+	queue.droppedCount = 0;
+	queue.summaryLines = [];
+}
+function getAnnounceQueue(key, settings, send) {
+	const existing = ANNOUNCE_QUEUES.get(key);
+	if (existing) {
+		existing.mode = settings.mode;
+		existing.debounceMs = typeof settings.debounceMs === "number" ? Math.max(0, settings.debounceMs) : existing.debounceMs;
+		existing.cap = typeof settings.cap === "number" && settings.cap > 0 ? Math.floor(settings.cap) : existing.cap;
+		existing.dropPolicy = settings.dropPolicy ?? existing.dropPolicy;
+		existing.send = send;
+		return existing;
+	}
+	const created = {
+		items: [],
+		draining: false,
+		lastEnqueuedAt: 0,
+		mode: settings.mode,
+		debounceMs: typeof settings.debounceMs === "number" ? Math.max(0, settings.debounceMs) : 1e3,
+		cap: typeof settings.cap === "number" && settings.cap > 0 ? Math.floor(settings.cap) : 20,
+		dropPolicy: settings.dropPolicy ?? "summarize",
+		droppedCount: 0,
+		summaryLines: [],
+		send
+	};
+	ANNOUNCE_QUEUES.set(key, created);
+	return created;
+}
+function scheduleAnnounceDrain(key) {
+	const queue = ANNOUNCE_QUEUES.get(key);
+	if (!queue || queue.draining) return;
+	queue.draining = true;
+	(async () => {
+		try {
+			let forceIndividualCollect = false;
+			while (queue.items.length > 0 || queue.droppedCount > 0) {
+				await waitForQueueDebounce(queue);
+				if (queue.mode === "collect") {
+					if (forceIndividualCollect) {
+						const next = queue.items[0];
+						if (!next) break;
+						await queue.send(next);
+						queue.items.shift();
+						continue;
+					}
+					if (hasCrossChannelItems(queue.items, (item) => {
+						if (!item.origin) return {};
+						if (!item.originKey) return { cross: true };
+						return { key: item.originKey };
+					})) {
+						forceIndividualCollect = true;
+						const next = queue.items[0];
+						if (!next) break;
+						await queue.send(next);
+						queue.items.shift();
+						continue;
+					}
+					const items = queue.items.slice();
+					const summary = previewQueueSummaryPrompt(queue);
+					const prompt = buildCollectPrompt({
+						title: "[Queued announce messages while agent was busy]",
+						items,
+						summary,
+						renderItem: (item, idx) => `---\nQueued #${idx + 1}\n${item.prompt}`.trim()
+					});
+					const last = items.at(-1);
+					if (!last) break;
+					await queue.send({
+						...last,
+						prompt
+					});
+					queue.items.splice(0, items.length);
+					if (summary) clearQueueSummaryState(queue);
+					continue;
+				}
+				const summaryPrompt = previewQueueSummaryPrompt(queue);
+				if (summaryPrompt) {
+					const next = queue.items[0];
+					if (!next) break;
+					await queue.send({
+						...next,
+						prompt: summaryPrompt
+					});
+					queue.items.shift();
+					clearQueueSummaryState(queue);
+					continue;
+				}
+				const next = queue.items[0];
+				if (!next) break;
+				await queue.send(next);
+				queue.items.shift();
+			}
+		} catch (err) {
+			queue.lastEnqueuedAt = Date.now();
+			defaultRuntime.error?.(`announce queue drain failed for ${key}: ${String(err)}`);
+		} finally {
+			queue.draining = false;
+			if (queue.items.length === 0 && queue.droppedCount === 0) ANNOUNCE_QUEUES.delete(key);
+			else scheduleAnnounceDrain(key);
+		}
+	})();
+}
+function enqueueAnnounce(params) {
+	const queue = getAnnounceQueue(params.key, params.settings, params.send);
+	queue.lastEnqueuedAt = Date.now();
+	if (!applyQueueDropPolicy({
+		queue,
+		summarize: (item) => item.summaryLine?.trim() || item.prompt.trim()
+	})) {
+		if (queue.dropPolicy === "new") scheduleAnnounceDrain(params.key);
+		return false;
+	}
+	const origin = normalizeDeliveryContext(params.item.origin);
+	const originKey = deliveryContextKey(origin);
+	queue.items.push({
+		...params.item,
+		origin,
+		originKey
+	});
+	scheduleAnnounceDrain(params.key);
+	return true;
+}
+
+//#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-helpers.ts
+function normalizeKey(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+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;
+}
+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
+	};
+}
+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
+	};
+}
+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;
+		return msg.role !== "toolResult";
+	});
+}
+/**
+* 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 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") {
+			const sanitized = sanitizeTextContent(text);
+			if (sanitized.trim()) chunks.push(sanitized);
+		}
+	}
+	const joined = chunks.join("").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/subagent-announce.ts
+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];
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		if (typeof entry?.inputTokens === "number" || typeof entry?.outputTokens === "number" || typeof entry?.totalTokens === "number") break;
+		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) {
+	return mergeDeliveryContext(requesterOrigin, deliveryContextFromSession(entry));
+}
+async function sendAnnounce(item) {
+	const requesterIsSubagent = getSubagentDepthFromSessionStore(item.sessionKey) >= 1;
+	const origin = item.origin;
+	const threadId = origin?.threadId != null && origin.threadId !== "" ? String(origin.threadId) : void 0;
+	await callGateway({
+		method: "agent",
+		params: {
+			sessionKey: item.sessionKey,
+			message: item.prompt,
+			channel: requesterIsSubagent ? void 0 : origin?.channel,
+			accountId: requesterIsSubagent ? void 0 : origin?.accountId,
+			to: requesterIsSubagent ? void 0 : origin?.to,
+			threadId: requesterIsSubagent ? void 0 : threadId,
+			deliver: !requesterIsSubagent,
+			idempotencyKey: crypto.randomUUID()
+		},
+		timeoutMs: 15e3
+	});
+}
+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) {
+	const { cfg, entry } = loadRequesterSessionEntry(params.requesterSessionKey);
+	const canonicalKey = resolveRequesterStoreKey(cfg, params.requesterSessionKey);
+	const sessionId = entry?.sessionId;
+	if (!sessionId) return "none";
+	const queueSettings = resolveQueueSettings({
+		cfg,
+		channel: entry?.channel ?? entry?.lastChannel,
+		sessionEntry: entry
+	});
+	const isActive = isEmbeddedPiRunActive(sessionId);
+	if (queueSettings.mode === "steer" || queueSettings.mode === "steer-backlog") {
+		if (/* @__PURE__ */ queueEmbeddedPiMessage(sessionId, params.triggerMessage)) return "steered";
+	}
+	const shouldFollowup = queueSettings.mode === "followup" || queueSettings.mode === "collect" || queueSettings.mode === "steer-backlog" || queueSettings.mode === "interrupt";
+	if (isActive && (shouldFollowup || queueSettings.mode === "steer")) {
+		const origin = resolveAnnounceOrigin(entry, params.requesterOrigin);
+		enqueueAnnounce({
+			key: canonicalKey,
+			item: {
+				prompt: params.triggerMessage,
+				summaryLine: params.summaryLine,
+				enqueuedAt: Date.now(),
+				sessionKey: canonicalKey,
+				origin
+			},
+			settings: queueSettings,
+			send: sendAnnounce
+		});
+		return "queued";
+	}
+	return "none";
+}
+function loadSessionEntryByKey(sessionKey) {
+	const cfg = loadConfig();
+	const agentId = resolveAgentIdFromSessionKey(sessionKey);
+	return loadSessionStore(resolveStorePath(cfg.session?.store, { agentId }))[sessionKey];
+}
+async function readLatestAssistantReplyWithRetry(params) {
+	const RETRY_INTERVAL_MS = 100;
+	let reply = params.initialReply?.trim() ? params.initialReply : void 0;
+	if (reply) return reply;
+	const deadline = Date.now() + Math.max(0, Math.min(params.maxWaitMs, 15e3));
+	while (Date.now() < deadline) {
+		await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
+		const latest = await readLatestAssistantReply({ sessionKey: params.sessionKey });
+		if (latest?.trim()) return latest;
+	}
+	return reply;
+}
+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 : 1);
+	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.",
+		"",
+		"## 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: NO_REPLY.";
+	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: NO_REPLY if this exact result was already delivered to the user in this same turn.`;
+}
+async function runSubagentAnnounceFlow(params) {
+	let didAnnounce = false;
+	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 (childSessionId && isEmbeddedPiRunActive(childSessionId)) {
+			if (!await /* @__PURE__ */ waitForEmbeddedPiRunEnd(childSessionId, settleTimeoutMs) && isEmbeddedPiRunActive(childSessionId)) {
+				shouldDeleteChildSession = false;
+				return false;
+			}
+		}
+		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 readLatestAssistantReply({ sessionKey: params.childSessionKey });
+		}
+		if (!reply) reply = await readLatestAssistantReply({ sessionKey: params.childSessionKey });
+		if (!reply?.trim()) reply = await readLatestAssistantReplyWithRetry({
+			sessionKey: params.childSessionKey,
+			initialReply: reply,
+			maxWaitMs: params.timeoutMs
+		});
+		if (!reply?.trim() && childSessionId && isEmbeddedPiRunActive(childSessionId)) {
+			shouldDeleteChildSession = false;
+			return false;
+		}
+		if (!outcome) outcome = { status: "unknown" };
+		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;
+		}
+		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 announceSessionId = childSessionId || "unknown";
+		const findings = reply || "(no output)";
+		let triggerMessage = "";
+		let requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
+		let requesterIsSubagent = requesterDepth >= 1;
+		if (requesterIsSubagent) {
+			const { isSubagentSessionRunActive, resolveRequesterForChildSession } = await Promise.resolve().then(() => subagent_registry_exports);
+			if (!isSubagentSessionRunActive(targetRequesterSessionKey)) {
+				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
+		});
+		const statsLine = await buildCompactAnnounceStatsLine({
+			sessionKey: params.childSessionKey,
+			startedAt: params.startedAt,
+			endedAt: params.endedAt
+		});
+		triggerMessage = [
+			`[System Message] [sessionId: ${announceSessionId}] A ${announceType} "${taskLabel}" just ${statusLabel}.`,
+			"",
+			"Result:",
+			findings,
+			"",
+			statsLine,
+			"",
+			replyInstruction
+		].join("\n");
+		const queued = await maybeQueueSubagentAnnounce({
+			requesterSessionKey: targetRequesterSessionKey,
+			triggerMessage,
+			summaryLine: taskLabel,
+			requesterOrigin: targetRequesterOrigin
+		});
+		if (queued === "steered") {
+			didAnnounce = true;
+			return true;
+		}
+		if (queued === "queued") {
+			didAnnounce = true;
+			return true;
+		}
+		let directOrigin = targetRequesterOrigin;
+		if (!requesterIsSubagent && !directOrigin) {
+			const { entry } = loadRequesterSessionEntry(targetRequesterSessionKey);
+			directOrigin = deliveryContextFromSession(entry);
+		}
+		await callGateway({
+			method: "agent",
+			params: {
+				sessionKey: targetRequesterSessionKey,
+				message: triggerMessage,
+				deliver: !requesterIsSubagent,
+				channel: requesterIsSubagent ? void 0 : directOrigin?.channel,
+				accountId: requesterIsSubagent ? void 0 : directOrigin?.accountId,
+				to: requesterIsSubagent ? void 0 : directOrigin?.to,
+				threadId: !requesterIsSubagent && directOrigin?.threadId != null && directOrigin.threadId !== "" ? String(directOrigin.threadId) : void 0,
+				idempotencyKey: crypto.randomUUID()
+			},
+			expectFinal: true,
+			timeoutMs: 15e3
+		});
+		didAnnounce = true;
+	} 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
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+	}
+	return didAnnounce;
+}
+
+//#endregion
+//#region src/agents/subagent-registry.store.ts
+const REGISTRY_VERSION = 2;
+function resolveSubagentStateDir(env = process.env) {
+	if (env.ANIMA_STATE_DIR?.trim()) return resolveStateDir(env);
+	if (env.VITEST || env.NODE_ENV === "test") return path.join(os.tmpdir(), "anima-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
+		});
+		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.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;
+function persistSubagentRuns() {
+	try {
+		saveSubagentRegistryToDisk(subagentRuns);
+	} catch {}
+}
+const resumedRuns = /* @__PURE__ */ new Set();
+function suppressAnnounceForSteerRestart(entry) {
+	return entry?.suppressAnnounceReason === "steer-restart";
+}
+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
+	}).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;
+	if (entry.cleanupCompletedAt) 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 {
+		const restored = loadSubagentRegistryFromDisk();
+		if (restored.size === 0) return;
+		for (const [runId, entry] of restored.entries()) {
+			if (!runId || !entry) continue;
+			if (!subagentRuns.has(runId)) subagentRuns.set(runId, entry);
+		}
+		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
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+	}
+	if (mutated) persistSubagentRuns();
+	if (subagentRuns.size === 0) stopSweeper();
+}
+function ensureListener() {
+	if (listenerStarted) return;
+	listenerStarted = true;
+	listenerStop = onAgentEvent((evt) => {
+		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;
+		entry.endedAt = typeof evt.data?.endedAt === "number" ? evt.data.endedAt : Date.now();
+		if (phase === "error") entry.outcome = {
+			status: "error",
+			error: typeof evt.data?.error === "string" ? evt.data.error : void 0
+		};
+		else if (evt.data?.aborted) entry.outcome = { status: "timeout" };
+		else entry.outcome = { status: "ok" };
+		persistSubagentRuns();
+		if (suppressAnnounceForSteerRestart(entry)) return;
+		if (!startSubagentAnnounceCleanupFlow(evt.runId, entry)) return;
+	});
+}
+function finalizeSubagentCleanup(runId, cleanup, didAnnounce) {
+	const entry = subagentRuns.get(runId);
+	if (!entry) return;
+	if (!didAnnounce) {
+		entry.cleanupHandled = false;
+		resumedRuns.delete(runId);
+		persistSubagentRuns();
+		return;
+	}
+	if (cleanup === "delete") {
+		subagentRuns.delete(runId);
+		persistSubagentRuns();
+		retryDeferredCompletedAnnounces(runId);
+		return;
+	}
+	entry.cleanupCompletedAt = Date.now();
+	persistSubagentRuns();
+	retryDeferredCompletedAnnounces(runId);
+}
+function retryDeferredCompletedAnnounces(excludeRunId) {
+	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;
+		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 archiveAtMs = 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,
+		outcome: void 0,
+		cleanupCompletedAt: void 0,
+		cleanupHandled: false,
+		suppressAnnounceReason: void 0,
+		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 archiveAtMs = 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,
+		label: params.label,
+		model: params.model,
+		runTimeoutSeconds,
+		createdAt: now,
+		startedAt: now,
+		archiveAtMs,
+		cleanupHandled: false
+	});
+	ensureListener();
+	persistSubagentRuns();
+	if (archiveAfterMs) 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;
+		entry.outcome = wait.status === "error" ? {
+			status: "error",
+			error: waitError
+		} : wait.status === "timeout" ? { status: "timeout" } : { status: "ok" };
+		mutated = true;
+		if (mutated) persistSubagentRuns();
+		if (suppressAnnounceForSteerRestart(entry)) return;
+		if (!startSubagentAnnounceCleanupFlow(runId, entry)) return;
+	} catch {}
+}
+function findRunIdsByChildSessionKey(childSessionKey) {
+	const key = childSessionKey.trim();
+	if (!key) return [];
+	const runIds = [];
+	for (const [runId, entry] of subagentRuns.entries()) if (entry.childSessionKey === key) runIds.push(runId);
+	return runIds;
+}
+function getRunsSnapshotForRead() {
+	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 subagentRuns.entries()) merged.set(runId, entry);
+	return merged;
+}
+function resolveRequesterForChildSession(childSessionKey) {
+	const key = childSessionKey.trim();
+	if (!key) return null;
+	let best;
+	for (const entry of getRunsSnapshotForRead().values()) {
+		if (entry.childSessionKey !== key) continue;
+		if (!best || entry.createdAt > best.createdAt) best = entry;
+	}
+	if (!best) return null;
+	return {
+		requesterSessionKey: best.requesterSessionKey,
+		requesterOrigin: normalizeDeliveryContext(best.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;
+	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.cleanupHandled = true;
+		entry.cleanupCompletedAt = now;
+		entry.suppressAnnounceReason = "killed";
+		updated += 1;
+	}
+	if (updated > 0) persistSubagentRuns();
+	return updated;
+}
+function listSubagentRunsForRequester(requesterSessionKey) {
+	const key = requesterSessionKey.trim();
+	if (!key) return [];
+	return [...subagentRuns.values()].filter((entry) => entry.requesterSessionKey === key);
+}
+function countActiveRunsForSession(requesterSessionKey) {
+	const key = requesterSessionKey.trim();
+	if (!key) return 0;
+	let count = 0;
+	for (const entry of getRunsSnapshotForRead().values()) {
+		if (entry.requesterSessionKey !== key) continue;
+		if (typeof entry.endedAt === "number") continue;
+		count += 1;
+	}
+	return count;
+}
+function countActiveDescendantRuns(rootSessionKey) {
+	const root = rootSessionKey.trim();
+	if (!root) return 0;
+	const runs = getRunsSnapshotForRead();
+	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 listDescendantRunsForRequester(rootSessionKey) {
+	const root = rootSessionKey.trim();
+	if (!root) return [];
+	const runs = getRunsSnapshotForRead();
+	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;
+}
+function initSubagentRegistry() {
+	restoreSubagentRunsOnce();
+}
+
+//#endregion
+export { startDiagnosticHeartbeat as $, getFollowupQueueDepth as A, resolveIdentityNamePrefix as B, resolveSessionReference as C, getSubagentDepthFromSessionStore as D, stripToolMessages as E, extractShortModelName as F, getQueueSize as G, clearSessionQueues as H, resolveAgentIdentity as I, setCommandLaneConcurrency as J, getTotalQueueSize as K, resolveEffectiveMessagesConfig as L, isRoutableChannel as M, routeReply as N, resolveQueueSettings as O, normalizeReplyPayload as P, logSessionStateChange as Q, resolveHumanDelayConfig as R, resolveMainSessionAlias as S, shouldResolveSessionIdInput as T, clearCommandLane as U, resolveMessagePrefix as V, getActiveTaskCount as W, logMessageProcessed as X, waitForActiveTasks as Y, logMessageQueued as Z, createAgentToAgentPolicy as _, listDescendantRunsForRequester as a, takeDirectiveToken as at, resolveDisplaySessionKey as b, markSubagentRunTerminated as c, subagent_registry_exports as d, stopDiagnosticHeartbeat as et, buildSubagentSystemPrompt as f, classifySessionKind as g, runAgentStep as h, initSubagentRegistry as i, skipDirectiveArgPrefix as it, scheduleFollowupDrain as j, enqueueFollowupRun as k, registerSubagentRun as l, readLatestAssistantReply as m, countActiveDescendantRuns as n, isDiagnosticsEnabled as nt, listSubagentRunsForRequester as o, runSubagentAnnounceFlow as p, resetAllLanes as q, countActiveRunsForSession as r, extractQueueDirective as rt, markSubagentRunForSteerRestart as s, clearSubagentRunSteerRestart as t, emitDiagnosticEvent as tt, replaceSubagentRunAfterSteer as u, deriveChannel as v, sanitizeTextContent as w, resolveInternalSessionKey as x, extractAssistantText as y, resolveIdentityName as z };