@hanzo/bot 2026.3.9 → 2026.3.10

package/dist/plugin-sdk/deliver-runtime-CB4wXMTH.js

@@ -0,0 +1,32 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./thinking-DE2FCBnv.js";
+import "./image-ops-BpYDXC6N.js";
+import "./pi-embedded-helpers-CeC8GbRi.js";
+import "./plugins-2gQWMmUN.js";
+import "./accounts-B8qv93DH.js";
+import "./accounts-D96D1U9M.js";
+import "./paths-CfGmXu9A.js";
+import "./fetch-Bv4TQOMH.js";
+import "./redact-85H1J7mo.js";
+import "./errors-D5bA02--.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./tool-images-B1I6LEp7.js";
+import "./tokens-C2tJ8uXs.js";
+import "./skills-BrE5Yb5o.js";
+import "./chrome-5jJIDTj0.js";
+import { t as deliverOutboundPayloads } from "./deliver-4NrmrRKu.js";
+import "./store-8XS_isi_.js";
+import "./send-Bplfz7UW.js";
+import "./outbound-attachment-CPfpUcdI.js";
+
+export { deliverOutboundPayloads };

package/dist/plugin-sdk/deps-send-discord.runtime-Di8ELKED.js

@@ -0,0 +1,23 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./image-ops-BpYDXC6N.js";
+import "./plugins-2gQWMmUN.js";
+import { h as sendMessageDiscord } from "./send-BQvcPd54.js";
+import "./fetch-Bv4TQOMH.js";
+import "./redact-85H1J7mo.js";
+import "./errors-D5bA02--.js";
+import "./channel-activity-VpA3MxPb.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./render-HmipMDlP.js";
+import "./tables-BhfDBQ58.js";
+
+export { sendMessageDiscord };

package/dist/plugin-sdk/deps-send-imessage.runtime-CWWtApbz.js

@@ -0,0 +1,22 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./image-ops-BpYDXC6N.js";
+import "./plugins-2gQWMmUN.js";
+import "./accounts-B8qv93DH.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./render-HmipMDlP.js";
+import "./tables-BhfDBQ58.js";
+import { t as sendMessageIMessage } from "./send-Cld7xlxq.js";
+import "./store-8XS_isi_.js";
+import "./outbound-attachment-CPfpUcdI.js";
+
+export { sendMessageIMessage };

package/dist/plugin-sdk/deps-send-signal.runtime-C6BGyoIY.js

@@ -0,0 +1,21 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./image-ops-BpYDXC6N.js";
+import "./plugins-2gQWMmUN.js";
+import "./accounts-D96D1U9M.js";
+import "./fetch-Bv4TQOMH.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./store-8XS_isi_.js";
+import { t as sendMessageSignal } from "./send-Bplfz7UW.js";
+import "./outbound-attachment-CPfpUcdI.js";
+
+export { sendMessageSignal };

package/dist/plugin-sdk/deps-send-slack.runtime-DgtITBuc.js

@@ -0,0 +1,19 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./image-ops-BpYDXC6N.js";
+import "./plugins-2gQWMmUN.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./render-HmipMDlP.js";
+import { t as sendMessageSlack } from "./send-C8gdhoLP.js";
+import "./tokens-C2tJ8uXs.js";
+
+export { sendMessageSlack };

package/dist/plugin-sdk/deps-send-telegram.runtime-DyY4XRxh.js

@@ -0,0 +1,24 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./image-ops-BpYDXC6N.js";
+import "./plugins-2gQWMmUN.js";
+import "./fetch-Bv4TQOMH.js";
+import "./redact-85H1J7mo.js";
+import "./errors-D5bA02--.js";
+import "./channel-activity-VpA3MxPb.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./render-HmipMDlP.js";
+import { o as sendMessageTelegram } from "./send-CTOVZqmi.js";
+import "./proxy-fetch-sX3-xzX1.js";
+import "./proxy-BFm9FJeW.js";
+
+export { sendMessageTelegram };

package/dist/plugin-sdk/deps-send-whatsapp.runtime-LKiQNFcF.js

