@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/channel.runtime-w3cW8r41.js

@@ -1,2528 +0,0 @@
-import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
-import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
-import { p as resolveThreadSessionKeys$1 } from "./session-key-Bte0mmcq.js";
-import { Nn as record, Rn as string, Tn as object, Xn as union, Zn as unknown } from "./schemas-Del5uzR8.js";
-import { n as safeParseWithSchema, t as safeParseJsonWithSchema } from "./zod-parse-B4dzFRWI.js";
-import { i as isLoopbackHost } from "./net-DCUMtgJy.js";
-import { i as parseStrictPositiveInteger } from "./parse-finite-number-C3Woj8eC.js";
-import { t as rawDataToString } from "./ws-C3qhmaFC.js";
-import { a as getReplyPayloadTtsSupplement, n as buildTtsSupplementMediaPayload } from "./reply-payload-CiT5mlcY.js";
-import { t as countOutboundMedia, u as isReasoningReplyPayload } from "./reply-payload-DMPQsrQC.js";
-import { k as resolveChannelStreamingPreviewToolProgress, s as formatChannelProgressDraftLineForEntry } from "./channel-streaming-BBW2i40H.js";
-import { a as resolveInboundLastRouteSessionKey } from "./resolve-route-C0-Q-Gjg.js";
-import { a as warnMissingProviderGroupPolicyFallbackOnce, n as resolveAllowlistProviderRuntimeGroupPolicy, r as resolveDefaultGroupPolicy } from "./runtime-group-policy-CmZDlIwd.js";
-import { l as resolvePinnedMainDmOwnerFromAllowlist } from "./dm-policy-shared-Bj-e8bT2.js";
-import { n as fetchWithSsrFGuard } from "./fetch-guard-CeBd6u85.js";
-import { a as deliverWithFinalizableLivePreviewAdapter, r as defineFinalizableLivePreviewAdapter } from "./live-CF0ee90S.js";
-import { n as createDebugProxyWebSocketAgent, r as resolveDebugProxySettings } from "./env-CAUZ9092.js";
-import "./error-runtime--zM-GsR-.js";
-import { n as captureWsEvent } from "./runtime-CrtvA8R4.js";
-import "./proxy-capture-BiTkVI2s.js";
-import "./string-coerce-runtime-DcopKqDR.js";
-import "./routing-AC-P99jg.js";
-import { i as formatInboundFromLabel$1 } from "./envelope-DUI2KFD9.js";
-import "./history-CaPbjSZl.js";
-import { t as createChannelReplyPipeline } from "./reply-pipeline-CbGLcDzV.js";
-import { t as createChannelHistoryWindow } from "./history-window-BQUXX_Lf.js";
-import { t as buildAgentMediaPayload } from "./agent-media-payload-CMMnUmpJ.js";
-import { d as ssrfPolicyFromPrivateNetworkOptIn, o as isPrivateNetworkOptInEnabled } from "./ssrf-policy-DsqKLgib.js";
-import "./ssrf-runtime-Gwgbj2qf.js";
-import { a as resolveChannelMediaMaxBytes } from "./media-runtime-CPXTkSQr.js";
-import { t as registerPluginHttpRoute } from "./http-registry-RBQyJi8F.js";
-import "./security-runtime-Q5KQBgu1.js";
-import "./gateway-runtime-raEVqCxi.js";
-import { t as listSkillCommandsForAgents } from "./skill-commands-No-ulihf.js";
-import { t as buildModelsProviderData } from "./commands-models-DJy73Scp.js";
-import "./extension-shared-D6I0yOLZ.js";
-import { n as logInboundDrop, r as logTypingFailure } from "./logging-Dr3f0mtP.js";
-import "./channel-inbound-CLiXSx1p.js";
-import { r as createFinalizableDraftLifecycle } from "./channel-lifecycle-DDnbT5P-.js";
-import "./channel-message-YAmKOwAT.js";
-import { n as createChannelPairingController } from "./channel-pairing-BQeyBt0a.js";
-import { t as createClaimableDedupe } from "./persistent-dedupe-Dz4p2d8x.js";
-import "./webhook-ingress-CG1vdjMj.js";
-import { a as resolveMattermostMonitorInboundAccess, r as normalizeMattermostAllowEntry, t as authorizeMattermostCommandInvocation } from "./monitor-auth-9lbTrakT.js";
-import { _ as readMattermostError, a as MattermostPostSchema, c as createMattermostPost, f as fetchMattermostMe, g as normalizeMattermostBaseUrl, h as fetchMattermostUserTeams, i as resolveMattermostReplyToMode, l as deleteMattermostPost, o as createMattermostClient, p as fetchMattermostUser, r as resolveMattermostAccount, t as listMattermostAccountIds, u as fetchMattermostChannel, v as sendMattermostTyping, y as updateMattermostPost } from "./accounts-DoryUQ_b.js";
-import { t as getMattermostRuntime } from "./runtime-BzvboXwU.js";
-import { C as resolveCallbackUrl, S as registerSlashCommands, _ as renderMattermostProviderPickerView, a as sendMessageMattermost, b as cleanupSlashCommands, c as computeInteractionCallbackUrl, d as setInteractionCallbackUrl, f as setInteractionSecret, g as renderMattermostModelsPickerView, h as parseMattermostModelPickerContext, l as createMattermostInteractionHandler, m as buildMattermostAllowedModelRefs, n as deactivateSlashCommands, o as resolveMattermostOpaqueTarget, p as deliverMattermostReplyPayload, r as getSlashCommandState, s as buildButtonProps, t as activateSlashCommands, u as resolveInteractionCallbackPath, v as resolveMattermostModelPickerCurrentModel, w as resolveSlashCommandConfig, x as isSlashCommandsEnabled, y as DEFAULT_COMMAND_SPECS } from "./slash-state-BZ06y0To.js";
-import { randomUUID } from "node:crypto";
-import WebSocket from "ws";
-//#region extensions/mattermost/src/mattermost/directory.ts
-function buildClient(params) {
-	const account = resolveMattermostAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	if (!account.enabled || !account.botToken || !account.baseUrl) return null;
-	return createMattermostClient({
-		baseUrl: account.baseUrl,
-		botToken: account.botToken,
-		allowPrivateNetwork: isPrivateNetworkOptInEnabled(account.config)
-	});
-}
-/**
-* Build clients from ALL enabled accounts (deduplicated by token).
-*
-* We always scan every account because:
-* - Private channels are only visible to bots that are members
-* - The requesting agent's account may have an expired/invalid token
-*
-* This means a single healthy bot token is enough for directory discovery.
-*/
-function buildClients(params) {
-	const accountIds = listMattermostAccountIds(params.cfg);
-	const seen = /* @__PURE__ */ new Set();
-	const clients = [];
-	for (const id of accountIds) {
-		const client = buildClient({
-			cfg: params.cfg,
-			accountId: id
-		});
-		if (client && !seen.has(client.token)) {
-			seen.add(client.token);
-			clients.push(client);
-		}
-	}
-	return clients;
-}
-/**
-* List channels (public + private) visible to any configured bot account.
-*
-* NOTE: Uses per_page=200 which covers most instances. Mattermost does not
-* return a "has more" indicator, so very large instances (200+ channels per bot)
-* may see incomplete results. Pagination can be added if needed.
-*/
-async function listMattermostDirectoryGroups(params) {
-	const clients = buildClients(params);
-	if (!clients.length) return [];
-	const q = normalizeLowercaseStringOrEmpty(params.query);
-	const seenIds = /* @__PURE__ */ new Set();
-	const entries = [];
-	for (const client of clients) try {
-		const me = await fetchMattermostMe(client);
-		const channels = await client.request(`/users/${me.id}/channels?per_page=200`);
-		for (const ch of channels) {
-			if (ch.type !== "O" && ch.type !== "P") continue;
-			if (seenIds.has(ch.id)) continue;
-			if (q) {
-				const name = normalizeLowercaseStringOrEmpty(ch.name);
-				const display = normalizeLowercaseStringOrEmpty(ch.display_name);
-				if (!name.includes(q) && !display.includes(q)) continue;
-			}
-			seenIds.add(ch.id);
-			entries.push({
-				kind: "group",
-				id: `channel:${ch.id}`,
-				name: ch.name ?? void 0,
-				handle: ch.display_name ?? void 0
-			});
-		}
-	} catch (err) {
-		console.debug?.("[mattermost-directory] listGroups: skipping account:", err?.message);
-		continue;
-	}
-	return params.limit && params.limit > 0 ? entries.slice(0, params.limit) : entries;
-}
-/**
-* List team members as peer directory entries.
-*
-* Uses only the first available client since all bots in a team see the same
-* user list (unlike channels where membership varies). Uses the first team
-* returned — multi-team setups will only see members from that team.
-*
-* NOTE: per_page=200 for member listing; same pagination caveat as groups.
-*/
-async function listMattermostDirectoryPeers(params) {
-	const clients = buildClients(params);
-	if (!clients.length) return [];
-	const client = clients[0];
-	try {
-		const me = await fetchMattermostMe(client);
-		const teams = await client.request("/users/me/teams");
-		if (!teams.length) return [];
-		const teamId = teams[0].id;
-		const q = normalizeLowercaseStringOrEmpty(params.query);
-		let users;
-		if (q) users = await client.request("/users/search", {
-			method: "POST",
-			body: JSON.stringify({
-				term: q,
-				team_id: teamId
-			})
-		});
-		else {
-			const userIds = (await client.request(`/teams/${teamId}/members?per_page=200`)).map((m) => m.user_id).filter((id) => id !== me.id);
-			if (!userIds.length) return [];
-			users = await client.request("/users/ids", {
-				method: "POST",
-				body: JSON.stringify(userIds)
-			});
-		}
-		const entries = users.filter((u) => u.id !== me.id).map((u) => ({
-			kind: "user",
-			id: `user:${u.id}`,
-			name: u.username ?? void 0,
-			handle: [u.first_name, u.last_name].filter(Boolean).join(" ").trim() || u.nickname || void 0
-		}));
-		return params.limit && params.limit > 0 ? entries.slice(0, params.limit) : entries;
-	} catch (err) {
-		console.debug?.("[mattermost-directory] listPeers failed:", err?.message);
-		return [];
-	}
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/draft-stream.ts
-const MATTERMOST_STREAM_MAX_CHARS = 4e3;
-const DEFAULT_THROTTLE_MS = 1e3;
-function normalizeMattermostDraftText(text, maxChars) {
-	const trimmed = text.trim();
-	if (!trimmed) return "";
-	if (trimmed.length <= maxChars) return trimmed;
-	return `${trimmed.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
-}
-function buildMattermostToolStatusText(params) {
-	return formatChannelProgressDraftLineForEntry(params.config, {
-		event: "tool",
-		name: params.name,
-		phase: params.phase,
-		args: params.args
-	}, params.detailMode ? { detailMode: params.detailMode } : void 0) ?? "Running tool...";
-}
-function createMattermostDraftStream(params) {
-	const maxChars = Math.min(params.maxChars ?? MATTERMOST_STREAM_MAX_CHARS, MATTERMOST_STREAM_MAX_CHARS);
-	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-	const streamState = {
-		stopped: false,
-		final: false
-	};
-	let streamPostId;
-	let lastSentText = "";
-	const sendOrEditStreamMessage = async (text) => {
-		if (streamState.stopped && !streamState.final) return false;
-		const normalized = normalizeMattermostDraftText(params.renderText?.(text) ?? text, maxChars);
-		if (!normalized) return false;
-		if (normalized === lastSentText) return true;
-		try {
-			if (streamPostId) await updateMattermostPost(params.client, streamPostId, { message: normalized });
-			else {
-				const postId = (await createMattermostPost(params.client, {
-					channelId: params.channelId,
-					message: normalized,
-					rootId: params.rootId
-				})).id?.trim();
-				if (!postId) {
-					streamState.stopped = true;
-					params.warn?.("mattermost stream preview stopped (missing post id from create)");
-					return false;
-				}
-				streamPostId = postId;
-			}
-			lastSentText = normalized;
-			return true;
-		} catch (err) {
-			streamState.stopped = true;
-			params.warn?.(`mattermost stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
-			return false;
-		}
-	};
-	const { loop, update, stop, clear, discardPending, seal } = createFinalizableDraftLifecycle({
-		throttleMs,
-		state: streamState,
-		sendOrEditStreamMessage,
-		readMessageId: () => streamPostId,
-		clearMessageId: () => {
-			streamPostId = void 0;
-		},
-		isValidMessageId: (value) => typeof value === "string" && value.length > 0,
-		deleteMessage: async (postId) => {
-			await deleteMattermostPost(params.client, postId);
-		},
-		warn: params.warn,
-		warnPrefix: "mattermost stream preview cleanup failed"
-	});
-	const forceNewMessage = () => {
-		streamPostId = void 0;
-		lastSentText = "";
-		loop.resetPending();
-		loop.resetThrottleWindow();
-	};
-	params.log?.(`mattermost stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
-	return {
-		update,
-		flush: loop.flush,
-		postId: () => streamPostId,
-		clear,
-		discardPending,
-		seal,
-		stop,
-		forceNewMessage
-	};
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor-gating.ts
-function mapMattermostChannelTypeToChatType(channelType) {
-	const normalized = channelType?.trim().toUpperCase();
-	if (!normalized) return "direct";
-	if (normalized === "D") return "direct";
-	if (normalized === "G" || normalized === "P") return "group";
-	return "channel";
-}
-function resolveMattermostTrustedChatKind(params) {
-	const channelType = params.channelType?.trim();
-	if (channelType) return mapMattermostChannelTypeToChatType(channelType);
-	return params.fallback ?? "direct";
-}
-function evaluateMattermostMentionGate(params) {
-	const shouldRequireMention = params.kind !== "direct" && params.resolveRequireMention({
-		cfg: params.cfg,
-		channel: "mattermost",
-		accountId: params.accountId,
-		groupId: params.channelId,
-		requireMentionOverride: params.requireMentionOverride
-	});
-	const shouldBypassMention = params.isControlCommand && shouldRequireMention && !params.wasMentioned && params.commandAuthorized;
-	const effectiveWasMentioned = params.wasMentioned || shouldBypassMention || params.oncharTriggered;
-	if (params.oncharEnabled && !params.oncharTriggered && !params.wasMentioned && !params.isControlCommand) return {
-		shouldRequireMention,
-		shouldBypassMention,
-		effectiveWasMentioned,
-		dropReason: "onchar-not-triggered"
-	};
-	if (params.kind !== "direct" && shouldRequireMention && params.canDetectMention && !effectiveWasMentioned) return {
-		shouldRequireMention,
-		shouldBypassMention,
-		effectiveWasMentioned,
-		dropReason: "missing-mention"
-	};
-	return {
-		shouldRequireMention,
-		shouldBypassMention,
-		effectiveWasMentioned,
-		dropReason: null
-	};
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor-helpers.ts
-const formatInboundFromLabel = formatInboundFromLabel$1;
-function resolveThreadSessionKeys(params) {
-	return resolveThreadSessionKeys$1({
-		...params,
-		normalizeThreadId: (threadId) => threadId
-	});
-}
-/**
-* Strip bot mention from message text while preserving newlines and
-* block-level Markdown formatting (headings, lists, blockquotes).
-*/
-function normalizeMention(text, mention) {
-	if (!mention) return text.trim();
-	const escaped = mention.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	const hasMentionRe = new RegExp(`@${escaped}\\b`, "i");
-	const leadingMentionRe = new RegExp(`^([\\t ]*)@${escaped}\\b[\\t ]*`, "i");
-	const trailingMentionRe = new RegExp(`[\\t ]*@${escaped}\\b[\\t ]*$`, "i");
-	const normalizedLines = text.split("\n").map((line) => {
-		const hadMention = hasMentionRe.test(line);
-		const normalizedLine = line.replace(leadingMentionRe, "$1").replace(trailingMentionRe, "").replace(new RegExp(`@${escaped}\\b`, "gi"), "").replace(/(\S)[ \t]{2,}/g, "$1 ");
-		return {
-			text: normalizedLine,
-			mentionOnlyBlank: hadMention && normalizedLine.trim() === ""
-		};
-	});
-	while (normalizedLines[0]?.mentionOnlyBlank) normalizedLines.shift();
-	while (normalizedLines.at(-1)?.text.trim() === "") normalizedLines.pop();
-	return normalizedLines.map((line) => line.text).join("\n");
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor-onchar.ts
-const DEFAULT_ONCHAR_PREFIXES = [">", "!"];
-function resolveOncharPrefixes(prefixes) {
-	const cleaned = prefixes?.map((entry) => entry.trim()).filter(Boolean) ?? DEFAULT_ONCHAR_PREFIXES;
-	return cleaned.length > 0 ? cleaned : DEFAULT_ONCHAR_PREFIXES;
-}
-function stripOncharPrefix(text, prefixes) {
-	const trimmed = text.trimStart();
-	for (const prefix of prefixes) {
-		if (!prefix) continue;
-		if (trimmed.startsWith(prefix)) return {
-			triggered: true,
-			stripped: trimmed.slice(prefix.length).trimStart()
-		};
-	}
-	return {
-		triggered: false,
-		stripped: text
-	};
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor-resources.ts
-const CHANNEL_CACHE_TTL_MS = 5 * 6e4;
-const USER_CACHE_TTL_MS = 10 * 6e4;
-function createMattermostMonitorResources(params) {
-	const { accountId, callbackUrl, client, logger, mediaMaxBytes, saveRemoteMedia, mediaKindFromMime } = params;
-	const channelCache = /* @__PURE__ */ new Map();
-	const userCache = /* @__PURE__ */ new Map();
-	const resolveMattermostMedia = async (fileIds) => {
-		const ids = (fileIds ?? []).map((id) => id?.trim()).filter(Boolean);
-		if (ids.length === 0) return [];
-		const out = [];
-		for (const fileId of ids) try {
-			const saved = await saveRemoteMedia({
-				url: `${client.apiBaseUrl}/files/${fileId}`,
-				requestInit: { headers: { Authorization: `Bearer ${client.token}` } },
-				filePathHint: fileId,
-				maxBytes: mediaMaxBytes,
-				ssrfPolicy: { allowedHostnames: [new URL(client.baseUrl).hostname] }
-			});
-			const contentType = saved.contentType ?? void 0;
-			out.push({
-				path: saved.path,
-				contentType,
-				kind: mediaKindFromMime(contentType) ?? "unknown"
-			});
-		} catch (err) {
-			logger.debug?.(`mattermost: failed to download file ${fileId}: ${String(err)}`);
-		}
-		return out;
-	};
-	const sendTypingIndicator = async (channelId, parentId) => {
-		await sendMattermostTyping(client, {
-			channelId,
-			parentId
-		});
-	};
-	const resolveChannelInfo = async (channelId) => {
-		const cached = channelCache.get(channelId);
-		if (cached && cached.expiresAt > Date.now()) return cached.value;
-		try {
-			const info = await fetchMattermostChannel(client, channelId);
-			channelCache.set(channelId, {
-				value: info,
-				expiresAt: Date.now() + CHANNEL_CACHE_TTL_MS
-			});
-			return info;
-		} catch (err) {
-			logger.debug?.(`mattermost: channel lookup failed: ${String(err)}`);
-			channelCache.set(channelId, {
-				value: null,
-				expiresAt: Date.now() + CHANNEL_CACHE_TTL_MS
-			});
-			return null;
-		}
-	};
-	const resolveUserInfo = async (userId) => {
-		const cached = userCache.get(userId);
-		if (cached && cached.expiresAt > Date.now()) return cached.value;
-		try {
-			const info = await fetchMattermostUser(client, userId);
-			userCache.set(userId, {
-				value: info,
-				expiresAt: Date.now() + USER_CACHE_TTL_MS
-			});
-			return info;
-		} catch (err) {
-			logger.debug?.(`mattermost: user lookup failed: ${String(err)}`);
-			userCache.set(userId, {
-				value: null,
-				expiresAt: Date.now() + USER_CACHE_TTL_MS
-			});
-			return null;
-		}
-	};
-	const buildModelPickerProps = (channelId, buttons) => buildButtonProps({
-		callbackUrl,
-		accountId,
-		channelId,
-		buttons
-	});
-	const updateModelPickerPost = async (params) => {
-		const props = buildModelPickerProps(params.channelId, params.buttons ?? []) ?? { attachments: [] };
-		await updateMattermostPost(client, params.postId, {
-			message: params.message,
-			props
-		});
-		return {};
-	};
-	return {
-		resolveMattermostMedia,
-		sendTypingIndicator,
-		resolveChannelInfo,
-		resolveUserInfo,
-		updateModelPickerPost
-	};
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor-slash.ts
-function buildSlashCommands(params) {
-	const commandsToRegister = [...DEFAULT_COMMAND_SPECS];
-	if (!params.nativeSkills) return commandsToRegister;
-	try {
-		const skillCommands = listSkillCommandsForAgents({ cfg: params.cfg });
-		for (const spec of skillCommands) {
-			const name = typeof spec.name === "string" ? spec.name.trim() : "";
-			if (!name) continue;
-			const trigger = name.startsWith("oc_") ? name : `oc_${name}`;
-			commandsToRegister.push({
-				trigger,
-				description: spec.description || `Run skill ${name}`,
-				autoComplete: true,
-				autoCompleteHint: "[args]",
-				originalName: name
-			});
-		}
-	} catch (err) {
-		params.runtime.error?.(`mattermost: failed to list skill commands: ${String(err)}`);
-	}
-	return commandsToRegister;
-}
-function dedupeSlashCommands(commands) {
-	const seen = /* @__PURE__ */ new Set();
-	return commands.filter((cmd) => {
-		const key = cmd.trigger.trim();
-		if (!key || seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-function buildTriggerMap(commands) {
-	const triggerMap = /* @__PURE__ */ new Map();
-	for (const cmd of commands) if (cmd.originalName) triggerMap.set(cmd.trigger, cmd.originalName);
-	return triggerMap;
-}
-function warnOnSuspiciousCallbackUrl(params) {
-	try {
-		const mmHost = new URL(normalizeMattermostBaseUrl(params.baseUrl) ?? params.baseUrl).hostname;
-		const callbackHost = new URL(params.callbackUrl).hostname;
-		if (isLoopbackHost(callbackHost) && !isLoopbackHost(mmHost)) params.runtime.error?.(`mattermost: slash commands callbackUrl resolved to ${params.callbackUrl} (loopback) while baseUrl is ${params.baseUrl}. This MAY be unreachable depending on your deployment. If native slash commands don't work, set channels.mattermost.commands.callbackUrl to a URL reachable from the Mattermost server (e.g. your public reverse proxy URL).`);
-	} catch {}
-}
-async function registerSlashCommandsAcrossTeams(params) {
-	const registered = [];
-	let teamRegistrationFailures = 0;
-	for (const team of params.teams) try {
-		const created = await registerSlashCommands({
-			client: params.client,
-			teamId: team.id,
-			creatorUserId: params.botUserId,
-			callbackUrl: params.callbackUrl,
-			commands: params.commands,
-			log: (msg) => params.runtime.log?.(msg)
-		});
-		registered.push(...created);
-	} catch (err) {
-		teamRegistrationFailures += 1;
-		params.runtime.error?.(`mattermost: failed to register slash commands for team ${team.id}: ${String(err)}`);
-	}
-	return {
-		registered,
-		teamRegistrationFailures
-	};
-}
-async function registerMattermostMonitorSlashCommands(params) {
-	const commandsRaw = params.account.config.commands;
-	const slashConfig = resolveSlashCommandConfig(commandsRaw);
-	if (!isSlashCommandsEnabled(slashConfig)) return;
-	try {
-		const teams = await fetchMattermostUserTeams(params.client, params.botUserId);
-		const slashCallbackUrl = resolveCallbackUrl({
-			config: slashConfig,
-			gatewayPort: parseStrictPositiveInteger(process.env.DAOCORE_GATEWAY_PORT?.trim()) ?? params.cfg.gateway?.port ?? 18789,
-			gatewayHost: params.cfg.gateway?.customBindHost ?? void 0
-		});
-		warnOnSuspiciousCallbackUrl({
-			runtime: params.runtime,
-			baseUrl: params.baseUrl,
-			callbackUrl: slashCallbackUrl
-		});
-		const dedupedCommands = dedupeSlashCommands(buildSlashCommands({
-			cfg: params.cfg,
-			runtime: params.runtime,
-			nativeSkills: slashConfig.nativeSkills === true
-		}));
-		const { registered, teamRegistrationFailures } = await registerSlashCommandsAcrossTeams({
-			client: params.client,
-			teams,
-			botUserId: params.botUserId,
-			callbackUrl: slashCallbackUrl,
-			commands: dedupedCommands,
-			runtime: params.runtime
-		});
-		if (registered.length === 0) {
-			params.runtime.error?.("mattermost: native slash commands enabled but no commands could be registered; keeping slash callbacks inactive");
-			return;
-		}
-		if (teamRegistrationFailures > 0) params.runtime.error?.(`mattermost: slash command registration completed with ${teamRegistrationFailures} team error(s)`);
-		activateSlashCommands({
-			account: params.account,
-			commandTokens: registered.map((cmd) => cmd.token).filter(Boolean),
-			registeredCommands: registered,
-			triggerMap: buildTriggerMap(dedupedCommands),
-			api: {
-				cfg: params.cfg,
-				runtime: params.runtime
-			},
-			log: (msg) => params.runtime.log?.(msg)
-		});
-		params.runtime.log?.(`mattermost: slash commands registered (${registered.length} commands across ${teams.length} teams, callback=${slashCallbackUrl})`);
-	} catch (err) {
-		params.runtime.error?.(`mattermost: failed to register slash commands: ${String(err)}`);
-	}
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor-websocket.ts
-const MattermostEventPayloadSchema = object({
-	event: string().optional(),
-	data: object({
-		post: union([string(), MattermostPostSchema]).optional(),
-		reaction: union([string(), record(string(), unknown())]).optional(),
-		channel_id: string().optional(),
-		channel_name: string().optional(),
-		channel_display_name: string().optional(),
-		channel_type: string().optional(),
-		sender_name: string().optional(),
-		team_id: string().optional()
-	}).optional(),
-	broadcast: object({
-		channel_id: string().optional(),
-		team_id: string().optional(),
-		user_id: string().optional()
-	}).optional()
-});
-function parseMattermostEventPayload(raw) {
-	return safeParseJsonWithSchema(MattermostEventPayloadSchema, raw);
-}
-function parseMattermostPost(value) {
-	if (typeof value === "string") return safeParseJsonWithSchema(MattermostPostSchema, value);
-	return safeParseWithSchema(MattermostPostSchema, value);
-}
-var WebSocketClosedBeforeOpenError = class extends Error {
-	constructor(code, reason) {
-		super(`websocket closed before open (code ${code})`);
-		this.code = code;
-		this.reason = reason;
-		this.name = "WebSocketClosedBeforeOpenError";
-	}
-};
-const defaultMattermostWebSocketFactory = (url) => {
-	const agent = createDebugProxyWebSocketAgent(resolveDebugProxySettings());
-	return new WebSocket(url, agent ? { agent } : void 0);
-};
-function parsePostedPayload(payload) {
-	if (payload.event !== "posted") return null;
-	const postData = payload.data?.post;
-	if (!postData) return null;
-	const post = parseMattermostPost(postData);
-	if (!post) return null;
-	return {
-		payload,
-		post
-	};
-}
-function createMattermostConnectOnce(opts) {
-	const webSocketFactory = opts.webSocketFactory ?? defaultMattermostWebSocketFactory;
-	const healthCheckIntervalMs = opts.healthCheckIntervalMs ?? 3e4;
-	const pingIntervalMs = opts.pingIntervalMs ?? 3e4;
-	const pongTimeoutMs = opts.pongTimeoutMs ?? 1e4;
-	return async () => {
-		const flowId = randomUUID();
-		const ws = webSocketFactory(opts.wsUrl);
-		const onAbort = () => ws.terminate();
-		opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
-		const getBotUpdateAt = opts.getBotUpdateAt;
-		try {
-			return await new Promise((resolve, reject) => {
-				let opened = false;
-				let settled = false;
-				let healthCheckEnabled = getBotUpdateAt != null;
-				let healthCheckInFlight = false;
-				let healthCheckTimer;
-				let protocolKeepaliveEnabled = true;
-				let protocolPingTimer;
-				let protocolPongTimer;
-				let initialUpdateAt;
-				const clearTimers = () => {
-					if (healthCheckTimer !== void 0) {
-						clearTimeout(healthCheckTimer);
-						healthCheckTimer = void 0;
-					}
-					if (protocolPingTimer !== void 0) {
-						clearTimeout(protocolPingTimer);
-						protocolPingTimer = void 0;
-					}
-					if (protocolPongTimer !== void 0) {
-						clearTimeout(protocolPongTimer);
-						protocolPongTimer = void 0;
-					}
-				};
-				const stopHealthChecks = () => {
-					healthCheckEnabled = false;
-					protocolKeepaliveEnabled = false;
-					clearTimers();
-				};
-				const sendProtocolPing = () => {
-					if (!protocolKeepaliveEnabled || settled) return;
-					if (protocolPongTimer !== void 0) clearTimeout(protocolPongTimer);
-					protocolPongTimer = setTimeout(() => {
-						protocolPongTimer = void 0;
-						if (!protocolKeepaliveEnabled || settled) return;
-						opts.runtime.error?.("mattermost websocket pong timeout — reconnecting");
-						stopHealthChecks();
-						ws.terminate();
-					}, pongTimeoutMs);
-					try {
-						ws.ping();
-					} catch (err) {
-						if (!protocolKeepaliveEnabled || settled) return;
-						opts.runtime.error?.(`mattermost websocket ping failed: ${String(err)}`);
-						stopHealthChecks();
-						ws.terminate();
-					}
-				};
-				const scheduleProtocolPing = () => {
-					if (!protocolKeepaliveEnabled || settled || protocolPingTimer !== void 0) return;
-					protocolPingTimer = setTimeout(() => {
-						protocolPingTimer = void 0;
-						sendProtocolPing();
-					}, pingIntervalMs);
-				};
-				const scheduleHealthCheck = () => {
-					if (!getBotUpdateAt || !healthCheckEnabled || settled || healthCheckInFlight) return;
-					healthCheckTimer = setTimeout(() => {
-						healthCheckTimer = void 0;
-						runHealthCheck();
-					}, healthCheckIntervalMs);
-				};
-				const runHealthCheck = async () => {
-					if (!getBotUpdateAt || !healthCheckEnabled || settled || healthCheckInFlight) return;
-					healthCheckInFlight = true;
-					try {
-						const current = await getBotUpdateAt();
-						if (!healthCheckEnabled || settled) return;
-						if (initialUpdateAt === void 0) {
-							initialUpdateAt = current;
-							return;
-						}
-						if (current !== initialUpdateAt) {
-							opts.runtime.log?.(`mattermost: bot account updated (update_at changed: ${initialUpdateAt} → ${current}) — reconnecting`);
-							stopHealthChecks();
-							ws.terminate();
-						}
-					} catch (err) {
-						if (!healthCheckEnabled || settled) return;
-						const label = initialUpdateAt === void 0 ? "mattermost: failed to get initial update_at" : "mattermost: health check error";
-						opts.runtime.error?.(`${label}: ${String(err)}`);
-					} finally {
-						healthCheckInFlight = false;
-						scheduleHealthCheck();
-					}
-				};
-				const resolveOnce = () => {
-					if (settled) return;
-					settled = true;
-					stopHealthChecks();
-					resolve();
-				};
-				const rejectOnce = (error) => {
-					if (settled) return;
-					settled = true;
-					stopHealthChecks();
-					reject(error);
-				};
-				ws.on("open", () => {
-					opened = true;
-					captureWsEvent({
-						url: opts.wsUrl,
-						direction: "local",
-						kind: "ws-open",
-						flowId,
-						meta: { subsystem: "mattermost-websocket" }
-					});
-					opts.statusSink?.({
-						connected: true,
-						lastConnectedAt: Date.now(),
-						lastError: null
-					});
-					const authPayload = JSON.stringify({
-						seq: opts.nextSeq(),
-						action: "authentication_challenge",
-						data: { token: opts.botToken }
-					});
-					captureWsEvent({
-						url: opts.wsUrl,
-						direction: "outbound",
-						kind: "ws-frame",
-						flowId,
-						payload: authPayload,
-						meta: {
-							subsystem: "mattermost-websocket",
-							eventType: "authentication_challenge"
-						}
-					});
-					ws.send(authPayload);
-					scheduleProtocolPing();
-					if (getBotUpdateAt) runHealthCheck();
-				});
-				ws.on("pong", () => {
-					if (protocolPongTimer !== void 0) {
-						clearTimeout(protocolPongTimer);
-						protocolPongTimer = void 0;
-					}
-					scheduleProtocolPing();
-				});
-				ws.on("message", async (data) => {
-					captureWsEvent({
-						url: opts.wsUrl,
-						direction: "inbound",
-						kind: "ws-frame",
-						flowId,
-						payload: Buffer.from(rawDataToString(data)),
-						meta: { subsystem: "mattermost-websocket" }
-					});
-					const payload = parseMattermostEventPayload(rawDataToString(data));
-					if (!payload) return;
-					if (payload.event === "reaction_added" || payload.event === "reaction_removed") {
-						if (!opts.onReaction) return;
-						try {
-							await opts.onReaction(payload);
-						} catch (err) {
-							opts.runtime.error?.(`mattermost reaction handler failed: ${String(err)}`);
-						}
-						return;
-					}
-					if (payload.event !== "posted") return;
-					const parsed = parsePostedPayload(payload);
-					if (!parsed) return;
-					try {
-						await opts.onPosted(parsed.post, parsed.payload);
-					} catch (err) {
-						opts.runtime.error?.(`mattermost handler failed: ${String(err)}`);
-					}
-				});
-				ws.on("close", (code, reason) => {
-					captureWsEvent({
-						url: opts.wsUrl,
-						direction: "local",
-						kind: "ws-close",
-						flowId,
-						closeCode: code,
-						payload: reason,
-						meta: { subsystem: "mattermost-websocket" }
-					});
-					stopHealthChecks();
-					const message = reasonToString(reason);
-					opts.statusSink?.({
-						connected: false,
-						lastDisconnect: {
-							at: Date.now(),
-							status: code,
-							error: message || void 0
-						}
-					});
-					if (opened) {
-						resolveOnce();
-						return;
-					}
-					rejectOnce(new WebSocketClosedBeforeOpenError(code, message || void 0));
-				});
-				ws.on("error", (err) => {
-					captureWsEvent({
-						url: opts.wsUrl,
-						direction: "local",
-						kind: "error",
-						flowId,
-						errorText: String(err),
-						meta: { subsystem: "mattermost-websocket" }
-					});
-					opts.runtime.error?.(`mattermost websocket error: ${String(err)}`);
-					opts.statusSink?.({ lastError: String(err) });
-					try {
-						ws.close();
-					} catch {}
-				});
-			});
-		} finally {
-			opts.abortSignal?.removeEventListener("abort", onAbort);
-		}
-	};
-}
-function reasonToString(reason) {
-	if (!reason) return "";
-	if (typeof reason === "string") return reason;
-	return reason.length > 0 ? reason.toString("utf8") : "";
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/no-visible-reply-diagnostic.ts
-/**
-* Detects the #80501 symptom: `deliverMattermostReplyPayload` accepted a
-* substantive (non-reasoning) payload, called the underlying
-* `deliverTextOrMediaReply`, and the outcome was `"empty"` — meaning the
-* payload had no text and no media to send, so no Mattermost API call
-* happened. The agent's run completes successfully, but no visible
-* channel/thread reply ever surfaces to the user.
-*
-* Returns a structured violation when the outcome is `"empty"` for a payload
-* that nominally carried user-facing content (text or media bytes that ended
-* up dropped by `resolveSendableOutboundReplyParts`/`sendMediaWithLeadingCaption`).
-* Returns `null` for `"reasoning_skipped"` (intentional suppression),
-* `"text"`, or `"media"` (successful visible sends).
-*/
-function evaluateMattermostNoVisibleReply(params) {
-	if (params.outcome !== "empty") return null;
-	const finalText = typeof params.payload.text === "string" ? params.payload.text.trim() : "";
-	const mediaUrlCount = countOutboundMedia(params.payload);
-	if (finalText.length === 0 && mediaUrlCount === 0) return null;
-	return {
-		reason: "no-visible-reply-after-final-delivery",
-		outcome: params.outcome,
-		finalTextLength: finalText.length,
-		mediaUrlCount
-	};
-}
-function formatMattermostNoVisibleReplyLog(params) {
-	return `mattermost no-visible-reply: ${params.violation.reason} to=${params.to} accountId=${params.accountId} agentId=${params.agentId ?? "unknown"} outcome=${params.violation.outcome} finalTextLength=${params.violation.finalTextLength} mediaUrlCount=${params.violation.mediaUrlCount}`;
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/reconnect.ts
-/**
-* Reconnection loop with exponential backoff.
-*
-* Calls `connectFn` in a while loop. On normal resolve (connection closed),
-* the backoff resets. On thrown error (connection failed), the current delay is
-* used, then doubled for the next retry.
-* The loop exits when `abortSignal` fires.
-*/
-async function runWithReconnect(connectFn, opts = {}) {
-	const { initialDelayMs = 2e3, maxDelayMs = 6e4 } = opts;
-	const jitterRatio = Math.max(0, opts.jitterRatio ?? 0);
-	const random = opts.random ?? Math.random;
-	let retryDelay = initialDelayMs;
-	let attempt = 0;
-	while (!opts.abortSignal?.aborted) {
-		let shouldIncreaseDelay = false;
-		let outcome = "resolved";
-		let error;
-		try {
-			await connectFn();
-			retryDelay = initialDelayMs;
-		} catch (err) {
-			if (opts.abortSignal?.aborted) return;
-			outcome = "rejected";
-			error = err;
-			opts.onError?.(err);
-			shouldIncreaseDelay = true;
-		}
-		if (opts.abortSignal?.aborted) return;
-		const delayMs = withJitter(retryDelay, jitterRatio, random);
-		if (!(opts.shouldReconnect?.({
-			attempt,
-			delayMs,
-			outcome,
-			error
-		}) ?? true)) return;
-		opts.onReconnect?.(delayMs);
-		await sleepAbortable(delayMs, opts.abortSignal);
-		if (shouldIncreaseDelay) retryDelay = Math.min(retryDelay * 2, maxDelayMs);
-		attempt++;
-	}
-}
-function withJitter(baseMs, jitterRatio, random) {
-	if (jitterRatio <= 0) return baseMs;
-	const normalized = Math.max(0, Math.min(1, random()));
-	const spread = baseMs * jitterRatio;
-	return Math.max(1, Math.round(baseMs - spread + normalized * spread * 2));
-}
-function sleepAbortable(ms, signal) {
-	return new Promise((resolve) => {
-		if (signal?.aborted) {
-			resolve();
-			return;
-		}
-		const onAbort = () => {
-			clearTimeout(timer);
-			resolve();
-		};
-		const timer = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/monitor.ts
-function shouldUpdateMattermostDraftToolProgress(account) {
-	return account.streamingMode !== "off" && resolveChannelStreamingPreviewToolProgress(account.config);
-}
-function shouldSuppressMattermostDefaultToolProgressMessages(account) {
-	return account.streamingMode !== "off";
-}
-const RECENT_MATTERMOST_MESSAGE_TTL_MS = 5 * 6e4;
-const RECENT_MATTERMOST_MESSAGE_MAX = 2e3;
-function normalizeInteractionSourceIps(values) {
-	return (values ?? []).map((value) => normalizeOptionalString(value)).filter((value) => Boolean(value));
-}
-const recentInboundMessages = createClaimableDedupe({
-	ttlMs: RECENT_MATTERMOST_MESSAGE_TTL_MS,
-	memoryMaxSize: RECENT_MATTERMOST_MESSAGE_MAX
-});
-var MattermostRetryableInboundError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "MattermostRetryableInboundError";
-	}
-};
-function buildMattermostModelPickerSelectMessageSid(params) {
-	const provider = normalizeLowercaseStringOrEmpty(params.provider);
-	const model = normalizeLowercaseStringOrEmpty(params.model);
-	return `interaction:${params.postId}:select:${provider}/${model}`;
-}
-function buildMattermostInboundReplayKeys(params) {
-	return [...new Set(params.messageIds.map((id) => `${params.accountId}:${id.trim()}`))].filter((key) => !key.endsWith(":"));
-}
-async function processMattermostReplayGuardedPost(params) {
-	const replayGuard = params.replayGuard ?? recentInboundMessages;
-	const replayKeys = buildMattermostInboundReplayKeys({
-		accountId: params.accountId,
-		messageIds: params.messageIds
-	});
-	if (replayKeys.length === 0) {
-		await params.handlePost();
-		return "processed";
-	}
-	const claimedKeys = [];
-	for (const replayKey of replayKeys) if ((await replayGuard.claim(replayKey)).kind === "claimed") claimedKeys.push(replayKey);
-	if (claimedKeys.length === 0) return "duplicate";
-	try {
-		await params.handlePost();
-		await Promise.all(claimedKeys.map((replayKey) => replayGuard.commit(replayKey)));
-		return "processed";
-	} catch (error) {
-		if (error instanceof MattermostRetryableInboundError) claimedKeys.forEach((replayKey) => replayGuard.release(replayKey, { error }));
-		else await Promise.all(claimedKeys.map((replayKey) => replayGuard.commit(replayKey)));
-		throw error;
-	}
-}
-function resolveRuntime(opts) {
-	return opts.runtime ?? {
-		log: console.log,
-		error: console.error,
-		exit: (code) => {
-			throw new Error(`exit ${code}`);
-		}
-	};
-}
-function isSystemPost(post) {
-	return normalizeOptionalString(post.type) !== void 0;
-}
-function channelChatType(kind) {
-	if (kind === "direct") return "direct";
-	if (kind === "group") return "group";
-	return "channel";
-}
-function resolveMattermostReplyRootId(params) {
-	if (params.kind === "direct") return;
-	const threadRootId = normalizeOptionalString(params.threadRootId);
-	if (threadRootId) return threadRootId;
-	return normalizeOptionalString(params.replyToId);
-}
-function canFinalizeMattermostPreviewInPlace(params) {
-	return resolveMattermostReplyRootId({
-		kind: params.kind,
-		threadRootId: params.threadRootId,
-		replyToId: params.replyToId
-	}) === params.previewRootId?.trim();
-}
-function createDisabledMattermostDraftStream() {
-	const noopAsync = async () => {};
-	return {
-		update: () => {},
-		flush: noopAsync,
-		postId: () => void 0,
-		clear: noopAsync,
-		discardPending: noopAsync,
-		seal: noopAsync,
-		stop: noopAsync,
-		forceNewMessage: () => {}
-	};
-}
-async function deliverMattermostReplyWithDraftPreview(params) {
-	if (isReasoningReplyPayload(params.payload)) return;
-	await deliverWithFinalizableLivePreviewAdapter({
-		kind: params.info.kind,
-		payload: params.payload,
-		adapter: defineFinalizableLivePreviewAdapter({
-			draft: {
-				flush: params.draftStream.flush,
-				clear: params.draftStream.clear,
-				discardPending: params.draftStream.discardPending,
-				seal: params.draftStream.seal,
-				id: params.draftStream.postId
-			},
-			buildFinalEdit: (payload) => {
-				const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
-				const ttsSupplement = getReplyPayloadTtsSupplement(payload);
-				const previewFinalText = params.resolvePreviewFinalText(payload.text ?? ttsSupplement?.spokenText);
-				if (hasMedia && !ttsSupplement || typeof previewFinalText !== "string" || payload.isError || !canFinalizeMattermostPreviewInPlace({
-					kind: params.kind,
-					previewRootId: params.effectiveReplyToId,
-					threadRootId: params.effectiveReplyToId,
-					replyToId: payload.replyToId
-				})) return;
-				return { message: previewFinalText };
-			},
-			editFinal: async (previewPostId, edit) => {
-				await updateMattermostPost(params.client, previewPostId, edit);
-			},
-			onPreviewFinalized: () => {
-				params.previewState.finalizedViaPreviewPost = true;
-			},
-			buildSupplementalPayload: (payload) => getReplyPayloadTtsSupplement(payload) ? buildTtsSupplementMediaPayload(payload) : void 0,
-			deliverSupplemental: async (payload) => {
-				await params.deliverPayload(payload);
-			},
-			logPreviewEditFailure: (err) => {
-				params.logVerboseMessage(`mattermost preview final edit failed; falling back to normal send (${String(err)})`);
-			}
-		}),
-		deliverNormally: async (payload) => {
-			const supplement = getReplyPayloadTtsSupplement(payload);
-			await params.deliverPayload(supplement && !payload.text?.trim() && supplement.visibleTextAlreadyDelivered !== true ? {
-				...payload,
-				text: supplement.spokenText
-			} : payload);
-		}
-	});
-}
-function formatMattermostFinalDeliveryOutcomeLog(params) {
-	const violation = evaluateMattermostNoVisibleReply({
-		outcome: params.outcome,
-		payload: params.payload
-	});
-	if (violation) return formatMattermostNoVisibleReplyLog({
-		violation,
-		to: params.to,
-		accountId: params.accountId,
-		agentId: params.agentId
-	});
-	if (params.outcome === "text" || params.outcome === "media") return `delivered reply to ${params.to}`;
-}
-function resolveMattermostEffectiveReplyToId(params) {
-	if (params.kind === "direct") return;
-	const threadRootId = normalizeOptionalString(params.threadRootId);
-	if (threadRootId && params.replyToMode !== "off") return threadRootId;
-	const postId = normalizeOptionalString(params.postId);
-	if (!postId) return;
-	return params.replyToMode === "all" || params.replyToMode === "first" || params.replyToMode === "batched" ? postId : void 0;
-}
-function resolveMattermostThreadSessionContext(params) {
-	const effectiveReplyToId = resolveMattermostEffectiveReplyToId({
-		kind: params.kind,
-		postId: params.postId,
-		replyToMode: params.replyToMode,
-		threadRootId: params.threadRootId
-	});
-	const threadKeys = resolveThreadSessionKeys({
-		baseSessionKey: params.baseSessionKey,
-		threadId: effectiveReplyToId,
-		parentSessionKey: effectiveReplyToId ? params.baseSessionKey : void 0
-	});
-	return {
-		effectiveReplyToId,
-		sessionKey: threadKeys.sessionKey,
-		parentSessionKey: threadKeys.parentSessionKey
-	};
-}
-function resolveMattermostReactionChannelId(payload) {
-	return normalizeOptionalString(payload.broadcast?.channel_id) ?? normalizeOptionalString(payload.data?.channel_id);
-}
-function buildMattermostAttachmentPlaceholder(mediaList) {
-	if (mediaList.length === 0) return "";
-	if (mediaList.length === 1) return `<media:${mediaList[0].kind === "unknown" ? "document" : mediaList[0].kind}>`;
-	const allImages = mediaList.every((media) => media.kind === "image");
-	const label = allImages ? "image" : "file";
-	const suffix = mediaList.length === 1 ? label : `${label}s`;
-	return `${allImages ? "<media:image>" : "<media:document>"} (${mediaList.length} ${suffix})`;
-}
-function buildMattermostWsUrl(baseUrl) {
-	const normalized = normalizeMattermostBaseUrl(baseUrl);
-	if (!normalized) throw new Error("Mattermost baseUrl is required");
-	return `${normalized.replace(/^http/i, "ws")}/api/v4/websocket`;
-}
-async function monitorMattermostProvider(opts = {}) {
-	const core = getMattermostRuntime();
-	const runtime = resolveRuntime(opts);
-	const cfg = opts.config ?? core.config.current();
-	const account = resolveMattermostAccount({
-		cfg,
-		accountId: opts.accountId
-	});
-	const pairing = createChannelPairingController({
-		core,
-		channel: "mattermost",
-		accountId: account.accountId
-	});
-	const botToken = normalizeOptionalString(opts.botToken) ?? normalizeOptionalString(account.botToken);
-	if (!botToken) throw new Error(`Mattermost bot token missing for account "${account.accountId}" (set channels.mattermost.accounts.${account.accountId}.botToken or MATTERMOST_BOT_TOKEN for default).`);
-	const baseUrl = normalizeMattermostBaseUrl(opts.baseUrl ?? account.baseUrl);
-	if (!baseUrl) throw new Error(`Mattermost baseUrl missing for account "${account.accountId}" (set channels.mattermost.accounts.${account.accountId}.baseUrl or MATTERMOST_URL for default).`);
-	const client = createMattermostClient({
-		baseUrl,
-		botToken,
-		allowPrivateNetwork: isPrivateNetworkOptInEnabled(account.config)
-	});
-	let botUser;
-	await runWithReconnect(async () => {
-		botUser = await fetchMattermostMe(client);
-	}, {
-		abortSignal: opts.abortSignal,
-		jitterRatio: .2,
-		shouldReconnect: ({ outcome }) => outcome === "rejected",
-		onError: (err) => {
-			runtime.error?.(`mattermost: API auth failed: ${String(err)}`);
-			opts.statusSink?.({
-				lastError: String(err),
-				connected: false
-			});
-		},
-		onReconnect: (delayMs) => {
-			runtime.log?.(`mattermost: API not accessible, retrying in ${Math.round(delayMs / 1e3)}s`);
-		}
-	});
-	if (opts.abortSignal?.aborted) return;
-	const botUserId = botUser.id;
-	const botUsername = normalizeOptionalString(botUser.username);
-	runtime.log?.(`mattermost connected as ${botUsername ? `@${botUsername}` : botUserId}`);
-	await registerMattermostMonitorSlashCommands({
-		client,
-		cfg,
-		runtime,
-		account,
-		baseUrl,
-		botUserId
-	});
-	const slashEnabled = getSlashCommandState(account.accountId) != null;
-	setInteractionSecret(account.accountId, botToken);
-	const interactionPath = resolveInteractionCallbackPath(account.accountId);
-	const callbackUrl = computeInteractionCallbackUrl(account.accountId, {
-		gateway: cfg.gateway,
-		interactions: account.config.interactions
-	});
-	setInteractionCallbackUrl(account.accountId, callbackUrl);
-	const allowedInteractionSourceIps = normalizeInteractionSourceIps(account.config.interactions?.allowedSourceIps);
-	try {
-		const mmHost = new URL(baseUrl).hostname;
-		const callbackHost = new URL(callbackUrl).hostname;
-		if (isLoopbackHost(callbackHost) && !isLoopbackHost(mmHost)) runtime.error?.(`mattermost: interactions callbackUrl resolved to ${callbackUrl} (loopback) while baseUrl is ${baseUrl}. This MAY be unreachable depending on your deployment. If button clicks don't work, set channels.mattermost.interactions.callbackBaseUrl to a URL reachable from the Mattermost server (e.g. your public reverse proxy URL).`);
-		if (!isLoopbackHost(callbackHost) && allowedInteractionSourceIps.length === 0) runtime.error?.(`mattermost: interactions callbackUrl resolved to ${callbackUrl} without channels.mattermost.interactions.allowedSourceIps. For safety, non-loopback callback sources will be rejected until you allowlist the Mattermost server or trusted ingress IPs.`);
-	} catch {}
-	const effectiveInteractionSourceIps = allowedInteractionSourceIps.length > 0 ? allowedInteractionSourceIps : ["127.0.0.1", "::1"];
-	const unregisterInteractions = registerPluginHttpRoute({
-		path: interactionPath,
-		fallbackPath: "/mattermost/interactions/default",
-		auth: "plugin",
-		handler: createMattermostInteractionHandler({
-			client,
-			botUserId,
-			accountId: account.accountId,
-			allowedSourceIps: effectiveInteractionSourceIps,
-			trustedProxies: cfg.gateway?.trustedProxies,
-			allowRealIpFallback: cfg.gateway?.allowRealIpFallback === true,
-			handleInteraction: handleModelPickerInteraction,
-			authorizeButtonClick: async ({ payload, post }) => {
-				const channelInfo = await resolveChannelInfo(payload.channel_id);
-				const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-					cfg,
-					surface: "mattermost"
-				});
-				const decision = await authorizeMattermostCommandInvocation({
-					account,
-					cfg,
-					senderId: payload.user_id,
-					senderName: payload.user_name ?? "",
-					channelId: payload.channel_id,
-					channelInfo,
-					readStoreAllowFrom: pairing.readAllowFromStore,
-					allowTextCommands,
-					hasControlCommand: false
-				});
-				if (decision.ok) return { ok: true };
-				return {
-					ok: false,
-					response: {
-						update: {
-							message: post.message ?? "",
-							props: post.props ?? void 0
-						},
-						ephemeral_text: `DaoCore ignored this action for ${decision.roomLabel}.`
-					}
-				};
-			},
-			resolveSessionKey: async ({ channelId, userId, post }) => {
-				const channelInfo = await resolveChannelInfo(channelId);
-				if (!channelInfo?.type) {
-					logVerboseMessage(`mattermost: drop interaction session event (cannot resolve channel type for ${channelId})`);
-					throw new Error("Mattermost channel type could not be resolved");
-				}
-				const kind = mapMattermostChannelTypeToChatType(channelInfo.type);
-				const teamId = channelInfo?.team_id ?? void 0;
-				const route = core.channel.routing.resolveAgentRoute({
-					cfg,
-					channel: "mattermost",
-					accountId: account.accountId,
-					teamId,
-					peer: {
-						kind,
-						id: kind === "direct" ? userId : channelId
-					}
-				});
-				const replyToMode = resolveMattermostReplyToMode(account, kind);
-				return resolveMattermostThreadSessionContext({
-					baseSessionKey: route.sessionKey,
-					kind,
-					postId: post.id || void 0,
-					replyToMode,
-					threadRootId: post.root_id
-				}).sessionKey;
-			},
-			dispatchButtonClick: async (opts) => {
-				const channelInfo = await resolveChannelInfo(opts.channelId);
-				if (!channelInfo?.type) {
-					logVerboseMessage(`mattermost: drop interaction dispatch (cannot resolve channel type for ${opts.channelId})`);
-					return;
-				}
-				const kind = mapMattermostChannelTypeToChatType(channelInfo.type);
-				const chatType = channelChatType(kind);
-				const teamId = channelInfo?.team_id ?? void 0;
-				const channelName = channelInfo?.name ?? void 0;
-				const channelDisplay = channelInfo?.display_name ?? channelName ?? opts.channelId;
-				const route = core.channel.routing.resolveAgentRoute({
-					cfg,
-					channel: "mattermost",
-					accountId: account.accountId,
-					teamId,
-					peer: {
-						kind,
-						id: kind === "direct" ? opts.userId : opts.channelId
-					}
-				});
-				const replyToMode = resolveMattermostReplyToMode(account, kind);
-				const threadContext = resolveMattermostThreadSessionContext({
-					baseSessionKey: route.sessionKey,
-					kind,
-					postId: opts.post.id || opts.postId,
-					replyToMode,
-					threadRootId: opts.post.root_id
-				});
-				const to = kind === "direct" ? `user:${opts.userId}` : `channel:${opts.channelId}`;
-				const bodyText = `[Button click: user @${opts.userName} selected "${opts.actionName}"]`;
-				const ctxPayload = core.channel.reply.finalizeInboundContext({
-					Body: bodyText,
-					BodyForAgent: bodyText,
-					RawBody: bodyText,
-					CommandBody: bodyText,
-					From: kind === "direct" ? `mattermost:${opts.userId}` : kind === "group" ? `mattermost:group:${opts.channelId}` : `mattermost:channel:${opts.channelId}`,
-					To: to,
-					SessionKey: threadContext.sessionKey,
-					ParentSessionKey: threadContext.parentSessionKey,
-					AccountId: route.accountId,
-					ChatType: chatType,
-					ConversationLabel: `mattermost:${opts.userName}`,
-					GroupSubject: kind !== "direct" ? channelDisplay : void 0,
-					GroupChannel: channelName ? `#${channelName}` : void 0,
-					GroupSpace: teamId,
-					SenderName: opts.userName,
-					SenderId: opts.userId,
-					Provider: "mattermost",
-					Surface: "mattermost",
-					MessageSid: `interaction:${opts.postId}:${opts.actionId}`,
-					ReplyToId: threadContext.effectiveReplyToId,
-					MessageThreadId: threadContext.effectiveReplyToId,
-					WasMentioned: true,
-					CommandAuthorized: false,
-					OriginatingChannel: "mattermost",
-					OriginatingTo: to
-				});
-				const textLimit = core.channel.text.resolveTextChunkLimit(cfg, "mattermost", account.accountId, { fallbackLimit: account.textChunkLimit ?? 4e3 });
-				const tableMode = core.channel.text.resolveMarkdownTableMode({
-					cfg,
-					channel: "mattermost",
-					accountId: account.accountId
-				});
-				const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelReplyPipeline({
-					cfg,
-					agentId: route.agentId,
-					channel: "mattermost",
-					accountId: account.accountId,
-					typing: {
-						start: () => sendTypingIndicator(opts.channelId, threadContext.effectiveReplyToId),
-						onStartError: (err) => {
-							logTypingFailure({
-								log: (message) => logger.debug?.(message),
-								channel: "mattermost",
-								target: opts.channelId,
-								error: err
-							});
-						}
-					}
-				});
-				const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
-					...replyPipeline,
-					humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
-					deliver: async (payload) => {
-						await deliverMattermostReplyPayload({
-							core,
-							cfg,
-							payload,
-							to,
-							accountId: account.accountId,
-							agentId: route.agentId,
-							replyToId: resolveMattermostReplyRootId({
-								kind,
-								threadRootId: threadContext.effectiveReplyToId,
-								replyToId: payload.replyToId
-							}),
-							textLimit,
-							tableMode,
-							sendMessage: sendMessageMattermost
-						});
-						runtime.log?.(`delivered button-click reply to ${to}`);
-					},
-					onError: (err, info) => {
-						runtime.error?.(`mattermost button-click ${info.kind} reply failed: ${String(err)}`);
-					},
-					onReplyStart: typingCallbacks?.onReplyStart
-				});
-				await core.channel.reply.dispatchReplyFromConfig({
-					ctx: ctxPayload,
-					cfg,
-					dispatcher,
-					replyOptions: {
-						...replyOptions,
-						disableBlockStreaming: typeof account.blockStreaming === "boolean" ? !account.blockStreaming : void 0,
-						onModelSelected
-					}
-				});
-				markDispatchIdle();
-			},
-			log: (msg) => runtime.log?.(msg)
-		}),
-		pluginId: "mattermost",
-		source: "mattermost-interactions",
-		accountId: account.accountId,
-		log: (msg) => runtime.log?.(msg)
-	});
-	const logger = core.logging.getChildLogger({ module: "mattermost" });
-	const logVerboseMessage = (message) => {
-		if (!core.logging.shouldLogVerbose()) return;
-		logger.debug?.(message);
-	};
-	const mediaMaxBytes = resolveChannelMediaMaxBytes({
-		cfg,
-		resolveChannelLimitMb: () => void 0,
-		accountId: account.accountId
-	}) ?? 8 * 1024 * 1024;
-	const historyLimit = Math.max(0, cfg.messages?.groupChat?.historyLimit ?? 50);
-	const channelHistories = /* @__PURE__ */ new Map();
-	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
-	const dmPolicy = account.config.dmPolicy ?? "pairing";
-	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
-		providerConfigPresent: cfg.channels?.mattermost !== void 0,
-		groupPolicy: account.config.groupPolicy,
-		defaultGroupPolicy
-	});
-	warnMissingProviderGroupPolicyFallbackOnce({
-		providerMissingFallbackApplied,
-		providerKey: "mattermost",
-		accountId: account.accountId,
-		log: (message) => logVerboseMessage(message)
-	});
-	const { resolveMattermostMedia, sendTypingIndicator, resolveChannelInfo, resolveUserInfo, updateModelPickerPost } = createMattermostMonitorResources({
-		accountId: account.accountId,
-		callbackUrl,
-		client,
-		logger: { debug: (message) => logger.debug?.(String(message)) },
-		mediaMaxBytes,
-		saveRemoteMedia: (params) => core.channel.media.saveRemoteMedia(params),
-		mediaKindFromMime: (contentType) => core.media.mediaKindFromMime(contentType)
-	});
-	const runModelPickerCommand = async (params) => {
-		const to = params.kind === "direct" ? `user:${params.senderId}` : `channel:${params.channelId}`;
-		const fromLabel = params.kind === "direct" ? `Mattermost DM from ${params.senderName}` : `Mattermost message in ${params.roomLabel} from ${params.senderName}`;
-		const ctxPayload = core.channel.reply.finalizeInboundContext({
-			Body: params.commandText,
-			BodyForAgent: params.commandText,
-			RawBody: params.commandText,
-			CommandBody: params.commandText,
-			From: params.kind === "direct" ? `mattermost:${params.senderId}` : params.kind === "group" ? `mattermost:group:${params.channelId}` : `mattermost:channel:${params.channelId}`,
-			To: to,
-			SessionKey: params.sessionKey,
-			ParentSessionKey: params.parentSessionKey,
-			AccountId: params.route.accountId,
-			ChatType: params.chatType,
-			ConversationLabel: fromLabel,
-			GroupSubject: params.kind !== "direct" ? params.channelDisplay || params.roomLabel : void 0,
-			GroupChannel: params.channelName ? `#${params.channelName}` : void 0,
-			GroupSpace: params.teamId,
-			SenderName: params.senderName,
-			SenderId: params.senderId,
-			Provider: "mattermost",
-			Surface: "mattermost",
-			MessageSid: params.messageSid ?? `interaction:${params.postId}:${Date.now()}`,
-			ReplyToId: params.effectiveReplyToId,
-			MessageThreadId: params.effectiveReplyToId,
-			Timestamp: Date.now(),
-			WasMentioned: true,
-			CommandAuthorized: params.commandAuthorized,
-			CommandSource: "native",
-			OriginatingChannel: "mattermost",
-			OriginatingTo: to
-		});
-		const tableMode = core.channel.text.resolveMarkdownTableMode({
-			cfg,
-			channel: "mattermost",
-			accountId: account.accountId
-		});
-		const textLimit = core.channel.text.resolveTextChunkLimit(cfg, "mattermost", account.accountId, { fallbackLimit: account.textChunkLimit ?? 4e3 });
-		const shouldDeliverReplies = params.deliverReplies === true;
-		const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelReplyPipeline({
-			cfg,
-			agentId: params.route.agentId,
-			channel: "mattermost",
-			accountId: account.accountId,
-			typing: shouldDeliverReplies ? {
-				start: () => sendTypingIndicator(params.channelId, params.effectiveReplyToId),
-				onStartError: (err) => {
-					logTypingFailure({
-						log: (message) => logger.debug?.(message),
-						channel: "mattermost",
-						target: params.channelId,
-						error: err
-					});
-				}
-			} : void 0
-		});
-		const capturedTexts = [];
-		const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
-			...replyPipeline,
-			deliver: async (payload) => {
-				const trimmedPayload = {
-					...payload,
-					text: core.channel.text.convertMarkdownTables(payload.text ?? "", tableMode).trim()
-				};
-				if (!shouldDeliverReplies) {
-					if (trimmedPayload.text) capturedTexts.push(trimmedPayload.text);
-					return;
-				}
-				await deliverMattermostReplyPayload({
-					core,
-					cfg,
-					payload: trimmedPayload,
-					to,
-					accountId: account.accountId,
-					agentId: params.route.agentId,
-					replyToId: resolveMattermostReplyRootId({
-						kind: params.kind,
-						threadRootId: params.effectiveReplyToId,
-						replyToId: trimmedPayload.replyToId
-					}),
-					textLimit,
-					tableMode: "off",
-					sendMessage: sendMessageMattermost
-				});
-			},
-			onError: (err, info) => {
-				runtime.error?.(`mattermost model picker ${info.kind} reply failed: ${String(err)}`);
-			},
-			onReplyStart: typingCallbacks?.onReplyStart
-		});
-		await core.channel.reply.withReplyDispatcher({
-			dispatcher,
-			onSettled: () => {
-				markDispatchIdle();
-			},
-			run: () => core.channel.reply.dispatchReplyFromConfig({
-				ctx: ctxPayload,
-				cfg,
-				dispatcher,
-				replyOptions: {
-					...replyOptions,
-					disableBlockStreaming: typeof account.blockStreaming === "boolean" ? !account.blockStreaming : void 0,
-					onModelSelected
-				}
-			})
-		});
-		return capturedTexts.join("\n\n").trim();
-	};
-	async function handleModelPickerInteraction(params) {
-		const pickerState = parseMattermostModelPickerContext(params.context);
-		if (!pickerState) return null;
-		if (pickerState.ownerUserId !== params.payload.user_id) return { ephemeral_text: "Only the person who opened this picker can use it." };
-		const channelInfo = await resolveChannelInfo(params.payload.channel_id);
-		const pickerCommandText = pickerState.action === "select" ? `/model ${pickerState.provider}/${pickerState.model}` : pickerState.action === "list" ? `/models ${pickerState.provider}` : "/models";
-		const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-			cfg,
-			surface: "mattermost"
-		});
-		const hasControlCommand = core.channel.text.hasControlCommand(pickerCommandText, cfg);
-		const auth = await authorizeMattermostCommandInvocation({
-			account,
-			cfg,
-			senderId: params.payload.user_id,
-			senderName: params.userName,
-			channelId: params.payload.channel_id,
-			channelInfo,
-			readStoreAllowFrom: pairing.readAllowFromStore,
-			allowTextCommands,
-			hasControlCommand
-		});
-		if (!auth.ok) {
-			if (auth.denyReason === "dm-pairing") {
-				const { code } = await pairing.upsertPairingRequest({
-					id: params.payload.user_id,
-					meta: { name: params.userName }
-				});
-				return { ephemeral_text: core.channel.pairing.buildPairingReply({
-					channel: "mattermost",
-					idLine: `Your Mattermost user id: ${params.payload.user_id}`,
-					code
-				}) };
-			}
-			return { ephemeral_text: auth.denyReason === "unknown-channel" ? "Temporary error: unable to determine channel type. Please try again." : auth.denyReason === "dm-disabled" ? "This bot is not accepting direct messages." : auth.denyReason === "channels-disabled" ? "Model picker actions are disabled in channels." : auth.denyReason === "channel-no-allowlist" ? "Model picker actions are not configured for this channel." : "Unauthorized." };
-		}
-		const kind = auth.kind;
-		const chatType = auth.chatType;
-		const teamId = auth.channelInfo.team_id ?? params.payload.team_id ?? void 0;
-		const channelName = auth.channelName || void 0;
-		const channelDisplay = auth.channelDisplay || auth.channelName || params.payload.channel_id;
-		const roomLabel = auth.roomLabel;
-		const route = core.channel.routing.resolveAgentRoute({
-			cfg,
-			channel: "mattermost",
-			accountId: account.accountId,
-			teamId,
-			peer: {
-				kind,
-				id: kind === "direct" ? params.payload.user_id : params.payload.channel_id
-			}
-		});
-		const replyToMode = resolveMattermostReplyToMode(account, kind);
-		const threadContext = resolveMattermostThreadSessionContext({
-			baseSessionKey: route.sessionKey,
-			kind,
-			postId: params.post.id || params.payload.post_id,
-			replyToMode,
-			threadRootId: params.post.root_id
-		});
-		const modelSessionRoute = {
-			agentId: route.agentId,
-			sessionKey: threadContext.sessionKey
-		};
-		const data = await buildModelsProviderData(cfg, route.agentId);
-		if (data.providers.length === 0) return await updateModelPickerPost({
-			channelId: params.payload.channel_id,
-			postId: params.payload.post_id,
-			message: "No models available."
-		});
-		if (pickerState.action === "providers" || pickerState.action === "back") {
-			const currentModel = resolveMattermostModelPickerCurrentModel({
-				cfg,
-				route: modelSessionRoute,
-				data
-			});
-			const view = renderMattermostProviderPickerView({
-				ownerUserId: pickerState.ownerUserId,
-				data,
-				currentModel
-			});
-			return await updateModelPickerPost({
-				channelId: params.payload.channel_id,
-				postId: params.payload.post_id,
-				message: view.text,
-				buttons: view.buttons
-			});
-		}
-		if (pickerState.action === "list") {
-			const currentModel = resolveMattermostModelPickerCurrentModel({
-				cfg,
-				route: modelSessionRoute,
-				data
-			});
-			const view = renderMattermostModelsPickerView({
-				ownerUserId: pickerState.ownerUserId,
-				data,
-				provider: pickerState.provider,
-				page: pickerState.page,
-				currentModel
-			});
-			return await updateModelPickerPost({
-				channelId: params.payload.channel_id,
-				postId: params.payload.post_id,
-				message: view.text,
-				buttons: view.buttons
-			});
-		}
-		const targetModelRef = `${pickerState.provider}/${pickerState.model}`;
-		if (!buildMattermostAllowedModelRefs(data).has(targetModelRef)) return { ephemeral_text: `That model is no longer available: ${targetModelRef}` };
-		(async () => {
-			try {
-				await runModelPickerCommand({
-					commandText: `/model ${targetModelRef}`,
-					commandAuthorized: auth.commandAuthorized,
-					route,
-					sessionKey: threadContext.sessionKey,
-					parentSessionKey: threadContext.parentSessionKey,
-					channelId: params.payload.channel_id,
-					senderId: params.payload.user_id,
-					senderName: params.userName,
-					kind,
-					chatType,
-					channelName,
-					channelDisplay,
-					roomLabel,
-					teamId,
-					postId: params.payload.post_id,
-					messageSid: buildMattermostModelPickerSelectMessageSid({
-						postId: params.payload.post_id,
-						provider: pickerState.provider,
-						model: pickerState.model
-					}),
-					effectiveReplyToId: threadContext.effectiveReplyToId,
-					deliverReplies: true
-				});
-				const updatedModel = resolveMattermostModelPickerCurrentModel({
-					cfg,
-					route: modelSessionRoute,
-					data,
-					skipCache: true
-				});
-				const view = renderMattermostModelsPickerView({
-					ownerUserId: pickerState.ownerUserId,
-					data,
-					provider: pickerState.provider,
-					page: pickerState.page,
-					currentModel: updatedModel
-				});
-				await updateModelPickerPost({
-					channelId: params.payload.channel_id,
-					postId: params.payload.post_id,
-					message: view.text,
-					buttons: view.buttons
-				});
-			} catch (err) {
-				runtime.error?.(`mattermost model picker select failed: ${String(err)}`);
-			}
-		})();
-		return {};
-	}
-	const handlePost = async (post, payload, messageIds) => {
-		const channelId = post.channel_id ?? payload.data?.channel_id ?? payload.broadcast?.channel_id;
-		if (!channelId) {
-			logVerboseMessage("mattermost: drop post (missing channel id)");
-			return;
-		}
-		const allMessageIds = messageIds?.length ? messageIds : post.id ? [post.id] : [];
-		if (allMessageIds.length === 0) {
-			logVerboseMessage("mattermost: drop post (missing message id)");
-			return;
-		}
-		if (await processMattermostReplayGuardedPost({
-			accountId: account.accountId,
-			messageIds: allMessageIds,
-			handlePost: async () => {
-				const senderId = post.user_id ?? payload.broadcast?.user_id;
-				if (!senderId) {
-					logVerboseMessage("mattermost: drop post (missing sender id)");
-					return;
-				}
-				if (senderId === botUserId) {
-					logVerboseMessage(`mattermost: drop post (self sender=${senderId})`);
-					return;
-				}
-				if (isSystemPost(post)) {
-					logVerboseMessage(`mattermost: drop post (system post type=${post.type ?? "unknown"})`);
-					return;
-				}
-				const channelInfo = await resolveChannelInfo(channelId);
-				const channelType = normalizeOptionalString(channelInfo?.type) ?? normalizeOptionalString(payload.data?.channel_type);
-				if (!channelType) {
-					logVerboseMessage(`mattermost: drop post (cannot resolve channel type for ${channelId})`);
-					return;
-				}
-				const kind = resolveMattermostTrustedChatKind({ channelType });
-				const chatType = channelChatType(kind);
-				const senderName = normalizeOptionalString(payload.data?.sender_name) ?? normalizeOptionalString((await resolveUserInfo(senderId))?.username) ?? senderId;
-				const rawText = normalizeOptionalString(post.message) ?? "";
-				const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-					cfg,
-					surface: "mattermost"
-				});
-				const isControlCommand = allowTextCommands && core.channel.commands.isControlCommandMessage(rawText, cfg);
-				const accessDecision = await resolveMattermostMonitorInboundAccess({
-					account,
-					cfg,
-					senderId,
-					senderName,
-					channelId,
-					kind,
-					groupPolicy,
-					readStoreAllowFrom: pairing.readAllowFromStore,
-					allowTextCommands,
-					hasControlCommand: isControlCommand,
-					eventKind: "message",
-					mayPair: true
-				});
-				const commandAuthorized = accessDecision.commandAccess.authorized;
-				if (accessDecision.ingress.decision !== "allow") {
-					if (kind === "direct") {
-						if (accessDecision.ingress.reasonCode === "dm_policy_disabled") {
-							logVerboseMessage(`mattermost: drop dm (dmPolicy=disabled sender=${senderId})`);
-							return;
-						}
-						if (accessDecision.ingress.decision === "pairing") {
-							const { code, created } = await pairing.upsertPairingRequest({
-								id: senderId,
-								meta: { name: senderName }
-							});
-							logVerboseMessage(`mattermost: pairing request sender=${senderId} created=${created}`);
-							if (created) try {
-								await sendMessageMattermost(`user:${senderId}`, core.channel.pairing.buildPairingReply({
-									channel: "mattermost",
-									idLine: `Your Mattermost user id: ${senderId}`,
-									code
-								}), {
-									cfg,
-									accountId: account.accountId
-								});
-								opts.statusSink?.({ lastOutboundAt: Date.now() });
-							} catch (err) {
-								logVerboseMessage(`mattermost: pairing reply failed for ${senderId}: ${String(err)}`);
-							}
-							return;
-						}
-						logVerboseMessage(`mattermost: drop dm sender=${senderId} (dmPolicy=${dmPolicy})`);
-						return;
-					}
-					if (accessDecision.ingress.reasonCode === "group_policy_disabled") {
-						logVerboseMessage("mattermost: drop group message (groupPolicy=disabled)");
-						return;
-					}
-					if (accessDecision.ingress.reasonCode === "group_policy_empty_allowlist") {
-						logVerboseMessage("mattermost: drop group message (no group allowlist)");
-						return;
-					}
-					if (accessDecision.ingress.reasonCode === "group_policy_not_allowlisted") {
-						logVerboseMessage(`mattermost: drop group sender=${senderId} (not in groupAllowFrom)`);
-						return;
-					}
-					logVerboseMessage(`mattermost: drop group message (groupPolicy=${groupPolicy} reason=${accessDecision.senderAccess.reasonCode})`);
-					return;
-				}
-				if (kind !== "direct" && accessDecision.commandAccess.shouldBlockControlCommand) {
-					logInboundDrop({
-						log: logVerboseMessage,
-						channel: "mattermost",
-						reason: "control command (unauthorized)",
-						target: senderId
-					});
-					return;
-				}
-				const teamId = payload.data?.team_id ?? channelInfo?.team_id ?? void 0;
-				const channelName = payload.data?.channel_name ?? channelInfo?.name ?? "";
-				const channelDisplay = payload.data?.channel_display_name ?? channelInfo?.display_name ?? channelName;
-				const roomLabel = channelName ? `#${channelName}` : channelDisplay || `#${channelId}`;
-				const route = core.channel.routing.resolveAgentRoute({
-					cfg,
-					channel: "mattermost",
-					accountId: account.accountId,
-					teamId,
-					peer: {
-						kind,
-						id: kind === "direct" ? senderId : channelId
-					}
-				});
-				const baseSessionKey = route.sessionKey;
-				const threadRootId = normalizeOptionalString(post.root_id);
-				const replyToMode = resolveMattermostReplyToMode(account, kind);
-				const { effectiveReplyToId, sessionKey, parentSessionKey } = resolveMattermostThreadSessionContext({
-					baseSessionKey,
-					kind,
-					postId: post.id,
-					replyToMode,
-					threadRootId
-				});
-				const historyKey = kind === "direct" ? null : sessionKey;
-				const mentionRegexes = core.channel.mentions.buildMentionRegexes(cfg, route.agentId);
-				const wasMentioned = kind !== "direct" && ((botUsername ? normalizeLowercaseStringOrEmpty(rawText).includes(`@${normalizeLowercaseStringOrEmpty(botUsername)}`) : false) || core.channel.mentions.matchesMentionPatterns(rawText, mentionRegexes));
-				const pendingBody = rawText || (post.file_ids?.length ? `[Mattermost ${post.file_ids.length === 1 ? "file" : "files"}]` : "");
-				const pendingSender = senderName;
-				const recordPendingHistory = () => {
-					const trimmed = pendingBody.trim();
-					createChannelHistoryWindow({ historyMap: channelHistories }).record({
-						limit: historyLimit,
-						historyKey: historyKey ?? "",
-						entry: historyKey && trimmed ? {
-							sender: pendingSender,
-							body: trimmed,
-							timestamp: typeof post.create_at === "number" ? post.create_at : void 0,
-							messageId: post.id ?? void 0
-						} : null
-					});
-				};
-				const oncharEnabled = account.chatmode === "onchar" && kind !== "direct";
-				const oncharPrefixes = oncharEnabled ? resolveOncharPrefixes(account.oncharPrefixes) : [];
-				const oncharResult = oncharEnabled ? stripOncharPrefix(rawText, oncharPrefixes) : {
-					triggered: false,
-					stripped: rawText
-				};
-				const oncharTriggered = oncharResult.triggered;
-				const canDetectMention = Boolean(botUsername) || mentionRegexes.length > 0;
-				const mentionDecision = evaluateMattermostMentionGate({
-					kind,
-					cfg,
-					accountId: account.accountId,
-					channelId,
-					threadRootId,
-					requireMentionOverride: account.requireMention,
-					resolveRequireMention: core.channel.groups.resolveRequireMention,
-					wasMentioned,
-					isControlCommand,
-					commandAuthorized,
-					oncharEnabled,
-					oncharTriggered,
-					canDetectMention
-				});
-				const { shouldRequireMention, shouldBypassMention } = mentionDecision;
-				if (mentionDecision.dropReason === "onchar-not-triggered") {
-					logVerboseMessage(`mattermost: drop group message (onchar not triggered channel=${channelId} sender=${senderId})`);
-					recordPendingHistory();
-					return;
-				}
-				if (mentionDecision.dropReason === "missing-mention") {
-					logVerboseMessage(`mattermost: drop group message (missing mention channel=${channelId} sender=${senderId} requireMention=${shouldRequireMention} bypass=${shouldBypassMention} canDetectMention=${canDetectMention})`);
-					recordPendingHistory();
-					return;
-				}
-				const mediaList = await resolveMattermostMedia(post.file_ids);
-				const mediaPlaceholder = buildMattermostAttachmentPlaceholder(mediaList);
-				const bodyText = normalizeMention([oncharTriggered ? oncharResult.stripped : rawText, mediaPlaceholder].filter(Boolean).join("\n").trim(), botUsername);
-				if (!bodyText) {
-					logVerboseMessage(`mattermost: drop group message (empty body after normalization channel=${channelId} sender=${senderId})`);
-					return;
-				}
-				core.channel.activity.record({
-					channel: "mattermost",
-					accountId: account.accountId,
-					direction: "inbound"
-				});
-				const fromLabel = formatInboundFromLabel({
-					isGroup: kind !== "direct",
-					groupLabel: channelDisplay || roomLabel,
-					groupId: channelId,
-					groupFallback: roomLabel || "Channel",
-					directLabel: senderName,
-					directId: senderId
-				});
-				const textWithId = `${bodyText}\n[mattermost message id: ${post.id ?? "unknown"} channel: ${channelId}]`;
-				let combinedBody = core.channel.reply.formatInboundEnvelope({
-					channel: "Mattermost",
-					from: fromLabel,
-					timestamp: typeof post.create_at === "number" ? post.create_at : void 0,
-					body: textWithId,
-					chatType,
-					sender: {
-						name: senderName,
-						id: senderId
-					}
-				});
-				if (historyKey) combinedBody = createChannelHistoryWindow({ historyMap: channelHistories }).buildPendingContext({
-					historyKey,
-					limit: historyLimit,
-					currentMessage: combinedBody,
-					formatEntry: (entry) => core.channel.reply.formatInboundEnvelope({
-						channel: "Mattermost",
-						from: fromLabel,
-						timestamp: entry.timestamp,
-						body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} channel:${channelId}]` : ""}`,
-						chatType,
-						senderLabel: entry.sender
-					})
-				});
-				const to = kind === "direct" ? `user:${senderId}` : `channel:${channelId}`;
-				const mediaPayload = buildAgentMediaPayload(mediaList);
-				const commandBody = rawText.trim();
-				const inboundHistory = historyKey && historyLimit > 0 ? createChannelHistoryWindow({ historyMap: channelHistories }).buildInboundHistory({
-					historyKey,
-					limit: historyLimit
-				}) : void 0;
-				const ctxPayload = core.channel.reply.finalizeInboundContext({
-					Body: combinedBody,
-					BodyForAgent: bodyText,
-					InboundHistory: inboundHistory,
-					RawBody: bodyText,
-					CommandBody: commandBody,
-					BodyForCommands: commandBody,
-					From: kind === "direct" ? `mattermost:${senderId}` : kind === "group" ? `mattermost:group:${channelId}` : `mattermost:channel:${channelId}`,
-					To: to,
-					SessionKey: sessionKey,
-					ParentSessionKey: parentSessionKey,
-					AccountId: route.accountId,
-					ChatType: chatType,
-					ConversationLabel: fromLabel,
-					GroupSubject: kind !== "direct" ? channelDisplay || roomLabel : void 0,
-					GroupChannel: channelName ? `#${channelName}` : void 0,
-					GroupSpace: teamId,
-					SenderName: senderName,
-					SenderId: senderId,
-					Provider: "mattermost",
-					Surface: "mattermost",
-					MessageSid: post.id ?? void 0,
-					MessageSids: allMessageIds.length > 1 ? allMessageIds : void 0,
-					MessageSidFirst: allMessageIds.length > 1 ? allMessageIds[0] : void 0,
-					MessageSidLast: allMessageIds.length > 1 ? allMessageIds[allMessageIds.length - 1] : void 0,
-					ReplyToId: effectiveReplyToId,
-					MessageThreadId: effectiveReplyToId,
-					Timestamp: typeof post.create_at === "number" ? post.create_at : void 0,
-					WasMentioned: kind !== "direct" ? mentionDecision.effectiveWasMentioned : void 0,
-					CommandAuthorized: commandAuthorized,
-					OriginatingChannel: "mattermost",
-					OriginatingTo: to,
-					...mediaPayload
-				});
-				const pinnedMainDmOwner = kind === "direct" ? resolvePinnedMainDmOwnerFromAllowlist({
-					dmScope: cfg.session?.dmScope,
-					allowFrom: account.config.allowFrom,
-					normalizeEntry: normalizeMattermostAllowEntry
-				}) : null;
-				const storePath = core.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
-				const previewLine = bodyText.slice(0, 200).replace(/\n/g, "\\n");
-				logVerboseMessage(`mattermost inbound: from=${ctxPayload.From} len=${bodyText.length} preview="${previewLine}"`);
-				const textLimit = core.channel.text.resolveTextChunkLimit(cfg, "mattermost", account.accountId, { fallbackLimit: account.textChunkLimit ?? 4e3 });
-				const tableMode = core.channel.text.resolveMarkdownTableMode({
-					cfg,
-					channel: "mattermost",
-					accountId: account.accountId
-				});
-				const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelReplyPipeline({
-					cfg,
-					agentId: route.agentId,
-					channel: "mattermost",
-					accountId: account.accountId,
-					typing: {
-						start: () => sendTypingIndicator(channelId, effectiveReplyToId),
-						onStartError: (err) => {
-							logTypingFailure({
-								log: (message) => logger.debug?.(message),
-								channel: "mattermost",
-								target: channelId,
-								error: err
-							});
-						}
-					}
-				});
-				const draftPreviewEnabled = account.streamingMode !== "off";
-				const draftToolProgressEnabled = shouldUpdateMattermostDraftToolProgress(account);
-				const suppressDefaultToolProgressMessages = shouldSuppressMattermostDefaultToolProgressMessages(account);
-				const draftStream = draftPreviewEnabled ? createMattermostDraftStream({
-					client,
-					channelId,
-					rootId: effectiveReplyToId,
-					throttleMs: 1200,
-					log: logVerboseMessage,
-					warn: logVerboseMessage
-				}) : createDisabledMattermostDraftStream();
-				let lastPartialText = "";
-				const previewState = { finalizedViaPreviewPost: false };
-				const resolvePreviewFinalText = (text) => {
-					if (typeof text !== "string") return;
-					const formatted = core.channel.text.convertMarkdownTables(text, tableMode);
-					const chunkMode = core.channel.text.resolveChunkMode(cfg, "mattermost", account.accountId);
-					const chunks = core.channel.text.chunkMarkdownTextWithMode(formatted, textLimit, chunkMode);
-					if (!chunks.length && formatted) chunks.push(formatted);
-					if (chunks.length != 1) return;
-					const trimmed = chunks[0]?.trim();
-					if (!trimmed) return;
-					if (lastPartialText && lastPartialText.startsWith(trimmed) && trimmed.length < lastPartialText.length) return;
-					return trimmed;
-				};
-				const updateDraftFromPartial = (text) => {
-					const cleaned = text?.trim();
-					if (!cleaned) return;
-					if (cleaned === lastPartialText) return;
-					if (lastPartialText && lastPartialText.startsWith(cleaned) && cleaned.length < lastPartialText.length) return;
-					lastPartialText = cleaned;
-					draftStream.update(cleaned);
-				};
-				const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
-					...replyPipeline,
-					humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
-					typingCallbacks,
-					deliver: async (payload, info) => {
-						await deliverMattermostReplyWithDraftPreview({
-							payload,
-							info,
-							kind,
-							client,
-							draftStream,
-							effectiveReplyToId,
-							resolvePreviewFinalText,
-							previewState,
-							logVerboseMessage,
-							deliverPayload: async (payloadToDeliver) => {
-								const deliveryLog = formatMattermostFinalDeliveryOutcomeLog({
-									outcome: await deliverMattermostReplyPayload({
-										core,
-										cfg,
-										payload: payloadToDeliver,
-										to,
-										accountId: account.accountId,
-										agentId: route.agentId,
-										replyToId: resolveMattermostReplyRootId({
-											kind,
-											threadRootId: effectiveReplyToId,
-											replyToId: payloadToDeliver.replyToId
-										}),
-										textLimit,
-										tableMode,
-										sendMessage: sendMessageMattermost
-									}),
-									payload: payloadToDeliver,
-									to,
-									accountId: account.accountId,
-									agentId: route.agentId
-								});
-								if (deliveryLog) runtime.log?.(deliveryLog);
-							}
-						});
-					},
-					onError: (err, info) => {
-						runtime.error?.(`mattermost ${info.kind} reply failed: ${String(err)}`);
-					}
-				});
-				const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
-					route,
-					sessionKey: route.sessionKey
-				});
-				let dispatchSettledBeforeStart = false;
-				try {
-					await core.channel.turn.run({
-						channel: "mattermost",
-						accountId: route.accountId,
-						raw: post,
-						adapter: {
-							ingest: () => ({
-								id: post.id ?? `${to}:${Date.now()}`,
-								timestamp: post.create_at ?? void 0,
-								rawText,
-								textForAgent: ctxPayload.BodyForAgent,
-								textForCommands: ctxPayload.CommandBody,
-								raw: post
-							}),
-							resolveTurn: () => ({
-								channel: "mattermost",
-								accountId: route.accountId,
-								routeSessionKey: route.sessionKey,
-								storePath,
-								ctxPayload,
-								recordInboundSession: core.channel.session.recordInboundSession,
-								record: {
-									updateLastRoute: kind === "direct" ? {
-										sessionKey: inboundLastRouteSessionKey,
-										channel: "mattermost",
-										to,
-										accountId: route.accountId,
-										mainDmOwnerPin: inboundLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner ? {
-											ownerRecipient: pinnedMainDmOwner,
-											senderRecipient: normalizeMattermostAllowEntry(senderId),
-											onSkip: ({ ownerRecipient, senderRecipient }) => {
-												logVerboseMessage(`mattermost: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`);
-											}
-										} : void 0
-									} : void 0,
-									onRecordError: (err) => {
-										logVerboseMessage(`mattermost: failed updating session meta id=${post.id ?? "unknown"}: ${String(err)}`);
-									}
-								},
-								history: {
-									isGroup: Boolean(historyKey),
-									historyKey: historyKey ?? void 0,
-									historyMap: channelHistories,
-									limit: historyLimit
-								},
-								onPreDispatchFailure: async () => {
-									dispatchSettledBeforeStart = true;
-									await core.channel.reply.settleReplyDispatcher({
-										dispatcher,
-										onSettled: () => {
-											markRunComplete();
-											markDispatchIdle();
-										}
-									});
-								},
-								runDispatch: () => core.channel.reply.withReplyDispatcher({
-									dispatcher,
-									onSettled: () => {
-										markDispatchIdle();
-									},
-									run: () => core.channel.reply.dispatchReplyFromConfig({
-										ctx: ctxPayload,
-										cfg,
-										dispatcher,
-										replyOptions: {
-											...replyOptions,
-											disableBlockStreaming: true,
-											...suppressDefaultToolProgressMessages ? { suppressDefaultToolProgressMessages: true } : {},
-											onModelSelected,
-											onPartialReply: (payload) => {
-												if (account.streamingMode !== "progress") updateDraftFromPartial(payload.text);
-											},
-											onAssistantMessageStart: () => {
-												lastPartialText = "";
-											},
-											onReasoningEnd: () => {
-												lastPartialText = "";
-											},
-											onReasoningStream: async () => {
-												if (!lastPartialText) draftStream.update("Thinking…");
-											},
-											onToolStart: async (payload) => {
-												if (!draftToolProgressEnabled) return;
-												draftStream.update(buildMattermostToolStatusText({
-													...payload,
-													config: account.config
-												}));
-											},
-											onItemEvent: async (payload) => {
-												if (!draftToolProgressEnabled) return;
-												const progressText = formatChannelProgressDraftLineForEntry(account.config, {
-													event: "item",
-													itemId: payload.itemId,
-													itemKind: payload.kind,
-													title: payload.title,
-													name: payload.name,
-													phase: payload.phase,
-													status: payload.status,
-													summary: payload.summary,
-													progressText: payload.progressText,
-													meta: payload.meta
-												});
-												if (progressText) draftStream.update(progressText);
-											}
-										}
-									})
-								})
-							})
-						}
-					});
-				} finally {
-					try {
-						await draftStream.stop();
-					} catch (err) {
-						logVerboseMessage(`mattermost draft preview cleanup failed: ${String(err)}`);
-					}
-					if (!dispatchSettledBeforeStart) markRunComplete();
-				}
-			}
-		}) === "duplicate") {
-			logVerboseMessage(`mattermost: drop post (dedupe account=${account.accountId} ids=${allMessageIds.length})`);
-			return;
-		}
-	};
-	const handleReactionEvent = async (payload) => {
-		const reactionData = payload.data?.reaction;
-		if (!reactionData) return;
-		let reaction = null;
-		if (typeof reactionData === "string") try {
-			reaction = JSON.parse(reactionData);
-		} catch {
-			return;
-		}
-		else if (typeof reactionData === "object") reaction = reactionData;
-		if (!reaction) return;
-		const userId = reaction.user_id?.trim();
-		const postId = reaction.post_id?.trim();
-		const emojiName = reaction.emoji_name?.trim();
-		if (!userId || !postId || !emojiName) return;
-		if (userId === botUserId) return;
-		const action = payload.event === "reaction_removed" ? "removed" : "added";
-		const senderName = normalizeOptionalString((await resolveUserInfo(userId))?.username) ?? userId;
-		const channelId = resolveMattermostReactionChannelId(payload);
-		if (!channelId) {
-			logVerboseMessage(`mattermost: drop reaction (no channel_id in broadcast, cannot enforce policy)`);
-			return;
-		}
-		const channelInfo = await resolveChannelInfo(channelId);
-		if (!channelInfo?.type) {
-			logVerboseMessage(`mattermost: drop reaction (cannot resolve channel type for ${channelId})`);
-			return;
-		}
-		const kind = mapMattermostChannelTypeToChatType(channelInfo.type);
-		const reactionAccess = await resolveMattermostMonitorInboundAccess({
-			account,
-			cfg,
-			senderId: userId,
-			senderName,
-			channelId,
-			kind,
-			groupPolicy,
-			readStoreAllowFrom: pairing.readAllowFromStore,
-			allowTextCommands: false,
-			hasControlCommand: false,
-			eventKind: "reaction",
-			mayPair: false
-		});
-		if (reactionAccess.ingress.decision !== "allow") {
-			if (kind === "direct") logVerboseMessage(`mattermost: drop reaction (dmPolicy=${dmPolicy} sender=${userId} reason=${reactionAccess.senderAccess.reasonCode})`);
-			else logVerboseMessage(`mattermost: drop reaction (groupPolicy=${groupPolicy} sender=${userId} reason=${reactionAccess.senderAccess.reasonCode} channel=${channelId})`);
-			return;
-		}
-		const teamId = channelInfo?.team_id ?? void 0;
-		const sessionKey = core.channel.routing.resolveAgentRoute({
-			cfg,
-			channel: "mattermost",
-			accountId: account.accountId,
-			teamId,
-			peer: {
-				kind,
-				id: kind === "direct" ? userId : channelId
-			}
-		}).sessionKey;
-		const eventText = `Mattermost reaction ${action}: :${emojiName}: by @${senderName} on post ${postId} in channel ${channelId}`;
-		core.system.enqueueSystemEvent(eventText, {
-			sessionKey,
-			contextKey: `mattermost:reaction:${postId}:${emojiName}:${userId}:${action}`
-		});
-		logVerboseMessage(`mattermost reaction: ${action} :${emojiName}: by ${senderName} on ${postId}`);
-	};
-	const inboundDebounceMs = core.channel.debounce.resolveInboundDebounceMs({
-		cfg,
-		channel: "mattermost"
-	});
-	const debouncer = core.channel.debounce.createInboundDebouncer({
-		debounceMs: inboundDebounceMs,
-		buildKey: (entry) => {
-			const channelId = entry.post.channel_id ?? entry.payload.data?.channel_id ?? entry.payload.broadcast?.channel_id;
-			if (!channelId) return null;
-			const threadId = normalizeOptionalString(entry.post.root_id);
-			const threadKey = threadId ? `thread:${threadId}` : "channel";
-			return `mattermost:${account.accountId}:${channelId}:${threadKey}`;
-		},
-		shouldDebounce: (entry) => {
-			if (entry.post.file_ids && entry.post.file_ids.length > 0) return false;
-			const text = normalizeOptionalString(entry.post.message) ?? "";
-			if (!text) return false;
-			return !core.channel.commands.isControlCommandMessage(text, cfg);
-		},
-		onFlush: async (entries) => {
-			const last = entries.at(-1);
-			if (!last) return;
-			if (entries.length === 1) {
-				await handlePost(last.post, last.payload);
-				return;
-			}
-			const combinedText = entries.map((entry) => normalizeOptionalString(entry.post.message) ?? "").filter(Boolean).join("\n");
-			const mergedPost = {
-				...last.post,
-				message: combinedText,
-				file_ids: []
-			};
-			const ids = entries.map((entry) => entry.post.id).filter(Boolean);
-			await handlePost(mergedPost, last.payload, ids.length > 0 ? ids : void 0);
-		},
-		onError: (err) => {
-			runtime.error?.(`mattermost debounce flush failed: ${String(err)}`);
-		}
-	});
-	const wsUrl = buildMattermostWsUrl(baseUrl);
-	let seq = 1;
-	const connectOnce = createMattermostConnectOnce({
-		wsUrl,
-		botToken,
-		abortSignal: opts.abortSignal,
-		statusSink: opts.statusSink,
-		runtime,
-		webSocketFactory: opts.webSocketFactory,
-		nextSeq: () => seq++,
-		getBotUpdateAt: async () => {
-			return (await fetchMattermostMe(client)).update_at ?? 0;
-		},
-		onPosted: async (post, payload) => {
-			await debouncer.enqueue({
-				post,
-				payload
-			});
-		},
-		onReaction: async (payload) => {
-			await handleReactionEvent(payload);
-		}
-	});
-	let slashShutdownCleanup = null;
-	if (slashEnabled) {
-		const runAbortCleanup = () => {
-			if (slashShutdownCleanup) return;
-			const commands = getSlashCommandState(account.accountId)?.registeredCommands ?? [];
-			deactivateSlashCommands(account.accountId);
-			slashShutdownCleanup = cleanupSlashCommands({
-				client,
-				commands,
-				log: (msg) => runtime.log?.(msg)
-			}).catch((err) => {
-				runtime.error?.(`mattermost: slash cleanup failed: ${String(err)}`);
-			});
-		};
-		if (opts.abortSignal?.aborted) runAbortCleanup();
-		else opts.abortSignal?.addEventListener("abort", runAbortCleanup, { once: true });
-	}
-	try {
-		await runWithReconnect(connectOnce, {
-			abortSignal: opts.abortSignal,
-			jitterRatio: .2,
-			onError: (err) => {
-				runtime.error?.(`mattermost connection failed: ${String(err)}`);
-				opts.statusSink?.({
-					lastError: String(err),
-					connected: false
-				});
-			},
-			onReconnect: (delayMs) => {
-				runtime.log?.(`mattermost reconnecting in ${Math.round(delayMs / 1e3)}s`);
-			}
-		});
-	} finally {
-		unregisterInteractions?.();
-	}
-	const slashShutdownCleanupPromise = slashShutdownCleanup;
-	if (slashShutdownCleanupPromise) await Promise.resolve(slashShutdownCleanupPromise);
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/probe.ts
-async function probeMattermost(baseUrl, botToken, timeoutMs = 2500, allowPrivateNetwork = false) {
-	const normalized = normalizeMattermostBaseUrl(baseUrl);
-	if (!normalized) return {
-		ok: false,
-		error: "baseUrl missing"
-	};
-	const url = `${normalized}/api/v4/users/me`;
-	const start = Date.now();
-	const controller = timeoutMs > 0 ? new AbortController() : void 0;
-	let timer = null;
-	if (controller) timer = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		const { response: res, release } = await fetchWithSsrFGuard({
-			url,
-			init: {
-				headers: { Authorization: `Bearer ${botToken}` },
-				signal: controller?.signal
-			},
-			auditContext: "mattermost-probe",
-			policy: ssrfPolicyFromPrivateNetworkOptIn(allowPrivateNetwork)
-		});
-		try {
-			const elapsedMs = Date.now() - start;
-			if (!res.ok) {
-				const detail = await readMattermostError(res);
-				return {
-					ok: false,
-					status: res.status,
-					error: detail || res.statusText,
-					elapsedMs
-				};
-			}
-			const bot = await res.json();
-			return {
-				ok: true,
-				status: res.status,
-				elapsedMs,
-				bot
-			};
-		} finally {
-			await release();
-		}
-	} catch (err) {
-		return {
-			ok: false,
-			status: null,
-			error: formatErrorMessage(err),
-			elapsedMs: Date.now() - start
-		};
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-//#endregion
-//#region extensions/mattermost/src/mattermost/reactions.ts
-const BOT_USER_CACHE_TTL_MS = 10 * 6e4;
-const botUserIdCache = /* @__PURE__ */ new Map();
-async function resolveBotUserId(client, cacheKey) {
-	const cached = botUserIdCache.get(cacheKey);
-	if (cached && cached.expiresAt > Date.now()) return cached.userId;
-	const userId = (await fetchMattermostMe(client))?.id?.trim();
-	if (!userId) return null;
-	botUserIdCache.set(cacheKey, {
-		userId,
-		expiresAt: Date.now() + BOT_USER_CACHE_TTL_MS
-	});
-	return userId;
-}
-async function addMattermostReaction(params) {
-	return runMattermostReaction(params, {
-		action: "add",
-		mutation: createReaction
-	});
-}
-async function removeMattermostReaction(params) {
-	return runMattermostReaction(params, {
-		action: "remove",
-		mutation: deleteReaction
-	});
-}
-async function runMattermostReaction(params, options) {
-	const resolved = resolveMattermostAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const baseUrl = resolved.baseUrl?.trim();
-	const botToken = resolved.botToken?.trim();
-	if (!baseUrl || !botToken) return {
-		ok: false,
-		error: "Mattermost botToken/baseUrl missing."
-	};
-	const client = createMattermostClient({
-		baseUrl,
-		botToken,
-		fetchImpl: params.fetchImpl,
-		allowPrivateNetwork: isPrivateNetworkOptInEnabled(resolved.config)
-	});
-	const userId = await resolveBotUserId(client, `${baseUrl}:${botToken}`);
-	if (!userId) return {
-		ok: false,
-		error: "Mattermost reactions failed: could not resolve bot user id."
-	};
-	try {
-		await options.mutation(client, {
-			userId,
-			postId: params.postId,
-			emojiName: params.emojiName
-		});
-	} catch (err) {
-		return {
-			ok: false,
-			error: `Mattermost ${options.action} reaction failed: ${String(err)}`
-		};
-	}
-	return { ok: true };
-}
-async function createReaction(client, params) {
-	await client.request("/reactions", {
-		method: "POST",
-		body: JSON.stringify({
-			user_id: params.userId,
-			post_id: params.postId,
-			emoji_name: params.emojiName
-		})
-	});
-}
-async function deleteReaction(client, params) {
-	const emoji = encodeURIComponent(params.emojiName);
-	await client.request(`/users/${params.userId}/posts/${params.postId}/reactions/${emoji}`, { method: "DELETE" });
-}
-//#endregion
-export { addMattermostReaction, listMattermostDirectoryGroups, listMattermostDirectoryPeers, monitorMattermostProvider, probeMattermost, removeMattermostReaction, resolveMattermostOpaqueTarget, sendMessageMattermost };