vora-ai 0.1.0

package/dist/content-blocks-DdN51R-1.js

@@ -0,0 +1,1640 @@
+import { n as defaultRuntime } from "./runtime-D0VpiCHi.js";
+import { n as resolveGlobalSingleton, t as resolveGlobalMap } from "./global-singleton-54zT3rCn.js";
+import { s as normalizeFastMode } from "./thinking.shared-C4SN38qn.js";
+import { i as resolveAgentConfig } from "./agent-scope-BsqFyt8u.js";
+import { a as logWarn, t as logDebug } from "./logger-BOH4EG1g.js";
+import { t as parseDurationMs } from "./parse-duration-FGYGEVrK.js";
+import { t as getChannelPlugin } from "./registry-CJH_346k.js";
+import "./plugins-BUhqQahf.js";
+import { r as loadEnabledBundleMcpConfig } from "./bundle-mcp-Bx8MNFO5.js";
+import { n as resolveGlobalDedupeCache } from "./dedupe-ClGH5AD-.js";
+import { a as logLaneEnqueue, i as logLaneDequeue, t as diag } from "./diagnostic-BYcJF51S.js";
+import { a as redactSensitiveUrlLikeString, i as redactSensitiveUrl } from "./redact-sensitive-url-BYqi2BEL.js";
+import { n as normalizeConfiguredMcpServers } from "./mcp-config-Bul9F_lO.js";
+import { t as isRoutableChannel } from "./route-reply-BhwCACur.js";
+import crypto from "node:crypto";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+//#region src/process/lanes.ts
+let CommandLane = /* @__PURE__ */ function(CommandLane) {
+	CommandLane["Main"] = "main";
+	CommandLane["Cron"] = "cron";
+	CommandLane["Subagent"] = "subagent";
+	CommandLane["Nested"] = "nested";
+	return CommandLane;
+}({});
+//#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";
+	}
+};
+/**
+* Dedicated error type thrown when a new command is rejected because the
+* gateway is currently draining for restart.
+*/
+var GatewayDrainingError = class extends Error {
+	constructor() {
+		super("Gateway is draining for restart; new tasks are not accepted");
+		this.name = "GatewayDrainingError";
+	}
+};
+function isExpectedNonErrorLaneFailure(err) {
+	return err instanceof Error && err.name === "LiveSessionModelSwitchError";
+}
+/**
+* Keep queue runtime state on globalThis so every bundled entry/chunk shares
+* the same lanes, counters, and draining flag in production builds.
+*/
+const COMMAND_QUEUE_STATE_KEY = Symbol.for("vora.commandQueueState");
+function getQueueState() {
+	return resolveGlobalSingleton(COMMAND_QUEUE_STATE_KEY, () => ({
+		gatewayDraining: false,
+		lanes: /* @__PURE__ */ new Map(),
+		nextTaskId: 1
+	}));
+}
+function normalizeLane(lane) {
+	return lane.trim() || CommandLane.Main;
+}
+function getLaneDepth(state) {
+	return state.queue.length + state.activeTaskIds.size;
+}
+function getLaneState(lane) {
+	const queueState = getQueueState();
+	const existing = queueState.lanes.get(lane);
+	if (existing) return existing;
+	const created = {
+		lane,
+		queue: [],
+		activeTaskIds: /* @__PURE__ */ new Set(),
+		maxConcurrent: 1,
+		draining: false,
+		generation: 0
+	};
+	queueState.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) {
+		if (state.activeTaskIds.size === 0 && state.queue.length > 0) diag.warn(`drainLane blocked: lane=${lane} draining=true active=0 queue=${state.queue.length}`);
+		return;
+	}
+	state.draining = true;
+	const pump = () => {
+		try {
+			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) {
+					try {
+						entry.onWait?.(waitedMs, state.queue.length);
+					} catch (err) {
+						diag.error(`lane onWait callback failed: lane=${lane} error="${String(err)}"`);
+					}
+					diag.warn(`lane wait exceeded: lane=${lane} waitedMs=${waitedMs} queueAhead=${state.queue.length}`);
+				}
+				logLaneDequeue(lane, waitedMs, state.queue.length);
+				const taskId = getQueueState().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);
+						const isProbeLane = lane.startsWith("auth-probe:") || lane.startsWith("session:probe-");
+						if (!isProbeLane && !isExpectedNonErrorLaneFailure(err)) diag.error(`lane task error: lane=${lane} durationMs=${Date.now() - startTime} error="${String(err)}"`);
+						else if (!isProbeLane) diag.debug(`lane task interrupted: lane=${lane} durationMs=${Date.now() - startTime} reason="${String(err)}"`);
+						if (completedCurrentGeneration) pump();
+						entry.reject(err);
+					}
+				})();
+			}
+		} finally {
+			state.draining = false;
+		}
+	};
+	pump();
+}
+/**
+* Mark gateway as draining for restart so new enqueues fail fast with
+* `GatewayDrainingError` instead of being silently killed on shutdown.
+*/
+function markGatewayDraining() {
+	getQueueState().gatewayDraining = true;
+}
+function setCommandLaneConcurrency(lane, maxConcurrent) {
+	const cleaned = normalizeLane(lane);
+	const state = getLaneState(cleaned);
+	state.maxConcurrent = Math.max(1, Math.floor(maxConcurrent));
+	drainLane(cleaned);
+}
+function enqueueCommandInLane(lane, task, opts) {
+	if (getQueueState().gatewayDraining) return Promise.reject(new GatewayDrainingError());
+	const cleaned = normalizeLane(lane);
+	const warnAfterMs = opts?.warnAfterMs ?? 2e3;
+	const state = getLaneState(cleaned);
+	return new Promise((resolve, reject) => {
+		state.queue.push({
+			task: () => task(),
+			resolve: (value) => resolve(value),
+			reject,
+			enqueuedAt: Date.now(),
+			warnAfterMs,
+			onWait: opts?.onWait
+		});
+		logLaneEnqueue(cleaned, getLaneDepth(state));
+		drainLane(cleaned);
+	});
+}
+function getQueueSize(lane = CommandLane.Main) {
+	const resolved = normalizeLane(lane);
+	const state = getQueueState().lanes.get(resolved);
+	if (!state) return 0;
+	return getLaneDepth(state);
+}
+function getTotalQueueSize() {
+	let total = 0;
+	for (const s of getQueueState().lanes.values()) total += getLaneDepth(s);
+	return total;
+}
+function clearCommandLane(lane = CommandLane.Main) {
+	const cleaned = normalizeLane(lane);
+	const state = getQueueState().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 queueState = getQueueState();
+	queueState.gatewayDraining = false;
+	const lanesToDrain = [];
+	for (const state of queueState.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() {
+	const queueState = getQueueState();
+	let total = 0;
+	for (const s of queueState.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 queueState = getQueueState();
+	const activeAtStart = /* @__PURE__ */ new Set();
+	for (const state of queueState.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 queueState.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/utils/provider-utils.ts
+/**
+* Utility functions for provider-specific logic and capabilities.
+*/
+/**
+* Returns true if the provider requires reasoning to be wrapped in tags
+* (e.g. <think> and <final>) in the text stream, rather than using native
+* API fields for reasoning/thinking.
+*/
+function isReasoningTagProvider(provider) {
+	if (!provider) return false;
+	const normalized = provider.trim().toLowerCase();
+	if (normalized === "google" || normalized === "google-gemini-cli" || normalized === "google-generative-ai") return true;
+	if (normalized.includes("minimax")) return true;
+	return false;
+}
+//#endregion
+//#region src/agents/mcp-config-shared.ts
+function isMcpConfigRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function toMcpStringRecord(value, options) {
+	if (!isMcpConfigRecord(value)) return;
+	const entries = Object.entries(value).map(([key, entry]) => {
+		if (typeof entry === "string") return [key, entry];
+		if (typeof entry === "number" || typeof entry === "boolean") return [key, String(entry)];
+		options?.onDroppedEntry?.(key, entry);
+		return null;
+	}).filter((entry) => entry !== null);
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function toMcpStringArray(value) {
+	if (!Array.isArray(value)) return;
+	const entries = value.filter((entry) => typeof entry === "string");
+	return entries.length > 0 ? entries : [];
+}
+//#endregion
+//#region src/agents/mcp-stdio.ts
+function resolveStdioMcpServerLaunchConfig(raw) {
+	if (!isMcpConfigRecord(raw)) return {
+		ok: false,
+		reason: "server config must be an object"
+	};
+	if (typeof raw.command !== "string" || raw.command.trim().length === 0) {
+		if (typeof raw.url === "string" && raw.url.trim().length > 0) return {
+			ok: false,
+			reason: "not a stdio server (has url)"
+		};
+		return {
+			ok: false,
+			reason: "its command is missing"
+		};
+	}
+	const cwd = typeof raw.cwd === "string" && raw.cwd.trim().length > 0 ? raw.cwd : typeof raw.workingDirectory === "string" && raw.workingDirectory.trim().length > 0 ? raw.workingDirectory : void 0;
+	return {
+		ok: true,
+		config: {
+			command: raw.command,
+			args: toMcpStringArray(raw.args),
+			env: toMcpStringRecord(raw.env),
+			cwd
+		}
+	};
+}
+function describeStdioMcpServerLaunchConfig(config) {
+	const args = Array.isArray(config.args) && config.args.length > 0 ? ` ${config.args.join(" ")}` : "";
+	const cwd = config.cwd ? ` (cwd=${config.cwd})` : "";
+	return `${config.command}${args}${cwd}`;
+}
+//#endregion
+//#region src/agents/embedded-pi-mcp.ts
+function loadEmbeddedPiMcpConfig(params) {
+	const bundleMcp = loadEnabledBundleMcpConfig({
+		workspaceDir: params.workspaceDir,
+		cfg: params.cfg
+	});
+	const configuredMcp = normalizeConfiguredMcpServers(params.cfg?.mcp?.servers);
+	return {
+		mcpServers: {
+			...bundleMcp.config.mcpServers,
+			...configuredMcp
+		},
+		diagnostics: bundleMcp.diagnostics
+	};
+}
+//#endregion
+//#region src/agents/mcp-http.ts
+function resolveHttpMcpServerLaunchConfig(raw, options) {
+	if (!isMcpConfigRecord(raw)) return {
+		ok: false,
+		reason: "server config must be an object"
+	};
+	if (typeof raw.url !== "string" || raw.url.trim().length === 0) return {
+		ok: false,
+		reason: "its url is missing"
+	};
+	const url = raw.url.trim();
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return {
+			ok: false,
+			reason: `its url is not a valid URL: ${redactSensitiveUrlLikeString(url)}`
+		};
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
+		ok: false,
+		reason: `only http and https URLs are supported, got ${parsed.protocol}`
+	};
+	let headers;
+	if (raw.headers !== void 0 && raw.headers !== null) if (!isMcpConfigRecord(raw.headers)) options?.onMalformedHeaders?.(raw.headers);
+	else headers = toMcpStringRecord(raw.headers, { onDroppedEntry: options?.onDroppedHeader });
+	return {
+		ok: true,
+		config: {
+			transportType: options?.transportType ?? "sse",
+			url,
+			headers
+		}
+	};
+}
+function describeHttpMcpServerLaunchConfig(config) {
+	return redactSensitiveUrl(config.url);
+}
+//#endregion
+//#region src/agents/mcp-transport-config.ts
+const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
+function getConnectionTimeoutMs(rawServer) {
+	if (rawServer && typeof rawServer === "object" && typeof rawServer.connectionTimeoutMs === "number" && rawServer.connectionTimeoutMs > 0) return rawServer.connectionTimeoutMs;
+	return DEFAULT_CONNECTION_TIMEOUT_MS;
+}
+function getRequestedTransport(rawServer) {
+	if (!rawServer || typeof rawServer !== "object" || typeof rawServer.transport !== "string") return "";
+	return (rawServer.transport ?? "").trim().toLowerCase();
+}
+function resolveHttpTransportConfig(serverName, rawServer, transportType) {
+	const launch = resolveHttpMcpServerLaunchConfig(rawServer, {
+		transportType,
+		onDroppedHeader: (key) => {
+			logWarn(`bundle-mcp: server "${serverName}": header "${key}" has an unsupported value type and was ignored.`);
+		},
+		onMalformedHeaders: () => {
+			logWarn(`bundle-mcp: server "${serverName}": "headers" must be a JSON object; the value was ignored.`);
+		}
+	});
+	if (!launch.ok) return null;
+	return {
+		kind: "http",
+		transportType: launch.config.transportType,
+		url: launch.config.url,
+		headers: launch.config.headers,
+		description: describeHttpMcpServerLaunchConfig(launch.config),
+		connectionTimeoutMs: getConnectionTimeoutMs(rawServer)
+	};
+}
+function resolveMcpTransportConfig(serverName, rawServer) {
+	const requestedTransport = getRequestedTransport(rawServer);
+	const stdioLaunch = resolveStdioMcpServerLaunchConfig(rawServer);
+	if (stdioLaunch.ok) return {
+		kind: "stdio",
+		transportType: "stdio",
+		command: stdioLaunch.config.command,
+		args: stdioLaunch.config.args,
+		env: stdioLaunch.config.env,
+		cwd: stdioLaunch.config.cwd,
+		description: describeStdioMcpServerLaunchConfig(stdioLaunch.config),
+		connectionTimeoutMs: getConnectionTimeoutMs(rawServer)
+	};
+	if (requestedTransport && requestedTransport !== "sse" && requestedTransport !== "streamable-http") {
+		logWarn(`bundle-mcp: skipped server "${serverName}" because transport "${requestedTransport}" is not supported.`);
+		return null;
+	}
+	if (requestedTransport === "streamable-http") {
+		const httpTransport = resolveHttpTransportConfig(serverName, rawServer, "streamable-http");
+		if (httpTransport) return httpTransport;
+	}
+	const sseTransport = resolveHttpTransportConfig(serverName, rawServer, "sse");
+	if (sseTransport) return sseTransport;
+	const httpLaunch = resolveHttpMcpServerLaunchConfig(rawServer);
+	const httpReason = httpLaunch.ok ? "not an HTTP MCP server" : httpLaunch.reason;
+	logWarn(`bundle-mcp: skipped server "${serverName}" because ${stdioLaunch.reason} and ${httpReason}.`);
+	return null;
+}
+//#endregion
+//#region src/agents/mcp-transport.ts
+function attachStderrLogging(serverName, transport) {
+	const stderr = transport.stderr;
+	if (!stderr || typeof stderr.on !== "function") return;
+	const onData = (chunk) => {
+		const message = String(chunk).trim();
+		if (!message) return;
+		for (const line of message.split(/\r?\n/)) {
+			const trimmed = line.trim();
+			if (trimmed) logDebug(`bundle-mcp:${serverName}: ${trimmed}`);
+		}
+	};
+	stderr.on("data", onData);
+	return () => {
+		if (typeof stderr.off === "function") stderr.off("data", onData);
+		else if (typeof stderr.removeListener === "function") stderr.removeListener("data", onData);
+	};
+}
+function buildSseEventSourceFetch(headers) {
+	return (url, init) => {
+		const sdkHeaders = {};
+		if (init?.headers) if (init.headers instanceof Headers) init.headers.forEach((value, key) => {
+			sdkHeaders[key] = value;
+		});
+		else Object.assign(sdkHeaders, init.headers);
+		return fetch(url, {
+			...init,
+			headers: {
+				...sdkHeaders,
+				...headers
+			}
+		});
+	};
+}
+function resolveMcpTransport(serverName, rawServer) {
+	const resolved = resolveMcpTransportConfig(serverName, rawServer);
+	if (!resolved) return null;
+	if (resolved.kind === "stdio") {
+		const transport = new StdioClientTransport({
+			command: resolved.command,
+			args: resolved.args,
+			env: resolved.env,
+			cwd: resolved.cwd,
+			stderr: "pipe"
+		});
+		return {
+			transport,
+			description: resolved.description,
+			transportType: "stdio",
+			connectionTimeoutMs: resolved.connectionTimeoutMs,
+			detachStderr: attachStderrLogging(serverName, transport)
+		};
+	}
+	if (resolved.transportType === "streamable-http") return {
+		transport: new StreamableHTTPClientTransport(new URL(resolved.url), { requestInit: resolved.headers ? { headers: resolved.headers } : void 0 }),
+		description: resolved.description,
+		transportType: "streamable-http",
+		connectionTimeoutMs: resolved.connectionTimeoutMs
+	};
+	const headers = { ...resolved.headers };
+	const hasHeaders = Object.keys(headers).length > 0;
+	return {
+		transport: new SSEClientTransport(new URL(resolved.url), {
+			requestInit: hasHeaders ? { headers } : void 0,
+			eventSourceInit: hasHeaders ? { fetch: buildSseEventSourceFetch(headers) } : void 0
+		}),
+		description: resolved.description,
+		transportType: "sse",
+		connectionTimeoutMs: resolved.connectionTimeoutMs
+	};
+}
+//#endregion
+//#region src/agents/pi-bundle-mcp-names.ts
+const TOOL_NAME_SAFE_RE = /[^A-Za-z0-9_-]/g;
+const TOOL_NAME_MAX_PREFIX = 30;
+const TOOL_NAME_MAX_TOTAL = 64;
+function sanitizeToolFragment(raw, fallback, maxChars) {
+	const normalized = raw.trim().replace(TOOL_NAME_SAFE_RE, "-") || fallback;
+	if (!maxChars) return normalized;
+	return normalized.length > maxChars ? normalized.slice(0, maxChars) : normalized;
+}
+function sanitizeServerName(raw, usedNames) {
+	const base = sanitizeToolFragment(raw, "mcp", TOOL_NAME_MAX_PREFIX);
+	let candidate = base;
+	let n = 2;
+	while (usedNames.has(candidate.toLowerCase())) {
+		const suffix = `-${n}`;
+		candidate = `${base.slice(0, Math.max(1, TOOL_NAME_MAX_PREFIX - suffix.length))}${suffix}`;
+		n += 1;
+	}
+	usedNames.add(candidate.toLowerCase());
+	return candidate;
+}
+function sanitizeToolName(raw) {
+	return sanitizeToolFragment(raw, "tool");
+}
+function normalizeReservedToolNames(names) {
+	return new Set(Array.from(names ?? [], (name) => name.trim().toLowerCase()).filter(Boolean));
+}
+function buildSafeToolName(params) {
+	const cleanedToolName = sanitizeToolName(params.toolName);
+	const maxToolChars = Math.max(1, TOOL_NAME_MAX_TOTAL - params.serverName.length - 2);
+	const truncatedToolName = cleanedToolName.slice(0, maxToolChars);
+	let candidateToolName = truncatedToolName || "tool";
+	let candidate = `${params.serverName}__${candidateToolName}`;
+	let n = 2;
+	while (params.reservedNames.has(candidate.toLowerCase())) {
+		const suffix = `-${n}`;
+		candidateToolName = `${(truncatedToolName || "tool").slice(0, Math.max(1, maxToolChars - suffix.length))}${suffix}`;
+		candidate = `${params.serverName}__${candidateToolName}`;
+		n += 1;
+	}
+	return candidate;
+}
+//#endregion
+//#region src/agents/pi-bundle-mcp-runtime.ts
+const SESSION_MCP_RUNTIME_MANAGER_KEY = Symbol.for("vora.sessionMcpRuntimeManager");
+function connectWithTimeout(client, transport, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`MCP server connection timed out after ${timeoutMs}ms`)), timeoutMs);
+		client.connect(transport).then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+function redactErrorUrls(error) {
+	return redactSensitiveUrlLikeString(String(error));
+}
+async function listAllTools(client) {
+	const tools = [];
+	let cursor;
+	do {
+		const page = await client.listTools(cursor ? { cursor } : void 0);
+		tools.push(...page.tools);
+		cursor = page.nextCursor;
+	} while (cursor);
+	return tools;
+}
+async function disposeSession(session) {
+	session.detachStderr?.();
+	if (session.transportType === "streamable-http") await session.transport.terminateSession().catch(() => {});
+	await session.client.close().catch(() => {});
+	await session.transport.close().catch(() => {});
+}
+function createCatalogFingerprint(servers) {
+	return crypto.createHash("sha1").update(JSON.stringify(servers)).digest("hex");
+}
+function loadSessionMcpConfig(params) {
+	const loaded = loadEmbeddedPiMcpConfig({
+		workspaceDir: params.workspaceDir,
+		cfg: params.cfg
+	});
+	if (params.logDiagnostics !== false) for (const diagnostic of loaded.diagnostics) logWarn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
+	return {
+		loaded,
+		fingerprint: createCatalogFingerprint(loaded.mcpServers)
+	};
+}
+function createDisposedError(sessionId) {
+	return /* @__PURE__ */ new Error(`bundle-mcp runtime disposed for session ${sessionId}`);
+}
+function createSessionMcpRuntime(params) {
+	const { loaded, fingerprint: configFingerprint } = loadSessionMcpConfig({
+		workspaceDir: params.workspaceDir,
+		cfg: params.cfg,
+		logDiagnostics: true
+	});
+	const createdAt = Date.now();
+	let lastUsedAt = createdAt;
+	let disposed = false;
+	let catalog = null;
+	let catalogInFlight;
+	const sessions = /* @__PURE__ */ new Map();
+	const failIfDisposed = () => {
+		if (disposed) throw createDisposedError(params.sessionId);
+	};
+	const getCatalog = async () => {
+		failIfDisposed();
+		if (catalog) return catalog;
+		if (catalogInFlight) return catalogInFlight;
+		catalogInFlight = (async () => {
+			if (Object.keys(loaded.mcpServers).length === 0) return {
+				version: 1,
+				generatedAt: Date.now(),
+				servers: {},
+				tools: []
+			};
+			const servers = {};
+			const tools = [];
+			const usedServerNames = /* @__PURE__ */ new Set();
+			try {
+				for (const [serverName, rawServer] of Object.entries(loaded.mcpServers)) {
+					failIfDisposed();
+					const resolved = resolveMcpTransport(serverName, rawServer);
+					if (!resolved) continue;
+					const safeServerName = sanitizeServerName(serverName, usedServerNames);
+					if (safeServerName !== serverName) logWarn(`bundle-mcp: server key "${serverName}" registered as "${safeServerName}" for provider-safe tool names.`);
+					const client = new Client({
+						name: "vora-bundle-mcp",
+						version: "0.0.0"
+					}, {});
+					const session = {
+						serverName,
+						client,
+						transport: resolved.transport,
+						transportType: resolved.transportType,
+						detachStderr: resolved.detachStderr
+					};
+					sessions.set(serverName, session);
+					try {
+						failIfDisposed();
+						await connectWithTimeout(client, resolved.transport, resolved.connectionTimeoutMs);
+						failIfDisposed();
+						const listedTools = await listAllTools(client);
+						failIfDisposed();
+						servers[serverName] = {
+							serverName,
+							launchSummary: resolved.description,
+							toolCount: listedTools.length
+						};
+						for (const tool of listedTools) {
+							const toolName = tool.name.trim();
+							if (!toolName) continue;
+							tools.push({
+								serverName,
+								safeServerName,
+								toolName,
+								title: tool.title,
+								description: tool.description?.trim() || void 0,
+								inputSchema: tool.inputSchema,
+								fallbackDescription: `Provided by bundle MCP server "${serverName}" (${resolved.description}).`
+							});
+						}
+					} catch (error) {
+						if (!disposed) logWarn(`bundle-mcp: failed to start server "${serverName}" (${resolved.description}): ${redactErrorUrls(error)}`);
+						await disposeSession(session);
+						sessions.delete(serverName);
+						failIfDisposed();
+					}
+				}
+				failIfDisposed();
+				return {
+					version: 1,
+					generatedAt: Date.now(),
+					servers,
+					tools
+				};
+			} catch (error) {
+				await Promise.allSettled(Array.from(sessions.values(), (session) => disposeSession(session)));
+				sessions.clear();
+				throw error;
+			}
+		})();
+		try {
+			const nextCatalog = await catalogInFlight;
+			failIfDisposed();
+			catalog = nextCatalog;
+			return nextCatalog;
+		} finally {
+			catalogInFlight = void 0;
+		}
+	};
+	return {
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		workspaceDir: params.workspaceDir,
+		configFingerprint,
+		createdAt,
+		get lastUsedAt() {
+			return lastUsedAt;
+		},
+		getCatalog,
+		markUsed() {
+			lastUsedAt = Date.now();
+		},
+		async callTool(serverName, toolName, input) {
+			failIfDisposed();
+			await getCatalog();
+			const session = sessions.get(serverName);
+			if (!session) throw new Error(`bundle-mcp server "${serverName}" is not connected`);
+			return await session.client.callTool({
+				name: toolName,
+				arguments: isMcpConfigRecord(input) ? input : {}
+			});
+		},
+		async dispose() {
+			if (disposed) return;
+			disposed = true;
+			catalog = null;
+			catalogInFlight = void 0;
+			const sessionsToClose = Array.from(sessions.values());
+			sessions.clear();
+			await Promise.allSettled(sessionsToClose.map((session) => disposeSession(session)));
+		}
+	};
+}
+function createSessionMcpRuntimeManager() {
+	const runtimesBySessionId = /* @__PURE__ */ new Map();
+	const sessionIdBySessionKey = /* @__PURE__ */ new Map();
+	const createInFlight = /* @__PURE__ */ new Map();
+	return {
+		async getOrCreate(params) {
+			if (params.sessionKey) sessionIdBySessionKey.set(params.sessionKey, params.sessionId);
+			const { fingerprint: nextFingerprint } = loadSessionMcpConfig({
+				workspaceDir: params.workspaceDir,
+				cfg: params.cfg,
+				logDiagnostics: false
+			});
+			const existing = runtimesBySessionId.get(params.sessionId);
+			if (existing) if (existing.workspaceDir !== params.workspaceDir || existing.configFingerprint !== nextFingerprint) {
+				runtimesBySessionId.delete(params.sessionId);
+				await existing.dispose();
+			} else {
+				existing.markUsed();
+				return existing;
+			}
+			const inFlight = createInFlight.get(params.sessionId);
+			if (inFlight) {
+				if (inFlight.workspaceDir === params.workspaceDir && inFlight.configFingerprint === nextFingerprint) return inFlight.promise;
+				createInFlight.delete(params.sessionId);
+				const staleRuntime = await inFlight.promise.catch(() => void 0);
+				runtimesBySessionId.delete(params.sessionId);
+				await staleRuntime?.dispose();
+			}
+			const created = Promise.resolve(createSessionMcpRuntime({
+				sessionId: params.sessionId,
+				sessionKey: params.sessionKey,
+				workspaceDir: params.workspaceDir,
+				cfg: params.cfg
+			})).then((runtime) => {
+				runtime.markUsed();
+				runtimesBySessionId.set(params.sessionId, runtime);
+				return runtime;
+			});
+			createInFlight.set(params.sessionId, {
+				promise: created,
+				workspaceDir: params.workspaceDir,
+				configFingerprint: nextFingerprint
+			});
+			try {
+				return await created;
+			} finally {
+				createInFlight.delete(params.sessionId);
+			}
+		},
+		bindSessionKey(sessionKey, sessionId) {
+			sessionIdBySessionKey.set(sessionKey, sessionId);
+		},
+		resolveSessionId(sessionKey) {
+			return sessionIdBySessionKey.get(sessionKey);
+		},
+		async disposeSession(sessionId) {
+			const inFlight = createInFlight.get(sessionId);
+			createInFlight.delete(sessionId);
+			let runtime = runtimesBySessionId.get(sessionId);
+			if (!runtime && inFlight) runtime = await inFlight.promise.catch(() => void 0);
+			runtimesBySessionId.delete(sessionId);
+			if (!runtime) {
+				for (const [sessionKey, mappedSessionId] of sessionIdBySessionKey.entries()) if (mappedSessionId === sessionId) sessionIdBySessionKey.delete(sessionKey);
+				return;
+			}
+			for (const [sessionKey, mappedSessionId] of sessionIdBySessionKey.entries()) if (mappedSessionId === sessionId) sessionIdBySessionKey.delete(sessionKey);
+			await runtime.dispose();
+		},
+		async disposeAll() {
+			const inFlightRuntimes = Array.from(createInFlight.values());
+			createInFlight.clear();
+			const runtimes = Array.from(runtimesBySessionId.values());
+			runtimesBySessionId.clear();
+			sessionIdBySessionKey.clear();
+			const lateRuntimes = await Promise.all(inFlightRuntimes.map(async ({ promise }) => await promise.catch(() => void 0)));
+			const allRuntimes = new Set(runtimes);
+			for (const runtime of lateRuntimes) if (runtime) allRuntimes.add(runtime);
+			await Promise.allSettled(Array.from(allRuntimes, (runtime) => runtime.dispose()));
+		},
+		listSessionIds() {
+			return Array.from(runtimesBySessionId.keys());
+		}
+	};
+}
+function getSessionMcpRuntimeManager() {
+	return resolveGlobalSingleton(SESSION_MCP_RUNTIME_MANAGER_KEY, createSessionMcpRuntimeManager);
+}
+async function getOrCreateSessionMcpRuntime(params) {
+	return await getSessionMcpRuntimeManager().getOrCreate(params);
+}
+async function disposeSessionMcpRuntime(sessionId) {
+	await getSessionMcpRuntimeManager().disposeSession(sessionId);
+}
+//#endregion
+//#region src/agents/pi-bundle-mcp-materialize.ts
+function toAgentToolResult(params) {
+	const content = Array.isArray(params.result.content) ? params.result.content : [];
+	const normalizedContent = content.length > 0 ? content : params.result.structuredContent !== void 0 ? [{
+		type: "text",
+		text: JSON.stringify(params.result.structuredContent, null, 2)
+	}] : [{
+		type: "text",
+		text: JSON.stringify({
+			status: params.result.isError === true ? "error" : "ok",
+			server: params.serverName,
+			tool: params.toolName
+		}, null, 2)
+	}];
+	const details = {
+		mcpServer: params.serverName,
+		mcpTool: params.toolName
+	};
+	if (params.result.structuredContent !== void 0) details.structuredContent = params.result.structuredContent;
+	if (params.result.isError === true) details.status = "error";
+	return {
+		content: normalizedContent,
+		details
+	};
+}
+async function materializeBundleMcpToolsForRun(params) {
+	params.runtime.markUsed();
+	const catalog = await params.runtime.getCatalog();
+	const reservedNames = normalizeReservedToolNames(params.reservedToolNames);
+	const tools = [];
+	for (const tool of catalog.tools) {
+		const originalName = tool.toolName.trim();
+		if (!originalName) continue;
+		const safeToolName = buildSafeToolName({
+			serverName: tool.safeServerName,
+			toolName: originalName,
+			reservedNames
+		});
+		if (safeToolName !== `${tool.safeServerName}__${originalName}`) logWarn(`bundle-mcp: tool "${tool.toolName}" from server "${tool.serverName}" registered as "${safeToolName}" to keep the tool name provider-safe.`);
+		reservedNames.add(safeToolName.toLowerCase());
+		tools.push({
+			name: safeToolName,
+			label: tool.title ?? tool.toolName,
+			description: tool.description || tool.fallbackDescription,
+			parameters: tool.inputSchema,
+			execute: async (_toolCallId, input) => {
+				const result = await params.runtime.callTool(tool.serverName, tool.toolName, input);
+				return toAgentToolResult({
+					serverName: tool.serverName,
+					toolName: tool.toolName,
+					result
+				});
+			}
+		});
+	}
+	return {
+		tools,
+		dispose: async () => {
+			await params.disposeRuntime?.();
+		}
+	};
+}
+async function createBundleMcpToolRuntime(params) {
+	const runtime = createSessionMcpRuntime({
+		sessionId: `bundle-mcp:${crypto.randomUUID()}`,
+		workspaceDir: params.workspaceDir,
+		cfg: params.cfg
+	});
+	return await materializeBundleMcpToolsForRun({
+		runtime,
+		reservedToolNames: params.reservedToolNames,
+		disposeRuntime: async () => {
+			await runtime.dispose();
+		}
+	});
+}
+//#endregion
+//#region src/agents/fast-mode.ts
+function resolveFastModeParam(extraParams) {
+	return normalizeFastMode(extraParams?.fastMode ?? extraParams?.fast_mode);
+}
+function resolveConfiguredFastModeRaw(params) {
+	const modelKey = `${params.provider}/${params.model}`;
+	const modelConfig = params.cfg?.agents?.defaults?.models?.[modelKey];
+	return modelConfig?.params?.fastMode ?? modelConfig?.params?.fast_mode;
+}
+function resolveFastModeState(params) {
+	const sessionOverride = normalizeFastMode(params.sessionEntry?.fastMode);
+	if (sessionOverride !== void 0) return {
+		enabled: sessionOverride,
+		source: "session"
+	};
+	const agentDefault = params.agentId && params.cfg ? resolveAgentConfig(params.cfg, params.agentId)?.fastModeDefault : void 0;
+	if (typeof agentDefault === "boolean") return {
+		enabled: agentDefault,
+		source: "agent"
+	};
+	const configured = normalizeFastMode(resolveConfiguredFastModeRaw(params));
+	if (configured !== void 0) return {
+		enabled: configured,
+		source: "config"
+	};
+	return {
+		enabled: false,
+		source: "default"
+	};
+}
+//#endregion
+//#region src/auto-reply/reply/directive-parsing.ts
+function skipDirectiveArgPrefix(raw) {
+	let i = 0;
+	const len = raw.length;
+	while (i < len && /\s/.test(raw[i])) i += 1;
+	if (raw[i] === ":") {
+		i += 1;
+		while (i < len && /\s/.test(raw[i])) i += 1;
+	}
+	return i;
+}
+function takeDirectiveToken(raw, startIndex) {
+	let i = startIndex;
+	const len = raw.length;
+	while (i < len && /\s/.test(raw[i])) i += 1;
+	if (i >= len) return {
+		token: null,
+		nextIndex: i
+	};
+	const start = i;
+	while (i < len && !/\s/.test(raw[i])) i += 1;
+	if (start === i) return {
+		token: null,
+		nextIndex: i
+	};
+	const token = raw.slice(start, i);
+	while (i < len && /\s/.test(raw[i])) i += 1;
+	return {
+		token,
+		nextIndex: i
+	};
+}
+//#endregion
+//#region src/auto-reply/reply/queue/normalize.ts
+function normalizeQueueMode(raw) {
+	if (!raw) return;
+	const cleaned = raw.trim().toLowerCase();
+	if (cleaned === "queue" || cleaned === "queued") return "steer";
+	if (cleaned === "interrupt" || cleaned === "interrupts" || cleaned === "abort") return "interrupt";
+	if (cleaned === "steer" || cleaned === "steering") return "steer";
+	if (cleaned === "followup" || cleaned === "follow-ups" || cleaned === "followups") return "followup";
+	if (cleaned === "collect" || cleaned === "coalesce") return "collect";
+	if (cleaned === "steer+backlog" || cleaned === "steer-backlog" || cleaned === "steer_backlog") return "steer-backlog";
+}
+function normalizeQueueDropPolicy(raw) {
+	if (!raw) return;
+	const cleaned = raw.trim().toLowerCase();
+	if (cleaned === "old" || cleaned === "oldest") return "old";
+	if (cleaned === "new" || cleaned === "newest") return "new";
+	if (cleaned === "summarize" || cleaned === "summary") return "summarize";
+}
+//#endregion
+//#region src/auto-reply/reply/queue/directive.ts
+function parseQueueDebounce(raw) {
+	if (!raw) return;
+	try {
+		const parsed = parseDurationMs(raw.trim(), { defaultUnit: "ms" });
+		if (!parsed || parsed < 0) return;
+		return Math.round(parsed);
+	} catch {
+		return;
+	}
+}
+function parseQueueCap(raw) {
+	if (!raw) return;
+	const num = Number(raw);
+	if (!Number.isFinite(num)) return;
+	const cap = Math.floor(num);
+	if (cap < 1) return;
+	return cap;
+}
+function parseQueueDirectiveArgs(raw) {
+	const len = raw.length;
+	let i = skipDirectiveArgPrefix(raw);
+	let consumed = i;
+	let queueMode;
+	let queueReset = false;
+	let rawMode;
+	let debounceMs;
+	let cap;
+	let dropPolicy;
+	let rawDebounce;
+	let rawCap;
+	let rawDrop;
+	let hasOptions = false;
+	const takeToken = () => {
+		const res = takeDirectiveToken(raw, i);
+		i = res.nextIndex;
+		return res.token;
+	};
+	while (i < len) {
+		const token = takeToken();
+		if (!token) break;
+		const lowered = token.trim().toLowerCase();
+		if (lowered === "default" || lowered === "reset" || lowered === "clear") {
+			queueReset = true;
+			consumed = i;
+			break;
+		}
+		if (lowered.startsWith("debounce:") || lowered.startsWith("debounce=")) {
+			rawDebounce = token.split(/[:=]/)[1] ?? "";
+			debounceMs = parseQueueDebounce(rawDebounce);
+			hasOptions = true;
+			consumed = i;
+			continue;
+		}
+		if (lowered.startsWith("cap:") || lowered.startsWith("cap=")) {
+			rawCap = token.split(/[:=]/)[1] ?? "";
+			cap = parseQueueCap(rawCap);
+			hasOptions = true;
+			consumed = i;
+			continue;
+		}
+		if (lowered.startsWith("drop:") || lowered.startsWith("drop=")) {
+			rawDrop = token.split(/[:=]/)[1] ?? "";
+			dropPolicy = normalizeQueueDropPolicy(rawDrop);
+			hasOptions = true;
+			consumed = i;
+			continue;
+		}
+		const mode = normalizeQueueMode(token);
+		if (mode) {
+			queueMode = mode;
+			rawMode = token;
+			consumed = i;
+			continue;
+		}
+		break;
+	}
+	return {
+		consumed,
+		queueMode,
+		queueReset,
+		rawMode,
+		debounceMs,
+		cap,
+		dropPolicy,
+		rawDebounce,
+		rawCap,
+		rawDrop,
+		hasOptions
+	};
+}
+function extractQueueDirective(body) {
+	if (!body) return {
+		cleaned: "",
+		hasDirective: false,
+		queueReset: false,
+		hasOptions: false
+	};
+	const match = /(?:^|\s)\/queue(?=$|\s|:)/i.exec(body);
+	if (!match) return {
+		cleaned: body.trim(),
+		hasDirective: false,
+		queueReset: false,
+		hasOptions: false
+	};
+	const start = match.index + match[0].indexOf("/queue");
+	const argsStart = start + 6;
+	const parsed = parseQueueDirectiveArgs(body.slice(argsStart));
+	return {
+		cleaned: `${body.slice(0, start)} ${body.slice(argsStart + parsed.consumed)}`.replace(/\s+/g, " ").trim(),
+		queueMode: parsed.queueMode,
+		queueReset: parsed.queueReset,
+		rawMode: parsed.rawMode,
+		debounceMs: parsed.debounceMs,
+		cap: parsed.cap,
+		dropPolicy: parsed.dropPolicy,
+		rawDebounce: parsed.rawDebounce,
+		rawCap: parsed.rawCap,
+		rawDrop: parsed.rawDrop,
+		hasDirective: true,
+		hasOptions: parsed.hasOptions
+	};
+}
+//#endregion
+//#region src/agents/pi-embedded-runner/lanes.ts
+function resolveSessionLane(key) {
+	const cleaned = key.trim() || CommandLane.Main;
+	return cleaned.startsWith("session:") ? cleaned : `session:${cleaned}`;
+}
+function resolveGlobalLane(lane) {
+	const cleaned = lane?.trim();
+	if (cleaned === CommandLane.Cron) return CommandLane.Nested;
+	return cleaned ? cleaned : CommandLane.Main;
+}
+function resolveEmbeddedSessionLane(key) {
+	return resolveSessionLane(key);
+}
+//#endregion
+//#region src/utils/queue-helpers.ts
+function clearQueueSummaryState(state) {
+	state.droppedCount = 0;
+	state.summaryLines = [];
+}
+function previewQueueSummaryPrompt(params) {
+	return buildQueueSummaryPrompt({
+		state: {
+			dropPolicy: params.state.dropPolicy,
+			droppedCount: params.state.droppedCount,
+			summaryLines: [...params.state.summaryLines]
+		},
+		noun: params.noun,
+		title: params.title
+	});
+}
+function applyQueueRuntimeSettings(params) {
+	params.target.mode = params.settings.mode;
+	params.target.debounceMs = typeof params.settings.debounceMs === "number" ? Math.max(0, params.settings.debounceMs) : params.target.debounceMs;
+	params.target.cap = typeof params.settings.cap === "number" && params.settings.cap > 0 ? Math.floor(params.settings.cap) : params.target.cap;
+	params.target.dropPolicy = params.settings.dropPolicy ?? params.target.dropPolicy;
+}
+function elideQueueText(text, limit = 140) {
+	if (text.length <= limit) return text;
+	return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+function buildQueueSummaryLine(text, limit = 160) {
+	return elideQueueText(text.replace(/\s+/g, " ").trim(), limit);
+}
+function shouldSkipQueueItem(params) {
+	if (!params.dedupe) return false;
+	return params.dedupe(params.item, params.items);
+}
+function applyQueueDropPolicy(params) {
+	const cap = params.queue.cap;
+	if (cap <= 0 || params.queue.items.length < cap) return true;
+	if (params.queue.dropPolicy === "new") return false;
+	const dropCount = params.queue.items.length - cap + 1;
+	const dropped = params.queue.items.splice(0, dropCount);
+	if (params.queue.dropPolicy === "summarize") {
+		for (const item of dropped) {
+			params.queue.droppedCount += 1;
+			params.queue.summaryLines.push(buildQueueSummaryLine(params.summarize(item)));
+		}
+		const limit = Math.max(0, params.summaryLimit ?? cap);
+		while (params.queue.summaryLines.length > limit) params.queue.summaryLines.shift();
+	}
+	return true;
+}
+function waitForQueueDebounce(queue) {
+	if (process.env.VORA_TEST_FAST === "1") return Promise.resolve();
+	const debounceMs = Math.max(0, queue.debounceMs);
+	if (debounceMs <= 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		const check = () => {
+			const since = Date.now() - queue.lastEnqueuedAt;
+			if (since >= debounceMs) {
+				resolve();
+				return;
+			}
+			setTimeout(check, debounceMs - since);
+		};
+		check();
+	});
+}
+function beginQueueDrain(map, key) {
+	const queue = map.get(key);
+	if (!queue || queue.draining) return;
+	queue.draining = true;
+	return queue;
+}
+async function drainNextQueueItem(items, run) {
+	const next = items[0];
+	if (!next) return false;
+	await run(next);
+	items.shift();
+	return true;
+}
+async function drainCollectItemIfNeeded(params) {
+	if (!params.forceIndividualCollect && !params.isCrossChannel) return "skipped";
+	if (params.isCrossChannel) params.setForceIndividualCollect?.(true);
+	return await drainNextQueueItem(params.items, params.run) ? "drained" : "empty";
+}
+async function drainCollectQueueStep(params) {
+	return await drainCollectItemIfNeeded({
+		forceIndividualCollect: params.collectState.forceIndividualCollect,
+		isCrossChannel: params.isCrossChannel,
+		setForceIndividualCollect: (next) => {
+			params.collectState.forceIndividualCollect = next;
+		},
+		items: params.items,
+		run: params.run
+	});
+}
+function buildQueueSummaryPrompt(params) {
+	if (params.state.dropPolicy !== "summarize" || params.state.droppedCount <= 0) return;
+	const noun = params.noun;
+	const lines = [params.title ?? `[Queue overflow] Dropped ${params.state.droppedCount} ${noun}${params.state.droppedCount === 1 ? "" : "s"} due to cap.`];
+	if (params.state.summaryLines.length > 0) {
+		lines.push("Summary:");
+		for (const line of params.state.summaryLines) lines.push(`- ${line}`);
+	}
+	clearQueueSummaryState(params.state);
+	return lines.join("\n");
+}
+function buildCollectPrompt(params) {
+	const blocks = [params.title];
+	if (params.summary) blocks.push(params.summary);
+	params.items.forEach((item, idx) => {
+		blocks.push(params.renderItem(item, idx));
+	});
+	return blocks.join("\n\n");
+}
+function hasCrossChannelItems(items, resolveKey) {
+	const keys = /* @__PURE__ */ new Set();
+	let hasUnkeyed = false;
+	for (const item of items) {
+		const resolved = resolveKey(item);
+		if (resolved.cross) return true;
+		if (!resolved.key) {
+			hasUnkeyed = true;
+			continue;
+		}
+		keys.add(resolved.key);
+	}
+	if (keys.size === 0) return false;
+	if (hasUnkeyed) return true;
+	return keys.size > 1;
+}
+//#endregion
+//#region src/auto-reply/reply/queue/state.ts
+const DEFAULT_QUEUE_DEBOUNCE_MS = 1e3;
+const FOLLOWUP_QUEUES = resolveGlobalMap(Symbol.for("vora.followupQueues"));
+function getExistingFollowupQueue(key) {
+	const cleaned = key.trim();
+	if (!cleaned) return;
+	return FOLLOWUP_QUEUES.get(cleaned);
+}
+function getFollowupQueue(key, settings) {
+	const existing = FOLLOWUP_QUEUES.get(key);
+	if (existing) {
+		applyQueueRuntimeSettings({
+			target: existing,
+			settings
+		});
+		return existing;
+	}
+	const created = {
+		items: [],
+		draining: false,
+		lastEnqueuedAt: 0,
+		mode: settings.mode,
+		debounceMs: typeof settings.debounceMs === "number" ? Math.max(0, settings.debounceMs) : DEFAULT_QUEUE_DEBOUNCE_MS,
+		cap: typeof settings.cap === "number" && settings.cap > 0 ? Math.floor(settings.cap) : 20,
+		dropPolicy: settings.dropPolicy ?? "summarize",
+		droppedCount: 0,
+		summaryLines: []
+	};
+	applyQueueRuntimeSettings({
+		target: created,
+		settings
+	});
+	FOLLOWUP_QUEUES.set(key, created);
+	return created;
+}
+function clearFollowupQueue(key) {
+	const cleaned = key.trim();
+	const queue = getExistingFollowupQueue(cleaned);
+	if (!queue) return 0;
+	const cleared = queue.items.length + queue.droppedCount;
+	queue.items.length = 0;
+	queue.droppedCount = 0;
+	queue.summaryLines = [];
+	queue.lastRun = void 0;
+	queue.lastEnqueuedAt = 0;
+	FOLLOWUP_QUEUES.delete(cleaned);
+	return cleared;
+}
+function refreshQueuedFollowupSession(params) {
+	const cleaned = params.key.trim();
+	if (!cleaned || !params.previousSessionId || !params.nextSessionId) return;
+	if (params.previousSessionId === params.nextSessionId) return;
+	const queue = getExistingFollowupQueue(cleaned);
+	if (!queue) return;
+	const rewriteRun = (run) => {
+		if (!run || run.sessionId !== params.previousSessionId) return;
+		run.sessionId = params.nextSessionId;
+		if (params.nextSessionFile?.trim()) run.sessionFile = params.nextSessionFile;
+	};
+	rewriteRun(queue.lastRun);
+	for (const item of queue.items) rewriteRun(item.run);
+}
+//#endregion
+//#region src/auto-reply/reply/queue/drain.ts
+const FOLLOWUP_RUN_CALLBACKS = resolveGlobalMap(Symbol.for("vora.followupDrainCallbacks"));
+function rememberFollowupDrainCallback(key, runFollowup) {
+	FOLLOWUP_RUN_CALLBACKS.set(key, runFollowup);
+}
+function clearFollowupDrainCallback(key) {
+	FOLLOWUP_RUN_CALLBACKS.delete(key);
+}
+/** Restart the drain for `key` if it is currently idle, using the stored callback. */
+function kickFollowupDrainIfIdle(key) {
+	const cb = FOLLOWUP_RUN_CALLBACKS.get(key);
+	if (!cb) return;
+	scheduleFollowupDrain(key, cb);
+}
+function resolveOriginRoutingMetadata(items) {
+	return {
+		originatingChannel: items.find((item) => item.originatingChannel)?.originatingChannel,
+		originatingTo: items.find((item) => item.originatingTo)?.originatingTo,
+		originatingAccountId: items.find((item) => item.originatingAccountId)?.originatingAccountId,
+		originatingThreadId: items.find((item) => item.originatingThreadId != null && item.originatingThreadId !== "")?.originatingThreadId
+	};
+}
+function resolveCrossChannelKey(item) {
+	const { originatingChannel: channel, originatingTo: to, originatingAccountId: accountId } = item;
+	const threadId = item.originatingThreadId;
+	if (!channel && !to && !accountId && (threadId == null || threadId === "")) return {};
+	if (!isRoutableChannel(channel) || !to) return { cross: true };
+	return { key: [
+		channel,
+		to,
+		accountId || "",
+		threadId != null && threadId !== "" ? String(threadId) : ""
+	].join("|") };
+}
+function scheduleFollowupDrain(key, runFollowup) {
+	const queue = beginQueueDrain(FOLLOWUP_QUEUES, key);
+	if (!queue) return;
+	const effectiveRunFollowup = FOLLOWUP_RUN_CALLBACKS.get(key) ?? runFollowup;
+	rememberFollowupDrainCallback(key, effectiveRunFollowup);
+	(async () => {
+		try {
+			const collectState = { forceIndividualCollect: false };
+			while (queue.items.length > 0 || queue.droppedCount > 0) {
+				await waitForQueueDebounce(queue);
+				if (queue.mode === "collect") {
+					const collectDrainResult = await drainCollectQueueStep({
+						collectState,
+						isCrossChannel: hasCrossChannelItems(queue.items, resolveCrossChannelKey),
+						items: queue.items,
+						run: effectiveRunFollowup
+					});
+					if (collectDrainResult === "empty") break;
+					if (collectDrainResult === "drained") continue;
+					const items = queue.items.slice();
+					const summary = previewQueueSummaryPrompt({
+						state: queue,
+						noun: "message"
+					});
+					const run = items.at(-1)?.run ?? queue.lastRun;
+					if (!run) break;
+					const routing = resolveOriginRoutingMetadata(items);
+					await effectiveRunFollowup({
+						prompt: buildCollectPrompt({
+							title: "[Queued messages while agent was busy]",
+							items,
+							summary,
+							renderItem: (item, idx) => `---\nQueued #${idx + 1}\n${item.prompt}`.trim()
+						}),
+						run,
+						enqueuedAt: Date.now(),
+						...routing
+					});
+					queue.items.splice(0, items.length);
+					if (summary) clearQueueSummaryState(queue);
+					continue;
+				}
+				const summaryPrompt = previewQueueSummaryPrompt({
+					state: queue,
+					noun: "message"
+				});
+				if (summaryPrompt) {
+					const run = queue.lastRun;
+					if (!run) break;
+					if (!await drainNextQueueItem(queue.items, async (item) => {
+						await effectiveRunFollowup({
+							prompt: summaryPrompt,
+							run,
+							enqueuedAt: Date.now(),
+							originatingChannel: item.originatingChannel,
+							originatingTo: item.originatingTo,
+							originatingAccountId: item.originatingAccountId,
+							originatingThreadId: item.originatingThreadId
+						});
+					})) break;
+					clearQueueSummaryState(queue);
+					continue;
+				}
+				if (!await drainNextQueueItem(queue.items, effectiveRunFollowup)) break;
+			}
+		} catch (err) {
+			queue.lastEnqueuedAt = Date.now();
+			defaultRuntime.error?.(`followup queue drain failed for ${key}: ${String(err)}`);
+		} finally {
+			queue.draining = false;
+			if (queue.items.length === 0 && queue.droppedCount === 0) {
+				FOLLOWUP_QUEUES.delete(key);
+				clearFollowupDrainCallback(key);
+			} else scheduleFollowupDrain(key, effectiveRunFollowup);
+		}
+	})();
+}
+//#endregion
+//#region src/auto-reply/reply/queue/cleanup.ts
+const defaultQueueCleanupDeps = {
+	resolveEmbeddedSessionLane,
+	clearCommandLane
+};
+const queueCleanupDeps = { ...defaultQueueCleanupDeps };
+function resolveQueueCleanupLaneResolver() {
+	return typeof queueCleanupDeps.resolveEmbeddedSessionLane === "function" ? queueCleanupDeps.resolveEmbeddedSessionLane : defaultQueueCleanupDeps.resolveEmbeddedSessionLane;
+}
+function resolveQueueCleanupLaneClearer() {
+	return typeof queueCleanupDeps.clearCommandLane === "function" ? queueCleanupDeps.clearCommandLane : defaultQueueCleanupDeps.clearCommandLane;
+}
+function clearSessionQueues(keys) {
+	const seen = /* @__PURE__ */ new Set();
+	let followupCleared = 0;
+	let laneCleared = 0;
+	const clearedKeys = [];
+	const resolveLane = resolveQueueCleanupLaneResolver();
+	const clearLane = resolveQueueCleanupLaneClearer();
+	for (const key of keys) {
+		const cleaned = key?.trim();
+		if (!cleaned || seen.has(cleaned)) continue;
+		seen.add(cleaned);
+		clearedKeys.push(cleaned);
+		followupCleared += clearFollowupQueue(cleaned);
+		clearFollowupDrainCallback(cleaned);
+		laneCleared += clearLane(resolveLane(cleaned));
+	}
+	return {
+		followupCleared,
+		laneCleared,
+		keys: clearedKeys
+	};
+}
+//#endregion
+//#region src/auto-reply/reply/queue/enqueue.ts
+const RECENT_QUEUE_MESSAGE_IDS = resolveGlobalDedupeCache(Symbol.for("vora.recentQueueMessageIds"), {
+	ttlMs: 300 * 1e3,
+	maxSize: 1e4
+});
+function buildRecentMessageIdKey(run, queueKey) {
+	const messageId = run.messageId?.trim();
+	if (!messageId) return;
+	return JSON.stringify([
+		"queue",
+		queueKey,
+		run.originatingChannel ?? "",
+		run.originatingTo ?? "",
+		run.originatingAccountId ?? "",
+		run.originatingThreadId == null ? "" : String(run.originatingThreadId),
+		messageId
+	]);
+}
+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", runFollowup, restartIfIdle = true) {
+	const queue = getFollowupQueue(key, settings);
+	const recentMessageIdKey = dedupeMode !== "none" ? buildRecentMessageIdKey(run, key) : void 0;
+	if (recentMessageIdKey && RECENT_QUEUE_MESSAGE_IDS.peek(recentMessageIdKey)) return false;
+	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);
+	if (recentMessageIdKey) RECENT_QUEUE_MESSAGE_IDS.check(recentMessageIdKey);
+	if (runFollowup) rememberFollowupDrainCallback(key, runFollowup);
+	if (restartIfIdle && !queue.draining) kickFollowupDrainIfIdle(key);
+	return true;
+}
+function getFollowupQueueDepth(key) {
+	const queue = getExistingFollowupQueue(key);
+	if (!queue) return 0;
+	return queue.items.length;
+}
+//#endregion
+//#region src/auto-reply/reply/queue/settings.ts
+function defaultQueueModeForChannel(_channel) {
+	return "collect";
+}
+/** Resolve per-channel debounce override from debounceMsByChannel map. */
+function resolveChannelDebounce(byChannel, channelKey) {
+	if (!channelKey || !byChannel) return;
+	const value = byChannel[channelKey];
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function resolvePluginDebounce(channelKey) {
+	if (!channelKey) return;
+	const value = getChannelPlugin(channelKey)?.defaults?.queue?.debounceMs;
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function resolveQueueSettings(params) {
+	const channelKey = params.channel?.trim().toLowerCase();
+	const queueCfg = params.cfg.messages?.queue;
+	const providerModeRaw = channelKey && queueCfg?.byChannel ? queueCfg.byChannel[channelKey] : void 0;
+	const resolvedMode = params.inlineMode ?? normalizeQueueMode(params.sessionEntry?.queueMode) ?? normalizeQueueMode(providerModeRaw) ?? normalizeQueueMode(queueCfg?.mode) ?? defaultQueueModeForChannel(channelKey);
+	const debounceRaw = params.inlineOptions?.debounceMs ?? params.sessionEntry?.queueDebounceMs ?? resolveChannelDebounce(queueCfg?.debounceMsByChannel, channelKey) ?? resolvePluginDebounce(channelKey) ?? queueCfg?.debounceMs ?? 1e3;
+	const capRaw = params.inlineOptions?.cap ?? params.sessionEntry?.queueCap ?? queueCfg?.cap ?? 20;
+	const dropRaw = params.inlineOptions?.dropPolicy ?? params.sessionEntry?.queueDrop ?? normalizeQueueDropPolicy(queueCfg?.drop) ?? "summarize";
+	return {
+		mode: resolvedMode,
+		debounceMs: typeof debounceRaw === "number" ? Math.max(0, debounceRaw) : void 0,
+		cap: typeof capRaw === "number" ? Math.max(1, Math.floor(capRaw)) : void 0,
+		dropPolicy: dropRaw
+	};
+}
+//#endregion
+//#region src/infra/outbound/conversation-id.ts
+function normalizeConversationId(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function resolveExplicitConversationTargetId(target) {
+	for (const prefix of [
+		"channel:",
+		"conversation:",
+		"group:",
+		"room:",
+		"dm:"
+	]) if (target.toLowerCase().startsWith(prefix)) return normalizeConversationId(target.slice(prefix.length));
+}
+function resolveConversationIdFromTargets(params) {
+	const threadId = params.threadId != null ? normalizeConversationId(String(params.threadId)) : void 0;
+	if (threadId) return threadId;
+	for (const rawTarget of params.targets) {
+		const target = normalizeConversationId(rawTarget);
+		if (!target) continue;
+		const explicitConversationId = resolveExplicitConversationTargetId(target);
+		if (explicitConversationId) return explicitConversationId;
+		if (target.includes(":") && explicitConversationId === void 0) continue;
+		const mentionMatch = target.match(/^<#(\d+)>$/);
+		if (mentionMatch?.[1]) return mentionMatch[1];
+		if (/^\d{6,}$/.test(target)) return target;
+	}
+}
+//#endregion
+//#region src/agents/timeout.ts
+const DEFAULT_AGENT_TIMEOUT_SECONDS = 2880 * 60;
+const MAX_SAFE_TIMEOUT_MS = 2147e6;
+const normalizeNumber = (value) => typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : void 0;
+function resolveAgentTimeoutSeconds(cfg) {
+	const seconds = normalizeNumber(cfg?.agents?.defaults?.timeoutSeconds) ?? DEFAULT_AGENT_TIMEOUT_SECONDS;
+	return Math.max(seconds, 1);
+}
+function resolveAgentTimeoutMs(opts) {
+	const minMs = Math.max(normalizeNumber(opts.minMs) ?? 1, 1);
+	const clampTimeoutMs = (valueMs) => Math.min(Math.max(valueMs, minMs), MAX_SAFE_TIMEOUT_MS);
+	const defaultMs = clampTimeoutMs(resolveAgentTimeoutSeconds(opts.cfg) * 1e3);
+	const NO_TIMEOUT_MS = MAX_SAFE_TIMEOUT_MS;
+	const overrideMs = normalizeNumber(opts.overrideMs);
+	if (overrideMs !== void 0) {
+		if (overrideMs === 0) return NO_TIMEOUT_MS;
+		if (overrideMs < 0) return defaultMs;
+		return clampTimeoutMs(overrideMs);
+	}
+	const overrideSeconds = normalizeNumber(opts.overrideSeconds);
+	if (overrideSeconds !== void 0) {
+		if (overrideSeconds === 0) return NO_TIMEOUT_MS;
+		if (overrideSeconds < 0) return defaultMs;
+		return clampTimeoutMs(overrideSeconds * 1e3);
+	}
+	return defaultMs;
+}
+//#endregion
+//#region src/agents/content-blocks.ts
+function collectTextContentBlocks(content) {
+	if (!Array.isArray(content)) return [];
+	const parts = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const rec = block;
+		if (rec.type === "text" && typeof rec.text === "string") parts.push(rec.text);
+	}
+	return parts;
+}
+//#endregion
+export { disposeSessionMcpRuntime as A, getTotalQueueSize as B, extractQueueDirective as C, resolveFastModeState as D, resolveFastModeParam as E, isReasoningTagProvider as F, CommandLane as G, resetAllLanes as H, clearCommandLane as I, enqueueCommandInLane as L, loadEmbeddedPiMcpConfig as M, describeStdioMcpServerLaunchConfig as N, createBundleMcpToolRuntime as O, resolveStdioMcpServerLaunchConfig as P, getActiveTaskCount as R, resolveSessionLane as S, takeDirectiveToken as T, setCommandLaneConcurrency as U, markGatewayDraining as V, waitForActiveTasks as W, hasCrossChannelItems as _, enqueueFollowupRun as a, resolveEmbeddedSessionLane as b, scheduleFollowupDrain as c, applyQueueRuntimeSettings as d, beginQueueDrain as f, drainNextQueueItem as g, drainCollectQueueStep as h, resolveQueueSettings as i, getOrCreateSessionMcpRuntime as j, materializeBundleMcpToolsForRun as k, refreshQueuedFollowupSession as l, clearQueueSummaryState as m, resolveAgentTimeoutMs as n, getFollowupQueueDepth as o, buildCollectPrompt as p, resolveConversationIdFromTargets as r, clearSessionQueues as s, collectTextContentBlocks as t, applyQueueDropPolicy as u, previewQueueSummaryPrompt as v, skipDirectiveArgPrefix as w, resolveGlobalLane as x, waitForQueueDebounce as y, getQueueSize as z };