@@ -0,0 +1,57 @@
+import "./run-with-concurrency-CFRxflYW.js";
+import "./accounts-D2p8t4UO.js";
+import "./reply-DmCyOPxV.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-CudVTZDi.js";
+import "./logger-2A0UE34q.js";
+import "./thinking-DE2FCBnv.js";
+import "./image-ops-BpYDXC6N.js";
+import "./pi-embedded-helpers-CeC8GbRi.js";
+import "./plugins-2gQWMmUN.js";
+import "./accounts-B8qv93DH.js";
+import "./accounts-D96D1U9M.js";
+import "./send-BQvcPd54.js";
+import "./paths-CfGmXu9A.js";
+import "./fetch-Bv4TQOMH.js";
+import "./redact-85H1J7mo.js";
+import "./errors-D5bA02--.js";
+import "./channel-activity-VpA3MxPb.js";
+import "./path-alias-guards-LILr7Hrs.js";
+import "./fs-safe-IQ0H7rVD.js";
+import "./ssrf-CbvrROKN.js";
+import "./fetch-guard-n0LVdzZL.js";
+import "./local-roots-DR-lR22p.js";
+import "./ir-DsMX3GcS.js";
+import "./render-HmipMDlP.js";
+import "./tables-BhfDBQ58.js";
+import "./send-Cld7xlxq.js";
+import "./send-CTOVZqmi.js";
+import "./tool-images-B1I6LEp7.js";
+import "./target-errors-0DW3k-Ae.js";
+import "./send-C8gdhoLP.js";
+import "./audio-transcription-runner-j0mQXKSH.js";
+import "./tokens-C2tJ8uXs.js";
+import "./skill-commands-BfHvtJx2.js";
+import "./skills-BrE5Yb5o.js";
+import "./chrome-5jJIDTj0.js";
+import "./deliver-4NrmrRKu.js";
+import "./diagnostic-DCPixRez.js";
+import "./store-8XS_isi_.js";
+import "./commands-registry-BVKCdwN_.js";
+import "./channel-web-BP3vDdim.js";
+import "./image-n-R2HcNg.js";
+import "./api-key-rotation-D0aZfxXH.js";
+import "./proxy-fetch-sX3-xzX1.js";
+import "./pi-model-discovery-DycOMKYh.js";
+import "./send-Bplfz7UW.js";
+import "./outbound-attachment-CPfpUcdI.js";
+import "./proxy-BFm9FJeW.js";
+import "./manager-ClUgSFkG.js";
+import "./query-expansion-B5Z0In1U.js";
+import { t as sendMessageWhatsApp } from "./outbound-Dqs8L8QW.js";
+import "./session-D4k86ARy.js";
+import "./login-CxFTtHEi.js";
+import "./web-BHzDLmns.js";
+
+export { sendMessageWhatsApp };

package/dist/plugin-sdk/diagnostic-DCPixRez.js

