@vibe-lark/larkpal 0.1.86 → 0.1.87

package/dist/transcript-E_-ISOkD-DWCfZP2p.mjs

@@ -1,2019 +0,0 @@
-import { c as normalizeOptionalString, o as normalizeLowercaseStringOrEmpty, s as normalizeOptionalLowercaseString, u as normalizeStringifiedOptionalString } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
-import { t as resolveBundledPluginsDir } from "./bundled-dir-U738ay4K-DXK0q_TV.mjs";
-import { O as parseDurationMs, a as parseByteSize, n as loadConfig } from "./io-CH2g3vsv-BOGlLlB8.mjs";
-import { Mt as formatErrorMessage, St as createSubsystemLogger, zt as normalizeChannelId } from "./bundled-compat-BpaDaAAu-D7oazKjD.mjs";
-import "./message-channel-Bk_YHfQg-AeNrPPpp.mjs";
-import { r as resolveLoaderPackageRoot, t as getCachedPluginJitiLoader } from "./jiti-loader-cache-Bat69wam-D6hCxboy.mjs";
-import { C as normalizeChannelId$1, t as getRuntimeConfigSnapshot, x as getLoadedChannelPlugin } from "./runtime-snapshot-C54O1-gI-40cbyi7P.mjs";
-import { n as getActivePluginChannelRegistryVersion } from "./runtime-Cym-fqI8-DaSDMH-a.mjs";
-import { c as parseThreadSessionSuffix } from "./session-key-Cn2QoOyX-CuHbJMgR.mjs";
-import "./config-Bim2pi8a-BQUdfiEi.mjs";
-import { c as isSessionArchiveArtifactName, n as resolveSessionFilePath, s as isPrimarySessionTranscriptFileName, t as resolveDefaultSessionStorePath } from "./paths-D6msg0S1-C2lYuisN.mjs";
-import { n as getProcessStartTime, r as isPidAlive, t as resolveProcessScopedMap } from "./process-scoped-map-B2cWkYET-CXwUZ8CZ.mjs";
-import { i as normalizeSessionDeliveryFields } from "./delivery-context.shared-j5hC5qb1-CI83RXXZ.mjs";
-import { a as resolveBundledFacadeModuleLocation, i as createFacadeResolutionKey$1, n as loadBundledPluginPublicSurfaceModuleSync$1, o as resolveCachedFacadeModuleLocation, r as loadFacadeModuleAtLocationSync$1 } from "./facade-loader-DFzIYYt_-CIr4HKtE.mjs";
-import { i as SessionManager } from "./dist-DD2aJ2UL.mjs";
-import { createRequire } from "node:module";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import fs$1 from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/types-ASqeFakT.js
-function normalizeSessionRuntimeModelFields(entry) {
-	const normalizedModel = normalizeOptionalString(entry.model);
-	const normalizedProvider = normalizeOptionalString(entry.modelProvider);
-	let next = entry;
-	if (!normalizedModel) {
-		if (entry.model !== void 0 || entry.modelProvider !== void 0) {
-			next = { ...next };
-			delete next.model;
-			delete next.modelProvider;
-		}
-		return next;
-	}
-	if (entry.model !== normalizedModel) {
-		if (next === entry) next = { ...next };
-		next.model = normalizedModel;
-	}
-	if (!normalizedProvider) {
-		if (entry.modelProvider !== void 0) {
-			if (next === entry) next = { ...next };
-			delete next.modelProvider;
-		}
-		return next;
-	}
-	if (entry.modelProvider !== normalizedProvider) {
-		if (next === entry) next = { ...next };
-		next.modelProvider = normalizedProvider;
-	}
-	return next;
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/session-write-lock-3uPK7XQA.js
-function isValidLockNumber(value) {
-	return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-const CLEANUP_SIGNALS = [
-	"SIGINT",
-	"SIGTERM",
-	"SIGQUIT",
-	"SIGABRT"
-];
-const CLEANUP_STATE_KEY = Symbol.for("openclaw.sessionWriteLockCleanupState");
-const HELD_LOCKS_KEY = Symbol.for("openclaw.sessionWriteLockHeldLocks");
-const WATCHDOG_STATE_KEY = Symbol.for("openclaw.sessionWriteLockWatchdogState");
-const DEFAULT_STALE_MS = 1800 * 1e3;
-const DEFAULT_MAX_HOLD_MS = 300 * 1e3;
-const DEFAULT_WATCHDOG_INTERVAL_MS = 6e4;
-const DEFAULT_TIMEOUT_GRACE_MS = 120 * 1e3;
-const MAX_LOCK_HOLD_MS = 2147e6;
-const HELD_LOCKS = resolveProcessScopedMap(HELD_LOCKS_KEY);
-function resolveCleanupState() {
-	const proc = process;
-	if (!proc[CLEANUP_STATE_KEY]) proc[CLEANUP_STATE_KEY] = {
-		registered: false,
-		exitHandler: void 0,
-		cleanupHandlers: /* @__PURE__ */ new Map()
-	};
-	return proc[CLEANUP_STATE_KEY];
-}
-function resolveWatchdogState() {
-	const proc = process;
-	if (!proc[WATCHDOG_STATE_KEY]) proc[WATCHDOG_STATE_KEY] = {
-		started: false,
-		intervalMs: DEFAULT_WATCHDOG_INTERVAL_MS
-	};
-	return proc[WATCHDOG_STATE_KEY];
-}
-function resolvePositiveMs(value, fallback, opts = {}) {
-	if (typeof value !== "number" || Number.isNaN(value) || value <= 0) return fallback;
-	if (value === Number.POSITIVE_INFINITY) return opts.allowInfinity ? value : fallback;
-	if (!Number.isFinite(value)) return fallback;
-	return value;
-}
-function resolveSessionLockMaxHoldFromTimeout(params) {
-	const minMs = resolvePositiveMs(params.minMs, DEFAULT_MAX_HOLD_MS);
-	const timeoutMs = resolvePositiveMs(params.timeoutMs, minMs, { allowInfinity: true });
-	if (timeoutMs === Number.POSITIVE_INFINITY) return MAX_LOCK_HOLD_MS;
-	const graceMs = resolvePositiveMs(params.graceMs, DEFAULT_TIMEOUT_GRACE_MS);
-	return Math.min(MAX_LOCK_HOLD_MS, Math.max(minMs, timeoutMs + graceMs));
-}
-async function releaseHeldLock(normalizedSessionFile, held, opts = {}) {
-	if (HELD_LOCKS.get(normalizedSessionFile) !== held) return false;
-	if (opts.force) held.count = 0;
-	else {
-		held.count -= 1;
-		if (held.count > 0) return false;
-	}
-	if (held.releasePromise) {
-		await held.releasePromise.catch(() => void 0);
-		return true;
-	}
-	HELD_LOCKS.delete(normalizedSessionFile);
-	held.releasePromise = (async () => {
-		try {
-			await held.handle.close();
-		} catch {}
-		try {
-			await fs$1.rm(held.lockPath, { force: true });
-		} catch {}
-	})();
-	try {
-		await held.releasePromise;
-		return true;
-	} finally {
-		held.releasePromise = void 0;
-		if (HELD_LOCKS.size === 0) stopWatchdogTimer();
-	}
-}
-/**
-* Synchronously release all held locks.
-* Used during process exit when async operations aren't reliable.
-*/
-function releaseAllLocksSync() {
-	for (const [sessionFile, held] of HELD_LOCKS) {
-		held.handle.close().catch(() => void 0);
-		try {
-			fs.rmSync(held.lockPath, { force: true });
-		} catch {}
-		HELD_LOCKS.delete(sessionFile);
-	}
-	if (HELD_LOCKS.size === 0) stopWatchdogTimer();
-}
-async function runLockWatchdogCheck(nowMs = Date.now()) {
-	let released = 0;
-	for (const [sessionFile, held] of HELD_LOCKS.entries()) {
-		const heldForMs = nowMs - held.acquiredAt;
-		if (heldForMs <= held.maxHoldMs) continue;
-		process.stderr.write(`[session-write-lock] releasing lock held for ${heldForMs}ms (max=${held.maxHoldMs}ms): ${held.lockPath}\n`);
-		if (await releaseHeldLock(sessionFile, held, { force: true })) released += 1;
-	}
-	return released;
-}
-function stopWatchdogTimer() {
-	const watchdogState = resolveWatchdogState();
-	if (watchdogState.timer) {
-		clearInterval(watchdogState.timer);
-		watchdogState.timer = void 0;
-	}
-	watchdogState.started = false;
-}
-function shouldStartBackgroundWatchdog() {
-	return process.env.VITEST !== "true" || process.env.OPENCLAW_TEST_SESSION_LOCK_WATCHDOG === "1";
-}
-function ensureWatchdogStarted(intervalMs) {
-	if (!shouldStartBackgroundWatchdog()) return;
-	const watchdogState = resolveWatchdogState();
-	if (watchdogState.started) return;
-	watchdogState.started = true;
-	watchdogState.intervalMs = intervalMs;
-	watchdogState.timer = setInterval(() => {
-		runLockWatchdogCheck().catch(() => {});
-	}, intervalMs);
-	watchdogState.timer.unref?.();
-}
-function handleTerminationSignal(signal) {
-	releaseAllLocksSync();
-	const cleanupState = resolveCleanupState();
-	if (process.listenerCount(signal) === 1) {
-		const handler = cleanupState.cleanupHandlers.get(signal);
-		if (handler) {
-			process.off(signal, handler);
-			cleanupState.cleanupHandlers.delete(signal);
-		}
-		try {
-			process.kill(process.pid, signal);
-		} catch {}
-	}
-}
-function registerCleanupHandlers() {
-	const cleanupState = resolveCleanupState();
-	cleanupState.registered = true;
-	if (!cleanupState.exitHandler) {
-		cleanupState.exitHandler = () => {
-			releaseAllLocksSync();
-		};
-		process.on("exit", cleanupState.exitHandler);
-	}
-	ensureWatchdogStarted(DEFAULT_WATCHDOG_INTERVAL_MS);
-	for (const signal of CLEANUP_SIGNALS) {
-		if (cleanupState.cleanupHandlers.has(signal)) continue;
-		try {
-			const handler = () => handleTerminationSignal(signal);
-			cleanupState.cleanupHandlers.set(signal, handler);
-			process.on(signal, handler);
-		} catch {}
-	}
-}
-async function readLockPayload(lockPath) {
-	try {
-		const raw = await fs$1.readFile(lockPath, "utf8");
-		const parsed = JSON.parse(raw);
-		const payload = {};
-		if (isValidLockNumber(parsed.pid) && parsed.pid > 0) payload.pid = parsed.pid;
-		if (typeof parsed.createdAt === "string") payload.createdAt = parsed.createdAt;
-		if (isValidLockNumber(parsed.starttime)) payload.starttime = parsed.starttime;
-		return payload;
-	} catch {
-		return null;
-	}
-}
-function inspectLockPayload(payload, staleMs, nowMs) {
-	const pid = isValidLockNumber(payload?.pid) && payload.pid > 0 ? payload.pid : null;
-	const pidAlive = pid !== null ? isPidAlive(pid) : false;
-	const createdAt = typeof payload?.createdAt === "string" ? payload.createdAt : null;
-	const createdAtMs = createdAt ? Date.parse(createdAt) : NaN;
-	const ageMs = Number.isFinite(createdAtMs) ? Math.max(0, nowMs - createdAtMs) : null;
-	const storedStarttime = isValidLockNumber(payload?.starttime) ? payload.starttime : null;
-	const pidRecycled = pidAlive && pid !== null && storedStarttime !== null ? (() => {
-		const currentStarttime = getProcessStartTime(pid);
-		return currentStarttime !== null && currentStarttime !== storedStarttime;
-	})() : false;
-	const staleReasons = [];
-	if (pid === null) staleReasons.push("missing-pid");
-	else if (!pidAlive) staleReasons.push("dead-pid");
-	else if (pidRecycled) staleReasons.push("recycled-pid");
-	if (ageMs === null) staleReasons.push("invalid-createdAt");
-	else if (ageMs > staleMs) staleReasons.push("too-old");
-	return {
-		pid,
-		pidAlive,
-		createdAt,
-		ageMs,
-		stale: staleReasons.length > 0,
-		staleReasons
-	};
-}
-function lockInspectionNeedsMtimeStaleFallback(details) {
-	return details.stale && details.staleReasons.every((reason) => reason === "missing-pid" || reason === "invalid-createdAt");
-}
-async function shouldReclaimContendedLockFile(lockPath, details, staleMs, nowMs) {
-	if (!details.stale) return false;
-	if (!lockInspectionNeedsMtimeStaleFallback(details)) return true;
-	try {
-		const stat = await fs$1.stat(lockPath);
-		return Math.max(0, nowMs - stat.mtimeMs) > staleMs;
-	} catch (error) {
-		return error?.code !== "ENOENT";
-	}
-}
-function shouldTreatAsOrphanSelfLock(params) {
-	if ((isValidLockNumber(params.payload?.pid) ? params.payload.pid : null) !== process.pid) return false;
-	if (isValidLockNumber(params.payload?.starttime)) return false;
-	return !HELD_LOCKS.has(params.normalizedSessionFile);
-}
-async function acquireSessionWriteLock(params) {
-	registerCleanupHandlers();
-	const allowReentrant = params.allowReentrant ?? false;
-	const timeoutMs = resolvePositiveMs(params.timeoutMs, 1e4, { allowInfinity: true });
-	const staleMs = resolvePositiveMs(params.staleMs, DEFAULT_STALE_MS);
-	const maxHoldMs = resolvePositiveMs(params.maxHoldMs, DEFAULT_MAX_HOLD_MS);
-	const sessionFile = path.resolve(params.sessionFile);
-	const sessionDir = path.dirname(sessionFile);
-	await fs$1.mkdir(sessionDir, { recursive: true });
-	let normalizedDir = sessionDir;
-	try {
-		normalizedDir = await fs$1.realpath(sessionDir);
-	} catch {}
-	const normalizedSessionFile = path.join(normalizedDir, path.basename(sessionFile));
-	const lockPath = `${normalizedSessionFile}.lock`;
-	const held = HELD_LOCKS.get(normalizedSessionFile);
-	if (allowReentrant && held) {
-		held.count += 1;
-		return { release: async () => {
-			await releaseHeldLock(normalizedSessionFile, held);
-		} };
-	}
-	const startedAt = Date.now();
-	let attempt = 0;
-	while (Date.now() - startedAt < timeoutMs) {
-		attempt += 1;
-		let handle = null;
-		try {
-			handle = await fs$1.open(lockPath, "wx");
-			const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-			const starttime = getProcessStartTime(process.pid);
-			const lockPayload = {
-				pid: process.pid,
-				createdAt
-			};
-			if (starttime !== null) lockPayload.starttime = starttime;
-			await handle.writeFile(JSON.stringify(lockPayload, null, 2), "utf8");
-			const createdHeld = {
-				count: 1,
-				handle,
-				lockPath,
-				acquiredAt: Date.now(),
-				maxHoldMs
-			};
-			HELD_LOCKS.set(normalizedSessionFile, createdHeld);
-			return { release: async () => {
-				await releaseHeldLock(normalizedSessionFile, createdHeld);
-			} };
-		} catch (err) {
-			if (handle) {
-				try {
-					await handle.close();
-				} catch {}
-				try {
-					await fs$1.rm(lockPath, { force: true });
-				} catch {}
-			}
-			if (err.code !== "EEXIST") throw err;
-			const payload = await readLockPayload(lockPath);
-			const nowMs = Date.now();
-			const inspected = inspectLockPayload(payload, staleMs, nowMs);
-			if (await shouldReclaimContendedLockFile(lockPath, shouldTreatAsOrphanSelfLock({
-				payload,
-				normalizedSessionFile
-			}) ? {
-				...inspected,
-				stale: true,
-				staleReasons: inspected.staleReasons.includes("orphan-self-pid") ? inspected.staleReasons : [...inspected.staleReasons, "orphan-self-pid"]
-			} : inspected, staleMs, nowMs)) {
-				await fs$1.rm(lockPath, { force: true });
-				continue;
-			}
-			const remainingMs = timeoutMs - (Date.now() - startedAt);
-			if (remainingMs <= 0) break;
-			const delay = Math.min(1e3, 50 * attempt, remainingMs);
-			await new Promise((r) => setTimeout(r, delay));
-		}
-	}
-	const payload = await readLockPayload(lockPath);
-	const owner = typeof payload?.pid === "number" ? `pid=${payload.pid}` : "unknown";
-	throw new Error(`session file locked (timeout ${timeoutMs}ms): ${owner} ${lockPath}`);
-}
-[...CLEANUP_SIGNALS];
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/json-files-DcOQMqKi.js
-function getErrorCode$1(err) {
-	return err instanceof Error ? err.code : void 0;
-}
-async function replaceFileWithWindowsFallback(tempPath, filePath, mode) {
-	try {
-		await fs$1.rename(tempPath, filePath);
-		return;
-	} catch (err) {
-		const code = getErrorCode$1(err);
-		if (process.platform !== "win32" || code !== "EPERM" && code !== "EEXIST") throw err;
-	}
-	await fs$1.copyFile(tempPath, filePath);
-	try {
-		await fs$1.chmod(filePath, mode);
-	} catch {}
-	await fs$1.rm(tempPath, { force: true }).catch(() => void 0);
-}
-async function writeTextAtomic(filePath, content, options) {
-	const mode = options?.mode ?? 384;
-	const payload = options?.appendTrailingNewline && !content.endsWith("\n") ? `${content}\n` : content;
-	const mkdirOptions = { recursive: true };
-	if (typeof options?.ensureDirMode === "number") mkdirOptions.mode = options.ensureDirMode;
-	await fs$1.mkdir(path.dirname(filePath), mkdirOptions);
-	const parentDir = path.dirname(filePath);
-	const tmp = `${filePath}.${randomUUID()}.tmp`;
-	try {
-		const tmpHandle = await fs$1.open(tmp, "w", mode);
-		try {
-			await tmpHandle.writeFile(payload, { encoding: "utf8" });
-			await tmpHandle.sync();
-		} finally {
-			await tmpHandle.close().catch(() => void 0);
-		}
-		try {
-			await fs$1.chmod(tmp, mode);
-		} catch {}
-		await replaceFileWithWindowsFallback(tmp, filePath, mode);
-		try {
-			const dirHandle = await fs$1.open(parentDir, "r");
-			try {
-				await dirHandle.sync();
-			} finally {
-				await dirHandle.close().catch(() => void 0);
-			}
-		} catch {}
-		try {
-			await fs$1.chmod(filePath, mode);
-		} catch {}
-	} finally {
-		await fs$1.rm(tmp, { force: true }).catch(() => void 0);
-	}
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/parse-finite-number-DdG2XOLD.js
-function normalizeNumericString(value) {
-	const trimmed = value.trim();
-	return trimmed ? trimmed : void 0;
-}
-function parseStrictInteger(value) {
-	if (typeof value === "number") return Number.isSafeInteger(value) ? value : void 0;
-	if (typeof value !== "string") return;
-	const normalized = normalizeNumericString(value);
-	if (!normalized || !/^[+-]?\d+$/.test(normalized)) return;
-	const parsed = Number(normalized);
-	return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-function parseStrictNonNegativeInteger(value) {
-	const parsed = parseStrictInteger(value);
-	return parsed !== void 0 && parsed >= 0 ? parsed : void 0;
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/store-cache-DufBlCJB.js
-function resolveCacheTtlMs(params) {
-	const { envValue, defaultTtlMs } = params;
-	if (envValue) {
-		const parsed = parseStrictNonNegativeInteger(envValue);
-		if (parsed !== void 0) return parsed;
-	}
-	return defaultTtlMs;
-}
-function isCacheEnabled(ttlMs) {
-	return ttlMs > 0;
-}
-function resolveCacheNumeric(value) {
-	return typeof value === "function" ? value() : value;
-}
-function resolvePruneIntervalMs(ttlMs, pruneIntervalMs) {
-	if (typeof pruneIntervalMs === "function") return Math.max(0, Math.floor(pruneIntervalMs(ttlMs)));
-	if (typeof pruneIntervalMs === "number") return Math.max(0, Math.floor(pruneIntervalMs));
-	return ttlMs;
-}
-function isCacheEntryExpired(storedAt, now, ttlMs) {
-	return now - storedAt > ttlMs;
-}
-function createExpiringMapCache(options) {
-	const cache = /* @__PURE__ */ new Map();
-	const now = options.clock ?? Date.now;
-	let lastPruneAt = 0;
-	function getTtlMs() {
-		return Math.max(0, Math.floor(resolveCacheNumeric(options.ttlMs)));
-	}
-	function maybePruneExpiredEntries(nowMs, ttlMs) {
-		if (!isCacheEnabled(ttlMs)) return;
-		if (nowMs - lastPruneAt < resolvePruneIntervalMs(ttlMs, options.pruneIntervalMs)) return;
-		for (const [key, entry] of cache.entries()) if (isCacheEntryExpired(entry.storedAt, nowMs, ttlMs)) cache.delete(key);
-		lastPruneAt = nowMs;
-	}
-	return {
-		get: (key) => {
-			const ttlMs = getTtlMs();
-			if (!isCacheEnabled(ttlMs)) return;
-			const nowMs = now();
-			maybePruneExpiredEntries(nowMs, ttlMs);
-			const entry = cache.get(key);
-			if (!entry) return;
-			if (isCacheEntryExpired(entry.storedAt, nowMs, ttlMs)) {
-				cache.delete(key);
-				return;
-			}
-			return entry.value;
-		},
-		set: (key, value) => {
-			const ttlMs = getTtlMs();
-			if (!isCacheEnabled(ttlMs)) return;
-			const nowMs = now();
-			maybePruneExpiredEntries(nowMs, ttlMs);
-			cache.set(key, {
-				storedAt: nowMs,
-				value
-			});
-		},
-		delete: (key) => {
-			cache.delete(key);
-		},
-		clear: () => {
-			cache.clear();
-			lastPruneAt = 0;
-		},
-		keys: () => [...cache.keys()],
-		size: () => cache.size,
-		pruneExpired: () => {
-			const ttlMs = getTtlMs();
-			if (!isCacheEnabled(ttlMs)) return;
-			const nowMs = now();
-			for (const [key, entry] of cache.entries()) if (isCacheEntryExpired(entry.storedAt, nowMs, ttlMs)) cache.delete(key);
-			lastPruneAt = nowMs;
-		}
-	};
-}
-function getFileStatSnapshot(filePath) {
-	try {
-		const stats = fs.statSync(filePath);
-		return {
-			mtimeMs: stats.mtimeMs,
-			sizeBytes: stats.size
-		};
-	} catch {
-		return;
-	}
-}
-const DEFAULT_SESSION_STORE_TTL_MS = 45e3;
-const SESSION_STORE_CACHE = createExpiringMapCache({ ttlMs: getSessionStoreTtl });
-const SESSION_STORE_SERIALIZED_CACHE = /* @__PURE__ */ new Map();
-function getSessionStoreTtl() {
-	return resolveCacheTtlMs({
-		envValue: process.env.OPENCLAW_SESSION_CACHE_TTL_MS,
-		defaultTtlMs: DEFAULT_SESSION_STORE_TTL_MS
-	});
-}
-function isSessionStoreCacheEnabled() {
-	return isCacheEnabled(getSessionStoreTtl());
-}
-function invalidateSessionStoreCache(storePath) {
-	SESSION_STORE_CACHE.delete(storePath);
-	SESSION_STORE_SERIALIZED_CACHE.delete(storePath);
-}
-function getSerializedSessionStore(storePath) {
-	return SESSION_STORE_SERIALIZED_CACHE.get(storePath);
-}
-function setSerializedSessionStore(storePath, serialized) {
-	if (serialized === void 0) {
-		SESSION_STORE_SERIALIZED_CACHE.delete(storePath);
-		return;
-	}
-	SESSION_STORE_SERIALIZED_CACHE.set(storePath, serialized);
-}
-function dropSessionStoreObjectCache(storePath) {
-	SESSION_STORE_CACHE.delete(storePath);
-}
-function readSessionStoreCache(params) {
-	const cached = SESSION_STORE_CACHE.get(params.storePath);
-	if (!cached) return null;
-	if (params.mtimeMs !== cached.mtimeMs || params.sizeBytes !== cached.sizeBytes) {
-		invalidateSessionStoreCache(params.storePath);
-		return null;
-	}
-	return structuredClone(cached.store);
-}
-function writeSessionStoreCache(params) {
-	SESSION_STORE_CACHE.set(params.storePath, {
-		store: structuredClone(params.store),
-		mtimeMs: params.mtimeMs,
-		sizeBytes: params.sizeBytes,
-		serialized: params.serialized
-	});
-	if (params.serialized !== void 0) SESSION_STORE_SERIALIZED_CACHE.set(params.storePath, params.serialized);
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/store-load-HmCzUIz7.js
-const log$1 = createSubsystemLogger("sessions/store");
-const DEFAULT_SESSION_PRUNE_AFTER_MS = 720 * 60 * 60 * 1e3;
-const DEFAULT_SESSION_MAX_ENTRIES = 500;
-const DEFAULT_SESSION_ROTATE_BYTES = 10485760;
-const DEFAULT_SESSION_MAINTENANCE_MODE = "enforce";
-const DEFAULT_SESSION_DISK_BUDGET_HIGH_WATER_RATIO = .8;
-function resolvePruneAfterMs(maintenance) {
-	const normalized = normalizeStringifiedOptionalString(maintenance?.pruneAfter ?? maintenance?.pruneDays);
-	if (!normalized) return DEFAULT_SESSION_PRUNE_AFTER_MS;
-	try {
-		return parseDurationMs(normalized, { defaultUnit: "d" });
-	} catch {
-		return DEFAULT_SESSION_PRUNE_AFTER_MS;
-	}
-}
-function resolveRotateBytes(maintenance) {
-	const raw = maintenance?.rotateBytes;
-	const normalized = normalizeStringifiedOptionalString(raw);
-	if (!normalized) return DEFAULT_SESSION_ROTATE_BYTES;
-	try {
-		return parseByteSize(normalized, { defaultUnit: "b" });
-	} catch {
-		return DEFAULT_SESSION_ROTATE_BYTES;
-	}
-}
-function resolveResetArchiveRetentionMs(maintenance, pruneAfterMs) {
-	const raw = maintenance?.resetArchiveRetention;
-	if (raw === false) return null;
-	const normalized = normalizeStringifiedOptionalString(raw);
-	if (!normalized) return pruneAfterMs;
-	try {
-		return parseDurationMs(normalized, { defaultUnit: "d" });
-	} catch {
-		return pruneAfterMs;
-	}
-}
-function resolveMaxDiskBytes(maintenance) {
-	const raw = maintenance?.maxDiskBytes;
-	const normalized = normalizeStringifiedOptionalString(raw);
-	if (!normalized) return null;
-	try {
-		return parseByteSize(normalized, { defaultUnit: "b" });
-	} catch {
-		return null;
-	}
-}
-function resolveHighWaterBytes(maintenance, maxDiskBytes) {
-	const computeDefault = () => {
-		if (maxDiskBytes == null) return null;
-		if (maxDiskBytes <= 0) return 0;
-		return Math.max(1, Math.min(maxDiskBytes, Math.floor(maxDiskBytes * DEFAULT_SESSION_DISK_BUDGET_HIGH_WATER_RATIO)));
-	};
-	if (maxDiskBytes == null) return null;
-	const raw = maintenance?.highWaterBytes;
-	const normalized = normalizeStringifiedOptionalString(raw);
-	if (!normalized) return computeDefault();
-	try {
-		const parsed = parseByteSize(normalized, { defaultUnit: "b" });
-		return Math.min(parsed, maxDiskBytes);
-	} catch {
-		return computeDefault();
-	}
-}
-/**
-* Resolve maintenance settings from openclaw.json (`session.maintenance`).
-* Falls back to built-in defaults when config is missing or unset.
-*/
-function resolveMaintenanceConfigFromInput(maintenance) {
-	const pruneAfterMs = resolvePruneAfterMs(maintenance);
-	const maxDiskBytes = resolveMaxDiskBytes(maintenance);
-	return {
-		mode: maintenance?.mode ?? DEFAULT_SESSION_MAINTENANCE_MODE,
-		pruneAfterMs,
-		maxEntries: maintenance?.maxEntries ?? DEFAULT_SESSION_MAX_ENTRIES,
-		rotateBytes: resolveRotateBytes(maintenance),
-		resetArchiveRetentionMs: resolveResetArchiveRetentionMs(maintenance, pruneAfterMs),
-		maxDiskBytes,
-		highWaterBytes: resolveHighWaterBytes(maintenance, maxDiskBytes)
-	};
-}
-/**
-* Remove entries whose `updatedAt` is older than the configured threshold.
-* Entries without `updatedAt` are kept (cannot determine staleness).
-* Mutates `store` in-place.
-*/
-function pruneStaleEntries(store, overrideMaxAgeMs, opts = {}) {
-	const maxAgeMs = overrideMaxAgeMs ?? resolveMaintenanceConfigFromInput().pruneAfterMs;
-	const cutoffMs = Date.now() - maxAgeMs;
-	let pruned = 0;
-	for (const [key, entry] of Object.entries(store)) {
-		if (opts.preserveKeys?.has(key)) continue;
-		if (entry?.updatedAt != null && entry.updatedAt < cutoffMs) {
-			opts.onPruned?.({
-				key,
-				entry
-			});
-			delete store[key];
-			pruned++;
-		}
-	}
-	if (pruned > 0 && opts.log !== false) log$1.info("pruned stale session entries", {
-		pruned,
-		maxAgeMs
-	});
-	return pruned;
-}
-function getEntryUpdatedAt$1(entry) {
-	return entry?.updatedAt ?? Number.NEGATIVE_INFINITY;
-}
-function getActiveSessionMaintenanceWarning(params) {
-	const activeSessionKey = params.activeSessionKey.trim();
-	if (!activeSessionKey) return null;
-	const activeEntry = params.store[activeSessionKey];
-	if (!activeEntry) return null;
-	const cutoffMs = (params.nowMs ?? Date.now()) - params.pruneAfterMs;
-	const wouldPrune = activeEntry.updatedAt != null ? activeEntry.updatedAt < cutoffMs : false;
-	const keys = Object.keys(params.store);
-	const wouldCap = wouldCapActiveSession({
-		store: params.store,
-		keys,
-		activeEntry,
-		activeSessionKey,
-		maxEntries: params.maxEntries
-	});
-	if (!wouldPrune && !wouldCap) return null;
-	return {
-		activeSessionKey,
-		activeUpdatedAt: activeEntry.updatedAt,
-		totalEntries: keys.length,
-		pruneAfterMs: params.pruneAfterMs,
-		maxEntries: params.maxEntries,
-		wouldPrune,
-		wouldCap
-	};
-}
-function wouldCapActiveSession(params) {
-	if (params.keys.length <= params.maxEntries) return false;
-	if (params.maxEntries <= 0) return true;
-	const activeUpdatedAt = getEntryUpdatedAt$1(params.activeEntry);
-	let newerOrTieBeforeActive = 0;
-	let seenActive = false;
-	for (const key of params.keys) {
-		if (key === params.activeSessionKey) {
-			seenActive = true;
-			continue;
-		}
-		const entryUpdatedAt = getEntryUpdatedAt$1(params.store[key]);
-		if (entryUpdatedAt > activeUpdatedAt || !seenActive && entryUpdatedAt === activeUpdatedAt) {
-			newerOrTieBeforeActive++;
-			if (newerOrTieBeforeActive >= params.maxEntries) return true;
-		}
-	}
-	return false;
-}
-/**
-* Cap the store to the N most recently updated entries.
-* Entries without `updatedAt` are sorted last (removed first when over limit).
-* Mutates `store` in-place.
-*/
-function capEntryCount(store, overrideMax, opts = {}) {
-	const maxEntries = overrideMax ?? resolveMaintenanceConfigFromInput().maxEntries;
-	const preservedCount = opts.preserveKeys ? Object.keys(store).filter((key) => opts.preserveKeys?.has(key)).length : 0;
-	const maxRemovableEntries = Math.max(0, maxEntries - preservedCount);
-	const keys = Object.keys(store).filter((key) => !opts.preserveKeys?.has(key));
-	if (keys.length <= maxRemovableEntries) return 0;
-	const toRemove = keys.toSorted((a, b) => {
-		const aTime = getEntryUpdatedAt$1(store[a]);
-		return getEntryUpdatedAt$1(store[b]) - aTime;
-	}).slice(maxRemovableEntries);
-	for (const key of toRemove) {
-		const entry = store[key];
-		if (entry) opts.onCapped?.({
-			key,
-			entry
-		});
-		delete store[key];
-	}
-	if (opts.log !== false) log$1.info("capped session entry count", {
-		removed: toRemove.length,
-		maxEntries
-	});
-	return toRemove.length;
-}
-async function getSessionFileSize(storePath) {
-	try {
-		return (await fs.promises.stat(storePath)).size;
-	} catch {
-		return null;
-	}
-}
-/**
-* Rotate the sessions file if it exceeds the configured size threshold.
-* Renames the current file to `sessions.json.bak.{timestamp}` and cleans up
-* old rotation backups, keeping only the 3 most recent `.bak.*` files.
-*/
-async function rotateSessionFile(storePath, overrideBytes) {
-	const maxBytes = overrideBytes ?? resolveMaintenanceConfigFromInput().rotateBytes;
-	const fileSize = await getSessionFileSize(storePath);
-	if (fileSize == null) return false;
-	if (fileSize <= maxBytes) return false;
-	const backupPath = `${storePath}.bak.${Date.now()}`;
-	try {
-		await fs.promises.rename(storePath, backupPath);
-		log$1.info("rotated session store file", {
-			backupPath: path.basename(backupPath),
-			sizeBytes: fileSize
-		});
-	} catch {
-		return false;
-	}
-	try {
-		const dir = path.dirname(storePath);
-		const baseName = path.basename(storePath);
-		const backups = (await fs.promises.readdir(dir)).filter((f) => f.startsWith(`${baseName}.bak.`)).toSorted().toReversed();
-		const maxBackups = 3;
-		if (backups.length > maxBackups) {
-			const toDelete = backups.slice(maxBackups);
-			for (const old of toDelete) await fs.promises.unlink(path.join(dir, old)).catch(() => void 0);
-			log$1.info("cleaned up old session store backups", { deleted: toDelete.length });
-		}
-	} catch {}
-	return true;
-}
-function applySessionStoreMigrations(store) {
-	for (const entry of Object.values(store)) {
-		if (!entry || typeof entry !== "object") continue;
-		const rec = entry;
-		if (typeof rec.channel !== "string" && typeof rec.provider === "string") {
-			rec.channel = rec.provider;
-			delete rec.provider;
-		}
-		if (typeof rec.lastChannel !== "string" && typeof rec.lastProvider === "string") {
-			rec.lastChannel = rec.lastProvider;
-			delete rec.lastProvider;
-		}
-		if (typeof rec.groupChannel !== "string" && typeof rec.room === "string") {
-			rec.groupChannel = rec.room;
-			delete rec.room;
-		} else if ("room" in rec) delete rec.room;
-	}
-}
-const log$2 = createSubsystemLogger("sessions/store");
-function isSessionStoreRecord(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeSessionEntryDelivery(entry) {
-	const normalized = normalizeSessionDeliveryFields({
-		channel: entry.channel,
-		lastChannel: entry.lastChannel,
-		lastTo: entry.lastTo,
-		lastAccountId: entry.lastAccountId,
-		lastThreadId: entry.lastThreadId ?? entry.deliveryContext?.threadId ?? entry.origin?.threadId,
-		deliveryContext: entry.deliveryContext
-	});
-	const nextDelivery = normalized.deliveryContext;
-	const sameDelivery = (entry.deliveryContext?.channel ?? void 0) === nextDelivery?.channel && (entry.deliveryContext?.to ?? void 0) === nextDelivery?.to && (entry.deliveryContext?.accountId ?? void 0) === nextDelivery?.accountId && (entry.deliveryContext?.threadId ?? void 0) === nextDelivery?.threadId;
-	const sameLast = entry.lastChannel === normalized.lastChannel && entry.lastTo === normalized.lastTo && entry.lastAccountId === normalized.lastAccountId && entry.lastThreadId === normalized.lastThreadId;
-	if (sameDelivery && sameLast) return entry;
-	return {
-		...entry,
-		deliveryContext: nextDelivery,
-		lastChannel: normalized.lastChannel,
-		lastTo: normalized.lastTo,
-		lastAccountId: normalized.lastAccountId,
-		lastThreadId: normalized.lastThreadId
-	};
-}
-function normalizeSessionStore(store) {
-	for (const [key, entry] of Object.entries(store)) {
-		if (!entry) continue;
-		const normalized = normalizeSessionEntryDelivery(normalizeSessionRuntimeModelFields(entry));
-		if (normalized !== entry) store[key] = normalized;
-	}
-}
-function loadSessionStore(storePath, opts = {}) {
-	if (!opts.skipCache && isSessionStoreCacheEnabled()) {
-		const currentFileStat = getFileStatSnapshot(storePath);
-		const cached = readSessionStoreCache({
-			storePath,
-			mtimeMs: currentFileStat?.mtimeMs,
-			sizeBytes: currentFileStat?.sizeBytes
-		});
-		if (cached) return cached;
-	}
-	let store = {};
-	let fileStat = getFileStatSnapshot(storePath);
-	let mtimeMs = fileStat?.mtimeMs;
-	let serializedFromDisk;
-	const maxReadAttempts = process.platform === "win32" ? 3 : 1;
-	const retryBuf = maxReadAttempts > 1 ? new Int32Array(new SharedArrayBuffer(4)) : void 0;
-	for (let attempt = 0; attempt < maxReadAttempts; attempt += 1) try {
-		const raw = fs.readFileSync(storePath, "utf-8");
-		if (raw.length === 0 && attempt < maxReadAttempts - 1) {
-			Atomics.wait(retryBuf, 0, 0, 50);
-			continue;
-		}
-		const parsed = JSON.parse(raw);
-		if (isSessionStoreRecord(parsed)) {
-			store = parsed;
-			serializedFromDisk = raw;
-		}
-		fileStat = getFileStatSnapshot(storePath) ?? fileStat;
-		mtimeMs = fileStat?.mtimeMs;
-		break;
-	} catch {
-		if (attempt < maxReadAttempts - 1) {
-			Atomics.wait(retryBuf, 0, 0, 50);
-			continue;
-		}
-	}
-	if (serializedFromDisk !== void 0) setSerializedSessionStore(storePath, serializedFromDisk);
-	else setSerializedSessionStore(storePath, void 0);
-	applySessionStoreMigrations(store);
-	normalizeSessionStore(store);
-	const maintenance = opts.maintenanceConfig ?? resolveMaintenanceConfigFromInput();
-	if (maintenance.mode === "enforce" && Object.keys(store).length > maintenance.maxEntries) {
-		const beforeCount = Object.keys(store).length;
-		const pruned = pruneStaleEntries(store, maintenance.pruneAfterMs, { log: false });
-		const capped = capEntryCount(store, maintenance.maxEntries, { log: false });
-		const afterCount = Object.keys(store).length;
-		if (pruned > 0 || capped > 0) {
-			serializedFromDisk = void 0;
-			setSerializedSessionStore(storePath, void 0);
-			log$2.info("applied load-time maintenance to oversized session store", {
-				storePath,
-				before: beforeCount,
-				after: afterCount,
-				pruned,
-				capped,
-				maxEntries: maintenance.maxEntries
-			});
-		}
-	}
-	if (!opts.skipCache && isSessionStoreCacheEnabled()) writeSessionStoreCache({
-		storePath,
-		store,
-		mtimeMs,
-		sizeBytes: fileStat?.sizeBytes,
-		serialized: serializedFromDisk
-	});
-	return structuredClone(store);
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/store-lock-state-DxRntb08.js
-const LOCK_QUEUES = /* @__PURE__ */ new Map();
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/store-D_G4w--8.js
-const NOOP_LOGGER = {
-	warn: () => {},
-	info: () => {}
-};
-function canonicalizePathForComparison(filePath) {
-	const resolved = path.resolve(filePath);
-	try {
-		return fs.realpathSync(resolved);
-	} catch {
-		return resolved;
-	}
-}
-function measureStoreBytes(store) {
-	return Buffer.byteLength(JSON.stringify(store, null, 2), "utf-8");
-}
-function measureStoreEntryChunkBytes(key, entry) {
-	const singleEntryStore = JSON.stringify({ [key]: entry }, null, 2);
-	if (!singleEntryStore.startsWith("{\n") || !singleEntryStore.endsWith("\n}")) return measureStoreBytes({ [key]: entry }) - 4;
-	const chunk = singleEntryStore.slice(2, -2);
-	return Buffer.byteLength(chunk, "utf-8");
-}
-function buildStoreEntryChunkSizeMap(store) {
-	const out = /* @__PURE__ */ new Map();
-	for (const [key, entry] of Object.entries(store)) out.set(key, measureStoreEntryChunkBytes(key, entry));
-	return out;
-}
-function getEntryUpdatedAt(entry) {
-	if (!entry) return 0;
-	const updatedAt = entry.updatedAt;
-	return Number.isFinite(updatedAt) ? updatedAt : 0;
-}
-function buildSessionIdRefCounts(store) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const entry of Object.values(store)) {
-		const sessionId = entry?.sessionId;
-		if (!sessionId) continue;
-		counts.set(sessionId, (counts.get(sessionId) ?? 0) + 1);
-	}
-	return counts;
-}
-function resolveSessionTranscriptPathForEntry(params) {
-	if (!params.entry.sessionId) return null;
-	try {
-		const resolved = resolveSessionFilePath(params.entry.sessionId, params.entry, { sessionsDir: params.sessionsDir });
-		const resolvedSessionsDir = canonicalizePathForComparison(params.sessionsDir);
-		const resolvedPath = canonicalizePathForComparison(resolved);
-		const relative = path.relative(resolvedSessionsDir, resolvedPath);
-		if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return null;
-		return resolvedPath;
-	} catch {
-		return null;
-	}
-}
-function resolveReferencedSessionTranscriptPaths(params) {
-	const referenced = /* @__PURE__ */ new Set();
-	for (const entry of Object.values(params.store)) {
-		const resolved = resolveSessionTranscriptPathForEntry({
-			sessionsDir: params.sessionsDir,
-			entry
-		});
-		if (resolved) referenced.add(canonicalizePathForComparison(resolved));
-	}
-	return referenced;
-}
-async function readSessionsDirFiles(sessionsDir) {
-	const dirEntries = await fs.promises.readdir(sessionsDir, { withFileTypes: true }).catch(() => []);
-	const files = [];
-	for (const dirent of dirEntries) {
-		if (!dirent.isFile()) continue;
-		const filePath = path.join(sessionsDir, dirent.name);
-		const stat = await fs.promises.stat(filePath).catch(() => null);
-		if (!stat?.isFile()) continue;
-		files.push({
-			path: filePath,
-			canonicalPath: canonicalizePathForComparison(filePath),
-			name: dirent.name,
-			size: stat.size,
-			mtimeMs: stat.mtimeMs
-		});
-	}
-	return files;
-}
-async function removeFileIfExists(filePath) {
-	const stat = await fs.promises.stat(filePath).catch(() => null);
-	if (!stat?.isFile()) return 0;
-	await fs.promises.rm(filePath, { force: true }).catch(() => void 0);
-	return stat.size;
-}
-async function removeFileForBudget(params) {
-	const resolvedPath = path.resolve(params.filePath);
-	const canonicalPath = params.canonicalPath ?? canonicalizePathForComparison(resolvedPath);
-	if (params.dryRun) {
-		if (params.simulatedRemovedPaths.has(canonicalPath)) return 0;
-		const size = params.fileSizesByPath.get(canonicalPath) ?? 0;
-		if (size <= 0) return 0;
-		params.simulatedRemovedPaths.add(canonicalPath);
-		return size;
-	}
-	return removeFileIfExists(resolvedPath);
-}
-async function enforceSessionDiskBudget(params) {
-	const maxBytes = params.maintenance.maxDiskBytes;
-	const highWaterBytes = params.maintenance.highWaterBytes;
-	if (maxBytes == null || highWaterBytes == null) return null;
-	const log = params.log ?? NOOP_LOGGER;
-	const dryRun = params.dryRun === true;
-	const sessionsDir = path.dirname(params.storePath);
-	const files = await readSessionsDirFiles(sessionsDir);
-	const fileSizesByPath = new Map(files.map((file) => [file.canonicalPath, file.size]));
-	const simulatedRemovedPaths = /* @__PURE__ */ new Set();
-	const resolvedStorePath = canonicalizePathForComparison(params.storePath);
-	const storeFile = files.find((file) => file.canonicalPath === resolvedStorePath);
-	let projectedStoreBytes = measureStoreBytes(params.store);
-	let total = files.reduce((sum, file) => sum + file.size, 0) - (storeFile?.size ?? 0) + projectedStoreBytes;
-	const totalBefore = total;
-	if (total <= maxBytes) return {
-		totalBytesBefore: totalBefore,
-		totalBytesAfter: total,
-		removedFiles: 0,
-		removedEntries: 0,
-		freedBytes: 0,
-		maxBytes,
-		highWaterBytes,
-		overBudget: false
-	};
-	if (params.warnOnly) {
-		log.warn("session disk budget exceeded (warn-only mode)", {
-			sessionsDir,
-			totalBytes: total,
-			maxBytes,
-			highWaterBytes
-		});
-		return {
-			totalBytesBefore: totalBefore,
-			totalBytesAfter: total,
-			removedFiles: 0,
-			removedEntries: 0,
-			freedBytes: 0,
-			maxBytes,
-			highWaterBytes,
-			overBudget: true
-		};
-	}
-	let removedFiles = 0;
-	let removedEntries = 0;
-	let freedBytes = 0;
-	const referencedPaths = resolveReferencedSessionTranscriptPaths({
-		sessionsDir,
-		store: params.store
-	});
-	const removableFileQueue = files.filter((file) => isSessionArchiveArtifactName(file.name) || isPrimarySessionTranscriptFileName(file.name) && !referencedPaths.has(file.canonicalPath)).toSorted((a, b) => a.mtimeMs - b.mtimeMs);
-	for (const file of removableFileQueue) {
-		if (total <= highWaterBytes) break;
-		const deletedBytes = await removeFileForBudget({
-			filePath: file.path,
-			canonicalPath: file.canonicalPath,
-			dryRun,
-			fileSizesByPath,
-			simulatedRemovedPaths
-		});
-		if (deletedBytes <= 0) continue;
-		total -= deletedBytes;
-		freedBytes += deletedBytes;
-		removedFiles += 1;
-	}
-	if (total > highWaterBytes) {
-		const activeSessionKey = normalizeOptionalLowercaseString(params.activeSessionKey);
-		const sessionIdRefCounts = buildSessionIdRefCounts(params.store);
-		const entryChunkBytesByKey = buildStoreEntryChunkSizeMap(params.store);
-		const keys = Object.keys(params.store).toSorted((a, b) => {
-			return getEntryUpdatedAt(params.store[a]) - getEntryUpdatedAt(params.store[b]);
-		});
-		for (const key of keys) {
-			if (total <= highWaterBytes) break;
-			if (activeSessionKey && normalizeLowercaseStringOrEmpty(key) === activeSessionKey) continue;
-			const entry = params.store[key];
-			if (!entry) continue;
-			const previousProjectedBytes = projectedStoreBytes;
-			delete params.store[key];
-			const chunkBytes = entryChunkBytesByKey.get(key);
-			entryChunkBytesByKey.delete(key);
-			if (typeof chunkBytes === "number" && Number.isFinite(chunkBytes) && chunkBytes >= 0) projectedStoreBytes = Math.max(2, projectedStoreBytes - (chunkBytes + 2));
-			else projectedStoreBytes = measureStoreBytes(params.store);
-			total += projectedStoreBytes - previousProjectedBytes;
-			removedEntries += 1;
-			const sessionId = entry.sessionId;
-			if (!sessionId) continue;
-			const nextRefCount = (sessionIdRefCounts.get(sessionId) ?? 1) - 1;
-			if (nextRefCount > 0) {
-				sessionIdRefCounts.set(sessionId, nextRefCount);
-				continue;
-			}
-			sessionIdRefCounts.delete(sessionId);
-			const transcriptPath = resolveSessionTranscriptPathForEntry({
-				sessionsDir,
-				entry
-			});
-			if (!transcriptPath) continue;
-			const deletedBytes = await removeFileForBudget({
-				filePath: transcriptPath,
-				dryRun,
-				fileSizesByPath,
-				simulatedRemovedPaths
-			});
-			if (deletedBytes <= 0) continue;
-			total -= deletedBytes;
-			freedBytes += deletedBytes;
-			removedFiles += 1;
-		}
-	}
-	if (!dryRun) {
-		if (total > highWaterBytes) log.warn("session disk budget still above high-water target after cleanup", {
-			sessionsDir,
-			totalBytes: total,
-			maxBytes,
-			highWaterBytes,
-			removedFiles,
-			removedEntries
-		});
-		else if (removedFiles > 0 || removedEntries > 0) log.info("applied session disk budget cleanup", {
-			sessionsDir,
-			totalBytesBefore: totalBefore,
-			totalBytesAfter: total,
-			maxBytes,
-			highWaterBytes,
-			removedFiles,
-			removedEntries
-		});
-	}
-	return {
-		totalBytesBefore: totalBefore,
-		totalBytesAfter: total,
-		removedFiles,
-		removedEntries,
-		freedBytes,
-		maxBytes,
-		highWaterBytes,
-		overBudget: true
-	};
-}
-function normalizeStoreSessionKey(sessionKey) {
-	return normalizeLowercaseStringOrEmpty(sessionKey);
-}
-function resolveMaintenanceConfig() {
-	let maintenance;
-	try {
-		maintenance = loadConfig().session?.maintenance;
-	} catch {}
-	return resolveMaintenanceConfigFromInput(maintenance);
-}
-const log = createSubsystemLogger("sessions/store");
-let sessionArchiveRuntimePromise = null;
-let sessionWriteLockAcquirerForTests = null;
-function loadSessionArchiveRuntime() {
-	sessionArchiveRuntimePromise ??= import("./session-archive.runtime-B52_5vs4-BG-_IwNJ.mjs");
-	return sessionArchiveRuntimePromise;
-}
-function updateSessionStoreWriteCaches(params) {
-	const fileStat = getFileStatSnapshot(params.storePath);
-	setSerializedSessionStore(params.storePath, params.serialized);
-	if (!isSessionStoreCacheEnabled()) {
-		dropSessionStoreObjectCache(params.storePath);
-		return;
-	}
-	writeSessionStoreCache({
-		storePath: params.storePath,
-		store: params.store,
-		mtimeMs: fileStat?.mtimeMs,
-		sizeBytes: fileStat?.sizeBytes,
-		serialized: params.serialized
-	});
-}
-function resolveMutableSessionStoreKey(store, sessionKey) {
-	const trimmed = sessionKey.trim();
-	if (!trimmed) return;
-	if (Object.prototype.hasOwnProperty.call(store, trimmed)) return trimmed;
-	const normalized = normalizeStoreSessionKey(trimmed);
-	if (Object.prototype.hasOwnProperty.call(store, normalized)) return normalized;
-	return Object.keys(store).find((key) => normalizeStoreSessionKey(key) === normalized);
-}
-function collectAcpMetadataSnapshot(store) {
-	const snapshot = /* @__PURE__ */ new Map();
-	for (const [sessionKey, entry] of Object.entries(store)) if (entry?.acp) snapshot.set(sessionKey, entry.acp);
-	return snapshot;
-}
-function preserveExistingAcpMetadata(params) {
-	const allowDrop = new Set((params.allowDropSessionKeys ?? []).map((key) => normalizeStoreSessionKey(key)));
-	for (const [previousKey, previousAcp] of params.previousAcpByKey.entries()) {
-		const normalizedKey = normalizeStoreSessionKey(previousKey);
-		if (allowDrop.has(normalizedKey)) continue;
-		const nextKey = resolveMutableSessionStoreKey(params.nextStore, previousKey);
-		if (!nextKey) continue;
-		const nextEntry = params.nextStore[nextKey];
-		if (!nextEntry || nextEntry.acp) continue;
-		params.nextStore[nextKey] = {
-			...nextEntry,
-			acp: previousAcp
-		};
-	}
-}
-async function saveSessionStoreUnlocked(storePath, store, opts) {
-	normalizeSessionStore(store);
-	if (!opts?.skipMaintenance) {
-		const maintenance = opts?.maintenanceConfig ? {
-			...opts.maintenanceConfig,
-			...opts?.maintenanceOverride
-		} : {
-			...resolveMaintenanceConfig(),
-			...opts?.maintenanceOverride
-		};
-		const shouldWarnOnly = maintenance.mode === "warn";
-		const beforeCount = Object.keys(store).length;
-		if (shouldWarnOnly) {
-			const activeSessionKey = opts?.activeSessionKey?.trim();
-			if (activeSessionKey) {
-				const warning = getActiveSessionMaintenanceWarning({
-					store,
-					activeSessionKey,
-					pruneAfterMs: maintenance.pruneAfterMs,
-					maxEntries: maintenance.maxEntries
-				});
-				if (warning) {
-					log.warn("session maintenance would evict active session; skipping enforcement", {
-						activeSessionKey: warning.activeSessionKey,
-						wouldPrune: warning.wouldPrune,
-						wouldCap: warning.wouldCap,
-						pruneAfterMs: warning.pruneAfterMs,
-						maxEntries: warning.maxEntries
-					});
-					await opts?.onWarn?.(warning);
-				}
-			}
-			const diskBudget = await enforceSessionDiskBudget({
-				store,
-				storePath,
-				activeSessionKey: opts?.activeSessionKey,
-				maintenance,
-				warnOnly: true,
-				log
-			});
-			await opts?.onMaintenanceApplied?.({
-				mode: maintenance.mode,
-				beforeCount,
-				afterCount: Object.keys(store).length,
-				pruned: 0,
-				capped: 0,
-				diskBudget
-			});
-		} else {
-			const preserveSessionKeys = opts?.activeSessionKey ? new Set([opts.activeSessionKey]) : void 0;
-			const removedSessionFiles = /* @__PURE__ */ new Map();
-			const pruned = pruneStaleEntries(store, maintenance.pruneAfterMs, {
-				onPruned: ({ entry }) => {
-					rememberRemovedSessionFile(removedSessionFiles, entry);
-				},
-				preserveKeys: preserveSessionKeys
-			});
-			const capped = capEntryCount(store, maintenance.maxEntries, {
-				onCapped: ({ entry }) => {
-					rememberRemovedSessionFile(removedSessionFiles, entry);
-				},
-				preserveKeys: preserveSessionKeys
-			});
-			const archivedDirs = /* @__PURE__ */ new Set();
-			const archivedForDeletedSessions = await archiveRemovedSessionTranscripts({
-				removedSessionFiles,
-				referencedSessionIds: new Set(Object.values(store).map((entry) => entry?.sessionId).filter((id) => Boolean(id))),
-				storePath,
-				reason: "deleted",
-				restrictToStoreDir: true
-			});
-			for (const archivedDir of archivedForDeletedSessions) archivedDirs.add(archivedDir);
-			if (archivedDirs.size > 0 || maintenance.resetArchiveRetentionMs != null) {
-				const { cleanupArchivedSessionTranscripts } = await loadSessionArchiveRuntime();
-				const targetDirs = archivedDirs.size > 0 ? [...archivedDirs] : [path.dirname(path.resolve(storePath))];
-				await cleanupArchivedSessionTranscripts({
-					directories: targetDirs,
-					olderThanMs: maintenance.pruneAfterMs,
-					reason: "deleted"
-				});
-				if (maintenance.resetArchiveRetentionMs != null) await cleanupArchivedSessionTranscripts({
-					directories: targetDirs,
-					olderThanMs: maintenance.resetArchiveRetentionMs,
-					reason: "reset"
-				});
-			}
-			await rotateSessionFile(storePath, maintenance.rotateBytes);
-			const diskBudget = await enforceSessionDiskBudget({
-				store,
-				storePath,
-				activeSessionKey: opts?.activeSessionKey,
-				maintenance,
-				warnOnly: false,
-				log
-			});
-			await opts?.onMaintenanceApplied?.({
-				mode: maintenance.mode,
-				beforeCount,
-				afterCount: Object.keys(store).length,
-				pruned,
-				capped,
-				diskBudget
-			});
-		}
-	}
-	await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
-	const json = JSON.stringify(store, null, 2);
-	if (getSerializedSessionStore(storePath) === json) {
-		updateSessionStoreWriteCaches({
-			storePath,
-			store,
-			serialized: json
-		});
-		return;
-	}
-	if (process.platform === "win32") {
-		for (let i = 0; i < 5; i++) try {
-			await writeSessionStoreAtomic({
-				storePath,
-				store,
-				serialized: json
-			});
-			return;
-		} catch (err) {
-			if (getErrorCode(err) === "ENOENT") return;
-			if (i < 4) {
-				await new Promise((r) => setTimeout(r, 50 * (i + 1)));
-				continue;
-			}
-			log.warn(`atomic write failed after 5 attempts: ${storePath}`);
-		}
-		return;
-	}
-	try {
-		await writeSessionStoreAtomic({
-			storePath,
-			store,
-			serialized: json
-		});
-	} catch (err) {
-		if (getErrorCode(err) === "ENOENT") {
-			try {
-				await writeSessionStoreAtomic({
-					storePath,
-					store,
-					serialized: json
-				});
-			} catch (err2) {
-				if (getErrorCode(err2) === "ENOENT") return;
-				throw err2;
-			}
-			return;
-		}
-		throw err;
-	}
-}
-async function updateSessionStore(storePath, mutator, opts) {
-	return await withSessionStoreLock(storePath, async () => {
-		const store = loadSessionStore(storePath, { skipCache: true });
-		const previousAcpByKey = collectAcpMetadataSnapshot(store);
-		const result = await mutator(store);
-		preserveExistingAcpMetadata({
-			previousAcpByKey,
-			nextStore: store,
-			allowDropSessionKeys: opts?.allowDropAcpMetaSessionKeys
-		});
-		await saveSessionStoreUnlocked(storePath, store, opts);
-		return result;
-	});
-}
-const SESSION_STORE_LOCK_MIN_HOLD_MS = 5e3;
-const SESSION_STORE_LOCK_TIMEOUT_GRACE_MS = 5e3;
-function getErrorCode(error) {
-	if (!error || typeof error !== "object" || !("code" in error)) return null;
-	return String(error.code);
-}
-function rememberRemovedSessionFile(removedSessionFiles, entry) {
-	if (!removedSessionFiles.has(entry.sessionId) || entry.sessionFile) removedSessionFiles.set(entry.sessionId, entry.sessionFile);
-}
-async function archiveRemovedSessionTranscripts(params) {
-	const { archiveSessionTranscripts } = await loadSessionArchiveRuntime();
-	const archivedDirs = /* @__PURE__ */ new Set();
-	for (const [sessionId, sessionFile] of params.removedSessionFiles) {
-		if (params.referencedSessionIds.has(sessionId)) continue;
-		const archived = archiveSessionTranscripts({
-			sessionId,
-			storePath: params.storePath,
-			sessionFile,
-			reason: params.reason,
-			restrictToStoreDir: params.restrictToStoreDir
-		});
-		for (const archivedPath of archived) archivedDirs.add(path.dirname(archivedPath));
-	}
-	return archivedDirs;
-}
-async function writeSessionStoreAtomic(params) {
-	await writeTextAtomic(params.storePath, params.serialized, { mode: 384 });
-	updateSessionStoreWriteCaches({
-		storePath: params.storePath,
-		store: params.store,
-		serialized: params.serialized
-	});
-}
-function lockTimeoutError(storePath) {
-	return /* @__PURE__ */ new Error(`timeout waiting for session store lock: ${storePath}`);
-}
-function resolveSessionStoreLockMaxHoldMs(timeoutMs) {
-	if (timeoutMs == null || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return;
-	return resolveSessionLockMaxHoldFromTimeout({
-		timeoutMs,
-		graceMs: SESSION_STORE_LOCK_TIMEOUT_GRACE_MS,
-		minMs: SESSION_STORE_LOCK_MIN_HOLD_MS
-	});
-}
-function getOrCreateLockQueue(storePath) {
-	const existing = LOCK_QUEUES.get(storePath);
-	if (existing) return existing;
-	const created = {
-		running: false,
-		pending: [],
-		drainPromise: null
-	};
-	LOCK_QUEUES.set(storePath, created);
-	return created;
-}
-async function drainSessionStoreLockQueue(storePath) {
-	const queue = LOCK_QUEUES.get(storePath);
-	if (!queue) return;
-	if (queue.drainPromise) {
-		await queue.drainPromise;
-		return;
-	}
-	queue.running = true;
-	queue.drainPromise = (async () => {
-		try {
-			while (queue.pending.length > 0) {
-				const task = queue.pending.shift();
-				if (!task) continue;
-				const remainingTimeoutMs = task.timeoutMs ?? Number.POSITIVE_INFINITY;
-				if (task.timeoutMs != null && remainingTimeoutMs <= 0) {
-					task.reject(lockTimeoutError(storePath));
-					continue;
-				}
-				let lock;
-				let result;
-				let failed;
-				let hasFailure = false;
-				try {
-					lock = await (sessionWriteLockAcquirerForTests ?? acquireSessionWriteLock)({
-						sessionFile: storePath,
-						timeoutMs: remainingTimeoutMs,
-						staleMs: task.staleMs,
-						maxHoldMs: resolveSessionStoreLockMaxHoldMs(task.timeoutMs)
-					});
-					result = await task.fn();
-				} catch (err) {
-					hasFailure = true;
-					failed = err;
-				} finally {
-					await lock?.release().catch(() => void 0);
-				}
-				if (hasFailure) {
-					task.reject(failed);
-					continue;
-				}
-				task.resolve(result);
-			}
-		} finally {
-			queue.running = false;
-			queue.drainPromise = null;
-			if (queue.pending.length === 0) LOCK_QUEUES.delete(storePath);
-			else queueMicrotask(() => {
-				drainSessionStoreLockQueue(storePath);
-			});
-		}
-	})();
-	await queue.drainPromise;
-}
-async function withSessionStoreLock(storePath, fn, opts = {}) {
-	if (!storePath || typeof storePath !== "string") throw new Error(`withSessionStoreLock: storePath must be a non-empty string, got ${JSON.stringify(storePath)}`);
-	const timeoutMs = opts.timeoutMs ?? 1e4;
-	const staleMs = opts.staleMs ?? 3e4;
-	opts.pollIntervalMs;
-	const hasTimeout = timeoutMs > 0 && Number.isFinite(timeoutMs);
-	const queue = getOrCreateLockQueue(storePath);
-	return await new Promise((resolve, reject) => {
-		const task = {
-			fn: async () => await fn(),
-			resolve: (value) => resolve(value),
-			reject,
-			timeoutMs: hasTimeout ? timeoutMs : void 0,
-			staleMs
-		};
-		queue.pending.push(task);
-		drainSessionStoreLockQueue(storePath);
-	});
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/facade-runtime-DJ_ZWLEP.js
-function createLazyFacadeValue(loadFacadeModule, key) {
-	return ((...args) => {
-		const value = loadFacadeModule()[key];
-		if (typeof value !== "function") return value;
-		return value(...args);
-	});
-}
-const OPENCLAW_PACKAGE_ROOT = resolveLoaderPackageRoot({
-	modulePath: fileURLToPath(import.meta.url),
-	moduleUrl: import.meta.url
-}) ?? fileURLToPath(new URL("../..", import.meta.url));
-const CURRENT_MODULE_PATH = fileURLToPath(import.meta.url);
-const OPENCLAW_SOURCE_EXTENSIONS_ROOT = path.resolve(OPENCLAW_PACKAGE_ROOT, "extensions");
-const cachedFacadeModuleLocationsByKey = /* @__PURE__ */ new Map();
-function createFacadeResolutionKey(params) {
-	const bundledPluginsDir = resolveBundledPluginsDir(params.env ?? process.env);
-	return createFacadeResolutionKey$1({
-		...params,
-		bundledPluginsDir
-	});
-}
-function resolveRegistryPluginModuleLocation(params) {
-	return loadFacadeActivationCheckRuntime().resolveRegistryPluginModuleLocation({
-		...params,
-		resolutionKey: createFacadeResolutionKey(params)
-	});
-}
-function resolveFacadeModuleLocationUncached(params) {
-	const bundledPluginsDir = resolveBundledPluginsDir(params.env ?? process.env);
-	const bundledLocation = resolveBundledFacadeModuleLocation({
-		...params,
-		currentModulePath: CURRENT_MODULE_PATH,
-		packageRoot: OPENCLAW_PACKAGE_ROOT,
-		bundledPluginsDir
-	});
-	if (bundledLocation) return bundledLocation;
-	return resolveRegistryPluginModuleLocation(params);
-}
-function resolveFacadeModuleLocation(params) {
-	return resolveCachedFacadeModuleLocation({
-		cache: cachedFacadeModuleLocationsByKey,
-		key: createFacadeResolutionKey(params),
-		resolve: () => resolveFacadeModuleLocationUncached(params)
-	});
-}
-const nodeRequire = createRequire(import.meta.url);
-const FACADE_ACTIVATION_CHECK_RUNTIME_CANDIDATES = ["./facade-activation-check.runtime.js", "./facade-activation-check.runtime.ts"];
-let facadeActivationCheckRuntimeModule;
-const facadeActivationCheckRuntimeJitiLoaders = /* @__PURE__ */ new Map();
-function getFacadeActivationCheckRuntimeJiti(modulePath) {
-	return getCachedPluginJitiLoader({
-		cache: facadeActivationCheckRuntimeJitiLoaders,
-		modulePath,
-		importerUrl: import.meta.url,
-		jitiFilename: import.meta.url,
-		aliasMap: {},
-		tryNative: false
-	});
-}
-function loadFacadeActivationCheckRuntimeFromCandidates(loadCandidate) {
-	for (const candidate of FACADE_ACTIVATION_CHECK_RUNTIME_CANDIDATES) try {
-		return loadCandidate(candidate);
-	} catch {}
-}
-function loadFacadeActivationCheckRuntime() {
-	if (facadeActivationCheckRuntimeModule) return facadeActivationCheckRuntimeModule;
-	facadeActivationCheckRuntimeModule = loadFacadeActivationCheckRuntimeFromCandidates((candidate) => nodeRequire(candidate));
-	if (facadeActivationCheckRuntimeModule) return facadeActivationCheckRuntimeModule;
-	facadeActivationCheckRuntimeModule = loadFacadeActivationCheckRuntimeFromCandidates((candidate) => getFacadeActivationCheckRuntimeJiti(candidate)(candidate));
-	if (facadeActivationCheckRuntimeModule) return facadeActivationCheckRuntimeModule;
-	throw new Error("Unable to load facade activation check runtime");
-}
-function loadFacadeModuleAtLocationSync(params) {
-	return loadFacadeModuleAtLocationSync$1(params);
-}
-function buildFacadeActivationCheckParams(params, location = resolveFacadeModuleLocation(params)) {
-	return {
-		...params,
-		location,
-		sourceExtensionsRoot: OPENCLAW_SOURCE_EXTENSIONS_ROOT,
-		resolutionKey: createFacadeResolutionKey(params)
-	};
-}
-function loadBundledPluginPublicSurfaceModuleSync(params) {
-	const location = resolveFacadeModuleLocation(params);
-	const trackedPluginId = () => loadFacadeActivationCheckRuntime().resolveTrackedFacadePluginId(buildFacadeActivationCheckParams(params, location));
-	if (!location) return loadBundledPluginPublicSurfaceModuleSync$1({
-		...params,
-		trackedPluginId
-	});
-	return loadFacadeModuleAtLocationSync({
-		location,
-		trackedPluginId
-	});
-}
-function loadActivatedBundledPluginPublicSurfaceModuleSync(params) {
-	loadFacadeActivationCheckRuntime().resolveActivatedBundledPluginPublicSurfaceAccessOrThrow(buildFacadeActivationCheckParams(params));
-	return loadBundledPluginPublicSurfaceModuleSync(params);
-}
-function tryLoadActivatedBundledPluginPublicSurfaceModuleSync(params) {
-	if (!loadFacadeActivationCheckRuntime().resolveBundledPluginPublicSurfaceAccess(buildFacadeActivationCheckParams(params)).allowed) return null;
-	return loadBundledPluginPublicSurfaceModuleSync(params);
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/session-conversation-DOWP59Dq.js
-const SESSION_KEY_API_ARTIFACT_BASENAME = "session-key-api.js";
-const bundledSessionConversationFallbackCache = /* @__PURE__ */ new Map();
-function normalizeResolvedChannel(channel) {
-	return normalizeChannelId$1(channel) ?? normalizeChannelId(channel) ?? normalizeOptionalLowercaseString(channel) ?? "";
-}
-function getMessagingAdapter(channel) {
-	const normalizedChannel = normalizeResolvedChannel(channel);
-	try {
-		return getLoadedChannelPlugin(normalizedChannel)?.messaging;
-	} catch {
-		return;
-	}
-}
-function dedupeConversationIds(values) {
-	const seen = /* @__PURE__ */ new Set();
-	const resolved = [];
-	for (const value of values) {
-		if (typeof value !== "string") continue;
-		const trimmed = value.trim();
-		if (!trimmed || seen.has(trimmed)) continue;
-		seen.add(trimmed);
-		resolved.push(trimmed);
-	}
-	return resolved;
-}
-function buildGenericConversationResolution(rawId) {
-	const trimmed = rawId.trim();
-	if (!trimmed) return null;
-	const parsed = parseThreadSessionSuffix(trimmed);
-	const id = (parsed.baseSessionKey ?? trimmed).trim();
-	if (!id) return null;
-	return {
-		id,
-		threadId: parsed.threadId,
-		baseConversationId: id,
-		parentConversationCandidates: dedupeConversationIds(parsed.threadId ? [parsed.baseSessionKey] : [])
-	};
-}
-function normalizeSessionConversationResolution(resolved) {
-	if (!resolved?.id?.trim()) return null;
-	return {
-		id: resolved.id.trim(),
-		threadId: normalizeOptionalString(resolved.threadId),
-		baseConversationId: normalizeOptionalString(resolved.baseConversationId) ?? dedupeConversationIds(resolved.parentConversationCandidates ?? []).at(-1) ?? resolved.id.trim(),
-		parentConversationCandidates: dedupeConversationIds(resolved.parentConversationCandidates ?? []),
-		hasExplicitParentConversationCandidates: Object.hasOwn(resolved, "parentConversationCandidates")
-	};
-}
-function resolveBundledSessionConversationFallback(params) {
-	if (isBundledSessionConversationFallbackDisabled(params.channel)) return null;
-	const dirName = normalizeResolvedChannel(params.channel);
-	const version = getActivePluginChannelRegistryVersion();
-	let cached = bundledSessionConversationFallbackCache.get(dirName);
-	if (!cached || cached.version !== version) {
-		let resolveSessionConversation = null;
-		try {
-			const loaded = tryLoadActivatedBundledPluginPublicSurfaceModuleSync({
-				dirName,
-				artifactBasename: SESSION_KEY_API_ARTIFACT_BASENAME
-			});
-			resolveSessionConversation = typeof loaded?.resolveSessionConversation === "function" ? loaded.resolveSessionConversation : null;
-		} catch {
-			resolveSessionConversation = null;
-		}
-		cached = {
-			version,
-			resolveSessionConversation
-		};
-		bundledSessionConversationFallbackCache.set(dirName, cached);
-	}
-	if (typeof cached.resolveSessionConversation !== "function") return null;
-	return normalizeSessionConversationResolution(cached.resolveSessionConversation({
-		kind: params.kind,
-		rawId: params.rawId
-	}));
-}
-function isBundledSessionConversationFallbackDisabled(channel) {
-	const snapshot = getRuntimeConfigSnapshot();
-	if (!snapshot?.plugins) return false;
-	if (snapshot.plugins.enabled === false) return true;
-	const entry = snapshot.plugins.entries?.[normalizeResolvedChannel(channel)];
-	return !!entry && typeof entry === "object" && entry.enabled === false;
-}
-function shouldProbeBundledSessionConversationFallback(rawId) {
-	return rawId.includes(":");
-}
-function resolveSessionConversationResolution(params) {
-	const rawId = params.rawId.trim();
-	if (!rawId) return null;
-	const messaging = getMessagingAdapter(params.channel);
-	const pluginResolved = normalizeSessionConversationResolution(messaging?.resolveSessionConversation?.({
-		kind: params.kind,
-		rawId
-	}));
-	const shouldTryBundledFallback = params.bundledFallback !== false && !messaging && shouldProbeBundledSessionConversationFallback(rawId);
-	const resolved = pluginResolved ?? (shouldTryBundledFallback ? resolveBundledSessionConversationFallback({
-		channel: params.channel,
-		kind: params.kind,
-		rawId
-	}) : null) ?? buildGenericConversationResolution(rawId);
-	if (!resolved) return null;
-	const parentConversationCandidates = dedupeConversationIds(pluginResolved?.hasExplicitParentConversationCandidates ? resolved.parentConversationCandidates : messaging?.resolveParentConversationCandidates?.({
-		kind: params.kind,
-		rawId
-	}) ?? resolved.parentConversationCandidates);
-	const baseConversationId = parentConversationCandidates.at(-1) ?? resolved.baseConversationId ?? resolved.id;
-	return {
-		...resolved,
-		baseConversationId,
-		parentConversationCandidates
-	};
-}
-function resolveSessionConversation(params) {
-	return resolveSessionConversationResolution(params);
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/transcript-events-e-pVl4cn.js
-const SESSION_TRANSCRIPT_LISTENERS = /* @__PURE__ */ new Set();
-function emitSessionTranscriptUpdate(update) {
-	const normalized = typeof update === "string" ? { sessionFile: update } : {
-		sessionFile: update.sessionFile,
-		sessionKey: update.sessionKey,
-		message: update.message,
-		messageId: update.messageId
-	};
-	const trimmed = normalizeOptionalString(normalized.sessionFile);
-	if (!trimmed) return;
-	const nextUpdate = {
-		sessionFile: trimmed,
-		...normalizeOptionalString(normalized.sessionKey) ? { sessionKey: normalizeOptionalString(normalized.sessionKey) } : {},
-		...normalized.message !== void 0 ? { message: normalized.message } : {},
-		...normalizeOptionalString(normalized.messageId) ? { messageId: normalizeOptionalString(normalized.messageId) } : {}
-	};
-	for (const listener of SESSION_TRANSCRIPT_LISTENERS) try {
-		listener(nextUpdate);
-	} catch {}
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/transcript-E_-ISOkD.js
-async function resolveAndPersistSessionFile(params) {
-	const { sessionId, sessionKey, sessionStore, storePath } = params;
-	const baseEntry = params.sessionEntry ?? sessionStore[sessionKey] ?? {
-		sessionId,
-		updatedAt: Date.now()
-	};
-	const shouldReusePersistedSessionFile = baseEntry.sessionId === sessionId;
-	const fallbackSessionFile = params.fallbackSessionFile?.trim();
-	const sessionFile = resolveSessionFilePath(sessionId, !shouldReusePersistedSessionFile ? fallbackSessionFile ? {
-		...baseEntry,
-		sessionFile: fallbackSessionFile
-	} : {
-		...baseEntry,
-		sessionFile: void 0
-	} : !baseEntry.sessionFile && fallbackSessionFile ? {
-		...baseEntry,
-		sessionFile: fallbackSessionFile
-	} : baseEntry, {
-		agentId: params.agentId,
-		sessionsDir: params.sessionsDir
-	});
-	const persistedEntry = {
-		...baseEntry,
-		sessionId,
-		updatedAt: Date.now(),
-		sessionFile
-	};
-	if (baseEntry.sessionId !== sessionId || baseEntry.sessionFile !== sessionFile) {
-		sessionStore[sessionKey] = persistedEntry;
-		await updateSessionStore(storePath, (store) => {
-			store[sessionKey] = {
-				...store[sessionKey],
-				...persistedEntry
-			};
-		}, params.activeSessionKey || params.maintenanceConfig ? {
-			...params.activeSessionKey ? { activeSessionKey: params.activeSessionKey } : {},
-			...params.maintenanceConfig ? { maintenanceConfig: params.maintenanceConfig } : {}
-		} : void 0);
-		return {
-			sessionFile,
-			sessionEntry: persistedEntry
-		};
-	}
-	sessionStore[sessionKey] = persistedEntry;
-	return {
-		sessionFile,
-		sessionEntry: persistedEntry
-	};
-}
-function stripQuery(value) {
-	const noHash = value.split("#")[0] ?? value;
-	return noHash.split("?")[0] ?? noHash;
-}
-function extractFileNameFromMediaUrl(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	const cleaned = stripQuery(trimmed);
-	try {
-		const parsed = new URL(cleaned);
-		const base = path.basename(parsed.pathname);
-		if (!base) return null;
-		try {
-			return decodeURIComponent(base);
-		} catch {
-			return base;
-		}
-	} catch {
-		const base = path.basename(cleaned);
-		if (!base || base === "/" || base === ".") return null;
-		return base;
-	}
-}
-function resolveMirroredTranscriptText(params) {
-	const mediaUrls = params.mediaUrls?.filter((url) => url && url.trim()) ?? [];
-	if (mediaUrls.length > 0) {
-		const names = mediaUrls.map((url) => extractFileNameFromMediaUrl(url)).filter((name) => Boolean(name && name.trim()));
-		if (names.length > 0) return names.join(", ");
-		return "media";
-	}
-	const trimmed = (params.text ?? "").trim();
-	return trimmed ? trimmed : null;
-}
-async function ensureSessionHeader(params) {
-	if (fs.existsSync(params.sessionFile)) return;
-	await fs.promises.mkdir(path.dirname(params.sessionFile), { recursive: true });
-	const header = {
-		type: "session",
-		version: 3,
-		id: params.sessionId,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		cwd: process.cwd()
-	};
-	await fs.promises.writeFile(params.sessionFile, `${JSON.stringify(header)}\n`, {
-		encoding: "utf-8",
-		mode: 384
-	});
-}
-async function appendAssistantMessageToSessionTranscript(params) {
-	const sessionKey = params.sessionKey.trim();
-	if (!sessionKey) return {
-		ok: false,
-		reason: "missing sessionKey"
-	};
-	const mirrorText = resolveMirroredTranscriptText({
-		text: params.text,
-		mediaUrls: params.mediaUrls
-	});
-	if (!mirrorText) return {
-		ok: false,
-		reason: "empty text"
-	};
-	return appendExactAssistantMessageToSessionTranscript({
-		agentId: params.agentId,
-		sessionKey,
-		storePath: params.storePath,
-		idempotencyKey: params.idempotencyKey,
-		updateMode: params.updateMode,
-		message: {
-			role: "assistant",
-			content: [{
-				type: "text",
-				text: mirrorText
-			}],
-			api: "openai-responses",
-			provider: "openclaw",
-			model: "delivery-mirror",
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: Date.now()
-		}
-	});
-}
-async function appendExactAssistantMessageToSessionTranscript(params) {
-	const sessionKey = params.sessionKey.trim();
-	if (!sessionKey) return {
-		ok: false,
-		reason: "missing sessionKey"
-	};
-	if (params.message.role !== "assistant") return {
-		ok: false,
-		reason: "message role must be assistant"
-	};
-	const storePath = params.storePath ?? resolveDefaultSessionStorePath(params.agentId);
-	const store = loadSessionStore(storePath, { skipCache: true });
-	const entry = store[normalizeStoreSessionKey(sessionKey)] ?? store[sessionKey];
-	if (!entry?.sessionId) return {
-		ok: false,
-		reason: `unknown sessionKey: ${sessionKey}`
-	};
-	let sessionFile;
-	try {
-		sessionFile = (await resolveAndPersistSessionFile({
-			sessionId: entry.sessionId,
-			sessionKey,
-			sessionStore: store,
-			storePath,
-			sessionEntry: entry,
-			agentId: params.agentId,
-			sessionsDir: path.dirname(storePath)
-		})).sessionFile;
-	} catch (err) {
-		return {
-			ok: false,
-			reason: formatErrorMessage(err)
-		};
-	}
-	await ensureSessionHeader({
-		sessionFile,
-		sessionId: entry.sessionId
-	});
-	const explicitIdempotencyKey = params.idempotencyKey ?? params.message.idempotencyKey;
-	const existingMessageId = explicitIdempotencyKey ? await transcriptHasIdempotencyKey(sessionFile, explicitIdempotencyKey) : void 0;
-	if (existingMessageId) return {
-		ok: true,
-		sessionFile,
-		messageId: existingMessageId
-	};
-	const latestEquivalentAssistantId = isRedundantDeliveryMirror(params.message) ? await findLatestEquivalentAssistantMessageId(sessionFile, params.message) : void 0;
-	if (latestEquivalentAssistantId) return {
-		ok: true,
-		sessionFile,
-		messageId: latestEquivalentAssistantId
-	};
-	const message = {
-		...params.message,
-		...explicitIdempotencyKey ? { idempotencyKey: explicitIdempotencyKey } : {}
-	};
-	const messageId = SessionManager.open(sessionFile).appendMessage(message);
-	switch (params.updateMode ?? "inline") {
-		case "inline":
-			emitSessionTranscriptUpdate({
-				sessionFile,
-				sessionKey,
-				message,
-				messageId
-			});
-			break;
-		case "file-only":
-			emitSessionTranscriptUpdate(sessionFile);
-			break;
-		case "none": break;
-	}
-	return {
-		ok: true,
-		sessionFile,
-		messageId
-	};
-}
-async function transcriptHasIdempotencyKey(transcriptPath, idempotencyKey) {
-	try {
-		const raw = await fs.promises.readFile(transcriptPath, "utf-8");
-		for (const line of raw.split(/\r?\n/)) {
-			if (!line.trim()) continue;
-			try {
-				const parsed = JSON.parse(line);
-				if (parsed.message?.idempotencyKey === idempotencyKey && typeof parsed.id === "string" && parsed.id) return parsed.id;
-			} catch {
-				continue;
-			}
-		}
-	} catch {
-		return;
-	}
-}
-function isRedundantDeliveryMirror(message) {
-	return message.provider === "openclaw" && message.model === "delivery-mirror";
-}
-function extractAssistantMessageText(message) {
-	if (!Array.isArray(message.content)) return null;
-	const parts = message.content.filter((part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0).map((part) => part.text.trim());
-	return parts.length > 0 ? parts.join("\n").trim() : null;
-}
-async function findLatestEquivalentAssistantMessageId(transcriptPath, message) {
-	const expectedText = extractAssistantMessageText(message);
-	if (!expectedText) return;
-	try {
-		const lines = (await fs.promises.readFile(transcriptPath, "utf-8")).split(/\r?\n/);
-		for (let index = lines.length - 1; index >= 0; index -= 1) {
-			const line = lines[index];
-			if (!line.trim()) continue;
-			try {
-				const parsed = JSON.parse(line);
-				const candidate = parsed.message;
-				if (!candidate || candidate.role !== "assistant") continue;
-				if (extractAssistantMessageText(candidate) !== expectedText) return;
-				if (typeof parsed.id === "string" && parsed.id) return parsed.id;
-				return;
-			} catch {
-				continue;
-			}
-		}
-	} catch {
-		return;
-	}
-}
-//#endregion
-export { createLazyFacadeValue as a, loadSessionStore as c, resolveSessionConversation as i, appendExactAssistantMessageToSessionTranscript as n, loadActivatedBundledPluginPublicSurfaceModuleSync as o, resolveMirroredTranscriptText as r, updateSessionStore as s, appendAssistantMessageToSessionTranscript as t };