remoteclaw 0.1.0-next.2abd2fa → 0.1.0-next.2e9a6cd

package/dist/web-B9gR_cGR.js

@@ -0,0 +1,3071 @@
+import { C as getChildLogger, g as toWhatsappJid, i as CHAT_CHANNEL_ORDER, t as createSubsystemLogger, u as escapeRegExp } from "./subsystem-BCkt9Ocb.js";
+import { $ as resolveDiscordAccount, A as INTERNAL_MESSAGE_CHANNEL, C as loadConfig, D as mergeInboundPathRoots, E as DEFAULT_IMESSAGE_ATTACHMENT_ROOTS, L as GATEWAY_CLIENT_IDS, R as GATEWAY_CLIENT_MODES, et as normalizeDiscordToken, l as chunkMarkdownTextWithMode, mt as normalizeAccountId, o as getDefaultMediaLocalRoots, pt as DEFAULT_ACCOUNT_ID, rt as formatCliCommand, s as resolveMarkdownTableMode, t as loadWebMedia, u as resolveChunkMode } from "./media-CmiNXiOZ.js";
+import { k as INPUT_PROVENANCE_KIND_VALUES } from "./usage-CAuX4vsd.js";
+import "./accounts-Bomfgw0M.js";
+import { t as generateSecureUuid } from "./secure-random-CBwDBdj1.js";
+import "./targets-3hewwPvM.js";
+import "./fetch-oku6r8tJ.js";
+import "./retry-BzWBtFpP.js";
+import { n as resolveDiscordTarget, t as parseDiscordTarget } from "./targets-Bkw_co-B.js";
+import "./store-Dw93tSB-.js";
+import "./send-CPBd6ItT.js";
+import { n as createDiscordRetryRunner, t as recordChannelActivity } from "./channel-activity-daCpxHdT.js";
+import "./render-6ahYfPwj.js";
+import { t as convertMarkdownTables } from "./tables-DRh09aPZ.js";
+import "./send-BZCfto_I.js";
+import fs from "node:fs/promises";
+import os, { homedir } from "node:os";
+import path, { join } from "node:path";
+import fsSync, { constants, readFileSync } from "node:fs";
+import JSON5 from "json5";
+import { promisify } from "node:util";
+import crypto, { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import AjvPkg from "ajv";
+import "ws";
+import { Type } from "@sinclair/typebox";
+import process$1 from "node:process";
+import "node-edge-tts";
+import { ChannelType, PermissionFlagsBits, Routes } from "discord-api-types/v10";
+import { Embed, RequestClient, serializePayload } from "@buape/carbon";
+import "discord-api-types/payloads/v10";
+import "@whiskeysockets/baileys";
+import "qrcode-terminal";
+
+//#region src/infra/device-identity.ts
+const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+
+//#endregion
+//#region src/infra/tls/gateway.ts
+const execFileAsync$1 = promisify(execFile);
+
+//#endregion
+//#region src/infra/json-files.ts
+function createAsyncLock() {
+	let lock = Promise.resolve();
+	return async function withLock(fn) {
+		const prev = lock;
+		let release;
+		lock = new Promise((resolve) => {
+			release = resolve;
+		});
+		await prev;
+		try {
+			return await fn();
+		} finally {
+			release?.();
+		}
+	};
+}
+
+//#endregion
+//#region src/infra/device-pairing.ts
+const PENDING_TTL_MS = 300 * 1e3;
+const withLock = createAsyncLock();
+
+//#endregion
+//#region src/sessions/session-label.ts
+const SESSION_LABEL_MAX_LENGTH = 64;
+
+//#endregion
+//#region src/gateway/protocol/schema/primitives.ts
+const NonEmptyString = Type.String({ minLength: 1 });
+const SessionLabelString = Type.String({
+	minLength: 1,
+	maxLength: SESSION_LABEL_MAX_LENGTH
+});
+const GatewayClientIdSchema = Type.Union(Object.values(GATEWAY_CLIENT_IDS).map((value) => Type.Literal(value)));
+const GatewayClientModeSchema = Type.Union(Object.values(GATEWAY_CLIENT_MODES).map((value) => Type.Literal(value)));
+
+//#endregion
+//#region src/gateway/protocol/schema/agent.ts
+const AgentEventSchema = Type.Object({
+	runId: NonEmptyString,
+	seq: Type.Integer({ minimum: 0 }),
+	stream: NonEmptyString,
+	ts: Type.Integer({ minimum: 0 }),
+	data: Type.Record(Type.String(), Type.Unknown())
+}, { additionalProperties: false });
+const SendParamsSchema = Type.Object({
+	to: NonEmptyString,
+	message: Type.Optional(Type.String()),
+	mediaUrl: Type.Optional(Type.String()),
+	mediaUrls: Type.Optional(Type.Array(Type.String())),
+	gifPlayback: Type.Optional(Type.Boolean()),
+	channel: Type.Optional(Type.String()),
+	accountId: Type.Optional(Type.String()),
+	threadId: Type.Optional(Type.String()),
+	sessionKey: Type.Optional(Type.String()),
+	idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const PollParamsSchema = Type.Object({
+	to: NonEmptyString,
+	question: NonEmptyString,
+	options: Type.Array(NonEmptyString, {
+		minItems: 2,
+		maxItems: 12
+	}),
+	maxSelections: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 12
+	})),
+	durationSeconds: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 604800
+	})),
+	durationHours: Type.Optional(Type.Integer({ minimum: 1 })),
+	silent: Type.Optional(Type.Boolean()),
+	isAnonymous: Type.Optional(Type.Boolean()),
+	threadId: Type.Optional(Type.String()),
+	channel: Type.Optional(Type.String()),
+	accountId: Type.Optional(Type.String()),
+	idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const AgentParamsSchema = Type.Object({
+	message: NonEmptyString,
+	agentId: Type.Optional(NonEmptyString),
+	to: Type.Optional(Type.String()),
+	replyTo: Type.Optional(Type.String()),
+	sessionId: Type.Optional(Type.String()),
+	sessionKey: Type.Optional(Type.String()),
+	thinking: Type.Optional(Type.String()),
+	deliver: Type.Optional(Type.Boolean()),
+	attachments: Type.Optional(Type.Array(Type.Unknown())),
+	channel: Type.Optional(Type.String()),
+	replyChannel: Type.Optional(Type.String()),
+	accountId: Type.Optional(Type.String()),
+	replyAccountId: Type.Optional(Type.String()),
+	threadId: Type.Optional(Type.String()),
+	groupId: Type.Optional(Type.String()),
+	groupChannel: Type.Optional(Type.String()),
+	groupSpace: Type.Optional(Type.String()),
+	timeout: Type.Optional(Type.Integer({ minimum: 0 })),
+	bestEffortDeliver: Type.Optional(Type.Boolean()),
+	lane: Type.Optional(Type.String()),
+	extraSystemPrompt: Type.Optional(Type.String()),
+	inputProvenance: Type.Optional(Type.Object({
+		kind: Type.String({ enum: [...INPUT_PROVENANCE_KIND_VALUES] }),
+		sourceSessionKey: Type.Optional(Type.String()),
+		sourceChannel: Type.Optional(Type.String()),
+		sourceTool: Type.Optional(Type.String())
+	}, { additionalProperties: false })),
+	idempotencyKey: NonEmptyString,
+	label: Type.Optional(SessionLabelString),
+	spawnedBy: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const AgentIdentityParamsSchema = Type.Object({
+	agentId: Type.Optional(NonEmptyString),
+	sessionKey: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const AgentIdentityResultSchema = Type.Object({
+	agentId: NonEmptyString,
+	name: Type.Optional(NonEmptyString),
+	avatar: Type.Optional(NonEmptyString),
+	emoji: Type.Optional(NonEmptyString)
+}, { additionalProperties: false });
+const AgentWaitParamsSchema = Type.Object({
+	runId: NonEmptyString,
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const WakeParamsSchema = Type.Object({
+	mode: Type.Union([Type.Literal("now"), Type.Literal("next-heartbeat")]),
+	text: NonEmptyString
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/agents-models-skills.ts
+const ModelChoiceSchema = Type.Object({
+	id: NonEmptyString,
+	name: NonEmptyString,
+	provider: NonEmptyString,
+	contextWindow: Type.Optional(Type.Integer({ minimum: 1 })),
+	reasoning: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const AgentSummarySchema = Type.Object({
+	id: NonEmptyString,
+	name: Type.Optional(NonEmptyString),
+	identity: Type.Optional(Type.Object({
+		name: Type.Optional(NonEmptyString),
+		theme: Type.Optional(NonEmptyString),
+		emoji: Type.Optional(NonEmptyString),
+		avatar: Type.Optional(NonEmptyString),
+		avatarUrl: Type.Optional(NonEmptyString)
+	}, { additionalProperties: false }))
+}, { additionalProperties: false });
+const AgentsListParamsSchema = Type.Object({}, { additionalProperties: false });
+const AgentsListResultSchema = Type.Object({
+	defaultId: NonEmptyString,
+	mainKey: NonEmptyString,
+	scope: Type.Union([Type.Literal("per-sender"), Type.Literal("global")]),
+	agents: Type.Array(AgentSummarySchema)
+}, { additionalProperties: false });
+const AgentsCreateParamsSchema = Type.Object({
+	name: NonEmptyString,
+	workspace: NonEmptyString,
+	emoji: Type.Optional(Type.String()),
+	avatar: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const AgentsCreateResultSchema = Type.Object({
+	ok: Type.Literal(true),
+	agentId: NonEmptyString,
+	name: NonEmptyString,
+	workspace: NonEmptyString
+}, { additionalProperties: false });
+const AgentsUpdateParamsSchema = Type.Object({
+	agentId: NonEmptyString,
+	name: Type.Optional(NonEmptyString),
+	workspace: Type.Optional(NonEmptyString),
+	model: Type.Optional(NonEmptyString),
+	avatar: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const AgentsUpdateResultSchema = Type.Object({
+	ok: Type.Literal(true),
+	agentId: NonEmptyString
+}, { additionalProperties: false });
+const AgentsDeleteParamsSchema = Type.Object({
+	agentId: NonEmptyString,
+	deleteFiles: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const AgentsDeleteResultSchema = Type.Object({
+	ok: Type.Literal(true),
+	agentId: NonEmptyString,
+	removedBindings: Type.Integer({ minimum: 0 })
+}, { additionalProperties: false });
+const AgentsFileEntrySchema = Type.Object({
+	name: NonEmptyString,
+	path: NonEmptyString,
+	missing: Type.Boolean(),
+	size: Type.Optional(Type.Integer({ minimum: 0 })),
+	updatedAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	content: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const AgentsFilesListParamsSchema = Type.Object({ agentId: NonEmptyString }, { additionalProperties: false });
+const AgentsFilesListResultSchema = Type.Object({
+	agentId: NonEmptyString,
+	workspace: NonEmptyString,
+	files: Type.Array(AgentsFileEntrySchema)
+}, { additionalProperties: false });
+const AgentsFilesGetParamsSchema = Type.Object({
+	agentId: NonEmptyString,
+	name: NonEmptyString
+}, { additionalProperties: false });
+const AgentsFilesGetResultSchema = Type.Object({
+	agentId: NonEmptyString,
+	workspace: NonEmptyString,
+	file: AgentsFileEntrySchema
+}, { additionalProperties: false });
+const AgentsFilesSetParamsSchema = Type.Object({
+	agentId: NonEmptyString,
+	name: NonEmptyString,
+	content: Type.String()
+}, { additionalProperties: false });
+const AgentsFilesSetResultSchema = Type.Object({
+	ok: Type.Literal(true),
+	agentId: NonEmptyString,
+	workspace: NonEmptyString,
+	file: AgentsFileEntrySchema
+}, { additionalProperties: false });
+const ModelsListParamsSchema = Type.Object({}, { additionalProperties: false });
+const ModelsListResultSchema = Type.Object({ models: Type.Array(ModelChoiceSchema) }, { additionalProperties: false });
+const ToolsCatalogParamsSchema = Type.Object({
+	agentId: Type.Optional(NonEmptyString),
+	includePlugins: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const ToolCatalogProfileSchema = Type.Object({
+	id: Type.Union([
+		Type.Literal("minimal"),
+		Type.Literal("coding"),
+		Type.Literal("messaging"),
+		Type.Literal("full")
+	]),
+	label: NonEmptyString
+}, { additionalProperties: false });
+const ToolCatalogEntrySchema = Type.Object({
+	id: NonEmptyString,
+	label: NonEmptyString,
+	description: Type.String(),
+	source: Type.Union([Type.Literal("core"), Type.Literal("plugin")]),
+	pluginId: Type.Optional(NonEmptyString),
+	optional: Type.Optional(Type.Boolean()),
+	defaultProfiles: Type.Array(Type.Union([
+		Type.Literal("minimal"),
+		Type.Literal("coding"),
+		Type.Literal("messaging"),
+		Type.Literal("full")
+	]))
+}, { additionalProperties: false });
+const ToolCatalogGroupSchema = Type.Object({
+	id: NonEmptyString,
+	label: NonEmptyString,
+	source: Type.Union([Type.Literal("core"), Type.Literal("plugin")]),
+	pluginId: Type.Optional(NonEmptyString),
+	tools: Type.Array(ToolCatalogEntrySchema)
+}, { additionalProperties: false });
+const ToolsCatalogResultSchema = Type.Object({
+	agentId: NonEmptyString,
+	profiles: Type.Array(ToolCatalogProfileSchema),
+	groups: Type.Array(ToolCatalogGroupSchema)
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/channels.ts
+const TalkModeParamsSchema = Type.Object({
+	enabled: Type.Boolean(),
+	phase: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const TalkConfigParamsSchema = Type.Object({ includeSecrets: Type.Optional(Type.Boolean()) }, { additionalProperties: false });
+const TalkProviderConfigSchema = Type.Object({
+	voiceId: Type.Optional(Type.String()),
+	voiceAliases: Type.Optional(Type.Record(Type.String(), Type.String())),
+	modelId: Type.Optional(Type.String()),
+	outputFormat: Type.Optional(Type.String()),
+	apiKey: Type.Optional(Type.String())
+}, { additionalProperties: true });
+const TalkConfigResultSchema = Type.Object({ config: Type.Object({
+	talk: Type.Optional(Type.Object({
+		provider: Type.Optional(Type.String()),
+		providers: Type.Optional(Type.Record(Type.String(), TalkProviderConfigSchema)),
+		voiceId: Type.Optional(Type.String()),
+		voiceAliases: Type.Optional(Type.Record(Type.String(), Type.String())),
+		modelId: Type.Optional(Type.String()),
+		outputFormat: Type.Optional(Type.String()),
+		apiKey: Type.Optional(Type.String()),
+		interruptOnSpeech: Type.Optional(Type.Boolean())
+	}, { additionalProperties: false })),
+	session: Type.Optional(Type.Object({ mainKey: Type.Optional(Type.String()) }, { additionalProperties: false })),
+	ui: Type.Optional(Type.Object({ seamColor: Type.Optional(Type.String()) }, { additionalProperties: false }))
+}, { additionalProperties: false }) }, { additionalProperties: false });
+const ChannelsStatusParamsSchema = Type.Object({
+	probe: Type.Optional(Type.Boolean()),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const ChannelAccountSnapshotSchema = Type.Object({
+	accountId: NonEmptyString,
+	name: Type.Optional(Type.String()),
+	enabled: Type.Optional(Type.Boolean()),
+	configured: Type.Optional(Type.Boolean()),
+	linked: Type.Optional(Type.Boolean()),
+	running: Type.Optional(Type.Boolean()),
+	connected: Type.Optional(Type.Boolean()),
+	reconnectAttempts: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastConnectedAt: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastError: Type.Optional(Type.String()),
+	lastStartAt: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastStopAt: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastInboundAt: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastOutboundAt: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastProbeAt: Type.Optional(Type.Integer({ minimum: 0 })),
+	mode: Type.Optional(Type.String()),
+	dmPolicy: Type.Optional(Type.String()),
+	allowFrom: Type.Optional(Type.Array(Type.String())),
+	tokenSource: Type.Optional(Type.String()),
+	botTokenSource: Type.Optional(Type.String()),
+	appTokenSource: Type.Optional(Type.String()),
+	baseUrl: Type.Optional(Type.String()),
+	allowUnmentionedGroups: Type.Optional(Type.Boolean()),
+	cliPath: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+	dbPath: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+	port: Type.Optional(Type.Union([Type.Integer({ minimum: 0 }), Type.Null()])),
+	probe: Type.Optional(Type.Unknown()),
+	audit: Type.Optional(Type.Unknown()),
+	application: Type.Optional(Type.Unknown())
+}, { additionalProperties: true });
+const ChannelUiMetaSchema = Type.Object({
+	id: NonEmptyString,
+	label: NonEmptyString,
+	detailLabel: NonEmptyString,
+	systemImage: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const ChannelsStatusResultSchema = Type.Object({
+	ts: Type.Integer({ minimum: 0 }),
+	channelOrder: Type.Array(NonEmptyString),
+	channelLabels: Type.Record(NonEmptyString, NonEmptyString),
+	channelDetailLabels: Type.Optional(Type.Record(NonEmptyString, NonEmptyString)),
+	channelSystemImages: Type.Optional(Type.Record(NonEmptyString, NonEmptyString)),
+	channelMeta: Type.Optional(Type.Array(ChannelUiMetaSchema)),
+	channels: Type.Record(NonEmptyString, Type.Unknown()),
+	channelAccounts: Type.Record(NonEmptyString, Type.Array(ChannelAccountSnapshotSchema)),
+	channelDefaultAccountId: Type.Record(NonEmptyString, NonEmptyString)
+}, { additionalProperties: false });
+const ChannelsLogoutParamsSchema = Type.Object({
+	channel: NonEmptyString,
+	accountId: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const WebLoginStartParamsSchema = Type.Object({
+	force: Type.Optional(Type.Boolean()),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	verbose: Type.Optional(Type.Boolean()),
+	accountId: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const WebLoginWaitParamsSchema = Type.Object({
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	accountId: Type.Optional(Type.String())
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/config.ts
+const ConfigGetParamsSchema = Type.Object({}, { additionalProperties: false });
+const ConfigSetParamsSchema = Type.Object({
+	raw: NonEmptyString,
+	baseHash: Type.Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ConfigApplyLikeParamsSchema = Type.Object({
+	raw: NonEmptyString,
+	baseHash: Type.Optional(NonEmptyString),
+	sessionKey: Type.Optional(Type.String()),
+	note: Type.Optional(Type.String()),
+	restartDelayMs: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const ConfigApplyParamsSchema = ConfigApplyLikeParamsSchema;
+const ConfigPatchParamsSchema = ConfigApplyLikeParamsSchema;
+const ConfigSchemaParamsSchema = Type.Object({}, { additionalProperties: false });
+const UpdateRunParamsSchema = Type.Object({
+	sessionKey: Type.Optional(Type.String()),
+	note: Type.Optional(Type.String()),
+	restartDelayMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 1 }))
+}, { additionalProperties: false });
+const ConfigUiHintSchema = Type.Object({
+	label: Type.Optional(Type.String()),
+	help: Type.Optional(Type.String()),
+	tags: Type.Optional(Type.Array(Type.String())),
+	group: Type.Optional(Type.String()),
+	order: Type.Optional(Type.Integer()),
+	advanced: Type.Optional(Type.Boolean()),
+	sensitive: Type.Optional(Type.Boolean()),
+	placeholder: Type.Optional(Type.String()),
+	itemTemplate: Type.Optional(Type.Unknown())
+}, { additionalProperties: false });
+const ConfigSchemaResponseSchema = Type.Object({
+	schema: Type.Unknown(),
+	uiHints: Type.Record(Type.String(), ConfigUiHintSchema),
+	version: NonEmptyString,
+	generatedAt: NonEmptyString
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/cron.ts
+function cronAgentTurnPayloadSchema(params) {
+	return Type.Object({
+		kind: Type.Literal("agentTurn"),
+		message: params.message,
+		model: Type.Optional(Type.String()),
+		thinking: Type.Optional(Type.String()),
+		timeoutSeconds: Type.Optional(Type.Integer({ minimum: 0 })),
+		allowUnsafeExternalContent: Type.Optional(Type.Boolean()),
+		deliver: Type.Optional(Type.Boolean()),
+		channel: Type.Optional(Type.String()),
+		to: Type.Optional(Type.String()),
+		bestEffortDeliver: Type.Optional(Type.Boolean())
+	}, { additionalProperties: false });
+}
+const CronSessionTargetSchema = Type.Union([Type.Literal("main"), Type.Literal("isolated")]);
+const CronWakeModeSchema = Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")]);
+const CronRunStatusSchema = Type.Union([
+	Type.Literal("ok"),
+	Type.Literal("error"),
+	Type.Literal("skipped")
+]);
+const CronSortDirSchema = Type.Union([Type.Literal("asc"), Type.Literal("desc")]);
+const CronJobsEnabledFilterSchema = Type.Union([
+	Type.Literal("all"),
+	Type.Literal("enabled"),
+	Type.Literal("disabled")
+]);
+const CronJobsSortBySchema = Type.Union([
+	Type.Literal("nextRunAtMs"),
+	Type.Literal("updatedAtMs"),
+	Type.Literal("name")
+]);
+const CronRunsStatusFilterSchema = Type.Union([
+	Type.Literal("all"),
+	Type.Literal("ok"),
+	Type.Literal("error"),
+	Type.Literal("skipped")
+]);
+const CronRunsStatusValueSchema = Type.Union([
+	Type.Literal("ok"),
+	Type.Literal("error"),
+	Type.Literal("skipped")
+]);
+const CronDeliveryStatusSchema = Type.Union([
+	Type.Literal("delivered"),
+	Type.Literal("not-delivered"),
+	Type.Literal("unknown"),
+	Type.Literal("not-requested")
+]);
+const CronCommonOptionalFields = {
+	agentId: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	sessionKey: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	description: Type.Optional(Type.String()),
+	enabled: Type.Optional(Type.Boolean()),
+	deleteAfterRun: Type.Optional(Type.Boolean())
+};
+function cronIdOrJobIdParams(extraFields) {
+	return Type.Union([Type.Object({
+		id: NonEmptyString,
+		...extraFields
+	}, { additionalProperties: false }), Type.Object({
+		jobId: NonEmptyString,
+		...extraFields
+	}, { additionalProperties: false })]);
+}
+const CronRunLogJobIdSchema = Type.String({
+	minLength: 1,
+	pattern: "^[^/\\\\]+$"
+});
+const CronScheduleSchema = Type.Union([
+	Type.Object({
+		kind: Type.Literal("at"),
+		at: NonEmptyString
+	}, { additionalProperties: false }),
+	Type.Object({
+		kind: Type.Literal("every"),
+		everyMs: Type.Integer({ minimum: 1 }),
+		anchorMs: Type.Optional(Type.Integer({ minimum: 0 }))
+	}, { additionalProperties: false }),
+	Type.Object({
+		kind: Type.Literal("cron"),
+		expr: NonEmptyString,
+		tz: Type.Optional(Type.String()),
+		staggerMs: Type.Optional(Type.Integer({ minimum: 0 }))
+	}, { additionalProperties: false })
+]);
+const CronPayloadSchema = Type.Union([Type.Object({
+	kind: Type.Literal("systemEvent"),
+	text: NonEmptyString
+}, { additionalProperties: false }), cronAgentTurnPayloadSchema({ message: NonEmptyString })]);
+const CronPayloadPatchSchema = Type.Union([Type.Object({
+	kind: Type.Literal("systemEvent"),
+	text: Type.Optional(NonEmptyString)
+}, { additionalProperties: false }), cronAgentTurnPayloadSchema({ message: Type.Optional(NonEmptyString) })]);
+const CronDeliverySharedProperties = {
+	channel: Type.Optional(Type.Union([Type.Literal("last"), NonEmptyString])),
+	bestEffort: Type.Optional(Type.Boolean())
+};
+const CronDeliveryNoopSchema = Type.Object({
+	mode: Type.Literal("none"),
+	...CronDeliverySharedProperties,
+	to: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const CronDeliveryAnnounceSchema = Type.Object({
+	mode: Type.Literal("announce"),
+	...CronDeliverySharedProperties,
+	to: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const CronDeliveryWebhookSchema = Type.Object({
+	mode: Type.Literal("webhook"),
+	...CronDeliverySharedProperties,
+	to: NonEmptyString
+}, { additionalProperties: false });
+const CronDeliverySchema = Type.Union([
+	CronDeliveryNoopSchema,
+	CronDeliveryAnnounceSchema,
+	CronDeliveryWebhookSchema
+]);
+const CronDeliveryPatchSchema = Type.Object({
+	mode: Type.Optional(Type.Union([
+		Type.Literal("none"),
+		Type.Literal("announce"),
+		Type.Literal("webhook")
+	])),
+	...CronDeliverySharedProperties,
+	to: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const CronJobStateSchema = Type.Object({
+	nextRunAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	runningAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastRunAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastRunStatus: Type.Optional(CronRunStatusSchema),
+	lastStatus: Type.Optional(CronRunStatusSchema),
+	lastError: Type.Optional(Type.String()),
+	lastDurationMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	consecutiveErrors: Type.Optional(Type.Integer({ minimum: 0 })),
+	lastDelivered: Type.Optional(Type.Boolean()),
+	lastDeliveryStatus: Type.Optional(CronDeliveryStatusSchema),
+	lastDeliveryError: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const CronJobSchema = Type.Object({
+	id: NonEmptyString,
+	agentId: Type.Optional(NonEmptyString),
+	sessionKey: Type.Optional(NonEmptyString),
+	name: NonEmptyString,
+	description: Type.Optional(Type.String()),
+	enabled: Type.Boolean(),
+	deleteAfterRun: Type.Optional(Type.Boolean()),
+	createdAtMs: Type.Integer({ minimum: 0 }),
+	updatedAtMs: Type.Integer({ minimum: 0 }),
+	schedule: CronScheduleSchema,
+	sessionTarget: CronSessionTargetSchema,
+	wakeMode: CronWakeModeSchema,
+	payload: CronPayloadSchema,
+	delivery: Type.Optional(CronDeliverySchema),
+	state: CronJobStateSchema
+}, { additionalProperties: false });
+const CronListParamsSchema = Type.Object({
+	includeDisabled: Type.Optional(Type.Boolean()),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 200
+	})),
+	offset: Type.Optional(Type.Integer({ minimum: 0 })),
+	query: Type.Optional(Type.String()),
+	enabled: Type.Optional(CronJobsEnabledFilterSchema),
+	sortBy: Type.Optional(CronJobsSortBySchema),
+	sortDir: Type.Optional(CronSortDirSchema)
+}, { additionalProperties: false });
+const CronStatusParamsSchema = Type.Object({}, { additionalProperties: false });
+const CronAddParamsSchema = Type.Object({
+	name: NonEmptyString,
+	...CronCommonOptionalFields,
+	schedule: CronScheduleSchema,
+	sessionTarget: CronSessionTargetSchema,
+	wakeMode: CronWakeModeSchema,
+	payload: CronPayloadSchema,
+	delivery: Type.Optional(CronDeliverySchema)
+}, { additionalProperties: false });
+const CronJobPatchSchema = Type.Object({
+	name: Type.Optional(NonEmptyString),
+	...CronCommonOptionalFields,
+	schedule: Type.Optional(CronScheduleSchema),
+	sessionTarget: Type.Optional(CronSessionTargetSchema),
+	wakeMode: Type.Optional(CronWakeModeSchema),
+	payload: Type.Optional(CronPayloadPatchSchema),
+	delivery: Type.Optional(CronDeliveryPatchSchema),
+	state: Type.Optional(Type.Partial(CronJobStateSchema))
+}, { additionalProperties: false });
+const CronUpdateParamsSchema = cronIdOrJobIdParams({ patch: CronJobPatchSchema });
+const CronRemoveParamsSchema = cronIdOrJobIdParams({});
+const CronRunParamsSchema = cronIdOrJobIdParams({ mode: Type.Optional(Type.Union([Type.Literal("due"), Type.Literal("force")])) });
+const CronRunsParamsSchema = Type.Object({
+	scope: Type.Optional(Type.Union([Type.Literal("job"), Type.Literal("all")])),
+	id: Type.Optional(CronRunLogJobIdSchema),
+	jobId: Type.Optional(CronRunLogJobIdSchema),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 200
+	})),
+	offset: Type.Optional(Type.Integer({ minimum: 0 })),
+	statuses: Type.Optional(Type.Array(CronRunsStatusValueSchema, {
+		minItems: 1,
+		maxItems: 3
+	})),
+	status: Type.Optional(CronRunsStatusFilterSchema),
+	deliveryStatuses: Type.Optional(Type.Array(CronDeliveryStatusSchema, {
+		minItems: 1,
+		maxItems: 4
+	})),
+	deliveryStatus: Type.Optional(CronDeliveryStatusSchema),
+	query: Type.Optional(Type.String()),
+	sortDir: Type.Optional(CronSortDirSchema)
+}, { additionalProperties: false });
+const CronRunLogEntrySchema = Type.Object({
+	ts: Type.Integer({ minimum: 0 }),
+	jobId: NonEmptyString,
+	action: Type.Literal("finished"),
+	status: Type.Optional(CronRunStatusSchema),
+	error: Type.Optional(Type.String()),
+	summary: Type.Optional(Type.String()),
+	delivered: Type.Optional(Type.Boolean()),
+	deliveryStatus: Type.Optional(CronDeliveryStatusSchema),
+	deliveryError: Type.Optional(Type.String()),
+	sessionId: Type.Optional(NonEmptyString),
+	sessionKey: Type.Optional(NonEmptyString),
+	runAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	durationMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	nextRunAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	model: Type.Optional(Type.String()),
+	provider: Type.Optional(Type.String()),
+	usage: Type.Optional(Type.Object({
+		input_tokens: Type.Optional(Type.Number()),
+		output_tokens: Type.Optional(Type.Number()),
+		total_tokens: Type.Optional(Type.Number()),
+		cache_read_tokens: Type.Optional(Type.Number()),
+		cache_write_tokens: Type.Optional(Type.Number())
+	}, { additionalProperties: false })),
+	jobName: Type.Optional(Type.String())
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/devices.ts
+const DevicePairListParamsSchema = Type.Object({}, { additionalProperties: false });
+const DevicePairApproveParamsSchema = Type.Object({ requestId: NonEmptyString }, { additionalProperties: false });
+const DevicePairRejectParamsSchema = Type.Object({ requestId: NonEmptyString }, { additionalProperties: false });
+const DevicePairRemoveParamsSchema = Type.Object({ deviceId: NonEmptyString }, { additionalProperties: false });
+const DeviceTokenRotateParamsSchema = Type.Object({
+	deviceId: NonEmptyString,
+	role: NonEmptyString,
+	scopes: Type.Optional(Type.Array(NonEmptyString))
+}, { additionalProperties: false });
+const DeviceTokenRevokeParamsSchema = Type.Object({
+	deviceId: NonEmptyString,
+	role: NonEmptyString
+}, { additionalProperties: false });
+const DevicePairRequestedEventSchema = Type.Object({
+	requestId: NonEmptyString,
+	deviceId: NonEmptyString,
+	publicKey: NonEmptyString,
+	displayName: Type.Optional(NonEmptyString),
+	platform: Type.Optional(NonEmptyString),
+	clientId: Type.Optional(NonEmptyString),
+	clientMode: Type.Optional(NonEmptyString),
+	role: Type.Optional(NonEmptyString),
+	roles: Type.Optional(Type.Array(NonEmptyString)),
+	scopes: Type.Optional(Type.Array(NonEmptyString)),
+	remoteIp: Type.Optional(NonEmptyString),
+	silent: Type.Optional(Type.Boolean()),
+	isRepair: Type.Optional(Type.Boolean()),
+	ts: Type.Integer({ minimum: 0 })
+}, { additionalProperties: false });
+const DevicePairResolvedEventSchema = Type.Object({
+	requestId: NonEmptyString,
+	deviceId: NonEmptyString,
+	decision: NonEmptyString,
+	ts: Type.Integer({ minimum: 0 })
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/snapshot.ts
+const PresenceEntrySchema = Type.Object({
+	host: Type.Optional(NonEmptyString),
+	ip: Type.Optional(NonEmptyString),
+	version: Type.Optional(NonEmptyString),
+	platform: Type.Optional(NonEmptyString),
+	deviceFamily: Type.Optional(NonEmptyString),
+	modelIdentifier: Type.Optional(NonEmptyString),
+	mode: Type.Optional(NonEmptyString),
+	lastInputSeconds: Type.Optional(Type.Integer({ minimum: 0 })),
+	reason: Type.Optional(NonEmptyString),
+	tags: Type.Optional(Type.Array(NonEmptyString)),
+	text: Type.Optional(Type.String()),
+	ts: Type.Integer({ minimum: 0 }),
+	deviceId: Type.Optional(NonEmptyString),
+	roles: Type.Optional(Type.Array(NonEmptyString)),
+	scopes: Type.Optional(Type.Array(NonEmptyString)),
+	instanceId: Type.Optional(NonEmptyString)
+}, { additionalProperties: false });
+const HealthSnapshotSchema = Type.Any();
+const SessionDefaultsSchema = Type.Object({
+	defaultAgentId: NonEmptyString,
+	mainKey: NonEmptyString,
+	mainSessionKey: NonEmptyString,
+	scope: Type.Optional(NonEmptyString)
+}, { additionalProperties: false });
+const StateVersionSchema = Type.Object({
+	presence: Type.Integer({ minimum: 0 }),
+	health: Type.Integer({ minimum: 0 })
+}, { additionalProperties: false });
+const SnapshotSchema = Type.Object({
+	presence: Type.Array(PresenceEntrySchema),
+	health: HealthSnapshotSchema,
+	stateVersion: StateVersionSchema,
+	uptimeMs: Type.Integer({ minimum: 0 }),
+	configPath: Type.Optional(NonEmptyString),
+	stateDir: Type.Optional(NonEmptyString),
+	sessionDefaults: Type.Optional(SessionDefaultsSchema),
+	authMode: Type.Optional(Type.Union([
+		Type.Literal("none"),
+		Type.Literal("token"),
+		Type.Literal("password"),
+		Type.Literal("trusted-proxy")
+	])),
+	updateAvailable: Type.Optional(Type.Object({
+		currentVersion: NonEmptyString,
+		latestVersion: NonEmptyString,
+		channel: NonEmptyString
+	}))
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/frames.ts
+const TickEventSchema = Type.Object({ ts: Type.Integer({ minimum: 0 }) }, { additionalProperties: false });
+const ShutdownEventSchema = Type.Object({
+	reason: NonEmptyString,
+	restartExpectedMs: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const ConnectParamsSchema = Type.Object({
+	minProtocol: Type.Integer({ minimum: 1 }),
+	maxProtocol: Type.Integer({ minimum: 1 }),
+	client: Type.Object({
+		id: GatewayClientIdSchema,
+		displayName: Type.Optional(NonEmptyString),
+		version: NonEmptyString,
+		platform: NonEmptyString,
+		deviceFamily: Type.Optional(NonEmptyString),
+		modelIdentifier: Type.Optional(NonEmptyString),
+		mode: GatewayClientModeSchema,
+		instanceId: Type.Optional(NonEmptyString)
+	}, { additionalProperties: false }),
+	caps: Type.Optional(Type.Array(NonEmptyString, { default: [] })),
+	commands: Type.Optional(Type.Array(NonEmptyString)),
+	permissions: Type.Optional(Type.Record(NonEmptyString, Type.Boolean())),
+	pathEnv: Type.Optional(Type.String()),
+	role: Type.Optional(NonEmptyString),
+	scopes: Type.Optional(Type.Array(NonEmptyString)),
+	device: Type.Optional(Type.Object({
+		id: NonEmptyString,
+		publicKey: NonEmptyString,
+		signature: NonEmptyString,
+		signedAt: Type.Integer({ minimum: 0 }),
+		nonce: NonEmptyString
+	}, { additionalProperties: false })),
+	auth: Type.Optional(Type.Object({
+		token: Type.Optional(Type.String()),
+		deviceToken: Type.Optional(Type.String()),
+		password: Type.Optional(Type.String())
+	}, { additionalProperties: false })),
+	locale: Type.Optional(Type.String()),
+	userAgent: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const HelloOkSchema = Type.Object({
+	type: Type.Literal("hello-ok"),
+	protocol: Type.Integer({ minimum: 1 }),
+	server: Type.Object({
+		version: NonEmptyString,
+		connId: NonEmptyString
+	}, { additionalProperties: false }),
+	features: Type.Object({
+		methods: Type.Array(NonEmptyString),
+		events: Type.Array(NonEmptyString)
+	}, { additionalProperties: false }),
+	snapshot: SnapshotSchema,
+	canvasHostUrl: Type.Optional(NonEmptyString),
+	auth: Type.Optional(Type.Object({
+		deviceToken: NonEmptyString,
+		role: NonEmptyString,
+		scopes: Type.Array(NonEmptyString),
+		issuedAtMs: Type.Optional(Type.Integer({ minimum: 0 }))
+	}, { additionalProperties: false })),
+	policy: Type.Object({
+		maxPayload: Type.Integer({ minimum: 1 }),
+		maxBufferedBytes: Type.Integer({ minimum: 1 }),
+		tickIntervalMs: Type.Integer({ minimum: 1 })
+	}, { additionalProperties: false })
+}, { additionalProperties: false });
+const ErrorShapeSchema = Type.Object({
+	code: NonEmptyString,
+	message: NonEmptyString,
+	details: Type.Optional(Type.Unknown()),
+	retryable: Type.Optional(Type.Boolean()),
+	retryAfterMs: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const RequestFrameSchema = Type.Object({
+	type: Type.Literal("req"),
+	id: NonEmptyString,
+	method: NonEmptyString,
+	params: Type.Optional(Type.Unknown())
+}, { additionalProperties: false });
+const ResponseFrameSchema = Type.Object({
+	type: Type.Literal("res"),
+	id: NonEmptyString,
+	ok: Type.Boolean(),
+	payload: Type.Optional(Type.Unknown()),
+	error: Type.Optional(ErrorShapeSchema)
+}, { additionalProperties: false });
+const EventFrameSchema = Type.Object({
+	type: Type.Literal("event"),
+	event: NonEmptyString,
+	payload: Type.Optional(Type.Unknown()),
+	seq: Type.Optional(Type.Integer({ minimum: 0 })),
+	stateVersion: Type.Optional(StateVersionSchema)
+}, { additionalProperties: false });
+const GatewayFrameSchema = Type.Union([
+	RequestFrameSchema,
+	ResponseFrameSchema,
+	EventFrameSchema
+], { discriminator: "type" });
+
+//#endregion
+//#region src/gateway/protocol/schema/logs-chat.ts
+const LogsTailParamsSchema = Type.Object({
+	cursor: Type.Optional(Type.Integer({ minimum: 0 })),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 5e3
+	})),
+	maxBytes: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 1e6
+	}))
+}, { additionalProperties: false });
+const LogsTailResultSchema = Type.Object({
+	file: NonEmptyString,
+	cursor: Type.Integer({ minimum: 0 }),
+	size: Type.Integer({ minimum: 0 }),
+	lines: Type.Array(Type.String()),
+	truncated: Type.Optional(Type.Boolean()),
+	reset: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const ChatHistoryParamsSchema = Type.Object({
+	sessionKey: NonEmptyString,
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 1e3
+	}))
+}, { additionalProperties: false });
+const ChatSendParamsSchema = Type.Object({
+	sessionKey: NonEmptyString,
+	message: Type.String(),
+	thinking: Type.Optional(Type.String()),
+	deliver: Type.Optional(Type.Boolean()),
+	attachments: Type.Optional(Type.Array(Type.Unknown())),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const ChatAbortParamsSchema = Type.Object({
+	sessionKey: NonEmptyString,
+	runId: Type.Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ChatInjectParamsSchema = Type.Object({
+	sessionKey: NonEmptyString,
+	message: NonEmptyString,
+	label: Type.Optional(Type.String({ maxLength: 100 }))
+}, { additionalProperties: false });
+const ChatEventSchema = Type.Object({
+	runId: NonEmptyString,
+	sessionKey: NonEmptyString,
+	seq: Type.Integer({ minimum: 0 }),
+	state: Type.Union([
+		Type.Literal("delta"),
+		Type.Literal("final"),
+		Type.Literal("aborted"),
+		Type.Literal("error")
+	]),
+	message: Type.Optional(Type.Unknown()),
+	errorMessage: Type.Optional(Type.String()),
+	usage: Type.Optional(Type.Unknown()),
+	stopReason: Type.Optional(Type.String())
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/nodes.ts
+const NodePairRequestParamsSchema = Type.Object({
+	nodeId: NonEmptyString,
+	displayName: Type.Optional(NonEmptyString),
+	platform: Type.Optional(NonEmptyString),
+	version: Type.Optional(NonEmptyString),
+	coreVersion: Type.Optional(NonEmptyString),
+	uiVersion: Type.Optional(NonEmptyString),
+	deviceFamily: Type.Optional(NonEmptyString),
+	modelIdentifier: Type.Optional(NonEmptyString),
+	caps: Type.Optional(Type.Array(NonEmptyString)),
+	commands: Type.Optional(Type.Array(NonEmptyString)),
+	remoteIp: Type.Optional(NonEmptyString),
+	silent: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const NodePairListParamsSchema = Type.Object({}, { additionalProperties: false });
+const NodePairApproveParamsSchema = Type.Object({ requestId: NonEmptyString }, { additionalProperties: false });
+const NodePairRejectParamsSchema = Type.Object({ requestId: NonEmptyString }, { additionalProperties: false });
+const NodePairVerifyParamsSchema = Type.Object({
+	nodeId: NonEmptyString,
+	token: NonEmptyString
+}, { additionalProperties: false });
+const NodeRenameParamsSchema = Type.Object({
+	nodeId: NonEmptyString,
+	displayName: NonEmptyString
+}, { additionalProperties: false });
+const NodeListParamsSchema = Type.Object({}, { additionalProperties: false });
+const NodeDescribeParamsSchema = Type.Object({ nodeId: NonEmptyString }, { additionalProperties: false });
+const NodeInvokeParamsSchema = Type.Object({
+	nodeId: NonEmptyString,
+	command: NonEmptyString,
+	params: Type.Optional(Type.Unknown()),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const NodeInvokeResultParamsSchema = Type.Object({
+	id: NonEmptyString,
+	nodeId: NonEmptyString,
+	ok: Type.Boolean(),
+	payload: Type.Optional(Type.Unknown()),
+	payloadJSON: Type.Optional(Type.String()),
+	error: Type.Optional(Type.Object({
+		code: Type.Optional(NonEmptyString),
+		message: Type.Optional(NonEmptyString)
+	}, { additionalProperties: false }))
+}, { additionalProperties: false });
+const NodeEventParamsSchema = Type.Object({
+	event: NonEmptyString,
+	payload: Type.Optional(Type.Unknown()),
+	payloadJSON: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const NodeInvokeRequestEventSchema = Type.Object({
+	id: NonEmptyString,
+	nodeId: NonEmptyString,
+	command: NonEmptyString,
+	paramsJSON: Type.Optional(Type.String()),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	idempotencyKey: Type.Optional(NonEmptyString)
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/push.ts
+const ApnsEnvironmentSchema = Type.String({ enum: ["sandbox", "production"] });
+const PushTestParamsSchema = Type.Object({
+	nodeId: NonEmptyString,
+	title: Type.Optional(Type.String()),
+	body: Type.Optional(Type.String()),
+	environment: Type.Optional(ApnsEnvironmentSchema)
+}, { additionalProperties: false });
+const PushTestResultSchema = Type.Object({
+	ok: Type.Boolean(),
+	status: Type.Integer(),
+	apnsId: Type.Optional(Type.String()),
+	reason: Type.Optional(Type.String()),
+	tokenSuffix: Type.String(),
+	topic: Type.String(),
+	environment: ApnsEnvironmentSchema
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/sessions.ts
+const SessionsListParamsSchema = Type.Object({
+	limit: Type.Optional(Type.Integer({ minimum: 1 })),
+	activeMinutes: Type.Optional(Type.Integer({ minimum: 1 })),
+	includeGlobal: Type.Optional(Type.Boolean()),
+	includeUnknown: Type.Optional(Type.Boolean()),
+	includeDerivedTitles: Type.Optional(Type.Boolean()),
+	includeLastMessage: Type.Optional(Type.Boolean()),
+	label: Type.Optional(SessionLabelString),
+	spawnedBy: Type.Optional(NonEmptyString),
+	agentId: Type.Optional(NonEmptyString),
+	search: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const SessionsPreviewParamsSchema = Type.Object({
+	keys: Type.Array(NonEmptyString, { minItems: 1 }),
+	limit: Type.Optional(Type.Integer({ minimum: 1 })),
+	maxChars: Type.Optional(Type.Integer({ minimum: 20 }))
+}, { additionalProperties: false });
+const SessionsResolveParamsSchema = Type.Object({
+	key: Type.Optional(NonEmptyString),
+	sessionId: Type.Optional(NonEmptyString),
+	label: Type.Optional(SessionLabelString),
+	agentId: Type.Optional(NonEmptyString),
+	spawnedBy: Type.Optional(NonEmptyString),
+	includeGlobal: Type.Optional(Type.Boolean()),
+	includeUnknown: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const SessionsPatchParamsSchema = Type.Object({
+	key: NonEmptyString,
+	label: Type.Optional(Type.Union([SessionLabelString, Type.Null()])),
+	verboseLevel: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	responseUsage: Type.Optional(Type.Union([
+		Type.Literal("off"),
+		Type.Literal("tokens"),
+		Type.Literal("full"),
+		Type.Literal("on"),
+		Type.Null()
+	])),
+	elevatedLevel: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	execHost: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	execSecurity: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	execAsk: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	execNode: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	model: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	spawnedBy: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+	spawnDepth: Type.Optional(Type.Union([Type.Integer({ minimum: 0 }), Type.Null()])),
+	sendPolicy: Type.Optional(Type.Union([
+		Type.Literal("allow"),
+		Type.Literal("deny"),
+		Type.Null()
+	])),
+	groupActivation: Type.Optional(Type.Union([
+		Type.Literal("mention"),
+		Type.Literal("always"),
+		Type.Null()
+	]))
+}, { additionalProperties: false });
+const SessionsResetParamsSchema = Type.Object({
+	key: NonEmptyString,
+	reason: Type.Optional(Type.Union([Type.Literal("new"), Type.Literal("reset")]))
+}, { additionalProperties: false });
+const SessionsDeleteParamsSchema = Type.Object({
+	key: NonEmptyString,
+	deleteTranscript: Type.Optional(Type.Boolean()),
+	emitLifecycleHooks: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const SessionsCompactParamsSchema = Type.Object({
+	key: NonEmptyString,
+	maxLines: Type.Optional(Type.Integer({ minimum: 1 }))
+}, { additionalProperties: false });
+const SessionsUsageParamsSchema = Type.Object({
+	key: Type.Optional(NonEmptyString),
+	startDate: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+	endDate: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+	mode: Type.Optional(Type.Union([
+		Type.Literal("utc"),
+		Type.Literal("gateway"),
+		Type.Literal("specific")
+	])),
+	utcOffset: Type.Optional(Type.String({ pattern: "^UTC[+-]\\d{1,2}(?::[0-5]\\d)?$" })),
+	limit: Type.Optional(Type.Integer({ minimum: 1 })),
+	includeContextWeight: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/schema/wizard.ts
+const WizardRunStatusSchema = Type.Union([
+	Type.Literal("running"),
+	Type.Literal("done"),
+	Type.Literal("cancelled"),
+	Type.Literal("error")
+]);
+const WizardStartParamsSchema = Type.Object({
+	mode: Type.Optional(Type.Union([Type.Literal("local"), Type.Literal("remote")])),
+	workspace: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const WizardAnswerSchema = Type.Object({
+	stepId: NonEmptyString,
+	value: Type.Optional(Type.Unknown())
+}, { additionalProperties: false });
+const WizardNextParamsSchema = Type.Object({
+	sessionId: NonEmptyString,
+	answer: Type.Optional(WizardAnswerSchema)
+}, { additionalProperties: false });
+const WizardSessionIdParamsSchema = Type.Object({ sessionId: NonEmptyString }, { additionalProperties: false });
+const WizardCancelParamsSchema = WizardSessionIdParamsSchema;
+const WizardStatusParamsSchema = WizardSessionIdParamsSchema;
+const WizardStepOptionSchema = Type.Object({
+	value: Type.Unknown(),
+	label: NonEmptyString,
+	hint: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const WizardStepSchema = Type.Object({
+	id: NonEmptyString,
+	type: Type.Union([
+		Type.Literal("note"),
+		Type.Literal("select"),
+		Type.Literal("text"),
+		Type.Literal("confirm"),
+		Type.Literal("multiselect"),
+		Type.Literal("progress"),
+		Type.Literal("action")
+	]),
+	title: Type.Optional(Type.String()),
+	message: Type.Optional(Type.String()),
+	options: Type.Optional(Type.Array(WizardStepOptionSchema)),
+	initialValue: Type.Optional(Type.Unknown()),
+	placeholder: Type.Optional(Type.String()),
+	sensitive: Type.Optional(Type.Boolean()),
+	executor: Type.Optional(Type.Union([Type.Literal("gateway"), Type.Literal("client")]))
+}, { additionalProperties: false });
+const WizardResultFields = {
+	done: Type.Boolean(),
+	step: Type.Optional(WizardStepSchema),
+	status: Type.Optional(WizardRunStatusSchema),
+	error: Type.Optional(Type.String())
+};
+const WizardNextResultSchema = Type.Object(WizardResultFields, { additionalProperties: false });
+const WizardStartResultSchema = Type.Object({
+	sessionId: NonEmptyString,
+	...WizardResultFields
+}, { additionalProperties: false });
+const WizardStatusResultSchema = Type.Object({
+	status: WizardRunStatusSchema,
+	error: Type.Optional(Type.String())
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/gateway/protocol/index.ts
+const ajv = new AjvPkg({
+	allErrors: true,
+	strict: false,
+	removeAdditional: false
+});
+const validateConnectParams = ajv.compile(ConnectParamsSchema);
+const validateRequestFrame = ajv.compile(RequestFrameSchema);
+const validateResponseFrame = ajv.compile(ResponseFrameSchema);
+const validateEventFrame = ajv.compile(EventFrameSchema);
+const validateSendParams = ajv.compile(SendParamsSchema);
+const validatePollParams = ajv.compile(PollParamsSchema);
+const validateAgentParams = ajv.compile(AgentParamsSchema);
+const validateAgentIdentityParams = ajv.compile(AgentIdentityParamsSchema);
+const validateAgentWaitParams = ajv.compile(AgentWaitParamsSchema);
+const validateWakeParams = ajv.compile(WakeParamsSchema);
+const validateAgentsListParams = ajv.compile(AgentsListParamsSchema);
+const validateAgentsCreateParams = ajv.compile(AgentsCreateParamsSchema);
+const validateAgentsUpdateParams = ajv.compile(AgentsUpdateParamsSchema);
+const validateAgentsDeleteParams = ajv.compile(AgentsDeleteParamsSchema);
+const validateAgentsFilesListParams = ajv.compile(AgentsFilesListParamsSchema);
+const validateAgentsFilesGetParams = ajv.compile(AgentsFilesGetParamsSchema);
+const validateAgentsFilesSetParams = ajv.compile(AgentsFilesSetParamsSchema);
+const validateNodePairRequestParams = ajv.compile(NodePairRequestParamsSchema);
+const validateNodePairListParams = ajv.compile(NodePairListParamsSchema);
+const validateNodePairApproveParams = ajv.compile(NodePairApproveParamsSchema);
+const validateNodePairRejectParams = ajv.compile(NodePairRejectParamsSchema);
+const validateNodePairVerifyParams = ajv.compile(NodePairVerifyParamsSchema);
+const validateNodeRenameParams = ajv.compile(NodeRenameParamsSchema);
+const validateNodeListParams = ajv.compile(NodeListParamsSchema);
+const validateNodeDescribeParams = ajv.compile(NodeDescribeParamsSchema);
+const validateNodeInvokeParams = ajv.compile(NodeInvokeParamsSchema);
+const validateNodeInvokeResultParams = ajv.compile(NodeInvokeResultParamsSchema);
+const validateNodeEventParams = ajv.compile(NodeEventParamsSchema);
+const validatePushTestParams = ajv.compile(PushTestParamsSchema);
+const validateSessionsListParams = ajv.compile(SessionsListParamsSchema);
+const validateSessionsPreviewParams = ajv.compile(SessionsPreviewParamsSchema);
+const validateSessionsResolveParams = ajv.compile(SessionsResolveParamsSchema);
+const validateSessionsPatchParams = ajv.compile(SessionsPatchParamsSchema);
+const validateSessionsResetParams = ajv.compile(SessionsResetParamsSchema);
+const validateSessionsDeleteParams = ajv.compile(SessionsDeleteParamsSchema);
+const validateSessionsCompactParams = ajv.compile(SessionsCompactParamsSchema);
+const validateSessionsUsageParams = ajv.compile(SessionsUsageParamsSchema);
+const validateConfigGetParams = ajv.compile(ConfigGetParamsSchema);
+const validateConfigSetParams = ajv.compile(ConfigSetParamsSchema);
+const validateConfigApplyParams = ajv.compile(ConfigApplyParamsSchema);
+const validateConfigPatchParams = ajv.compile(ConfigPatchParamsSchema);
+const validateConfigSchemaParams = ajv.compile(ConfigSchemaParamsSchema);
+const validateWizardStartParams = ajv.compile(WizardStartParamsSchema);
+const validateWizardNextParams = ajv.compile(WizardNextParamsSchema);
+const validateWizardCancelParams = ajv.compile(WizardCancelParamsSchema);
+const validateWizardStatusParams = ajv.compile(WizardStatusParamsSchema);
+const validateTalkModeParams = ajv.compile(TalkModeParamsSchema);
+const validateTalkConfigParams = ajv.compile(TalkConfigParamsSchema);
+const validateChannelsStatusParams = ajv.compile(ChannelsStatusParamsSchema);
+const validateChannelsLogoutParams = ajv.compile(ChannelsLogoutParamsSchema);
+const validateModelsListParams = ajv.compile(ModelsListParamsSchema);
+const validateToolsCatalogParams = ajv.compile(ToolsCatalogParamsSchema);
+const validateCronListParams = ajv.compile(CronListParamsSchema);
+const validateCronStatusParams = ajv.compile(CronStatusParamsSchema);
+const validateCronAddParams = ajv.compile(CronAddParamsSchema);
+const validateCronUpdateParams = ajv.compile(CronUpdateParamsSchema);
+const validateCronRemoveParams = ajv.compile(CronRemoveParamsSchema);
+const validateCronRunParams = ajv.compile(CronRunParamsSchema);
+const validateCronRunsParams = ajv.compile(CronRunsParamsSchema);
+const validateDevicePairListParams = ajv.compile(DevicePairListParamsSchema);
+const validateDevicePairApproveParams = ajv.compile(DevicePairApproveParamsSchema);
+const validateDevicePairRejectParams = ajv.compile(DevicePairRejectParamsSchema);
+const validateDevicePairRemoveParams = ajv.compile(DevicePairRemoveParamsSchema);
+const validateDeviceTokenRotateParams = ajv.compile(DeviceTokenRotateParamsSchema);
+const validateDeviceTokenRevokeParams = ajv.compile(DeviceTokenRevokeParamsSchema);
+const validateLogsTailParams = ajv.compile(LogsTailParamsSchema);
+const validateChatHistoryParams = ajv.compile(ChatHistoryParamsSchema);
+const validateChatSendParams = ajv.compile(ChatSendParamsSchema);
+const validateChatAbortParams = ajv.compile(ChatAbortParamsSchema);
+const validateChatInjectParams = ajv.compile(ChatInjectParamsSchema);
+const validateChatEvent = ajv.compile(ChatEventSchema);
+const validateUpdateRunParams = ajv.compile(UpdateRunParamsSchema);
+const validateWebLoginStartParams = ajv.compile(WebLoginStartParamsSchema);
+const validateWebLoginWaitParams = ajv.compile(WebLoginWaitParamsSchema);
+
+//#endregion
+//#region src/gateway/method-scopes.ts
+const ADMIN_SCOPE = "operator.admin";
+const READ_SCOPE = "operator.read";
+const WRITE_SCOPE = "operator.write";
+const APPROVALS_SCOPE = "operator.approvals";
+const PAIRING_SCOPE = "operator.pairing";
+const METHOD_SCOPE_GROUPS = {
+	[APPROVALS_SCOPE]: [
+		"exec.approval.request",
+		"exec.approval.waitDecision",
+		"exec.approval.resolve"
+	],
+	[PAIRING_SCOPE]: [
+		"node.pair.request",
+		"node.pair.list",
+		"node.pair.approve",
+		"node.pair.reject",
+		"node.pair.verify",
+		"device.pair.list",
+		"device.pair.approve",
+		"device.pair.reject",
+		"device.pair.remove",
+		"device.token.rotate",
+		"device.token.revoke",
+		"node.rename"
+	],
+	[READ_SCOPE]: [
+		"health",
+		"logs.tail",
+		"channels.status",
+		"status",
+		"usage.status",
+		"usage.cost",
+		"tts.status",
+		"tts.providers",
+		"models.list",
+		"tools.catalog",
+		"plugin:tools:list",
+		"agents.list",
+		"agent.identity.get",
+		"voicewake.get",
+		"sessions.list",
+		"sessions.preview",
+		"sessions.resolve",
+		"sessions.usage",
+		"sessions.usage.timeseries",
+		"sessions.usage.logs",
+		"cron.list",
+		"cron.status",
+		"cron.runs",
+		"system-presence",
+		"last-heartbeat",
+		"node.list",
+		"node.describe",
+		"chat.history",
+		"config.get",
+		"talk.config",
+		"agents.files.list",
+		"agents.files.get"
+	],
+	[WRITE_SCOPE]: [
+		"send",
+		"poll",
+		"agent",
+		"agent.wait",
+		"wake",
+		"talk.mode",
+		"tts.enable",
+		"tts.disable",
+		"tts.convert",
+		"tts.setProvider",
+		"voicewake.set",
+		"node.invoke",
+		"sessions.spawn",
+		"sessions.subagents",
+		"chat.send",
+		"chat.abort",
+		"browser.request",
+		"push.test",
+		"hooks.tool.before",
+		"hooks.tool.after",
+		"plugin:tools:invoke",
+		"message:send",
+		"message:reply",
+		"message:thread-reply",
+		"message:broadcast",
+		"message:sendAttachment",
+		"message:sendWithEffect"
+	],
+	[ADMIN_SCOPE]: [
+		"channels.logout",
+		"agents.create",
+		"agents.update",
+		"agents.delete",
+		"cron.add",
+		"cron.update",
+		"cron.remove",
+		"cron.run",
+		"sessions.patch",
+		"sessions.reset",
+		"sessions.delete",
+		"sessions.compact",
+		"connect",
+		"chat.inject",
+		"web.login.start",
+		"web.login.wait",
+		"set-heartbeats",
+		"system-event",
+		"agents.files.set",
+		"message:delete",
+		"message:react",
+		"message:pin",
+		"message:readMessages"
+	]
+};
+const METHOD_SCOPE_BY_NAME = new Map(Object.entries(METHOD_SCOPE_GROUPS).flatMap(([scope, methods]) => methods.map((method) => [method, scope])));
+
+//#endregion
+//#region src/logging/diagnostic-session-state.ts
+const SESSION_STATE_TTL_MS = 1800 * 1e3;
+const SESSION_STATE_PRUNE_INTERVAL_MS = 60 * 1e3;
+
+//#endregion
+//#region src/logging/diagnostic.ts
+const diag = createSubsystemLogger("diagnostic");
+
+//#endregion
+//#region src/infra/outbound/session-binding-service.ts
+function normalizeConversationRef(ref) {
+	return {
+		channel: ref.channel.trim().toLowerCase(),
+		accountId: normalizeAccountId(ref.accountId),
+		conversationId: ref.conversationId.trim(),
+		parentConversationId: ref.parentConversationId?.trim() || void 0
+	};
+}
+function toAdapterKey(params) {
+	return `${params.channel.trim().toLowerCase()}:${normalizeAccountId(params.accountId)}`;
+}
+const ADAPTERS_BY_CHANNEL_ACCOUNT = /* @__PURE__ */ new Map();
+function resolveAdapterForConversation(ref) {
+	const normalized = normalizeConversationRef(ref);
+	const key = toAdapterKey({
+		channel: normalized.channel,
+		accountId: normalized.accountId
+	});
+	return ADAPTERS_BY_CHANNEL_ACCOUNT.get(key) ?? null;
+}
+function dedupeBindings(records) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (!record?.bindingId) continue;
+		byId.set(record.bindingId, record);
+	}
+	return [...byId.values()];
+}
+function createDefaultSessionBindingService() {
+	return {
+		bind: async (input) => {
+			const normalizedConversation = normalizeConversationRef(input.conversation);
+			const adapter = resolveAdapterForConversation(normalizedConversation);
+			if (!adapter?.bind) throw new Error(`Session binding adapter unavailable for ${normalizedConversation.channel}:${normalizedConversation.accountId}`);
+			const bound = await adapter.bind({
+				...input,
+				conversation: normalizedConversation
+			});
+			if (!bound) throw new Error("Session binding adapter failed to bind target conversation");
+			return bound;
+		},
+		listBySession: (targetSessionKey) => {
+			const key = targetSessionKey.trim();
+			if (!key) return [];
+			const results = [];
+			for (const adapter of ADAPTERS_BY_CHANNEL_ACCOUNT.values()) {
+				const entries = adapter.listBySession(key);
+				if (entries.length > 0) results.push(...entries);
+			}
+			return dedupeBindings(results);
+		},
+		resolveByConversation: (ref) => {
+			const normalized = normalizeConversationRef(ref);
+			if (!normalized.channel || !normalized.conversationId) return null;
+			const adapter = resolveAdapterForConversation(normalized);
+			if (!adapter) return null;
+			return adapter.resolveByConversation(normalized);
+		},
+		touch: (bindingId, at) => {
+			const normalizedBindingId = bindingId.trim();
+			if (!normalizedBindingId) return;
+			for (const adapter of ADAPTERS_BY_CHANNEL_ACCOUNT.values()) adapter.touch?.(normalizedBindingId, at);
+		},
+		unbind: async (input) => {
+			const removed = [];
+			for (const adapter of ADAPTERS_BY_CHANNEL_ACCOUNT.values()) {
+				if (!adapter.unbind) continue;
+				const entries = await adapter.unbind(input);
+				if (entries.length > 0) removed.push(...entries);
+			}
+			return dedupeBindings(removed);
+		}
+	};
+}
+const DEFAULT_SESSION_BINDING_SERVICE = createDefaultSessionBindingService();
+
+//#endregion
+//#region src/agents/tool-display.json
+var tool_display_default = {
+	version: 1,
+	fallback: {
+		"emoji": "🧩",
+		"detailKeys": [
+			"command",
+			"path",
+			"url",
+			"targetUrl",
+			"targetId",
+			"ref",
+			"element",
+			"node",
+			"nodeId",
+			"id",
+			"requestId",
+			"to",
+			"channelId",
+			"guildId",
+			"userId",
+			"name",
+			"query",
+			"pattern",
+			"messageId"
+		]
+	},
+	tools: {
+		"attach": {
+			"emoji": "📎",
+			"title": "Attach",
+			"detailKeys": [
+				"path",
+				"url",
+				"fileName"
+			]
+		},
+		"browser": {
+			"emoji": "🌐",
+			"title": "Browser",
+			"actions": {
+				"status": { "label": "status" },
+				"start": { "label": "start" },
+				"stop": { "label": "stop" },
+				"tabs": { "label": "tabs" },
+				"open": {
+					"label": "open",
+					"detailKeys": ["targetUrl"]
+				},
+				"focus": {
+					"label": "focus",
+					"detailKeys": ["targetId"]
+				},
+				"close": {
+					"label": "close",
+					"detailKeys": ["targetId"]
+				},
+				"snapshot": {
+					"label": "snapshot",
+					"detailKeys": [
+						"targetUrl",
+						"targetId",
+						"ref",
+						"element",
+						"format"
+					]
+				},
+				"screenshot": {
+					"label": "screenshot",
+					"detailKeys": [
+						"targetUrl",
+						"targetId",
+						"ref",
+						"element"
+					]
+				},
+				"navigate": {
+					"label": "navigate",
+					"detailKeys": ["targetUrl", "targetId"]
+				},
+				"console": {
+					"label": "console",
+					"detailKeys": ["level", "targetId"]
+				},
+				"pdf": {
+					"label": "pdf",
+					"detailKeys": ["targetId"]
+				},
+				"upload": {
+					"label": "upload",
+					"detailKeys": [
+						"paths",
+						"ref",
+						"inputRef",
+						"element",
+						"targetId"
+					]
+				},
+				"dialog": {
+					"label": "dialog",
+					"detailKeys": [
+						"accept",
+						"promptText",
+						"targetId"
+					]
+				},
+				"act": {
+					"label": "act",
+					"detailKeys": [
+						"request.kind",
+						"request.ref",
+						"request.selector",
+						"request.text",
+						"request.value"
+					]
+				}
+			}
+		},
+		"canvas": {
+			"emoji": "🖼️",
+			"title": "Canvas",
+			"actions": {
+				"present": {
+					"label": "present",
+					"detailKeys": [
+						"target",
+						"node",
+						"nodeId"
+					]
+				},
+				"hide": {
+					"label": "hide",
+					"detailKeys": ["node", "nodeId"]
+				},
+				"navigate": {
+					"label": "navigate",
+					"detailKeys": [
+						"url",
+						"node",
+						"nodeId"
+					]
+				},
+				"eval": {
+					"label": "eval",
+					"detailKeys": [
+						"javaScript",
+						"node",
+						"nodeId"
+					]
+				},
+				"snapshot": {
+					"label": "snapshot",
+					"detailKeys": [
+						"format",
+						"node",
+						"nodeId"
+					]
+				},
+				"a2ui_push": {
+					"label": "A2UI push",
+					"detailKeys": [
+						"jsonlPath",
+						"node",
+						"nodeId"
+					]
+				},
+				"a2ui_reset": {
+					"label": "A2UI reset",
+					"detailKeys": ["node", "nodeId"]
+				}
+			}
+		},
+		"nodes": {
+			"emoji": "📱",
+			"title": "Nodes",
+			"actions": {
+				"status": { "label": "status" },
+				"describe": {
+					"label": "describe",
+					"detailKeys": ["node", "nodeId"]
+				},
+				"pending": { "label": "pending" },
+				"approve": {
+					"label": "approve",
+					"detailKeys": ["requestId"]
+				},
+				"reject": {
+					"label": "reject",
+					"detailKeys": ["requestId"]
+				},
+				"notify": {
+					"label": "notify",
+					"detailKeys": [
+						"node",
+						"nodeId",
+						"title",
+						"body"
+					]
+				},
+				"camera_snap": {
+					"label": "camera snap",
+					"detailKeys": [
+						"node",
+						"nodeId",
+						"facing",
+						"deviceId"
+					]
+				},
+				"camera_list": {
+					"label": "camera list",
+					"detailKeys": ["node", "nodeId"]
+				},
+				"camera_clip": {
+					"label": "camera clip",
+					"detailKeys": [
+						"node",
+						"nodeId",
+						"facing",
+						"duration",
+						"durationMs"
+					]
+				},
+				"screen_record": {
+					"label": "screen record",
+					"detailKeys": [
+						"node",
+						"nodeId",
+						"duration",
+						"durationMs",
+						"fps",
+						"screenIndex"
+					]
+				}
+			}
+		},
+		"cron": {
+			"emoji": "⏰",
+			"title": "Cron",
+			"actions": {
+				"status": { "label": "status" },
+				"list": { "label": "list" },
+				"add": {
+					"label": "add",
+					"detailKeys": [
+						"job.name",
+						"job.id",
+						"job.schedule",
+						"job.cron"
+					]
+				},
+				"update": {
+					"label": "update",
+					"detailKeys": ["id"]
+				},
+				"remove": {
+					"label": "remove",
+					"detailKeys": ["id"]
+				},
+				"run": {
+					"label": "run",
+					"detailKeys": ["id"]
+				},
+				"runs": {
+					"label": "runs",
+					"detailKeys": ["id"]
+				},
+				"wake": {
+					"label": "wake",
+					"detailKeys": ["text", "mode"]
+				}
+			}
+		},
+		"gateway": {
+			"emoji": "🔌",
+			"title": "Gateway",
+			"actions": { "restart": {
+				"label": "restart",
+				"detailKeys": ["reason", "delayMs"]
+			} }
+		},
+		"message": {
+			"emoji": "✉️",
+			"title": "Message",
+			"actions": {
+				"send": {
+					"label": "send",
+					"detailKeys": [
+						"provider",
+						"to",
+						"media",
+						"replyTo",
+						"threadId"
+					]
+				},
+				"poll": {
+					"label": "poll",
+					"detailKeys": [
+						"provider",
+						"to",
+						"pollQuestion"
+					]
+				},
+				"react": {
+					"label": "react",
+					"detailKeys": [
+						"provider",
+						"to",
+						"messageId",
+						"emoji",
+						"remove"
+					]
+				},
+				"reactions": {
+					"label": "reactions",
+					"detailKeys": [
+						"provider",
+						"to",
+						"messageId",
+						"limit"
+					]
+				},
+				"read": {
+					"label": "read",
+					"detailKeys": [
+						"provider",
+						"to",
+						"limit"
+					]
+				},
+				"edit": {
+					"label": "edit",
+					"detailKeys": [
+						"provider",
+						"to",
+						"messageId"
+					]
+				},
+				"delete": {
+					"label": "delete",
+					"detailKeys": [
+						"provider",
+						"to",
+						"messageId"
+					]
+				},
+				"pin": {
+					"label": "pin",
+					"detailKeys": [
+						"provider",
+						"to",
+						"messageId"
+					]
+				},
+				"unpin": {
+					"label": "unpin",
+					"detailKeys": [
+						"provider",
+						"to",
+						"messageId"
+					]
+				},
+				"list-pins": {
+					"label": "list pins",
+					"detailKeys": ["provider", "to"]
+				},
+				"permissions": {
+					"label": "permissions",
+					"detailKeys": [
+						"provider",
+						"channelId",
+						"to"
+					]
+				},
+				"thread-create": {
+					"label": "thread create",
+					"detailKeys": [
+						"provider",
+						"channelId",
+						"threadName"
+					]
+				},
+				"thread-list": {
+					"label": "thread list",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"channelId"
+					]
+				},
+				"thread-reply": {
+					"label": "thread reply",
+					"detailKeys": [
+						"provider",
+						"channelId",
+						"messageId"
+					]
+				},
+				"search": {
+					"label": "search",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"query"
+					]
+				},
+				"sticker": {
+					"label": "sticker",
+					"detailKeys": [
+						"provider",
+						"to",
+						"stickerId"
+					]
+				},
+				"member-info": {
+					"label": "member",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId"
+					]
+				},
+				"role-info": {
+					"label": "roles",
+					"detailKeys": ["provider", "guildId"]
+				},
+				"emoji-list": {
+					"label": "emoji list",
+					"detailKeys": ["provider", "guildId"]
+				},
+				"emoji-upload": {
+					"label": "emoji upload",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"emojiName"
+					]
+				},
+				"sticker-upload": {
+					"label": "sticker upload",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"stickerName"
+					]
+				},
+				"role-add": {
+					"label": "role add",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId",
+						"roleId"
+					]
+				},
+				"role-remove": {
+					"label": "role remove",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId",
+						"roleId"
+					]
+				},
+				"channel-info": {
+					"label": "channel",
+					"detailKeys": ["provider", "channelId"]
+				},
+				"channel-list": {
+					"label": "channels",
+					"detailKeys": ["provider", "guildId"]
+				},
+				"voice-status": {
+					"label": "voice",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId"
+					]
+				},
+				"event-list": {
+					"label": "events",
+					"detailKeys": ["provider", "guildId"]
+				},
+				"event-create": {
+					"label": "event create",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"eventName"
+					]
+				},
+				"timeout": {
+					"label": "timeout",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId"
+					]
+				},
+				"kick": {
+					"label": "kick",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId"
+					]
+				},
+				"ban": {
+					"label": "ban",
+					"detailKeys": [
+						"provider",
+						"guildId",
+						"userId"
+					]
+				}
+			}
+		},
+		"agents_list": {
+			"emoji": "🧭",
+			"title": "Agents",
+			"detailKeys": []
+		},
+		"sessions_list": {
+			"emoji": "🗂️",
+			"title": "Sessions",
+			"detailKeys": [
+				"kinds",
+				"limit",
+				"activeMinutes",
+				"messageLimit"
+			]
+		},
+		"sessions_history": {
+			"emoji": "🧾",
+			"title": "Session History",
+			"detailKeys": [
+				"sessionKey",
+				"limit",
+				"includeTools"
+			]
+		},
+		"sessions_send": {
+			"emoji": "📨",
+			"title": "Session Send",
+			"detailKeys": [
+				"label",
+				"sessionKey",
+				"agentId",
+				"timeoutSeconds"
+			]
+		},
+		"sessions_spawn": {
+			"emoji": "🧑‍🔧",
+			"title": "Sub-agent",
+			"detailKeys": [
+				"label",
+				"task",
+				"agentId",
+				"model",
+				"thinking",
+				"runTimeoutSeconds",
+				"cleanup"
+			]
+		},
+		"subagents": {
+			"emoji": "🤖",
+			"title": "Subagents",
+			"actions": {
+				"list": {
+					"label": "list",
+					"detailKeys": ["recentMinutes"]
+				},
+				"kill": {
+					"label": "kill",
+					"detailKeys": ["target"]
+				},
+				"steer": {
+					"label": "steer",
+					"detailKeys": ["target"]
+				}
+			}
+		},
+		"session_status": {
+			"emoji": "📊",
+			"title": "Session Status",
+			"detailKeys": ["sessionKey", "model"]
+		},
+		"whatsapp_login": {
+			"emoji": "🟢",
+			"title": "WhatsApp Login",
+			"actions": {
+				"start": { "label": "start" },
+				"wait": { "label": "wait" }
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/agents/tool-display.ts
+const TOOL_DISPLAY_CONFIG = tool_display_default;
+const FALLBACK = TOOL_DISPLAY_CONFIG.fallback ?? { emoji: "🧩" };
+const TOOL_MAP = TOOL_DISPLAY_CONFIG.tools ?? {};
+
+//#endregion
+//#region src/agents/subagent-announce.ts
+const FAST_TEST_MODE = process.env.REMOTECLAW_TEST_FAST === "1";
+
+//#endregion
+//#region src/agents/subagent-registry.ts
+/**
+* Announce entries older than this are force-expired even if delivery never
+* succeeded. Guards against stale registry entries surviving gateway restarts.
+*/
+const ANNOUNCE_EXPIRY_MS = 5 * 6e4;
+
+//#endregion
+//#region src/web/auto-reply/constants.ts
+const DEFAULT_WEB_MEDIA_BYTES = 5 * 1024 * 1024;
+
+//#endregion
+//#region src/media-understanding/defaults.ts
+const MB = 1024 * 1024;
+const DEFAULT_MAX_BYTES = {
+	image: 10 * MB,
+	audio: 20 * MB,
+	video: 50 * MB
+};
+const DEFAULT_VIDEO_MAX_BASE64_BYTES = 70 * MB;
+const CLI_OUTPUT_MAX_BUFFER = 5 * MB;
+
+//#endregion
+//#region src/media/input-files.ts
+const DEFAULT_INPUT_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_INPUT_FILE_MAX_BYTES = 5 * 1024 * 1024;
+
+//#endregion
+//#region src/media-understanding/attachments.ts
+const DEFAULT_LOCAL_PATH_ROOTS = mergeInboundPathRoots(getDefaultMediaLocalRoots(), DEFAULT_IMESSAGE_ATTACHMENT_ROOTS);
+
+//#endregion
+//#region src/tts/tts-core.ts
+const TEMP_FILE_CLEANUP_DELAY_MS = 300 * 1e3;
+
+//#endregion
+//#region src/auto-reply/reply/commands-export-session.ts
+const EXPORT_HTML_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "export-html");
+
+//#endregion
+//#region src/discord/monitor/thread-bindings.types.ts
+const DEFAULT_THREAD_BINDING_TTL_MS = 1440 * 60 * 1e3;
+
+//#endregion
+//#region src/discord/monitor/thread-bindings.state.ts
+const THREAD_BINDINGS_STATE_KEY = "__remoteclawDiscordThreadBindingsState";
+function createThreadBindingsGlobalState() {
+	return {
+		managersByAccountId: /* @__PURE__ */ new Map(),
+		bindingsByThreadId: /* @__PURE__ */ new Map(),
+		bindingsBySessionKey: /* @__PURE__ */ new Map(),
+		tokensByAccountId: /* @__PURE__ */ new Map(),
+		recentUnboundWebhookEchoesByBindingKey: /* @__PURE__ */ new Map(),
+		reusableWebhooksByAccountChannel: /* @__PURE__ */ new Map(),
+		persistByAccountId: /* @__PURE__ */ new Map(),
+		loadedBindings: false
+	};
+}
+function resolveThreadBindingsGlobalState() {
+	const runtimeGlobal = globalThis;
+	if (!runtimeGlobal[THREAD_BINDINGS_STATE_KEY]) runtimeGlobal[THREAD_BINDINGS_STATE_KEY] = createThreadBindingsGlobalState();
+	return runtimeGlobal[THREAD_BINDINGS_STATE_KEY];
+}
+const THREAD_BINDINGS_STATE = resolveThreadBindingsGlobalState();
+const MANAGERS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.managersByAccountId;
+const BINDINGS_BY_THREAD_ID = THREAD_BINDINGS_STATE.bindingsByThreadId;
+const BINDINGS_BY_SESSION_KEY = THREAD_BINDINGS_STATE.bindingsBySessionKey;
+const TOKENS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.tokensByAccountId;
+const RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY = THREAD_BINDINGS_STATE.recentUnboundWebhookEchoesByBindingKey;
+const REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL = THREAD_BINDINGS_STATE.reusableWebhooksByAccountChannel;
+const PERSIST_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.persistByAccountId;
+
+//#endregion
+//#region src/discord/client.ts
+function resolveToken(params) {
+	const explicit = normalizeDiscordToken(params.explicit);
+	if (explicit) return explicit;
+	const fallback = normalizeDiscordToken(params.fallbackToken);
+	if (!fallback) throw new Error(`Discord bot token missing for account "${params.accountId}" (set discord.accounts.${params.accountId}.token or DISCORD_BOT_TOKEN for default).`);
+	return fallback;
+}
+function resolveRest(token, rest) {
+	return rest ?? new RequestClient(token);
+}
+function createDiscordRestClient(opts, cfg = loadConfig()) {
+	const account = resolveDiscordAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const token = resolveToken({
+		explicit: opts.token,
+		accountId: account.accountId,
+		fallbackToken: account.token
+	});
+	return {
+		token,
+		rest: resolveRest(token, opts.rest),
+		account
+	};
+}
+function createDiscordClient(opts, cfg = loadConfig()) {
+	const { token, rest, account } = createDiscordRestClient(opts, cfg);
+	return {
+		token,
+		rest,
+		request: createDiscordRetryRunner({
+			retry: opts.retry,
+			configRetry: account.config.retry,
+			verbose: opts.verbose
+		})
+	};
+}
+function resolveDiscordRest(opts) {
+	return createDiscordRestClient(opts).rest;
+}
+
+//#endregion
+//#region src/discord/chunk.ts
+const DEFAULT_MAX_CHARS = 2e3;
+const DEFAULT_MAX_LINES = 17;
+const FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+function countLines(text) {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+function parseFenceLine(line) {
+	const match = line.match(FENCE_RE);
+	if (!match) return null;
+	const indent = match[1] ?? "";
+	const marker = match[2] ?? "";
+	return {
+		indent,
+		markerChar: marker[0] ?? "`",
+		markerLen: marker.length,
+		openLine: line
+	};
+}
+function closeFenceLine(openFence) {
+	return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
+}
+function closeFenceIfNeeded(text, openFence) {
+	if (!openFence) return text;
+	const closeLine = closeFenceLine(openFence);
+	if (!text) return closeLine;
+	if (!text.endsWith("\n")) return `${text}\n${closeLine}`;
+	return `${text}${closeLine}`;
+}
+function splitLongLine(line, maxChars, opts) {
+	const limit = Math.max(1, Math.floor(maxChars));
+	if (line.length <= limit) return [line];
+	const out = [];
+	let remaining = line;
+	while (remaining.length > limit) {
+		if (opts.preserveWhitespace) {
+			out.push(remaining.slice(0, limit));
+			remaining = remaining.slice(limit);
+			continue;
+		}
+		const window = remaining.slice(0, limit);
+		let breakIdx = -1;
+		for (let i = window.length - 1; i >= 0; i--) if (/\s/.test(window[i])) {
+			breakIdx = i;
+			break;
+		}
+		if (breakIdx <= 0) breakIdx = limit;
+		out.push(remaining.slice(0, breakIdx));
+		remaining = remaining.slice(breakIdx);
+	}
+	if (remaining.length) out.push(remaining);
+	return out;
+}
+/**
+* Chunks outbound Discord text by both character count and (soft) line count,
+* while keeping fenced code blocks balanced across chunks.
+*/
+function chunkDiscordText(text, opts = {}) {
+	const maxChars = Math.max(1, Math.floor(opts.maxChars ?? DEFAULT_MAX_CHARS));
+	const maxLines = Math.max(1, Math.floor(opts.maxLines ?? DEFAULT_MAX_LINES));
+	const body = text ?? "";
+	if (!body) return [];
+	if (body.length <= maxChars && countLines(body) <= maxLines) return [body];
+	const lines = body.split("\n");
+	const chunks = [];
+	let current = "";
+	let currentLines = 0;
+	let openFence = null;
+	const flush = () => {
+		if (!current) return;
+		const payload = closeFenceIfNeeded(current, openFence);
+		if (payload.trim().length) chunks.push(payload);
+		current = "";
+		currentLines = 0;
+		if (openFence) {
+			current = openFence.openLine;
+			currentLines = 1;
+		}
+	};
+	for (const originalLine of lines) {
+		const fenceInfo = parseFenceLine(originalLine);
+		const wasInsideFence = openFence !== null;
+		let nextOpenFence = openFence;
+		if (fenceInfo) {
+			if (!openFence) nextOpenFence = fenceInfo;
+			else if (openFence.markerChar === fenceInfo.markerChar && fenceInfo.markerLen >= openFence.markerLen) nextOpenFence = null;
+		}
+		const reserveChars = nextOpenFence ? closeFenceLine(nextOpenFence).length + 1 : 0;
+		const reserveLines = nextOpenFence ? 1 : 0;
+		const effectiveMaxChars = maxChars - reserveChars;
+		const effectiveMaxLines = maxLines - reserveLines;
+		const charLimit = effectiveMaxChars > 0 ? effectiveMaxChars : maxChars;
+		const lineLimit = effectiveMaxLines > 0 ? effectiveMaxLines : maxLines;
+		const prefixLen = current.length > 0 ? current.length + 1 : 0;
+		const segments = splitLongLine(originalLine, Math.max(1, charLimit - prefixLen), { preserveWhitespace: wasInsideFence });
+		for (let segIndex = 0; segIndex < segments.length; segIndex++) {
+			const segment = segments[segIndex];
+			const isLineContinuation = segIndex > 0;
+			const addition = `${isLineContinuation ? "" : current.length > 0 ? "\n" : ""}${segment}`;
+			const nextLen = current.length + addition.length;
+			const nextLines = currentLines + (isLineContinuation ? 0 : 1);
+			if ((nextLen > charLimit || nextLines > lineLimit) && current.length > 0) flush();
+			if (current.length > 0) {
+				current += addition;
+				if (!isLineContinuation) currentLines += 1;
+			} else {
+				current = segment;
+				currentLines = 1;
+			}
+		}
+		openFence = nextOpenFence;
+	}
+	if (current.length) {
+		const payload = closeFenceIfNeeded(current, openFence);
+		if (payload.trim().length) chunks.push(payload);
+	}
+	return rebalanceReasoningItalics(text, chunks);
+}
+function chunkDiscordTextWithMode(text, opts) {
+	if ((opts.chunkMode ?? "length") !== "newline") return chunkDiscordText(text, opts);
+	const lineChunks = chunkMarkdownTextWithMode(text, Math.max(1, Math.floor(opts.maxChars ?? DEFAULT_MAX_CHARS)), "newline");
+	const chunks = [];
+	for (const line of lineChunks) {
+		const nested = chunkDiscordText(line, opts);
+		if (!nested.length && line) {
+			chunks.push(line);
+			continue;
+		}
+		chunks.push(...nested);
+	}
+	return chunks;
+}
+function rebalanceReasoningItalics(source, chunks) {
+	if (chunks.length <= 1) return chunks;
+	if (!(source.startsWith("Reasoning:\n_") && source.trimEnd().endsWith("_"))) return chunks;
+	const adjusted = [...chunks];
+	for (let i = 0; i < adjusted.length; i++) {
+		const isLast = i === adjusted.length - 1;
+		const current = adjusted[i];
+		if (!current.trimEnd().endsWith("_")) adjusted[i] = `${current}_`;
+		if (isLast) break;
+		const next = adjusted[i + 1];
+		const leadingWhitespaceLen = next.length - next.trimStart().length;
+		const leadingWhitespace = next.slice(0, leadingWhitespaceLen);
+		const nextBody = next.slice(leadingWhitespaceLen);
+		if (!nextBody.startsWith("_")) adjusted[i + 1] = `${leadingWhitespace}_${nextBody}`;
+	}
+	return adjusted;
+}
+
+//#endregion
+//#region src/discord/send.permissions.ts
+const PERMISSION_ENTRIES = Object.entries(PermissionFlagsBits).filter(([, value]) => typeof value === "bigint");
+const ALL_PERMISSIONS = PERMISSION_ENTRIES.reduce((acc, [, value]) => acc | value, 0n);
+const ADMINISTRATOR_BIT = PermissionFlagsBits.Administrator;
+function addPermissionBits(base, add) {
+	if (!add) return base;
+	return base | BigInt(add);
+}
+function removePermissionBits(base, deny) {
+	if (!deny) return base;
+	return base & ~BigInt(deny);
+}
+function bitfieldToPermissions(bitfield) {
+	return PERMISSION_ENTRIES.filter(([, value]) => (bitfield & value) === value).map(([name]) => name).toSorted();
+}
+function hasAdministrator(bitfield) {
+	return (bitfield & ADMINISTRATOR_BIT) === ADMINISTRATOR_BIT;
+}
+function isThreadChannelType(channelType) {
+	return channelType === ChannelType.GuildNewsThread || channelType === ChannelType.GuildPublicThread || channelType === ChannelType.GuildPrivateThread;
+}
+async function fetchBotUserId(rest) {
+	const me = await rest.get(Routes.user("@me"));
+	if (!me?.id) throw new Error("Failed to resolve bot user id");
+	return me.id;
+}
+async function fetchChannelPermissionsDiscord(channelId, opts = {}) {
+	const rest = resolveDiscordRest(opts);
+	const channel = await rest.get(Routes.channel(channelId));
+	const channelType = "type" in channel ? channel.type : void 0;
+	const guildId = "guild_id" in channel ? channel.guild_id : void 0;
+	if (!guildId) return {
+		channelId,
+		permissions: [],
+		raw: "0",
+		isDm: true,
+		channelType
+	};
+	const botId = await fetchBotUserId(rest);
+	const [guild, member] = await Promise.all([rest.get(Routes.guild(guildId)), rest.get(Routes.guildMember(guildId, botId))]);
+	const rolesById = new Map((guild.roles ?? []).map((role) => [role.id, role]));
+	const everyoneRole = rolesById.get(guildId);
+	let base = 0n;
+	if (everyoneRole?.permissions) base = addPermissionBits(base, everyoneRole.permissions);
+	for (const roleId of member.roles ?? []) {
+		const role = rolesById.get(roleId);
+		if (role?.permissions) base = addPermissionBits(base, role.permissions);
+	}
+	if (hasAdministrator(base)) return {
+		channelId,
+		guildId,
+		permissions: bitfieldToPermissions(ALL_PERMISSIONS),
+		raw: ALL_PERMISSIONS.toString(),
+		isDm: false,
+		channelType
+	};
+	let permissions = base;
+	const overwrites = "permission_overwrites" in channel ? channel.permission_overwrites ?? [] : [];
+	for (const overwrite of overwrites) if (overwrite.id === guildId) {
+		permissions = removePermissionBits(permissions, overwrite.deny ?? "0");
+		permissions = addPermissionBits(permissions, overwrite.allow ?? "0");
+	}
+	for (const overwrite of overwrites) if (member.roles?.includes(overwrite.id)) {
+		permissions = removePermissionBits(permissions, overwrite.deny ?? "0");
+		permissions = addPermissionBits(permissions, overwrite.allow ?? "0");
+	}
+	for (const overwrite of overwrites) if (overwrite.id === botId) {
+		permissions = removePermissionBits(permissions, overwrite.deny ?? "0");
+		permissions = addPermissionBits(permissions, overwrite.allow ?? "0");
+	}
+	return {
+		channelId,
+		guildId,
+		permissions: bitfieldToPermissions(permissions),
+		raw: permissions.toString(),
+		isDm: false,
+		channelType
+	};
+}
+
+//#endregion
+//#region src/discord/send.types.ts
+var DiscordSendError = class extends Error {
+	constructor(message, opts) {
+		super(message);
+		this.name = "DiscordSendError";
+		if (opts) Object.assign(this, opts);
+	}
+	toString() {
+		return this.message;
+	}
+};
+const DISCORD_MAX_EMOJI_BYTES = 256 * 1024;
+const DISCORD_MAX_STICKER_BYTES = 512 * 1024;
+
+//#endregion
+//#region src/discord/send.shared.ts
+const DISCORD_TEXT_LIMIT = 2e3;
+const DISCORD_MISSING_PERMISSIONS = 50013;
+const DISCORD_CANNOT_DM = 50007;
+/**
+* Parse and resolve Discord recipient, including username lookup.
+* This enables sending DMs by username (e.g., "john.doe") by querying
+* the Discord directory to resolve usernames to user IDs.
+*
+* @param raw - The recipient string (username, ID, or known format)
+* @param accountId - Discord account ID to use for directory lookup
+* @returns Parsed DiscordRecipient with resolved user ID if applicable
+*/
+async function parseAndResolveRecipient(raw, accountId) {
+	const cfg = loadConfig();
+	const accountInfo = resolveDiscordAccount({
+		cfg,
+		accountId
+	});
+	const trimmed = raw.trim();
+	const parseOptions = { ambiguousMessage: `Ambiguous Discord recipient "${trimmed}". Use "user:${trimmed}" for DMs or "channel:${trimmed}" for channel messages.` };
+	const resolved = await resolveDiscordTarget(raw, {
+		cfg,
+		accountId: accountInfo.accountId
+	}, parseOptions);
+	if (resolved) return {
+		kind: resolved.kind,
+		id: resolved.id
+	};
+	const parsed = parseDiscordTarget(raw, parseOptions);
+	if (!parsed) throw new Error("Recipient is required for Discord sends");
+	return {
+		kind: parsed.kind,
+		id: parsed.id
+	};
+}
+function getDiscordErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = "code" in err && err.code !== void 0 ? err.code : "rawError" in err && err.rawError && typeof err.rawError === "object" ? err.rawError.code : void 0;
+	if (typeof candidate === "number") return candidate;
+	if (typeof candidate === "string" && /^\d+$/.test(candidate)) return Number(candidate);
+}
+async function buildDiscordSendError(err, ctx) {
+	if (err instanceof DiscordSendError) return err;
+	const code = getDiscordErrorCode(err);
+	if (code === DISCORD_CANNOT_DM) return new DiscordSendError("discord dm failed: user blocks dms or privacy settings disallow it", { kind: "dm-blocked" });
+	if (code !== DISCORD_MISSING_PERMISSIONS) return err;
+	let missing = [];
+	try {
+		const permissions = await fetchChannelPermissionsDiscord(ctx.channelId, {
+			rest: ctx.rest,
+			token: ctx.token
+		});
+		const current = new Set(permissions.permissions);
+		const required = ["ViewChannel", "SendMessages"];
+		if (isThreadChannelType(permissions.channelType)) required.push("SendMessagesInThreads");
+		if (ctx.hasMedia) required.push("AttachFiles");
+		missing = required.filter((permission) => !current.has(permission));
+	} catch {}
+	return new DiscordSendError(`${missing.length ? `missing permissions in channel ${ctx.channelId}: ${missing.join(", ")}` : `missing permissions in channel ${ctx.channelId}`}. bot might be muted or blocked by role/channel overrides`, {
+		kind: "missing-permissions",
+		channelId: ctx.channelId,
+		missingPermissions: missing
+	});
+}
+async function resolveChannelId(rest, recipient, request) {
+	if (recipient.kind === "channel") return { channelId: recipient.id };
+	const dmChannel = await request(() => rest.post(Routes.userChannels(), { body: { recipient_id: recipient.id } }), "dm-channel");
+	if (!dmChannel?.id) throw new Error("Failed to create Discord DM channel");
+	return {
+		channelId: dmChannel.id,
+		dm: true
+	};
+}
+async function resolveDiscordChannelType(rest, channelId) {
+	try {
+		return (await rest.get(Routes.channel(channelId)))?.type;
+	} catch {
+		return;
+	}
+}
+const SUPPRESS_NOTIFICATIONS_FLAG = 4096;
+function buildDiscordTextChunks(text, opts = {}) {
+	if (!text) return [];
+	const chunks = chunkDiscordTextWithMode(text, {
+		maxChars: opts.maxChars ?? DISCORD_TEXT_LIMIT,
+		maxLines: opts.maxLinesPerMessage,
+		chunkMode: opts.chunkMode
+	});
+	if (!chunks.length && text) chunks.push(text);
+	return chunks;
+}
+function hasV2Components(components) {
+	return Boolean(components?.some((component) => "isV2" in component && component.isV2));
+}
+function resolveDiscordSendComponents(params) {
+	if (!params.components || !params.isFirst) return;
+	return typeof params.components === "function" ? params.components(params.text) : params.components;
+}
+function normalizeDiscordEmbeds(embeds) {
+	if (!embeds?.length) return;
+	return embeds.map((embed) => embed instanceof Embed ? embed : new Embed(embed));
+}
+function resolveDiscordSendEmbeds(params) {
+	if (!params.embeds || !params.isFirst) return;
+	return normalizeDiscordEmbeds(params.embeds);
+}
+function buildDiscordMessagePayload(params) {
+	const payload = {};
+	const hasV2 = hasV2Components(params.components);
+	const trimmed = params.text.trim();
+	if (!hasV2 && trimmed) payload.content = params.text;
+	if (params.components?.length) payload.components = params.components;
+	if (!hasV2 && params.embeds?.length) payload.embeds = params.embeds;
+	if (params.flags !== void 0) payload.flags = params.flags;
+	if (params.files?.length) payload.files = params.files;
+	return payload;
+}
+function stripUndefinedFields(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function toDiscordFileBlob(data) {
+	if (data instanceof Blob) return data;
+	const arrayBuffer = new ArrayBuffer(data.byteLength);
+	new Uint8Array(arrayBuffer).set(data);
+	return new Blob([arrayBuffer]);
+}
+async function sendDiscordText(rest, channelId, text, replyTo, request, maxLinesPerMessage, components, embeds, chunkMode, silent) {
+	if (!text.trim()) throw new Error("Message must be non-empty for Discord sends");
+	const messageReference = replyTo ? {
+		message_id: replyTo,
+		fail_if_not_exists: false
+	} : void 0;
+	const flags = silent ? SUPPRESS_NOTIFICATIONS_FLAG : void 0;
+	const chunks = buildDiscordTextChunks(text, {
+		maxLinesPerMessage,
+		chunkMode
+	});
+	const sendChunk = async (chunk, isFirst) => {
+		const body = stripUndefinedFields({
+			...serializePayload(buildDiscordMessagePayload({
+				text: chunk,
+				components: resolveDiscordSendComponents({
+					components,
+					text: chunk,
+					isFirst
+				}),
+				embeds: resolveDiscordSendEmbeds({
+					embeds,
+					isFirst
+				}),
+				flags
+			})),
+			...messageReference ? { message_reference: messageReference } : {}
+		});
+		return await request(() => rest.post(Routes.channelMessages(channelId), { body }), "text");
+	};
+	if (chunks.length === 1) return await sendChunk(chunks[0], true);
+	let last = null;
+	for (const [index, chunk] of chunks.entries()) last = await sendChunk(chunk, index === 0);
+	if (!last) throw new Error("Discord send failed (empty chunk result)");
+	return last;
+}
+async function sendDiscordMedia(rest, channelId, text, mediaUrl, mediaLocalRoots, replyTo, request, maxLinesPerMessage, components, embeds, chunkMode, silent) {
+	const media = await loadWebMedia(mediaUrl, { localRoots: mediaLocalRoots });
+	const chunks = text ? buildDiscordTextChunks(text, {
+		maxLinesPerMessage,
+		chunkMode
+	}) : [];
+	const caption = chunks[0] ?? "";
+	const messageReference = replyTo ? {
+		message_id: replyTo,
+		fail_if_not_exists: false
+	} : void 0;
+	const flags = silent ? SUPPRESS_NOTIFICATIONS_FLAG : void 0;
+	const fileData = toDiscordFileBlob(media.buffer);
+	const payload = buildDiscordMessagePayload({
+		text: caption,
+		components: resolveDiscordSendComponents({
+			components,
+			text: caption,
+			isFirst: true
+		}),
+		embeds: resolveDiscordSendEmbeds({
+			embeds,
+			isFirst: true
+		}),
+		flags,
+		files: [{
+			data: fileData,
+			name: media.fileName ?? "upload"
+		}]
+	});
+	const res = await request(() => rest.post(Routes.channelMessages(channelId), { body: stripUndefinedFields({
+		...serializePayload(payload),
+		...messageReference ? { message_reference: messageReference } : {}
+	}) }), "media");
+	for (const chunk of chunks.slice(1)) {
+		if (!chunk.trim()) continue;
+		await sendDiscordText(rest, channelId, chunk, replyTo, request, maxLinesPerMessage, void 0, void 0, chunkMode, silent);
+	}
+	return res;
+}
+
+//#endregion
+//#region src/discord/voice-message.ts
+/**
+* Discord Voice Message Support
+*
+* Implements sending voice messages via Discord's API.
+* Voice messages require:
+* - OGG/Opus format audio
+* - Waveform data (base64 encoded, up to 256 samples, 0-255 values)
+* - Duration in seconds
+* - Message flag 8192 (IS_VOICE_MESSAGE)
+* - No other content (text, embeds, etc.)
+*/
+const execFileAsync = promisify(execFile);
+
+//#endregion
+//#region src/discord/send.outbound.ts
+async function sendDiscordThreadTextChunks(params) {
+	for (const chunk of params.chunks) await sendDiscordText(params.rest, params.threadId, chunk, void 0, params.request, params.maxLinesPerMessage, void 0, void 0, params.chunkMode, params.silent);
+}
+/** Discord thread names are capped at 100 characters. */
+const DISCORD_THREAD_NAME_LIMIT = 100;
+/** Derive a thread title from the first non-empty line of the message text. */
+function deriveForumThreadName(text) {
+	return (text.split("\n").find((l) => l.trim())?.trim() ?? "").slice(0, DISCORD_THREAD_NAME_LIMIT) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 16);
+}
+/** Forum/Media channels cannot receive regular messages; detect them here. */
+function isForumLikeType(channelType) {
+	return channelType === ChannelType.GuildForum || channelType === ChannelType.GuildMedia;
+}
+function toDiscordSendResult(result, fallbackChannelId) {
+	return {
+		messageId: result.id ? String(result.id) : "unknown",
+		channelId: String(result.channel_id ?? fallbackChannelId)
+	};
+}
+async function sendMessageDiscord(to, text, opts = {}) {
+	const cfg = loadConfig();
+	const accountInfo = resolveDiscordAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "discord",
+		accountId: accountInfo.accountId
+	});
+	const chunkMode = resolveChunkMode(cfg, "discord", accountInfo.accountId);
+	const textWithTables = convertMarkdownTables(text ?? "", tableMode);
+	const { token, rest, request } = createDiscordClient(opts, cfg);
+	const { channelId } = await resolveChannelId(rest, await parseAndResolveRecipient(to, opts.accountId), request);
+	if (isForumLikeType(await resolveDiscordChannelType(rest, channelId))) {
+		const threadName = deriveForumThreadName(textWithTables);
+		const chunks = buildDiscordTextChunks(textWithTables, {
+			maxLinesPerMessage: accountInfo.config.maxLinesPerMessage,
+			chunkMode
+		});
+		const starterContent = chunks[0]?.trim() ? chunks[0] : threadName;
+		const starterPayload = buildDiscordMessagePayload({
+			text: starterContent,
+			components: resolveDiscordSendComponents({
+				components: opts.components,
+				text: starterContent,
+				isFirst: true
+			}),
+			embeds: resolveDiscordSendEmbeds({
+				embeds: opts.embeds,
+				isFirst: true
+			}),
+			flags: opts.silent ? 4096 : void 0
+		});
+		let threadRes;
+		try {
+			threadRes = await request(() => rest.post(Routes.threads(channelId), { body: {
+				name: threadName,
+				message: stripUndefinedFields(serializePayload(starterPayload))
+			} }), "forum-thread");
+		} catch (err) {
+			throw await buildDiscordSendError(err, {
+				channelId,
+				rest,
+				token,
+				hasMedia: Boolean(opts.mediaUrl)
+			});
+		}
+		const threadId = threadRes.id;
+		const messageId = threadRes.message?.id ?? threadId;
+		const resultChannelId = threadRes.message?.channel_id ?? threadId;
+		const remainingChunks = chunks.slice(1);
+		try {
+			if (opts.mediaUrl) {
+				const [mediaCaption, ...afterMediaChunks] = remainingChunks;
+				await sendDiscordMedia(rest, threadId, mediaCaption ?? "", opts.mediaUrl, opts.mediaLocalRoots, void 0, request, accountInfo.config.maxLinesPerMessage, void 0, void 0, chunkMode, opts.silent);
+				await sendDiscordThreadTextChunks({
+					rest,
+					threadId,
+					chunks: afterMediaChunks,
+					request,
+					maxLinesPerMessage: accountInfo.config.maxLinesPerMessage,
+					chunkMode,
+					silent: opts.silent
+				});
+			} else await sendDiscordThreadTextChunks({
+				rest,
+				threadId,
+				chunks: remainingChunks,
+				request,
+				maxLinesPerMessage: accountInfo.config.maxLinesPerMessage,
+				chunkMode,
+				silent: opts.silent
+			});
+		} catch (err) {
+			throw await buildDiscordSendError(err, {
+				channelId: threadId,
+				rest,
+				token,
+				hasMedia: Boolean(opts.mediaUrl)
+			});
+		}
+		recordChannelActivity({
+			channel: "discord",
+			accountId: accountInfo.accountId,
+			direction: "outbound"
+		});
+		return toDiscordSendResult({
+			id: messageId,
+			channel_id: resultChannelId
+		}, channelId);
+	}
+	let result;
+	try {
+		if (opts.mediaUrl) result = await sendDiscordMedia(rest, channelId, textWithTables, opts.mediaUrl, opts.mediaLocalRoots, opts.replyTo, request, accountInfo.config.maxLinesPerMessage, opts.components, opts.embeds, chunkMode, opts.silent);
+		else result = await sendDiscordText(rest, channelId, textWithTables, opts.replyTo, request, accountInfo.config.maxLinesPerMessage, opts.components, opts.embeds, chunkMode, opts.silent);
+	} catch (err) {
+		throw await buildDiscordSendError(err, {
+			channelId,
+			rest,
+			token,
+			hasMedia: Boolean(opts.mediaUrl)
+		});
+	}
+	recordChannelActivity({
+		channel: "discord",
+		accountId: accountInfo.accountId,
+		direction: "outbound"
+	});
+	return toDiscordSendResult(result, channelId);
+}
+
+//#endregion
+//#region src/discord/components-registry.ts
+const DEFAULT_COMPONENT_TTL_MS = 1800 * 1e3;
+
+//#endregion
+//#region src/discord/send.components.ts
+const DISCORD_FORUM_LIKE_TYPES = new Set([ChannelType.GuildForum, ChannelType.GuildMedia]);
+
+//#endregion
+//#region src/infra/restart.ts
+const restartLog = createSubsystemLogger("restart");
+
+//#endregion
+//#region src/auto-reply/reply/elevated-allowlist-matcher.ts
+const SENDER_PREFIXES = [
+	...CHAT_CHANNEL_ORDER,
+	INTERNAL_MESSAGE_CHANNEL,
+	"user",
+	"group",
+	"channel"
+];
+const SENDER_PREFIX_RE = new RegExp(`^(${SENDER_PREFIXES.join("|")}):`, "i");
+
+//#endregion
+//#region src/auth/env-injection.ts
+const log$3 = createSubsystemLogger("auth-env");
+
+//#endregion
+//#region src/middleware/auth-key-retry.ts
+const log$2 = createSubsystemLogger("auth-retry");
+
+//#endregion
+//#region src/infra/session-maintenance-warning.ts
+const log$1 = createSubsystemLogger("session-maintenance-warning");
+
+//#endregion
+//#region src/auto-reply/reply/session.ts
+const log = createSubsystemLogger("session-init");
+
+//#endregion
+//#region src/logging/redact-identifier.ts
+function sha256HexPrefix(value, len = 12) {
+	const safeLen = Number.isFinite(len) ? Math.max(1, Math.floor(len)) : 12;
+	return crypto.createHash("sha256").update(value).digest("hex").slice(0, safeLen);
+}
+function redactIdentifier(value, opts) {
+	const trimmed = value?.trim();
+	if (!trimmed) return "-";
+	return `sha256:${sha256HexPrefix(trimmed, opts?.len ?? 12)}`;
+}
+
+//#endregion
+//#region src/markdown/whatsapp.ts
+/**
+* Convert standard Markdown formatting to WhatsApp-compatible markup.
+*
+* WhatsApp uses its own formatting syntax:
+*   bold:          *text*
+*   italic:        _text_
+*   strikethrough: ~text~
+*   monospace:     ```text```
+*
+* Standard Markdown uses:
+*   bold:          **text** or __text__
+*   italic:        *text* or _text_
+*   strikethrough: ~~text~~
+*   code:          `text` (inline) or ```text``` (block)
+*
+* The conversion preserves fenced code blocks and inline code,
+* then converts bold and strikethrough markers.
+*/
+/** Placeholder tokens used during conversion to protect code spans. */
+const FENCE_PLACEHOLDER = "\0FENCE";
+const INLINE_CODE_PLACEHOLDER = "\0CODE";
+/**
+* Convert standard Markdown bold/italic/strikethrough to WhatsApp formatting.
+*
+* Order of operations matters:
+* 1. Protect fenced code blocks (```...```) — already WhatsApp-compatible
+* 2. Protect inline code (`...`) — leave as-is
+* 3. Convert **bold** → *bold* and __bold__ → *bold*
+* 4. Convert ~~strike~~ → ~strike~
+* 5. Restore protected spans
+*
+* Italic *text* and _text_ are left alone since WhatsApp uses _text_ for italic
+* and single * is already WhatsApp bold — no conversion needed for single markers.
+*/
+function markdownToWhatsApp(text) {
+	if (!text) return text;
+	const fences = [];
+	let result = text.replace(/```[\s\S]*?```/g, (match) => {
+		fences.push(match);
+		return `${FENCE_PLACEHOLDER}${fences.length - 1}`;
+	});
+	const inlineCodes = [];
+	result = result.replace(/`[^`\n]+`/g, (match) => {
+		inlineCodes.push(match);
+		return `${INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}`;
+	});
+	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+	result = result.replace(/__(.+?)__/g, "*$1*");
+	result = result.replace(/~~(.+?)~~/g, "~$1~");
+	result = result.replace(new RegExp(`${escapeRegExp(INLINE_CODE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
+	result = result.replace(new RegExp(`${escapeRegExp(FENCE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+	return result;
+}
+
+//#endregion
+//#region src/web/active-listener.ts
+const listeners = /* @__PURE__ */ new Map();
+function resolveWebAccountId(accountId) {
+	return (accountId ?? "").trim() || DEFAULT_ACCOUNT_ID;
+}
+function requireActiveWebListener(accountId) {
+	const id = resolveWebAccountId(accountId);
+	const listener = listeners.get(id) ?? null;
+	if (!listener) throw new Error(`No active WhatsApp Web listener (account: ${id}). Start the gateway, then link WhatsApp with: ${formatCliCommand(`remoteclaw channels login --channel whatsapp --account ${id}`)}.`);
+	return {
+		accountId: id,
+		listener
+	};
+}
+
+//#endregion
+//#region src/web/outbound.ts
+const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+async function sendMessageWhatsApp(to, body, options) {
+	let text = body;
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const { listener: active, accountId: resolvedAccountId } = requireActiveWebListener(options.accountId);
+	const tableMode = resolveMarkdownTableMode({
+		cfg: loadConfig(),
+		channel: "whatsapp",
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	text = convertMarkdownTables(text ?? "", tableMode);
+	text = markdownToWhatsApp(text);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		const redactedJid = redactIdentifier(jid);
+		let mediaBuffer;
+		let mediaType;
+		let documentFileName;
+		if (options.mediaUrl) {
+			const media = await loadWebMedia(options.mediaUrl, { localRoots: options.mediaLocalRoots });
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.contentType;
+			if (media.kind === "audio") mediaType = media.contentType === "audio/ogg" ? "audio/ogg; codecs=opus" : media.contentType ?? "application/octet-stream";
+			else if (media.kind === "video") text = caption ?? "";
+			else if (media.kind === "image") text = caption ?? "";
+			else {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			}
+		}
+		outboundLog.info(`Sending message -> ${redactedJid}${options.mediaUrl ? " (media)" : ""}`);
+		logger.info({
+			jid: redactedJid,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "sending message");
+		await active.sendComposingTo(to);
+		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
+		const sendOptions = options.gifPlayback || accountId || documentFileName ? {
+			...options.gifPlayback ? { gifPlayback: true } : {},
+			...documentFileName ? { fileName: documentFileName } : {},
+			accountId
+		} : void 0;
+		const messageId = (sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent message ${messageId} -> ${redactedJid}${options.mediaUrl ? " (media)" : ""} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent message");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "failed to send via web session");
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/web/session.ts
+let credsSaveQueue = Promise.resolve();
+
+//#endregion
+//#region src/web/auto-reply/loggers.ts
+const whatsappLog = createSubsystemLogger("gateway/channels/whatsapp");
+const whatsappInboundLog = whatsappLog.child("inbound");
+const whatsappOutboundLog = whatsappLog.child("outbound");
+const whatsappHeartbeatLog = whatsappLog.child("heartbeat");
+
+//#endregion
+//#region src/infra/map-size.ts
+function pruneMapToMaxSize(map, maxSize) {
+	const limit = Math.max(0, Math.floor(maxSize));
+	if (limit <= 0) {
+		map.clear();
+		return;
+	}
+	while (map.size > limit) {
+		const oldest = map.keys().next();
+		if (oldest.done) break;
+		map.delete(oldest.value);
+	}
+}
+
+//#endregion
+//#region src/infra/dedupe.ts
+function createDedupeCache(options) {
+	const ttlMs = Math.max(0, options.ttlMs);
+	const maxSize = Math.max(0, Math.floor(options.maxSize));
+	const cache = /* @__PURE__ */ new Map();
+	const touch = (key, now) => {
+		cache.delete(key);
+		cache.set(key, now);
+	};
+	const prune = (now) => {
+		const cutoff = ttlMs > 0 ? now - ttlMs : void 0;
+		if (cutoff !== void 0) {
+			for (const [entryKey, entryTs] of cache) if (entryTs < cutoff) cache.delete(entryKey);
+		}
+		if (maxSize <= 0) {
+			cache.clear();
+			return;
+		}
+		pruneMapToMaxSize(cache, maxSize);
+	};
+	const hasUnexpired = (key, now, touchOnRead) => {
+		const existing = cache.get(key);
+		if (existing === void 0) return false;
+		if (ttlMs > 0 && now - existing >= ttlMs) {
+			cache.delete(key);
+			return false;
+		}
+		if (touchOnRead) touch(key, now);
+		return true;
+	};
+	return {
+		check: (key, now = Date.now()) => {
+			if (!key) return false;
+			if (hasUnexpired(key, now, true)) return true;
+			touch(key, now);
+			prune(now);
+			return false;
+		},
+		peek: (key, now = Date.now()) => {
+			if (!key) return false;
+			return hasUnexpired(key, now, false);
+		},
+		clear: () => {
+			cache.clear();
+		},
+		size: () => cache.size
+	};
+}
+
+//#endregion
+//#region src/web/inbound/dedupe.ts
+const recentInboundMessages = createDedupeCache({
+	ttlMs: 20 * 6e4,
+	maxSize: 5e3
+});
+
+//#endregion
+//#region src/auto-reply/reply/inbound-dedupe.ts
+const inboundDedupeCache = createDedupeCache({
+	ttlMs: 20 * 6e4,
+	maxSize: 5e3
+});
+
+//#endregion
+export { DiscordSendError as n, fetchChannelPermissionsDiscord as r, sendMessageWhatsApp, sendMessageDiscord as t };