@@ -0,0 +1,319 @@
+import { n as loadConfig } from "./config-CudVTZDi.js";
+import { a as createSubsystemLogger } from "./logger-2A0UE34q.js";
+
+//#region src/infra/diagnostic-events.ts
+function getDiagnosticEventsState() {
+	const globalStore = globalThis;
+	if (!globalStore.__openclawDiagnosticEventsState) globalStore.__openclawDiagnosticEventsState = {
+		seq: 0,
+		listeners: /* @__PURE__ */ new Set(),
+		dispatchDepth: 0
+	};
+	return globalStore.__openclawDiagnosticEventsState;
+}
+function isDiagnosticsEnabled(config) {
+	return config?.diagnostics?.enabled === true;
+}
+function emitDiagnosticEvent(event) {
+	const state = getDiagnosticEventsState();
+	if (state.dispatchDepth > 100) {
+		console.error(`[diagnostic-events] recursion guard tripped at depth=${state.dispatchDepth}, dropping type=${event.type}`);
+		return;
+	}
+	const enriched = {
+		...event,
+		seq: state.seq += 1,
+		ts: Date.now()
+	};
+	state.dispatchDepth += 1;
+	for (const listener of state.listeners) try {
+		listener(enriched);
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.stack ?? err.message : typeof err === "string" ? err : String(err);
+		console.error(`[diagnostic-events] listener error type=${enriched.type} seq=${enriched.seq}: ${errorMessage}`);
+	}
+	state.dispatchDepth -= 1;
+}
+function onDiagnosticEvent(listener) {
+	const state = getDiagnosticEventsState();
+	state.listeners.add(listener);
+	return () => {
+		state.listeners.delete(listener);
+	};
+}
+
+//#endregion
+//#region src/logging/diagnostic-session-state.ts
+const diagnosticSessionStates = /* @__PURE__ */ new Map();
+const SESSION_STATE_TTL_MS = 1800 * 1e3;
+const SESSION_STATE_PRUNE_INTERVAL_MS = 60 * 1e3;
+const SESSION_STATE_MAX_ENTRIES = 2e3;
+let lastSessionPruneAt = 0;
+function pruneDiagnosticSessionStates(now = Date.now(), force = false) {
+	const shouldPruneForSize = diagnosticSessionStates.size > SESSION_STATE_MAX_ENTRIES;
+	if (!force && !shouldPruneForSize && now - lastSessionPruneAt < SESSION_STATE_PRUNE_INTERVAL_MS) return;
+	lastSessionPruneAt = now;
+	for (const [key, state] of diagnosticSessionStates.entries()) {
+		const ageMs = now - state.lastActivity;
+		if (state.state === "idle" && state.queueDepth <= 0 && ageMs > SESSION_STATE_TTL_MS) diagnosticSessionStates.delete(key);
+	}
+	if (diagnosticSessionStates.size <= SESSION_STATE_MAX_ENTRIES) return;
+	const excess = diagnosticSessionStates.size - SESSION_STATE_MAX_ENTRIES;
+	const ordered = Array.from(diagnosticSessionStates.entries()).toSorted((a, b) => a[1].lastActivity - b[1].lastActivity);
+	for (let i = 0; i < excess; i += 1) {
+		const key = ordered[i]?.[0];
+		if (!key) break;
+		diagnosticSessionStates.delete(key);
+	}
+}
+function resolveSessionKey({ sessionKey, sessionId }) {
+	return sessionKey ?? sessionId ?? "unknown";
+}
+function findStateBySessionId(sessionId) {
+	for (const state of diagnosticSessionStates.values()) if (state.sessionId === sessionId) return state;
+}
+function getDiagnosticSessionState(ref) {
+	pruneDiagnosticSessionStates();
+	const key = resolveSessionKey(ref);
+	const existing = diagnosticSessionStates.get(key) ?? (ref.sessionId && findStateBySessionId(ref.sessionId));
+	if (existing) {
+		if (ref.sessionId) existing.sessionId = ref.sessionId;
+		if (ref.sessionKey) existing.sessionKey = ref.sessionKey;
+		return existing;
+	}
+	const created = {
+		sessionId: ref.sessionId,
+		sessionKey: ref.sessionKey,
+		lastActivity: Date.now(),
+		state: "idle",
+		queueDepth: 0
+	};
+	diagnosticSessionStates.set(key, created);
+	pruneDiagnosticSessionStates(Date.now(), true);
+	return created;
+}
+
+//#endregion
+//#region src/logging/diagnostic.ts
+const diag = createSubsystemLogger("diagnostic");
+const webhookStats = {
+	received: 0,
+	processed: 0,
+	errors: 0,
+	lastReceived: 0
+};
+let lastActivityAt = 0;
+const DEFAULT_STUCK_SESSION_WARN_MS = 12e4;
+const MIN_STUCK_SESSION_WARN_MS = 1e3;
+const MAX_STUCK_SESSION_WARN_MS = 1440 * 60 * 1e3;
+let commandPollBackoffRuntimePromise = null;
+function loadCommandPollBackoffRuntime() {
+	commandPollBackoffRuntimePromise ??= import("./command-poll-backoff.runtime-DqO-toxL.js");
+	return commandPollBackoffRuntimePromise;
+}
+function markActivity() {
+	lastActivityAt = Date.now();
+}
+function resolveStuckSessionWarnMs(config) {
+	const raw = config?.diagnostics?.stuckSessionWarnMs;
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return DEFAULT_STUCK_SESSION_WARN_MS;
+	const rounded = Math.floor(raw);
+	if (rounded < MIN_STUCK_SESSION_WARN_MS || rounded > MAX_STUCK_SESSION_WARN_MS) return DEFAULT_STUCK_SESSION_WARN_MS;
+	return rounded;
+}
+function logWebhookReceived(params) {
+	webhookStats.received += 1;
+	webhookStats.lastReceived = Date.now();
+	if (diag.isEnabled("debug")) diag.debug(`webhook received: channel=${params.channel} type=${params.updateType ?? "unknown"} chatId=${params.chatId ?? "unknown"} total=${webhookStats.received}`);
+	emitDiagnosticEvent({
+		type: "webhook.received",
+		channel: params.channel,
+		updateType: params.updateType,
+		chatId: params.chatId
+	});
+	markActivity();
+}
+function logWebhookProcessed(params) {
+	webhookStats.processed += 1;
+	if (diag.isEnabled("debug")) diag.debug(`webhook processed: channel=${params.channel} type=${params.updateType ?? "unknown"} chatId=${params.chatId ?? "unknown"} duration=${params.durationMs ?? 0}ms processed=${webhookStats.processed}`);
+	emitDiagnosticEvent({
+		type: "webhook.processed",
+		channel: params.channel,
+		updateType: params.updateType,
+		chatId: params.chatId,
+		durationMs: params.durationMs
+	});
+	markActivity();
+}
+function logWebhookError(params) {
+	webhookStats.errors += 1;
+	diag.error(`webhook error: channel=${params.channel} type=${params.updateType ?? "unknown"} chatId=${params.chatId ?? "unknown"} error="${params.error}" errors=${webhookStats.errors}`);
+	emitDiagnosticEvent({
+		type: "webhook.error",
+		channel: params.channel,
+		updateType: params.updateType,
+		chatId: params.chatId,
+		error: params.error
+	});
+	markActivity();
+}
+function logMessageQueued(params) {
+	const state = getDiagnosticSessionState(params);
+	state.queueDepth += 1;
+	state.lastActivity = Date.now();
+	if (diag.isEnabled("debug")) diag.debug(`message queued: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} source=${params.source} queueDepth=${state.queueDepth} sessionState=${state.state}`);
+	emitDiagnosticEvent({
+		type: "message.queued",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		channel: params.channel,
+		source: params.source,
+		queueDepth: state.queueDepth
+	});
+	markActivity();
+}
+function logMessageProcessed(params) {
+	if (params.outcome === "error" ? diag.isEnabled("error") : diag.isEnabled("debug")) {
+		const payload = `message processed: channel=${params.channel} chatId=${params.chatId ?? "unknown"} messageId=${params.messageId ?? "unknown"} sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} outcome=${params.outcome} duration=${params.durationMs ?? 0}ms${params.reason ? ` reason=${params.reason}` : ""}${params.error ? ` error="${params.error}"` : ""}`;
+		if (params.outcome === "error") diag.error(payload);
+		else diag.debug(payload);
+	}
+	emitDiagnosticEvent({
+		type: "message.processed",
+		channel: params.channel,
+		chatId: params.chatId,
+		messageId: params.messageId,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		durationMs: params.durationMs,
+		outcome: params.outcome,
+		reason: params.reason,
+		error: params.error
+	});
+	markActivity();
+}
+function logSessionStateChange(params) {
+	const state = getDiagnosticSessionState(params);
+	const isProbeSession = state.sessionId?.startsWith("probe-") ?? false;
+	const prevState = state.state;
+	state.state = params.state;
+	state.lastActivity = Date.now();
+	if (params.state === "idle") state.queueDepth = Math.max(0, state.queueDepth - 1);
+	if (!isProbeSession && diag.isEnabled("debug")) diag.debug(`session state: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} prev=${prevState} new=${params.state} reason="${params.reason ?? ""}" queueDepth=${state.queueDepth}`);
+	emitDiagnosticEvent({
+		type: "session.state",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		prevState,
+		state: params.state,
+		reason: params.reason,
+		queueDepth: state.queueDepth
+	});
+	markActivity();
+}
+function logSessionStuck(params) {
+	const state = getDiagnosticSessionState(params);
+	diag.warn(`stuck session: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} state=${params.state} age=${Math.round(params.ageMs / 1e3)}s queueDepth=${state.queueDepth}`);
+	emitDiagnosticEvent({
+		type: "session.stuck",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		state: params.state,
+		ageMs: params.ageMs,
+		queueDepth: state.queueDepth
+	});
+	markActivity();
+}
+function logLaneEnqueue(lane, queueSize) {
+	diag.debug(`lane enqueue: lane=${lane} queueSize=${queueSize}`);
+	emitDiagnosticEvent({
+		type: "queue.lane.enqueue",
+		lane,
+		queueSize
+	});
+	markActivity();
+}
+function logLaneDequeue(lane, waitMs, queueSize) {
+	diag.debug(`lane dequeue: lane=${lane} waitMs=${waitMs} queueSize=${queueSize}`);
+	emitDiagnosticEvent({
+		type: "queue.lane.dequeue",
+		lane,
+		queueSize,
+		waitMs
+	});
+	markActivity();
+}
+function logToolLoopAction(params) {
+	const payload = `tool loop: sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} tool=${params.toolName} level=${params.level} action=${params.action} detector=${params.detector} count=${params.count}${params.pairedToolName ? ` pairedTool=${params.pairedToolName}` : ""} message="${params.message}"`;
+	if (params.level === "critical") diag.error(payload);
+	else diag.warn(payload);
+	emitDiagnosticEvent({
+		type: "tool.loop",
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		toolName: params.toolName,
+		level: params.level,
+		action: params.action,
+		detector: params.detector,
+		count: params.count,
+		message: params.message,
+		pairedToolName: params.pairedToolName
+	});
+	markActivity();
+}
+let heartbeatInterval = null;
+function startDiagnosticHeartbeat(config) {
+	if (heartbeatInterval) return;
+	heartbeatInterval = setInterval(() => {
+		let heartbeatConfig = config;
+		if (!heartbeatConfig) try {
+			heartbeatConfig = loadConfig();
+		} catch {
+			heartbeatConfig = void 0;
+		}
+		const stuckSessionWarnMs = resolveStuckSessionWarnMs(heartbeatConfig);
+		const now = Date.now();
+		pruneDiagnosticSessionStates(now, true);
+		const activeCount = Array.from(diagnosticSessionStates.values()).filter((s) => s.state === "processing").length;
+		const waitingCount = Array.from(diagnosticSessionStates.values()).filter((s) => s.state === "waiting").length;
+		const totalQueued = Array.from(diagnosticSessionStates.values()).reduce((sum, s) => sum + s.queueDepth, 0);
+		if (!(lastActivityAt > 0 || webhookStats.received > 0 || activeCount > 0 || waitingCount > 0 || totalQueued > 0)) return;
+		if (now - lastActivityAt > 12e4 && activeCount === 0 && waitingCount === 0) return;
+		diag.debug(`heartbeat: webhooks=${webhookStats.received}/${webhookStats.processed}/${webhookStats.errors} active=${activeCount} waiting=${waitingCount} queued=${totalQueued}`);
+		emitDiagnosticEvent({
+			type: "diagnostic.heartbeat",
+			webhooks: {
+				received: webhookStats.received,
+				processed: webhookStats.processed,
+				errors: webhookStats.errors
+			},
+			active: activeCount,
+			waiting: waitingCount,
+			queued: totalQueued
+		});
+		loadCommandPollBackoffRuntime().then(({ pruneStaleCommandPolls }) => {
+			for (const [, state] of diagnosticSessionStates) pruneStaleCommandPolls(state);
+		}).catch((err) => {
+			diag.debug(`command-poll-backoff prune failed: ${String(err)}`);
+		});
+		for (const [, state] of diagnosticSessionStates) {
+			const ageMs = now - state.lastActivity;
+			if (state.state === "processing" && ageMs > stuckSessionWarnMs) logSessionStuck({
+				sessionId: state.sessionId,
+				sessionKey: state.sessionKey,
+				state: state.state,
+				ageMs
+			});
+		}
+	}, 3e4);
+	heartbeatInterval.unref?.();
+}
+function stopDiagnosticHeartbeat() {
+	if (heartbeatInterval) {
+		clearInterval(heartbeatInterval);
+		heartbeatInterval = null;
+	}
+}
+
+//#endregion
+export { logMessageQueued as a, logWebhookError as c, startDiagnosticHeartbeat as d, stopDiagnosticHeartbeat as f, onDiagnosticEvent as g, isDiagnosticsEnabled as h, logMessageProcessed as i, logWebhookProcessed as l, emitDiagnosticEvent as m, logLaneDequeue as n, logSessionStateChange as o, getDiagnosticSessionState as p, logLaneEnqueue as r, logToolLoopAction as s, diag as t, logWebhookReceived as u };

package/dist/plugin-sdk/discord.js

@@ -4,7 +4,7 @@ import chalk, { Chalk } from "chalk";
 import fs, { constants } from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import json5 from "json5";
+import JSON5 from "json5";
 import { isDeepStrictEqual, promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import { execFile, execFileSync, spawn } from "node:child_process";
@@ -812,7 +812,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = json5.parse(raw)?.logging;
+		const logging = JSON5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {
@@ -6046,7 +6046,7 @@ const defaultResolver = {
 		resolvedPath,
 		rootRealDir
 	}),
-	parseJson: (raw) => json5.parse(raw)
+	parseJson: (raw) => JSON5.parse(raw)
 };
 /**
 * Resolves all $include directives in a parsed config object.
@@ -13506,7 +13506,7 @@ function resolveConfigPathForDeps(deps) {
 function normalizeDeps(overrides = {}) {
 	return {
 		fs: overrides.fs ?? fs,
-		json5: overrides.json5 ?? json5,
+		json5: overrides.json5 ?? JSON5,
 		env: overrides.env ?? process.env,
 		homedir: overrides.homedir ?? (() => resolveRequiredHomeDir(overrides.env ?? process.env, os.homedir)),
 		configPath: overrides.configPath ?? "",
@@ -13517,11 +13517,11 @@ function maybeLoadDotEnvForConfig(env) {
 	if (env !== process.env) return;
 	loadDotEnv({ quiet: true });
 }
-function parseConfigJson5(raw, json5$1 = json5) {
+function parseConfigJson5(raw, json5 = JSON5) {
 	try {
 		return {
 			ok: true,
-			parsed: json5$1.parse(raw)
+			parsed: json5.parse(raw)
 		};
 	} catch (err) {
 		return {

package/dist/plugin-sdk/errors-D5bA02--.js

@@ -0,0 +1,54 @@
+import { t as redactSensitiveText } from "./redact-85H1J7mo.js";
+
+//#region src/infra/errors.ts
+function extractErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const code = err.code;
+	if (typeof code === "string") return code;
+	if (typeof code === "number") return String(code);
+}
+function readErrorName(err) {
+	if (!err || typeof err !== "object") return "";
+	const name = err.name;
+	return typeof name === "string" ? name : "";
+}
+function collectErrorGraphCandidates(err, resolveNested) {
+	const queue = [err];
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current == null || seen.has(current)) continue;
+		seen.add(current);
+		candidates.push(current);
+		if (!current || typeof current !== "object" || !resolveNested) continue;
+		for (const nested of resolveNested(current)) if (nested != null && !seen.has(nested)) queue.push(nested);
+	}
+	return candidates;
+}
+/**
+* Type guard for NodeJS.ErrnoException (any error with a `code` property).
+*/
+function isErrno(err) {
+	return Boolean(err && typeof err === "object" && "code" in err);
+}
+function formatErrorMessage(err) {
+	let formatted;
+	if (err instanceof Error) formatted = err.message || err.name || "Error";
+	else if (typeof err === "string") formatted = err;
+	else if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") formatted = String(err);
+	else try {
+		formatted = JSON.stringify(err);
+	} catch {
+		formatted = Object.prototype.toString.call(err);
+	}
+	return redactSensitiveText(formatted);
+}
+function formatUncaughtError(err) {
+	if (extractErrorCode(err) === "INVALID_CONFIG") return formatErrorMessage(err);
+	if (err instanceof Error) return redactSensitiveText(err.stack ?? err.message ?? err.name);
+	return formatErrorMessage(err);
+}
+
+//#endregion
+export { isErrno as a, formatUncaughtError as i, extractErrorCode as n, readErrorName as o, formatErrorMessage as r, collectErrorGraphCandidates as t };