fengming 0.3.7 → 0.3.9

package/dist/sessions-DXAdVXIx.js

@@ -0,0 +1,1917 @@
+import { c as normalizeOptionalString, p as readStringValue, s as normalizeOptionalLowercaseString } from "./string-coerce-DKw2K5wM.js";
+import { i as formatErrorMessage } from "./errors-C_Wa6a5T.js";
+import "./agent-scope-EEbMCF2I.js";
+import { c as parseAgentSessionKey } from "./session-key-utils-CdfsDYvz.js";
+import { d as resolveAgentIdFromSessionKey, l as normalizeAgentId, v as toAgentStoreSessionKey } from "./session-key-CJf5_zWs.js";
+import { c as resolveDefaultAgentId, n as listAgentIds, o as resolveAgentWorkspaceDir } from "./agent-scope-config-BHdZonI2.js";
+import { c as measureDiagnosticsTimelineSpan, l as measureDiagnosticsTimelineSpanSync } from "./plugin-metadata-snapshot-CHymO30I.js";
+import { f as normalizeReasoningLevel, p as normalizeThinkLevel } from "./thinking-BmfCvr5O.js";
+import { n as GATEWAY_CLIENT_IDS } from "./client-info-D6_UASoA.js";
+import { $t as validateSessionsSendParams, Bt as validateSessionsCompactionListParams, Ft as validateSessionsAbortParams, Gt as validateSessionsListParams, Ht as validateSessionsCreateParams, It as validateSessionsCleanupParams, Jt as validateSessionsPatchParams, Kt as validateSessionsMessagesSubscribeParams, Lt as validateSessionsCompactParams, Qt as validateSessionsResolveParams, Ri as ErrorCodes, Rt as validateSessionsCompactionBranchParams, Ut as validateSessionsDeleteParams, Vt as validateSessionsCompactionRestoreParams, Wt as validateSessionsDescribeParams, Xt as validateSessionsPreviewParams, Yt as validateSessionsPluginPatchParams, Zt as validateSessionsResetParams, qt as validateSessionsMessagesUnsubscribeParams, zi as errorShape, zt as validateSessionsCompactionGetParams } from "./src-B1Y482-m.js";
+import { t as ADMIN_SCOPE } from "./operator-scopes-DGvgHuOd.js";
+import { T as patchPluginSessionExtension } from "./loader-Ct7uZnva.js";
+import { i as hasInternalHookListeners, m as triggerInternalHook, n as createInternalHookEvent } from "./internal-hooks-DgzYHw8L.js";
+import { t as isPluginJsonValue } from "./host-hook-json-BHsxXV1L.js";
+import { i as resolveMainSessionKey, n as resolveAgentMainSessionKey } from "./main-session-BxJmPEXx.js";
+import { a as resolveStoredSessionKeyForAgentStore, i as resolveSessionStoreKey, o as resolveStoredSessionOwnerAgentId, r as resolveSessionStoreAgentId } from "./session-store-key-dbCfepNe.js";
+import { a as resolveSessionFilePathOptions, i as resolveSessionFilePath } from "./paths-C79m3Aob.js";
+import { t as loadSessionStore } from "./store-load-CVdafI-Y.js";
+import { d as updateSessionStore } from "./store-DH20opqS.js";
+import { t as listConfiguredSessionStoreAgentIds } from "./targets-CQE5epyU.js";
+import { t as loadCombinedSessionStoreForGateway } from "./combined-store-gateway-n-bwAWEx.js";
+import { i as serializeSessionCleanupResult, r as runSessionsCleanup } from "./sessions-CtMqsEs2.js";
+import "./transcript-jsonl-LFU2CQ2E.js";
+import { S as waitForEmbeddedAgentRunEnd, n as abortEmbeddedAgentRun, o as isEmbeddedAgentRunActive } from "./runs-B0iD89hy.js";
+import { a as readRecentSessionMessagesWithStatsAsync, c as readSessionMessageCountAsync, o as readRecentSessionTranscriptLines, u as readSessionPreviewItemsFromTranscript } from "./session-utils.fs-D-Ly08WB.js";
+import { a as resolveSessionTranscriptCandidates, t as archiveFileOnDisk } from "./session-transcript-files.fs-CusxaEql.js";
+import { t as resolveModelAgentRuntimeMetadata } from "./agent-runtime-metadata-CbrTK-1N.js";
+import { c as loadSessionEntry, d as resolveDeletedAgentIdFromSessionKey, f as resolveFreshestSessionEntryFromStoreKeys, g as resolveSessionDisplayModelIdentityRef, l as migrateAndPruneGatewaySessionStoreKey, m as resolveGatewaySessionStoreTarget, o as listSessionsFromStoreAsync, s as loadGatewaySessionRow, t as buildGatewaySessionRow, v as resolveSessionModelRef } from "./session-utils-pgndLXV7.js";
+import { r as triggerSessionPatchHook } from "./fengming-tools-DBLsJfsf.js";
+import { a as clearSessionQueues } from "./queue-Bp_sf0n7.js";
+import { g as listSessionCompactionCheckpoints, h as getSessionCompactionCheckpoint, m as forkCompactionCheckpointTranscriptAsync } from "./model-context-tokens-BT85ZQUi.js";
+import { n as compactEmbeddedAgentSession } from "./embedded-agent-DxwzoZkp.js";
+import { i as chatHandlers } from "./chat-Czh_tXM0.js";
+import { n as setGatewayDedupeEntry } from "./agent-wait-dedupe-I81_F2tr.js";
+import { t as resolveSessionKeyFromResolveParams } from "./sessions-resolve-C3ORcdmo.js";
+import { t as reactivateCompletedSubagentSession } from "./session-subagent-reactivation-CH0C2I6Y.js";
+import { n as resolveSessionKeyForRun } from "./server-session-key-BKIo1HjL.js";
+import { t as assertValidParams } from "./validation-V7yffIu7.js";
+import { t as applySessionsPatchToStore } from "./sessions-patch-BYC5gvY1.js";
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/gateway/server-methods/sessions.ts
+function filterSessionStoreToConfiguredAgents(cfg, store) {
+	const configuredAgentIds = new Set(listConfiguredSessionStoreAgentIds(cfg));
+	const isConfiguredSessionKey = (key) => {
+		const normalizedKey = normalizeOptionalString(key);
+		if (!normalizedKey) return false;
+		const agentId = resolveSessionStoreAgentId(cfg, resolveSessionStoreKey({
+			cfg,
+			sessionKey: normalizedKey
+		}));
+		return configuredAgentIds.has(normalizeAgentId(agentId));
+	};
+	return Object.fromEntries(Object.entries(store).filter(([key, entry]) => {
+		if (key === "global" || key === "unknown") return true;
+		if (isConfiguredSessionKey(key)) return true;
+		return isConfiguredSessionKey(entry?.spawnedBy) || isConfiguredSessionKey(entry?.parentSessionKey);
+	}));
+}
+function inheritSessionRuntimeSelection(parentEntry) {
+	if (!parentEntry) return {};
+	return {
+		...parentEntry.providerOverride ? { providerOverride: parentEntry.providerOverride } : {},
+		...parentEntry.modelOverride ? { modelOverride: parentEntry.modelOverride } : {},
+		...parentEntry.modelOverrideSource ? { modelOverrideSource: parentEntry.modelOverrideSource } : {},
+		...parentEntry.agentRuntimeOverride ? { agentRuntimeOverride: parentEntry.agentRuntimeOverride } : {},
+		...parentEntry.modelProvider ? { modelProvider: parentEntry.modelProvider } : {},
+		...parentEntry.model ? { model: parentEntry.model } : {},
+		...typeof parentEntry.contextTokens === "number" ? { contextTokens: parentEntry.contextTokens } : {},
+		...parentEntry.thinkingLevel ? { thinkingLevel: parentEntry.thinkingLevel } : {},
+		...typeof parentEntry.fastMode === "boolean" ? { fastMode: parentEntry.fastMode } : {},
+		...parentEntry.verboseLevel ? { verboseLevel: parentEntry.verboseLevel } : {},
+		...parentEntry.traceLevel ? { traceLevel: parentEntry.traceLevel } : {},
+		...parentEntry.reasoningLevel ? { reasoningLevel: parentEntry.reasoningLevel } : {},
+		...parentEntry.elevatedLevel ? { elevatedLevel: parentEntry.elevatedLevel } : {},
+		...parentEntry.authProfileOverride ? { authProfileOverride: parentEntry.authProfileOverride } : {},
+		...parentEntry.authProfileOverrideSource ? { authProfileOverrideSource: parentEntry.authProfileOverrideSource } : {}
+	};
+}
+let sessionsRuntimeModulePromise;
+let loggedSlowSessionsListCatalog = false;
+const SESSIONS_LIST_MODEL_CATALOG_TIMEOUT_MS = 750;
+function loadSessionsRuntimeModule() {
+	sessionsRuntimeModulePromise ??= import("./sessions.runtime.js");
+	return sessionsRuntimeModulePromise;
+}
+async function loadOptionalSessionsListModelCatalog(context) {
+	let timeout;
+	const timedOut = Symbol("sessions-list-model-catalog-timeout");
+	const timeoutPromise = new Promise((resolve) => {
+		timeout = setTimeout(() => resolve(timedOut), SESSIONS_LIST_MODEL_CATALOG_TIMEOUT_MS);
+		timeout.unref?.();
+	});
+	try {
+		const result = await Promise.race([context.loadGatewayModelCatalog().catch(() => void 0), timeoutPromise]);
+		if (result === timedOut) {
+			if (!loggedSlowSessionsListCatalog) {
+				loggedSlowSessionsListCatalog = true;
+				context.logGateway.debug(`sessions.list continuing without model catalog after ${SESSIONS_LIST_MODEL_CATALOG_TIMEOUT_MS}ms`);
+			}
+			return;
+		}
+		return Array.isArray(result) ? result : void 0;
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function requireSessionKey(key, respond) {
+	const normalized = normalizeOptionalString(typeof key === "string" ? key : typeof key === "number" ? String(key) : typeof key === "bigint" ? String(key) : "") ?? "";
+	if (!normalized) {
+		respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
+		return null;
+	}
+	return normalized;
+}
+function rejectPluginRuntimeDeleteMismatch(params) {
+	const pluginOwnerId = normalizeOptionalString(params.client?.internal?.pluginRuntimeOwnerId);
+	if (!pluginOwnerId || !params.entry) return false;
+	if (normalizeOptionalString(params.entry.pluginOwnerId) === pluginOwnerId) return false;
+	params.respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `Plugin "${pluginOwnerId}" cannot delete session "${params.key}" because it did not create it.`));
+	return true;
+}
+function resolveGatewaySessionTargetFromKey(key, cfg, opts) {
+	const target = resolveGatewaySessionStoreTarget({
+		cfg,
+		key,
+		...opts?.agentId ? { agentId: opts.agentId } : {}
+	});
+	return {
+		cfg,
+		target,
+		storePath: target.storePath
+	};
+}
+function resolveOptionalInitialSessionMessage(params) {
+	if (typeof params.task === "string" && params.task.trim()) return params.task;
+	if (typeof params.message === "string" && params.message.trim()) return params.message;
+}
+function shouldAttachPendingMessageSeq(params) {
+	if (params.cached) return false;
+	return (params.payload && typeof params.payload === "object" ? params.payload.status : void 0) === "started";
+}
+function emitSessionsChanged(context, payload) {
+	const connIds = context.getSessionEventSubscriberConnIds();
+	if (connIds.size === 0) return;
+	const sessionRow = payload.sessionKey ? loadGatewaySessionRow(payload.sessionKey, payload.sessionKey === "global" && payload.agentId ? { agentId: payload.agentId } : void 0) : null;
+	const omitUnscopedGlobalGoal = payload.sessionKey === "global" && !payload.agentId;
+	const defaultAgentId = resolveDefaultAgentId(context.getRuntimeConfig());
+	context.broadcastToConnIds("sessions.changed", {
+		...payload,
+		ts: Date.now(),
+		...sessionRow ? {
+			updatedAt: sessionRow.updatedAt ?? void 0,
+			sessionId: sessionRow.sessionId,
+			kind: sessionRow.kind,
+			channel: sessionRow.channel,
+			subject: sessionRow.subject,
+			groupChannel: sessionRow.groupChannel,
+			space: sessionRow.space,
+			chatType: sessionRow.chatType,
+			origin: sessionRow.origin,
+			spawnedBy: sessionRow.spawnedBy,
+			spawnedWorkspaceDir: sessionRow.spawnedWorkspaceDir,
+			spawnedCwd: sessionRow.spawnedCwd,
+			forkedFromParent: sessionRow.forkedFromParent,
+			spawnDepth: sessionRow.spawnDepth,
+			subagentRole: sessionRow.subagentRole,
+			subagentControlScope: sessionRow.subagentControlScope,
+			label: sessionRow.label,
+			displayName: sessionRow.displayName,
+			deliveryContext: sessionRow.deliveryContext,
+			parentSessionKey: sessionRow.parentSessionKey,
+			childSessions: sessionRow.childSessions,
+			thinkingLevel: sessionRow.thinkingLevel,
+			fastMode: sessionRow.fastMode,
+			verboseLevel: sessionRow.verboseLevel,
+			traceLevel: sessionRow.traceLevel,
+			reasoningLevel: sessionRow.reasoningLevel,
+			elevatedLevel: sessionRow.elevatedLevel,
+			sendPolicy: sessionRow.sendPolicy,
+			systemSent: sessionRow.systemSent,
+			abortedLastRun: sessionRow.abortedLastRun,
+			inputTokens: sessionRow.inputTokens,
+			outputTokens: sessionRow.outputTokens,
+			lastChannel: sessionRow.lastChannel,
+			lastTo: sessionRow.lastTo,
+			lastAccountId: sessionRow.lastAccountId,
+			lastThreadId: sessionRow.lastThreadId,
+			totalTokens: sessionRow.totalTokens,
+			totalTokensFresh: sessionRow.totalTokensFresh,
+			...omitUnscopedGlobalGoal ? {} : { goal: sessionRow.goal ?? null },
+			contextTokens: sessionRow.contextTokens,
+			estimatedCostUsd: sessionRow.estimatedCostUsd,
+			responseUsage: sessionRow.responseUsage,
+			modelProvider: sessionRow.modelProvider,
+			model: sessionRow.model,
+			status: sessionRow.status,
+			hasActiveRun: hasTrackedActiveSessionRun({
+				context,
+				requestedKey: payload.sessionKey ?? sessionRow.key,
+				canonicalKey: sessionRow.key,
+				agentId: sessionRow.key === "global" ? payload.agentId : void 0,
+				defaultAgentId
+			}),
+			startedAt: sessionRow.startedAt,
+			endedAt: sessionRow.endedAt,
+			runtimeMs: sessionRow.runtimeMs,
+			compactionCheckpointCount: sessionRow.compactionCheckpointCount,
+			latestCompactionCheckpoint: sessionRow.latestCompactionCheckpoint,
+			pluginExtensions: sessionRow.pluginExtensions
+		} : {}
+	}, connIds, { dropIfSlow: true });
+}
+function emitSessionOperation(context, payload) {
+	const connIds = context.getSessionEventSubscriberConnIds();
+	if (connIds.size === 0) return;
+	context.broadcastToConnIds("session.operation", {
+		...payload,
+		ts: Date.now()
+	}, connIds, { dropIfSlow: true });
+}
+function rejectWebchatSessionMutation(params) {
+	if (!params.client?.connect || !params.isWebchatConnect(params.client.connect)) return false;
+	if (params.client.connect.client.id === GATEWAY_CLIENT_IDS.CONTROL_UI) return false;
+	params.respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `webchat clients cannot ${params.action} sessions; use chat.send for session-scoped updates`));
+	return true;
+}
+function buildDashboardSessionKey(agentId) {
+	return `agent:${agentId}:dashboard:${randomUUID()}`;
+}
+function cloneCheckpointSessionEntry(params) {
+	return {
+		...params.currentEntry,
+		sessionId: params.nextSessionId,
+		sessionFile: params.nextSessionFile,
+		updatedAt: Date.now(),
+		systemSent: false,
+		abortedLastRun: false,
+		startedAt: void 0,
+		endedAt: void 0,
+		runtimeMs: void 0,
+		status: void 0,
+		inputTokens: void 0,
+		outputTokens: void 0,
+		cacheRead: void 0,
+		cacheWrite: void 0,
+		estimatedCostUsd: void 0,
+		totalTokens: typeof params.totalTokens === "number" && Number.isFinite(params.totalTokens) ? params.totalTokens : void 0,
+		totalTokensFresh: typeof params.totalTokens === "number" && Number.isFinite(params.totalTokens) ? true : void 0,
+		label: params.label ?? params.currentEntry.label,
+		parentSessionKey: params.parentSessionKey ?? params.currentEntry.parentSessionKey,
+		compactionCheckpoints: params.preserveCompactionCheckpoints ? params.currentEntry.compactionCheckpoints : void 0
+	};
+}
+function resolveCheckpointForkSource(checkpoint) {
+	const preCompactionFile = checkpoint.preCompaction.sessionFile?.trim();
+	if (preCompactionFile) return {
+		sourceFile: preCompactionFile,
+		sourceLeafId: checkpoint.preCompaction.leafId,
+		totalTokens: checkpoint.tokensBefore
+	};
+	const postCompactionFile = checkpoint.postCompaction.sessionFile?.trim();
+	if (!postCompactionFile) return null;
+	const postCompactionLeafId = checkpoint.postCompaction.leafId ?? checkpoint.postCompaction.entryId;
+	if (!postCompactionLeafId) return null;
+	return {
+		sourceFile: postCompactionFile,
+		sourceLeafId: postCompactionLeafId,
+		totalTokens: checkpoint.tokensAfter
+	};
+}
+function isAgentMainSessionKey(cfg, sessionKey) {
+	const parsed = parseAgentSessionKey(sessionKey);
+	if (!parsed) return false;
+	return sessionKey === resolveAgentMainSessionKey({
+		cfg,
+		agentId: parsed.agentId
+	});
+}
+async function createAgentMainSessionForSend(params) {
+	const agentId = parseAgentSessionKey(params.canonicalKey)?.agentId;
+	if (!agentId) return {
+		ok: false,
+		error: errorShape(ErrorCodes.INVALID_REQUEST, `session not found: ${params.canonicalKey}`)
+	};
+	let createResult;
+	await sessionsHandlers["sessions.create"]({
+		req: params.req,
+		params: {
+			key: params.canonicalKey,
+			agentId
+		},
+		respond: (ok, payload, error) => {
+			createResult = {
+				ok,
+				payload: payload && typeof payload === "object" ? payload : void 0,
+				error
+			};
+		},
+		context: params.context,
+		client: params.client,
+		isWebchatConnect: params.isWebchatConnect
+	});
+	if (!createResult) return {
+		ok: false,
+		error: errorShape(ErrorCodes.UNAVAILABLE, "sessions.create did not respond")
+	};
+	if (!createResult.ok) return {
+		ok: false,
+		error: createResult.error ?? errorShape(ErrorCodes.UNAVAILABLE, "failed to create session")
+	};
+	const createdKey = normalizeOptionalString(createResult.payload?.key) ?? params.canonicalKey;
+	const loaded = loadSessionEntry(createdKey);
+	if (!loaded.entry?.sessionId) return {
+		ok: false,
+		error: errorShape(ErrorCodes.UNAVAILABLE, `session not created: ${createdKey}`)
+	};
+	return {
+		ok: true,
+		entry: loaded.entry,
+		canonicalKey: loaded.canonicalKey,
+		storePath: loaded.storePath
+	};
+}
+function ensureSessionTranscriptFile(params) {
+	try {
+		const transcriptPath = resolveSessionFilePath(params.sessionId, params.sessionFile ? { sessionFile: params.sessionFile } : void 0, resolveSessionFilePathOptions({
+			storePath: params.storePath,
+			agentId: params.agentId
+		}));
+		if (!fs.existsSync(transcriptPath)) {
+			fs.mkdirSync(path.dirname(transcriptPath), { recursive: true });
+			const header = {
+				type: "session",
+				version: 3,
+				id: params.sessionId,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				cwd: process.cwd()
+			};
+			fs.writeFileSync(transcriptPath, `${JSON.stringify(header)}\n`, {
+				encoding: "utf-8",
+				mode: 384
+			});
+		}
+		return {
+			ok: true,
+			transcriptPath
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: formatErrorMessage(err)
+		};
+	}
+}
+function resolveAbortSessionKey(params) {
+	if (params.activeRunSessionKey) return params.activeRunSessionKey;
+	const candidates = [
+		params.canonicalKey,
+		params.requestedKey,
+		...params.aliasKeys ?? []
+	];
+	for (const active of params.context.chatAbortControllers.values()) for (const candidate of candidates) if (active.sessionKey === candidate) return candidate;
+	return params.requestedKey;
+}
+function resolveSessionKeyAgentId(sessionKey, cfg) {
+	const key = normalizeOptionalString(sessionKey);
+	if (!key) return;
+	if (!parseAgentSessionKey(key) && key.toLowerCase().startsWith("agent:")) return;
+	return resolveSessionStoreAgentId(cfg, resolveSessionStoreKey({
+		cfg,
+		sessionKey: key
+	}));
+}
+function sessionKeyBelongsToAgent(sessionKey, agentId, cfg) {
+	const key = normalizeOptionalString(sessionKey);
+	if (cfg.session?.scope === "global" && key?.toLowerCase() === "global") return true;
+	const sessionAgentId = resolveSessionKeyAgentId(sessionKey, cfg);
+	return Boolean(sessionAgentId && sessionAgentId === normalizeAgentId(agentId));
+}
+function resolveScopedAbortKey(params) {
+	const key = normalizeOptionalString(params.key);
+	if (!key) return;
+	const requestedAgentId = normalizeOptionalString(params.agentId);
+	if (!requestedAgentId) return key;
+	const scopedAgentId = normalizeAgentId(requestedAgentId);
+	const ownerAgentId = resolveStoredSessionOwnerAgentId({
+		cfg: params.cfg,
+		agentId: scopedAgentId,
+		sessionKey: key
+	});
+	if (ownerAgentId && ownerAgentId !== scopedAgentId) return;
+	return resolveStoredSessionKeyForAgentStore({
+		cfg: params.cfg,
+		agentId: scopedAgentId,
+		sessionKey: key
+	});
+}
+function collectTrackedActiveSessionRuns(context) {
+	const runs = [];
+	if (!(context.chatAbortControllers instanceof Map)) return runs;
+	for (const active of context.chatAbortControllers.values()) if (active.projectSessionActive !== false && typeof active.sessionKey === "string" && active.sessionKey.trim()) runs.push({
+		sessionKey: active.sessionKey,
+		agentId: typeof active.agentId === "string" ? normalizeAgentId(active.agentId) : void 0
+	});
+	return runs;
+}
+function isTrackedActiveSessionRunForKey(active, key, agentId, defaultAgentId) {
+	if (active.sessionKey !== key) return false;
+	if (key !== "global" || agentId === void 0) return true;
+	const activeAgentId = active.agentId ?? defaultAgentId;
+	return activeAgentId ? normalizeAgentId(activeAgentId) === normalizeAgentId(agentId) : false;
+}
+function hasTrackedActiveSessionRun(params) {
+	return collectTrackedActiveSessionRuns(params.context).some((active) => isTrackedActiveSessionRunForKey(active, params.canonicalKey, params.agentId, params.defaultAgentId) || isTrackedActiveSessionRunForKey(active, params.requestedKey, params.agentId, params.defaultAgentId));
+}
+function resolveSessionMessageSubscriptionKey(params) {
+	const agentId = params.agentId ? normalizeAgentId(params.agentId) : params.canonicalKey === "global" && params.defaultAgentId ? normalizeAgentId(params.defaultAgentId) : void 0;
+	return params.canonicalKey === "global" && agentId ? `agent:${agentId}:global` : params.canonicalKey;
+}
+function resolveRequestedGlobalAgentId(cfg, key, explicitAgentId) {
+	const canonicalKey = resolveSessionStoreKey({
+		cfg,
+		sessionKey: key
+	});
+	const parsed = parseAgentSessionKey(key);
+	const requestedAgentId = normalizeOptionalString(explicitAgentId);
+	if (requestedAgentId) {
+		const agentId = normalizeAgentId(requestedAgentId);
+		if (!listAgentIds(cfg).includes(agentId)) return {
+			ok: false,
+			error: errorShape(ErrorCodes.INVALID_REQUEST, `Unknown agent id "${explicitAgentId}"`)
+		};
+		if (parsed?.agentId && normalizeAgentId(parsed.agentId) !== agentId) return {
+			ok: false,
+			error: errorShape(ErrorCodes.INVALID_REQUEST, "session key agent does not match agentId")
+		};
+		if (canonicalKey !== "global") {
+			if ((parsed?.agentId ? normalizeAgentId(parsed.agentId) : normalizeAgentId(resolveSessionStoreAgentId(cfg, canonicalKey))) !== agentId) return {
+				ok: false,
+				error: errorShape(ErrorCodes.INVALID_REQUEST, "session key agent does not match agentId")
+			};
+		}
+		return {
+			ok: true,
+			agentId
+		};
+	}
+	if (!parsed?.agentId) return { ok: true };
+	const inferredAgentId = normalizeAgentId(parsed.agentId);
+	if (canonicalKey === "global" && !listAgentIds(cfg).includes(inferredAgentId)) return {
+		ok: false,
+		error: errorShape(ErrorCodes.INVALID_REQUEST, `Unknown agent id "${parsed.agentId}"`)
+	};
+	return {
+		ok: true,
+		agentId: canonicalKey === "global" ? inferredAgentId : void 0
+	};
+}
+async function interruptSessionRunIfActive(params) {
+	const cfg = params.context.getRuntimeConfig();
+	const hasTrackedRun = hasTrackedActiveSessionRun({
+		context: params.context,
+		requestedKey: params.requestedKey,
+		canonicalKey: params.canonicalKey,
+		agentId: params.agentId,
+		defaultAgentId: resolveDefaultAgentId(cfg)
+	});
+	const hasEmbeddedRun = typeof params.sessionId === "string" && params.sessionId ? isEmbeddedAgentRunActive(params.sessionId) : false;
+	if (!hasTrackedRun && !hasEmbeddedRun) return { interrupted: false };
+	if (hasTrackedRun) {
+		let abortOk = true;
+		let abortError;
+		const abortSessionKey = resolveAbortSessionKey({
+			context: params.context,
+			requestedKey: params.requestedKey,
+			canonicalKey: params.canonicalKey
+		});
+		await chatHandlers["chat.abort"]({
+			req: params.req,
+			params: {
+				sessionKey: abortSessionKey,
+				...params.canonicalKey === "global" && params.agentId ? { agentId: params.agentId } : {}
+			},
+			respond: (ok, _payload, error) => {
+				abortOk = ok;
+				abortError = error;
+			},
+			context: params.context,
+			client: params.client,
+			isWebchatConnect: params.isWebchatConnect
+		});
+		if (!abortOk) return {
+			interrupted: true,
+			error: abortError ?? errorShape(ErrorCodes.UNAVAILABLE, "failed to interrupt active session")
+		};
+	}
+	if (hasEmbeddedRun && params.sessionId) abortEmbeddedAgentRun(params.sessionId);
+	clearSessionQueues([
+		params.requestedKey,
+		params.canonicalKey,
+		params.sessionId
+	]);
+	if (hasEmbeddedRun && params.sessionId) {
+		if (!await waitForEmbeddedAgentRunEnd(params.sessionId, 15e3)) return {
+			interrupted: true,
+			error: errorShape(ErrorCodes.UNAVAILABLE, `Session ${params.requestedKey} is still active; try again in a moment.`)
+		};
+	}
+	return { interrupted: true };
+}
+async function handleSessionSend(params) {
+	if (!assertValidParams(params.params, validateSessionsSendParams, params.method, params.respond)) return;
+	const p = params.params;
+	const key = requireSessionKey(p.key, params.respond);
+	if (!key) return;
+	const cfg = params.context.getRuntimeConfig();
+	const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, p.agentId);
+	if (!requestedAgent.ok) {
+		params.respond(false, void 0, requestedAgent.error);
+		return;
+	}
+	const requestedAgentId = requestedAgent.agentId;
+	let { entry, canonicalKey, storePath } = loadSessionEntry(key, { agentId: requestedAgentId });
+	const deletedAgentId = resolveDeletedAgentIdFromSessionKey(cfg, canonicalKey);
+	if (deletedAgentId !== null) {
+		params.respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `Agent "${deletedAgentId}" no longer exists in configuration`));
+		return;
+	}
+	if (!entry?.sessionId && !params.interruptIfActive && isAgentMainSessionKey(cfg, canonicalKey)) {
+		const created = await createAgentMainSessionForSend({
+			req: params.req,
+			canonicalKey,
+			context: params.context,
+			client: params.client,
+			isWebchatConnect: params.isWebchatConnect
+		});
+		if (!created.ok) {
+			params.respond(false, void 0, created.error);
+			return;
+		}
+		entry = created.entry;
+		canonicalKey = created.canonicalKey;
+		storePath = created.storePath;
+	}
+	if (!entry?.sessionId) {
+		params.respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `session not found: ${key}`));
+		return;
+	}
+	let interruptedActiveRun = false;
+	if (params.interruptIfActive) {
+		const interruptResult = await interruptSessionRunIfActive({
+			req: params.req,
+			context: params.context,
+			client: params.client,
+			isWebchatConnect: params.isWebchatConnect,
+			requestedKey: key,
+			canonicalKey,
+			agentId: requestedAgentId,
+			sessionId: entry.sessionId
+		});
+		if (interruptResult.error) {
+			params.respond(false, void 0, interruptResult.error);
+			return;
+		}
+		interruptedActiveRun = interruptResult.interrupted;
+	}
+	const messageSeq = await readSessionMessageCountAsync(entry.sessionId, storePath, entry.sessionFile) + 1;
+	let sendAcked = false;
+	let sendPayload;
+	let sendCached = false;
+	let startedRunId;
+	const rawIdempotencyKey = p.idempotencyKey;
+	const idempotencyKey = typeof rawIdempotencyKey === "string" && rawIdempotencyKey.trim() ? rawIdempotencyKey.trim() : randomUUID();
+	await chatHandlers["chat.send"]({
+		req: params.req,
+		params: {
+			sessionKey: canonicalKey,
+			...canonicalKey === "global" && requestedAgentId ? { agentId: requestedAgentId } : {},
+			message: p.message,
+			thinking: p.thinking,
+			attachments: p.attachments,
+			timeoutMs: p.timeoutMs,
+			idempotencyKey
+		},
+		respond: (ok, payload, error, meta) => {
+			sendAcked = ok;
+			sendPayload = payload;
+			sendCached = meta?.cached === true;
+			startedRunId = payload && typeof payload === "object" && typeof payload.runId === "string" ? payload.runId : void 0;
+			if (ok && shouldAttachPendingMessageSeq({
+				payload,
+				cached: meta?.cached === true
+			})) {
+				params.respond(true, {
+					...payload && typeof payload === "object" ? payload : {},
+					messageSeq,
+					...interruptedActiveRun ? { interruptedActiveRun: true } : {}
+				}, void 0, meta);
+				return;
+			}
+			params.respond(ok, ok && payload && typeof payload === "object" ? {
+				...payload,
+				...interruptedActiveRun ? { interruptedActiveRun: true } : {}
+			} : payload, error, meta);
+		},
+		context: params.context,
+		client: params.client,
+		isWebchatConnect: params.isWebchatConnect
+	});
+	if (sendAcked) {
+		if (shouldAttachPendingMessageSeq({
+			payload: sendPayload,
+			cached: sendCached
+		})) await reactivateCompletedSubagentSession({
+			sessionKey: canonicalKey,
+			runId: startedRunId
+		});
+		emitSessionsChanged(params.context, {
+			sessionKey: canonicalKey,
+			...canonicalKey === "global" && requestedAgentId ? { agentId: requestedAgentId } : {},
+			reason: interruptedActiveRun ? "steer" : "send"
+		});
+	}
+}
+const sessionsHandlers = {
+	"sessions.list": async ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsListParams, "sessions.list", respond)) return;
+		const p = params;
+		const cfg = context.getRuntimeConfig();
+		const configuredAgentsOnly = p.configuredAgentsOnly === true;
+		respond(true, await measureDiagnosticsTimelineSpan("gateway.sessions.list", async () => {
+			const { storePath, store } = measureDiagnosticsTimelineSpanSync("gateway.sessions.list.store_load", () => loadCombinedSessionStoreForGateway(cfg, { agentId: p.agentId }), {
+				config: cfg,
+				phase: "sessions.list",
+				attributes: {
+					agentId: p.agentId ?? null,
+					configuredAgentsOnly
+				}
+			});
+			const listStore = configuredAgentsOnly ? filterSessionStoreToConfiguredAgents(cfg, store) : store;
+			const modelCatalog = await measureDiagnosticsTimelineSpan("gateway.sessions.list.model_catalog", () => loadOptionalSessionsListModelCatalog(context), {
+				config: cfg,
+				phase: "sessions.list"
+			});
+			const result = await measureDiagnosticsTimelineSpan("gateway.sessions.list.rows", () => listSessionsFromStoreAsync({
+				cfg,
+				storePath,
+				store: listStore,
+				modelCatalog,
+				opts: p
+			}), {
+				config: cfg,
+				phase: "sessions.list",
+				attributes: { storeEntries: Object.keys(listStore).length }
+			});
+			const sessions = measureDiagnosticsTimelineSpanSync("gateway.sessions.list.active_run_flags", () => {
+				const activeRuns = collectTrackedActiveSessionRuns(context);
+				return result.sessions.map((session) => Object.assign({}, session, { hasActiveRun: activeRuns.some((active) => isTrackedActiveSessionRunForKey(active, session.key, session.key === "global" ? p.agentId : void 0, resolveDefaultAgentId(cfg))) }));
+			}, {
+				config: cfg,
+				phase: "sessions.list",
+				attributes: { sessions: result.sessions.length }
+			});
+			return {
+				...result,
+				sessions
+			};
+		}, {
+			config: cfg,
+			phase: "sessions.list",
+			attributes: {
+				agentId: p.agentId ?? null,
+				configuredAgentsOnly
+			}
+		}), void 0);
+	},
+	"sessions.cleanup": async ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsCleanupParams, "sessions.cleanup", respond)) return;
+		const p = params;
+		try {
+			const { mode, appliedSummaries } = await runSessionsCleanup({
+				cfg: context.getRuntimeConfig(),
+				opts: {
+					agent: p.agent,
+					allAgents: p.allAgents,
+					enforce: p.enforce,
+					activeKey: p.activeKey,
+					fixMissing: p.fixMissing,
+					fixDmScope: p.fixDmScope
+				}
+			});
+			respond(true, serializeSessionCleanupResult({
+				mode,
+				dryRun: false,
+				summaries: appliedSummaries
+			}), void 0);
+			for (const summary of appliedSummaries) {
+				emitSessionsChanged(context, {
+					reason: "cleanup",
+					sessionKey: void 0
+				});
+				if (summary.wouldMutate) context.logGateway.debug(`sessions.cleanup applied ${summary.storePath}: ${summary.beforeCount} -> ${summary.afterCount}`);
+			}
+		} catch (error) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, formatErrorMessage(error)));
+		}
+	},
+	"sessions.subscribe": ({ client, context, respond }) => {
+		const connId = client?.connId?.trim();
+		if (connId) context.subscribeSessionEvents(connId);
+		respond(true, { subscribed: Boolean(connId) }, void 0);
+	},
+	"sessions.unsubscribe": ({ client, context, respond }) => {
+		const connId = client?.connId?.trim();
+		if (connId) context.unsubscribeSessionEvents(connId);
+		respond(true, { subscribed: false }, void 0);
+	},
+	"sessions.messages.subscribe": ({ params, client, context, respond }) => {
+		if (!assertValidParams(params, validateSessionsMessagesSubscribeParams, "sessions.messages.subscribe", respond)) return;
+		const connId = client?.connId?.trim();
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const cfg = context.getRuntimeConfig();
+		const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const requestedAgentId = requestedAgent.agentId;
+		const { canonicalKey } = loadSessionEntry(key, { agentId: requestedAgentId });
+		const subscriptionKey = resolveSessionMessageSubscriptionKey({
+			canonicalKey,
+			agentId: requestedAgentId,
+			defaultAgentId: resolveDefaultAgentId(cfg)
+		});
+		if (connId) {
+			context.subscribeSessionMessageEvents(connId, subscriptionKey);
+			respond(true, {
+				subscribed: true,
+				key: canonicalKey
+			}, void 0);
+			return;
+		}
+		respond(true, {
+			subscribed: false,
+			key: canonicalKey
+		}, void 0);
+	},
+	"sessions.messages.unsubscribe": ({ params, client, context, respond }) => {
+		if (!assertValidParams(params, validateSessionsMessagesUnsubscribeParams, "sessions.messages.unsubscribe", respond)) return;
+		const connId = client?.connId?.trim();
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const cfg = context.getRuntimeConfig();
+		const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const requestedAgentId = requestedAgent.agentId;
+		const { canonicalKey } = loadSessionEntry(key, { agentId: requestedAgentId });
+		const subscriptionKey = resolveSessionMessageSubscriptionKey({
+			canonicalKey,
+			agentId: requestedAgentId,
+			defaultAgentId: resolveDefaultAgentId(cfg)
+		});
+		if (connId) context.unsubscribeSessionMessageEvents(connId, subscriptionKey);
+		respond(true, {
+			subscribed: false,
+			key: canonicalKey
+		}, void 0);
+	},
+	"sessions.preview": ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsPreviewParams, "sessions.preview", respond)) return;
+		const p = params;
+		const keys = (Array.isArray(p.keys) ? p.keys : []).map((key) => normalizeOptionalString(key ?? "")).filter((key) => Boolean(key)).slice(0, 64);
+		const limit = typeof p.limit === "number" && Number.isFinite(p.limit) ? Math.max(1, p.limit) : 12;
+		const maxChars = typeof p.maxChars === "number" && Number.isFinite(p.maxChars) ? Math.max(20, p.maxChars) : 240;
+		if (keys.length === 0) {
+			respond(true, {
+				ts: Date.now(),
+				previews: []
+			}, void 0);
+			return;
+		}
+		const cfg = context.getRuntimeConfig();
+		const storeCache = /* @__PURE__ */ new Map();
+		const previews = [];
+		for (const key of keys) try {
+			const storeTarget = resolveGatewaySessionStoreTarget({
+				cfg,
+				key,
+				scanLegacyKeys: false
+			});
+			const store = storeCache.get(storeTarget.storePath) ?? loadSessionStore(storeTarget.storePath);
+			storeCache.set(storeTarget.storePath, store);
+			const target = resolveGatewaySessionStoreTarget({
+				cfg,
+				key,
+				store
+			});
+			const entry = resolveFreshestSessionEntryFromStoreKeys(store, target.storeKeys);
+			if (!entry?.sessionId) {
+				previews.push({
+					key,
+					status: "missing",
+					items: []
+				});
+				continue;
+			}
+			const items = readSessionPreviewItemsFromTranscript(entry.sessionId, target.storePath, entry.sessionFile, target.agentId, limit, maxChars);
+			previews.push({
+				key,
+				status: items.length > 0 ? "ok" : "empty",
+				items
+			});
+		} catch {
+			previews.push({
+				key,
+				status: "error",
+				items: []
+			});
+		}
+		respond(true, {
+			ts: Date.now(),
+			previews
+		}, void 0);
+	},
+	"sessions.describe": ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsDescribeParams, "sessions.describe", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const cfg = context.getRuntimeConfig();
+		const { target, storePath } = resolveGatewaySessionTargetFromKey(key, cfg);
+		const store = loadSessionStore(storePath);
+		const entry = resolveFreshestSessionEntryFromStoreKeys(store, target.storeKeys);
+		if (!entry) {
+			respond(true, { session: null }, void 0);
+			return;
+		}
+		respond(true, { session: buildGatewaySessionRow({
+			cfg,
+			storePath,
+			store,
+			key: target.canonicalKey,
+			entry,
+			includeDerivedTitles: p.includeDerivedTitles,
+			includeLastMessage: p.includeLastMessage,
+			transcriptUsageMaxBytes: 64 * 1024
+		}) }, void 0);
+	},
+	"sessions.resolve": async ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsResolveParams, "sessions.resolve", respond)) return;
+		const p = params;
+		const resolved = await resolveSessionKeyFromResolveParams({
+			cfg: context.getRuntimeConfig(),
+			p
+		});
+		if (!resolved.ok) {
+			respond(false, void 0, resolved.error);
+			return;
+		}
+		respond(true, {
+			ok: true,
+			key: resolved.key
+		}, void 0);
+	},
+	"sessions.compaction.list": ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsCompactionListParams, "sessions.compaction.list", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const requestedAgent = resolveRequestedGlobalAgentId(context.getRuntimeConfig(), key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const { entry, canonicalKey } = loadSessionEntry(key, { agentId: requestedAgent.agentId });
+		respond(true, {
+			ok: true,
+			key: canonicalKey,
+			checkpoints: listSessionCompactionCheckpoints(entry)
+		}, void 0);
+	},
+	"sessions.compaction.get": ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsCompactionGetParams, "sessions.compaction.get", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const checkpointId = normalizeOptionalString(p.checkpointId) ?? "";
+		if (!checkpointId) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "checkpointId required"));
+			return;
+		}
+		const requestedAgent = resolveRequestedGlobalAgentId(context.getRuntimeConfig(), key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const { entry, canonicalKey } = loadSessionEntry(key, { agentId: requestedAgent.agentId });
+		const checkpoint = getSessionCompactionCheckpoint({
+			entry,
+			checkpointId
+		});
+		if (!checkpoint) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `checkpoint not found: ${checkpointId}`));
+			return;
+		}
+		respond(true, {
+			ok: true,
+			key: canonicalKey,
+			checkpoint
+		}, void 0);
+	},
+	"sessions.create": async ({ req, params, respond, context, client, isWebchatConnect }) => {
+		if (!assertValidParams(params, validateSessionsCreateParams, "sessions.create", respond)) return;
+		const p = params;
+		const cfg = context.getRuntimeConfig();
+		const requestedKey = normalizeOptionalString(p.key);
+		const agentId = normalizeAgentId(normalizeOptionalString(p.agentId) ?? resolveDefaultAgentId(cfg));
+		if (requestedKey) {
+			const requestedAgentId = parseAgentSessionKey(requestedKey)?.agentId;
+			if (requestedAgentId && requestedAgentId !== agentId && normalizeOptionalString(p.agentId)) {
+				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `sessions.create key agent (${requestedAgentId}) does not match agentId (${agentId})`));
+				return;
+			}
+		}
+		const parentSessionKey = normalizeOptionalString(p.parentSessionKey);
+		let canonicalParentSessionKey;
+		let parentSessionEntry;
+		let parentSelectedAgentId;
+		if (parentSessionKey) {
+			if (resolveSessionStoreKey({
+				cfg,
+				sessionKey: parentSessionKey
+			}) === "global") {
+				const parentRequestedAgent = resolveRequestedGlobalAgentId(cfg, parentSessionKey, p.agentId);
+				if (!parentRequestedAgent.ok) {
+					respond(false, void 0, parentRequestedAgent.error);
+					return;
+				}
+				parentSelectedAgentId = parentRequestedAgent.agentId;
+			}
+			const parent = loadSessionEntry(parentSessionKey, parentSelectedAgentId ? { agentId: parentSelectedAgentId } : void 0);
+			if (!parent.entry?.sessionId) {
+				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `unknown parent session: ${parentSessionKey}`));
+				return;
+			}
+			canonicalParentSessionKey = parent.canonicalKey;
+			parentSessionEntry = parent.entry;
+		}
+		if (canonicalParentSessionKey && p.emitCommandHooks === true && !requestedKey && !resolveOptionalInitialSessionMessage(p) && cfg.session?.dmScope === "main") {
+			const parentMainKey = resolveAgentMainSessionKey({
+				cfg,
+				agentId: normalizeAgentId(parentSelectedAgentId ?? resolveAgentIdFromSessionKey(canonicalParentSessionKey) ?? resolveDefaultAgentId(cfg))
+			});
+			if (canonicalParentSessionKey === parentMainKey) {
+				const { performGatewaySessionReset } = await loadSessionsRuntimeModule();
+				const resetResult = await performGatewaySessionReset({
+					key: canonicalParentSessionKey,
+					...canonicalParentSessionKey === "global" && parentSelectedAgentId ? { agentId: parentSelectedAgentId } : {},
+					reason: "new",
+					commandSource: "webchat"
+				});
+				if (!resetResult.ok) {
+					respond(false, void 0, resetResult.error);
+					return;
+				}
+				respond(true, {
+					ok: true,
+					key: resetResult.key,
+					sessionId: resetResult.entry.sessionId,
+					entry: resetResult.entry,
+					runStarted: false
+				}, void 0);
+				emitSessionsChanged(context, {
+					sessionKey: resetResult.key,
+					...resetResult.key === "global" ? { agentId: resetResult.agentId } : {},
+					reason: "new"
+				});
+				return;
+			}
+		}
+		if (canonicalParentSessionKey && p.emitCommandHooks === true) {
+			const { entry: parentEntry } = loadSessionEntry(canonicalParentSessionKey, parentSelectedAgentId ? { agentId: parentSelectedAgentId } : void 0);
+			const workspaceDir = resolveAgentWorkspaceDir(cfg, normalizeAgentId(parentSelectedAgentId ?? resolveAgentIdFromSessionKey(canonicalParentSessionKey) ?? resolveDefaultAgentId(cfg)));
+			if (hasInternalHookListeners("command", "new")) await triggerInternalHook(createInternalHookEvent("command", "new", canonicalParentSessionKey, {
+				sessionEntry: parentEntry,
+				previousSessionEntry: parentEntry,
+				commandSource: "webchat",
+				cfg,
+				workspaceDir
+			}));
+			const parentTarget = resolveGatewaySessionStoreTarget({
+				cfg,
+				key: canonicalParentSessionKey,
+				...canonicalParentSessionKey === "global" && parentSelectedAgentId ? { agentId: parentSelectedAgentId } : {}
+			});
+			const { emitGatewayBeforeResetPluginHook } = await loadSessionsRuntimeModule();
+			await emitGatewayBeforeResetPluginHook({
+				cfg,
+				key: canonicalParentSessionKey,
+				target: parentTarget,
+				storePath: parentTarget.storePath,
+				entry: parentEntry,
+				reason: "new"
+			});
+		}
+		const loweredRequestedKey = normalizeOptionalLowercaseString(requestedKey);
+		const target = resolveGatewaySessionStoreTarget({
+			cfg,
+			key: requestedKey ? loweredRequestedKey === "global" || loweredRequestedKey === "unknown" ? loweredRequestedKey : toAgentStoreSessionKey({
+				agentId,
+				requestKey: requestedKey,
+				mainKey: cfg.session?.mainKey
+			}) : buildDashboardSessionKey(agentId),
+			agentId
+		});
+		const targetAgentId = target.agentId;
+		const created = await updateSessionStore(target.storePath, async (store) => {
+			const patched = await applySessionsPatchToStore({
+				cfg,
+				store,
+				storeKey: target.canonicalKey,
+				agentId: targetAgentId,
+				patch: {
+					key: target.canonicalKey,
+					label: normalizeOptionalString(p.label),
+					model: normalizeOptionalString(p.model)
+				},
+				loadGatewayModelCatalog: context.loadGatewayModelCatalog
+			});
+			if (!patched.ok || !canonicalParentSessionKey) return patched;
+			const inheritedSelection = normalizeOptionalString(p.model) ? {} : inheritSessionRuntimeSelection(parentSessionEntry);
+			const nextEntry = {
+				...patched.entry,
+				...inheritedSelection,
+				parentSessionKey: canonicalParentSessionKey
+			};
+			store[target.canonicalKey] = nextEntry;
+			return {
+				...patched,
+				entry: nextEntry
+			};
+		});
+		if (!created.ok) {
+			respond(false, void 0, created.error);
+			return;
+		}
+		const ensured = ensureSessionTranscriptFile({
+			sessionId: created.entry.sessionId,
+			storePath: target.storePath,
+			sessionFile: created.entry.sessionFile,
+			agentId: targetAgentId
+		});
+		if (!ensured.ok) {
+			await updateSessionStore(target.storePath, (store) => {
+				delete store[target.canonicalKey];
+			});
+			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, `failed to create session transcript: ${ensured.error}`));
+			return;
+		}
+		const createdEntry = created.entry.sessionFile === ensured.transcriptPath ? created.entry : {
+			...created.entry,
+			sessionFile: ensured.transcriptPath
+		};
+		if (createdEntry !== created.entry) await updateSessionStore(target.storePath, (store) => {
+			const existing = store[target.canonicalKey];
+			if (existing) store[target.canonicalKey] = {
+				...existing,
+				sessionFile: ensured.transcriptPath
+			};
+		});
+		const initialMessage = resolveOptionalInitialSessionMessage(p);
+		let runPayload;
+		let runError;
+		let runMeta;
+		const messageSeq = initialMessage ? await readSessionMessageCountAsync(createdEntry.sessionId, target.storePath, createdEntry.sessionFile) + 1 : void 0;
+		if (initialMessage) await chatHandlers["chat.send"]({
+			req,
+			params: {
+				sessionKey: target.canonicalKey,
+				...target.canonicalKey === "global" ? { agentId: target.agentId } : {},
+				message: initialMessage,
+				idempotencyKey: randomUUID()
+			},
+			respond: (ok, payload, error, meta) => {
+				if (ok && payload && typeof payload === "object") runPayload = payload;
+				else runError = error;
+				runMeta = meta;
+			},
+			context,
+			client,
+			isWebchatConnect
+		});
+		const runStarted = runPayload !== void 0 && shouldAttachPendingMessageSeq({
+			payload: runPayload,
+			cached: runMeta?.cached === true
+		});
+		respond(true, {
+			ok: true,
+			key: target.canonicalKey,
+			sessionId: createdEntry.sessionId,
+			entry: createdEntry,
+			runStarted,
+			...runPayload ? runPayload : {},
+			...runStarted && typeof messageSeq === "number" ? { messageSeq } : {},
+			...runError ? { runError } : {}
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: target.canonicalKey,
+			...target.canonicalKey === "global" ? { agentId: target.agentId } : {},
+			reason: "create"
+		});
+		if (runStarted) emitSessionsChanged(context, {
+			sessionKey: target.canonicalKey,
+			...target.canonicalKey === "global" ? { agentId: target.agentId } : {},
+			reason: "send"
+		});
+		if (canonicalParentSessionKey && p.emitCommandHooks === true) {
+			const { entry: parentEntry } = loadSessionEntry(canonicalParentSessionKey, parentSelectedAgentId ? { agentId: parentSelectedAgentId } : void 0);
+			const parentTarget = resolveGatewaySessionStoreTarget({
+				cfg,
+				key: canonicalParentSessionKey,
+				...canonicalParentSessionKey === "global" && parentSelectedAgentId ? { agentId: parentSelectedAgentId } : {}
+			});
+			const { emitGatewaySessionEndPluginHook, emitGatewaySessionStartPluginHook } = await loadSessionsRuntimeModule();
+			emitGatewaySessionEndPluginHook({
+				cfg,
+				sessionKey: canonicalParentSessionKey,
+				sessionId: parentEntry?.sessionId,
+				storePath: parentTarget.storePath,
+				sessionFile: parentEntry?.sessionFile,
+				agentId: parentTarget.agentId,
+				reason: "new",
+				nextSessionId: createdEntry.sessionId,
+				nextSessionKey: target.canonicalKey
+			});
+			emitGatewaySessionStartPluginHook({
+				cfg,
+				sessionKey: target.canonicalKey,
+				sessionId: createdEntry.sessionId,
+				resumedFrom: parentEntry?.sessionId,
+				storePath: target.storePath,
+				sessionFile: createdEntry.sessionFile,
+				agentId: target.agentId
+			});
+		}
+	},
+	"sessions.compaction.branch": async ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsCompactionBranchParams, "sessions.compaction.branch", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const checkpointId = typeof p.checkpointId === "string" && p.checkpointId.trim() ? p.checkpointId.trim() : "";
+		if (!checkpointId) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "checkpointId required"));
+			return;
+		}
+		const requestedAgent = resolveRequestedGlobalAgentId(context.getRuntimeConfig(), key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const { cfg: loadedCfg, entry, canonicalKey } = loadSessionEntry(key, { agentId: requestedAgent.agentId });
+		const target = resolveGatewaySessionStoreTarget({
+			cfg: loadedCfg,
+			key: canonicalKey,
+			agentId: requestedAgent.agentId
+		});
+		if (!entry?.sessionId) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `session not found: ${key}`));
+			return;
+		}
+		const checkpoint = getSessionCompactionCheckpoint({
+			entry,
+			checkpointId
+		});
+		const forkSource = checkpoint ? resolveCheckpointForkSource(checkpoint) : null;
+		if (!checkpoint || !forkSource) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `checkpoint not found: ${checkpointId}`));
+			return;
+		}
+		const branchedSession = await forkCompactionCheckpointTranscriptAsync({
+			sourceFile: forkSource.sourceFile,
+			sourceLeafId: forkSource.sourceLeafId,
+			sessionDir: path.dirname(forkSource.sourceFile)
+		});
+		if (!branchedSession?.sessionFile) {
+			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, "failed to create checkpoint branch transcript"));
+			return;
+		}
+		const nextKey = buildDashboardSessionKey(target.agentId);
+		const label = entry.label?.trim() ? `${entry.label.trim()} (checkpoint)` : "Checkpoint branch";
+		const nextEntry = cloneCheckpointSessionEntry({
+			currentEntry: entry,
+			nextSessionId: branchedSession.sessionId,
+			nextSessionFile: branchedSession.sessionFile,
+			label,
+			parentSessionKey: canonicalKey,
+			totalTokens: forkSource.totalTokens
+		});
+		await updateSessionStore(target.storePath, (store) => {
+			store[nextKey] = nextEntry;
+		});
+		respond(true, {
+			ok: true,
+			sourceKey: canonicalKey,
+			key: nextKey,
+			sessionId: nextEntry.sessionId,
+			checkpoint,
+			entry: nextEntry
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: canonicalKey,
+			...canonicalKey === "global" && requestedAgent.agentId ? { agentId: requestedAgent.agentId } : {},
+			reason: "checkpoint-branch"
+		});
+		emitSessionsChanged(context, {
+			sessionKey: nextKey,
+			reason: "checkpoint-branch"
+		});
+	},
+	"sessions.compaction.restore": async ({ req, params, respond, context, client, isWebchatConnect }) => {
+		if (!assertValidParams(params, validateSessionsCompactionRestoreParams, "sessions.compaction.restore", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		if (rejectWebchatSessionMutation({
+			action: "restore",
+			client,
+			isWebchatConnect,
+			respond
+		})) return;
+		const checkpointId = typeof p.checkpointId === "string" && p.checkpointId.trim() ? p.checkpointId.trim() : "";
+		if (!checkpointId) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "checkpointId required"));
+			return;
+		}
+		const requestedAgent = resolveRequestedGlobalAgentId(context.getRuntimeConfig(), key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const { entry, canonicalKey, storePath } = loadSessionEntry(key, { agentId: requestedAgent.agentId });
+		if (!entry?.sessionId) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `session not found: ${key}`));
+			return;
+		}
+		const checkpoint = getSessionCompactionCheckpoint({
+			entry,
+			checkpointId
+		});
+		const forkSource = checkpoint ? resolveCheckpointForkSource(checkpoint) : null;
+		if (!checkpoint || !forkSource) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `checkpoint not found: ${checkpointId}`));
+			return;
+		}
+		const interruptResult = await interruptSessionRunIfActive({
+			req,
+			context,
+			client,
+			isWebchatConnect,
+			requestedKey: key,
+			canonicalKey,
+			agentId: requestedAgent.agentId,
+			sessionId: entry.sessionId
+		});
+		if (interruptResult.error) {
+			respond(false, void 0, interruptResult.error);
+			return;
+		}
+		const restoredSession = await forkCompactionCheckpointTranscriptAsync({
+			sourceFile: forkSource.sourceFile,
+			sourceLeafId: forkSource.sourceLeafId,
+			sessionDir: path.dirname(forkSource.sourceFile)
+		});
+		if (!restoredSession?.sessionFile) {
+			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, "failed to restore checkpoint transcript"));
+			return;
+		}
+		const nextEntry = cloneCheckpointSessionEntry({
+			currentEntry: entry,
+			nextSessionId: restoredSession.sessionId,
+			nextSessionFile: restoredSession.sessionFile,
+			totalTokens: forkSource.totalTokens,
+			preserveCompactionCheckpoints: true
+		});
+		await updateSessionStore(storePath, (store) => {
+			store[canonicalKey] = nextEntry;
+		});
+		respond(true, {
+			ok: true,
+			key: canonicalKey,
+			sessionId: nextEntry.sessionId,
+			checkpoint,
+			entry: nextEntry
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: canonicalKey,
+			...canonicalKey === "global" && requestedAgent.agentId ? { agentId: requestedAgent.agentId } : {},
+			reason: "checkpoint-restore"
+		});
+	},
+	"sessions.send": async ({ req, params, respond, context, client, isWebchatConnect }) => {
+		await handleSessionSend({
+			method: "sessions.send",
+			req,
+			params,
+			respond,
+			context,
+			client,
+			isWebchatConnect,
+			interruptIfActive: false
+		});
+	},
+	"sessions.steer": async ({ req, params, respond, context, client, isWebchatConnect }) => {
+		await handleSessionSend({
+			method: "sessions.steer",
+			req,
+			params,
+			respond,
+			context,
+			client,
+			isWebchatConnect,
+			interruptIfActive: true
+		});
+	},
+	"sessions.abort": async ({ req, params, respond, context, client, isWebchatConnect }) => {
+		if (!assertValidParams(params, validateSessionsAbortParams, "sessions.abort", respond)) return;
+		const p = params;
+		const cfg = context.getRuntimeConfig();
+		const requestedRunId = readStringValue(p.runId);
+		const requestedKey = normalizeOptionalString(p.key);
+		const requestedParamAgentId = normalizeOptionalString(p.agentId);
+		const scopedRequestedKey = resolveScopedAbortKey({
+			cfg,
+			key: requestedKey,
+			agentId: requestedParamAgentId
+		});
+		if (requestedKey && requestedParamAgentId && !scopedRequestedKey) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "session key agent does not match agentId"));
+			return;
+		}
+		const requestedKeyAgentId = scopedRequestedKey ? resolveSessionKeyAgentId(scopedRequestedKey, cfg) : void 0;
+		const activeRun = requestedRunId ? context.chatAbortControllers.get(requestedRunId) : void 0;
+		const activeRunSessionKey = activeRun?.sessionKey;
+		const activeRunAgentId = normalizeOptionalString(activeRun?.agentId);
+		const inferredRunAgentId = requestedParamAgentId ?? (requestedRunId && scopedRequestedKey?.toLowerCase() === "global" ? activeRunAgentId : void 0) ?? requestedKeyAgentId ?? (requestedRunId && !activeRunSessionKey ? resolveDefaultAgentId(cfg) : void 0);
+		const requestedRunAgentId = requestedRunId ? inferredRunAgentId ? normalizeAgentId(inferredRunAgentId) : void 0 : void 0;
+		const scopedActiveRunSessionKey = activeRunSessionKey ? requestedRunAgentId ? sessionKeyBelongsToAgent(activeRunSessionKey, requestedRunAgentId, cfg) ? activeRunSessionKey : void 0 : activeRunSessionKey : void 0;
+		const keyCandidate = scopedRequestedKey ?? scopedActiveRunSessionKey ?? (requestedRunId ? resolveSessionKeyForRun(requestedRunId, { agentId: requestedRunAgentId ?? resolveDefaultAgentId(cfg) }) : void 0);
+		if (!keyCandidate && requestedRunId) {
+			respond(true, {
+				ok: true,
+				abortedRunId: null,
+				status: "no-active-run"
+			});
+			return;
+		}
+		const key = requireSessionKey(keyCandidate, respond);
+		if (!key) return;
+		const requestedGlobalAgent = resolveRequestedGlobalAgentId(cfg, key, requestedParamAgentId ?? requestedRunAgentId);
+		if (!requestedGlobalAgent.ok) {
+			respond(false, void 0, requestedGlobalAgent.error);
+			return;
+		}
+		const requestedGlobalAgentId = requestedGlobalAgent.agentId;
+		const { canonicalKey } = loadSessionEntry(key, { agentId: requestedGlobalAgentId });
+		const resolvedAbortSessionKey = resolveAbortSessionKey({
+			context,
+			requestedKey: key,
+			canonicalKey,
+			activeRunSessionKey: scopedActiveRunSessionKey,
+			aliasKeys: requestedKey && requestedKey !== key && (!requestedParamAgentId || sessionKeyBelongsToAgent(requestedKey, requestedParamAgentId, cfg)) ? [requestedKey] : void 0
+		});
+		const abortSessionKey = canonicalKey === "global" && requestedGlobalAgentId ? "global" : resolvedAbortSessionKey;
+		const abortAgentId = abortSessionKey === "global" ? requestedGlobalAgentId ?? activeRunAgentId : void 0;
+		const preAbortRunKinds = /* @__PURE__ */ new Map();
+		if (requestedRunId) preAbortRunKinds.set(requestedRunId, context.chatAbortControllers.get(requestedRunId)?.kind);
+		else for (const [rid, entry] of context.chatAbortControllers) preAbortRunKinds.set(rid, entry.kind);
+		let abortedRunId = null;
+		await chatHandlers["chat.abort"]({
+			req,
+			params: {
+				sessionKey: abortSessionKey,
+				runId: requestedRunId,
+				...abortAgentId ? { agentId: abortAgentId } : {}
+			},
+			respond: (ok, payload, error, meta) => {
+				if (!ok) {
+					respond(ok, payload, error, meta);
+					return;
+				}
+				const firstAbortedRunId = (payload && typeof payload === "object" && Array.isArray(payload.runIds) ? payload.runIds.filter((value) => Boolean(normalizeOptionalString(value))) : [])[0] ?? null;
+				abortedRunId = firstAbortedRunId;
+				if (firstAbortedRunId) {
+					const endedAt = Date.now();
+					const dedupePrefix = preAbortRunKinds.get(firstAbortedRunId) === "agent" ? "agent" : "chat";
+					setGatewayDedupeEntry({
+						dedupe: context.dedupe,
+						key: `${dedupePrefix}:${firstAbortedRunId}`,
+						entry: {
+							ts: endedAt,
+							ok: true,
+							payload: {
+								status: "timeout",
+								runId: firstAbortedRunId,
+								...abortAgentId ? { agentId: abortAgentId } : {},
+								stopReason: "rpc",
+								endedAt
+							}
+						}
+					});
+				}
+				respond(true, {
+					ok: true,
+					abortedRunId,
+					status: abortedRunId ? "aborted" : "no-active-run"
+				}, void 0, meta);
+			},
+			context,
+			client,
+			isWebchatConnect
+		});
+		if (abortedRunId) emitSessionsChanged(context, {
+			sessionKey: canonicalKey,
+			...canonicalKey === "global" && abortAgentId ? { agentId: abortAgentId } : {},
+			reason: "abort"
+		});
+	},
+	"sessions.patch": async ({ params, respond, context, client, isWebchatConnect }) => {
+		if (!assertValidParams(params, validateSessionsPatchParams, "sessions.patch", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		if (rejectWebchatSessionMutation({
+			action: "patch",
+			client,
+			isWebchatConnect,
+			respond
+		})) return;
+		const cfg = context.getRuntimeConfig();
+		const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const requestedAgentId = requestedAgent.agentId;
+		const { target, storePath } = resolveGatewaySessionTargetFromKey(key, cfg, { agentId: requestedAgentId });
+		const applied = await updateSessionStore(storePath, async (store) => {
+			const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+				cfg,
+				key,
+				store,
+				agentId: requestedAgentId
+			});
+			return await applySessionsPatchToStore({
+				cfg,
+				store,
+				storeKey: primaryKey,
+				agentId: requestedAgentId,
+				patch: p,
+				loadGatewayModelCatalog: context.loadGatewayModelCatalog
+			});
+		});
+		if (!applied.ok) {
+			respond(false, void 0, applied.error);
+			return;
+		}
+		triggerSessionPatchHook({
+			cfg,
+			sessionEntry: applied.entry,
+			sessionKey: target.canonicalKey ?? key,
+			patch: p
+		});
+		const parsed = parseAgentSessionKey(target.canonicalKey ?? key);
+		const agentId = normalizeAgentId(target.canonicalKey === "global" ? target.agentId : parsed?.agentId ?? resolveDefaultAgentId(cfg));
+		const resolved = resolveSessionModelRef(cfg, applied.entry, agentId);
+		const resolvedDisplayModel = resolveSessionDisplayModelIdentityRef({
+			cfg,
+			agentId,
+			provider: resolved.provider,
+			model: resolved.model
+		});
+		const agentRuntime = resolveModelAgentRuntimeMetadata({
+			cfg,
+			agentId,
+			provider: resolvedDisplayModel.provider,
+			model: resolvedDisplayModel.model,
+			sessionKey: target.canonicalKey ?? key,
+			acpRuntime: applied.entry?.acp != null,
+			acpBackend: applied.entry?.acp?.backend
+		});
+		respond(true, {
+			ok: true,
+			path: storePath,
+			key: target.canonicalKey,
+			entry: applied.entry,
+			resolved: {
+				modelProvider: resolvedDisplayModel.provider,
+				model: resolvedDisplayModel.model,
+				agentRuntime
+			}
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: target.canonicalKey,
+			...target.canonicalKey === "global" && requestedAgentId ? { agentId: requestedAgentId } : {},
+			reason: "patch"
+		});
+	},
+	"sessions.pluginPatch": async ({ params, respond, context, client, isWebchatConnect }) => {
+		if (!assertValidParams(params, validateSessionsPluginPatchParams, "sessions.pluginPatch", respond)) return;
+		const key = requireSessionKey(params.key, respond);
+		if (!key) return;
+		if (rejectWebchatSessionMutation({
+			action: "patch",
+			client,
+			isWebchatConnect,
+			respond
+		})) return;
+		if (!(Array.isArray(client?.connect.scopes) ? client.connect.scopes : []).includes("operator.admin")) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `sessions.pluginPatch requires gateway scope: ${ADMIN_SCOPE}`));
+			return;
+		}
+		const pluginId = normalizeOptionalString(params.pluginId);
+		const namespace = normalizeOptionalString(params.namespace);
+		if (!pluginId || !namespace) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "pluginId and namespace are required"));
+			return;
+		}
+		if (params.unset === true && params.value !== void 0) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "sessions.pluginPatch cannot specify both unset and value"));
+			return;
+		}
+		if (params.value !== void 0 && !isPluginJsonValue(params.value)) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "sessions.pluginPatch value must be JSON-compatible"));
+			return;
+		}
+		const patched = await patchPluginSessionExtension({
+			cfg: context.getRuntimeConfig(),
+			sessionKey: key,
+			pluginId,
+			namespace,
+			value: params.value,
+			unset: params.unset === true
+		});
+		if (!patched.ok) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, patched.error));
+			return;
+		}
+		respond(true, {
+			ok: true,
+			key: patched.key,
+			value: patched.value
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: patched.key,
+			reason: "plugin-patch"
+		});
+	},
+	"sessions.reset": async ({ params, respond, context }) => {
+		if (!assertValidParams(params, validateSessionsResetParams, "sessions.reset", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		const reason = p.reason === "new" ? "new" : "reset";
+		const { performGatewaySessionReset } = await loadSessionsRuntimeModule();
+		const result = await performGatewaySessionReset({
+			key,
+			...p.agentId ? { agentId: p.agentId } : {},
+			reason,
+			commandSource: "gateway:sessions.reset"
+		});
+		if (!result.ok) {
+			respond(false, void 0, result.error);
+			return;
+		}
+		respond(true, {
+			ok: true,
+			key: result.key,
+			entry: result.entry
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: result.key,
+			...result.key === "global" ? { agentId: result.agentId } : {},
+			reason
+		});
+	},
+	"sessions.delete": async ({ params, respond, client, isWebchatConnect, context }) => {
+		if (!assertValidParams(params, validateSessionsDeleteParams, "sessions.delete", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		if (rejectWebchatSessionMutation({
+			action: "delete",
+			client,
+			isWebchatConnect,
+			respond
+		})) return;
+		const cfg = context.getRuntimeConfig();
+		const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const requestedAgentId = requestedAgent.agentId;
+		const { target, storePath } = resolveGatewaySessionTargetFromKey(key, cfg, { agentId: requestedAgentId });
+		const mainKey = resolveMainSessionKey(cfg);
+		const isSelectedNonDefaultGlobal = target.canonicalKey === "global" && requestedAgentId !== void 0 && requestedAgentId !== resolveDefaultAgentId(cfg);
+		if (target.canonicalKey === mainKey && !isSelectedNonDefaultGlobal) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `Cannot delete the main session (${mainKey}).`));
+			return;
+		}
+		const deleteTranscript = typeof p.deleteTranscript === "boolean" ? p.deleteTranscript : true;
+		const { archiveSessionTranscriptsForSessionDetailed, cleanupSessionBeforeMutation, emitGatewaySessionEndPluginHook, emitSessionUnboundLifecycleEvent } = await loadSessionsRuntimeModule();
+		const { entry, legacyKey, canonicalKey } = loadSessionEntry(key, { agentId: requestedAgentId });
+		if (rejectPluginRuntimeDeleteMismatch({
+			client,
+			key: canonicalKey ?? key,
+			entry,
+			respond
+		})) return;
+		const mutationCleanupError = await cleanupSessionBeforeMutation({
+			cfg,
+			key,
+			target,
+			entry,
+			legacyKey,
+			canonicalKey,
+			reason: "session-delete"
+		});
+		if (mutationCleanupError) {
+			respond(false, void 0, mutationCleanupError);
+			return;
+		}
+		const sessionId = entry?.sessionId;
+		const deleted = await updateSessionStore(storePath, (store) => {
+			const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+				cfg,
+				key,
+				store,
+				agentId: requestedAgentId
+			});
+			const hadEntry = Boolean(store[primaryKey]);
+			if (hadEntry) delete store[primaryKey];
+			return hadEntry;
+		});
+		const archivedTranscripts = deleted && deleteTranscript ? archiveSessionTranscriptsForSessionDetailed({
+			sessionId,
+			storePath,
+			sessionFile: entry?.sessionFile,
+			agentId: target.agentId,
+			reason: "deleted"
+		}) : [];
+		const archived = archivedTranscripts.map((entry) => entry.archivedPath);
+		if (deleted) {
+			emitGatewaySessionEndPluginHook({
+				cfg,
+				sessionKey: target.canonicalKey ?? key,
+				sessionId,
+				storePath,
+				sessionFile: entry?.sessionFile,
+				agentId: target.agentId,
+				reason: "deleted",
+				archivedTranscripts
+			});
+			const emitLifecycleHooks = p.emitLifecycleHooks !== false;
+			await emitSessionUnboundLifecycleEvent({
+				targetSessionKey: target.canonicalKey ?? key,
+				reason: "session-delete",
+				emitHooks: emitLifecycleHooks
+			});
+		}
+		respond(true, {
+			ok: true,
+			key: target.canonicalKey,
+			deleted,
+			archived
+		}, void 0);
+		if (deleted) emitSessionsChanged(context, {
+			sessionKey: target.canonicalKey,
+			...target.canonicalKey === "global" && requestedAgentId ? { agentId: requestedAgentId } : {},
+			reason: "delete"
+		});
+	},
+	"sessions.get": async ({ params, respond, context }) => {
+		const p = params;
+		const key = requireSessionKey(p.key ?? p.sessionKey, respond);
+		if (!key) return;
+		const limit = typeof p.limit === "number" && Number.isFinite(p.limit) ? Math.max(1, Math.floor(p.limit)) : 200;
+		const cfg = context.getRuntimeConfig();
+		const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, normalizeOptionalString(p.agentId));
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const { target, storePath } = resolveGatewaySessionTargetFromKey(key, cfg, { agentId: requestedAgent.agentId });
+		const entry = resolveFreshestSessionEntryFromStoreKeys(loadSessionStore(storePath), target.storeKeys);
+		if (!entry?.sessionId) {
+			respond(true, { messages: [] }, void 0);
+			return;
+		}
+		const { messages } = await readRecentSessionMessagesWithStatsAsync(entry.sessionId, storePath, entry.sessionFile, {
+			maxMessages: limit,
+			maxLines: limit * 20 + 20
+		});
+		respond(true, { messages }, void 0);
+	},
+	"sessions.compact": async ({ req, params, respond, context, client, isWebchatConnect }) => {
+		if (!assertValidParams(params, validateSessionsCompactParams, "sessions.compact", respond)) return;
+		const p = params;
+		const key = requireSessionKey(p.key, respond);
+		if (!key) return;
+		if (rejectWebchatSessionMutation({
+			action: "compact",
+			client,
+			isWebchatConnect,
+			respond
+		})) return;
+		const maxLines = typeof p.maxLines === "number" && Number.isFinite(p.maxLines) ? Math.max(1, Math.floor(p.maxLines)) : void 0;
+		const cfg = context.getRuntimeConfig();
+		const requestedAgent = resolveRequestedGlobalAgentId(cfg, key, p.agentId);
+		if (!requestedAgent.ok) {
+			respond(false, void 0, requestedAgent.error);
+			return;
+		}
+		const requestedAgentId = requestedAgent.agentId;
+		const { target, storePath } = resolveGatewaySessionTargetFromKey(key, cfg, { agentId: requestedAgentId });
+		const compactTarget = await updateSessionStore(storePath, (store) => {
+			const { entry, primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+				cfg,
+				key,
+				store,
+				agentId: requestedAgentId
+			});
+			return {
+				entry,
+				primaryKey
+			};
+		});
+		const entry = compactTarget.entry;
+		const sessionId = entry?.sessionId;
+		if (!sessionId) {
+			respond(true, {
+				ok: true,
+				key: target.canonicalKey,
+				compacted: false,
+				reason: "no sessionId"
+			}, void 0);
+			return;
+		}
+		const filePath = resolveSessionTranscriptCandidates(sessionId, storePath, entry?.sessionFile, target.agentId).find((candidate) => fs.existsSync(candidate));
+		if (!filePath) {
+			respond(true, {
+				ok: true,
+				key: target.canonicalKey,
+				compacted: false,
+				reason: "no transcript"
+			}, void 0);
+			return;
+		}
+		if (maxLines === void 0) {
+			const interruptResult = await interruptSessionRunIfActive({
+				req,
+				context,
+				client,
+				isWebchatConnect,
+				requestedKey: key,
+				canonicalKey: target.canonicalKey,
+				agentId: requestedAgentId,
+				sessionId
+			});
+			if (interruptResult.error) {
+				respond(false, void 0, interruptResult.error);
+				return;
+			}
+			const resolvedModel = resolveSessionModelRef(cfg, entry, target.agentId);
+			const workspaceDir = normalizeOptionalString(entry?.spawnedWorkspaceDir) || resolveAgentWorkspaceDir(cfg, target.agentId);
+			const cwd = normalizeOptionalString(entry?.spawnedCwd);
+			const operationId = randomUUID();
+			emitSessionOperation(context, {
+				operationId,
+				operation: "compact",
+				phase: "start",
+				sessionKey: target.canonicalKey,
+				...target.canonicalKey === "global" && target.agentId ? { agentId: target.agentId } : {}
+			});
+			let result;
+			try {
+				result = await compactEmbeddedAgentSession({
+					sessionId,
+					sessionKey: target.canonicalKey,
+					agentId: target.agentId,
+					allowGatewaySubagentBinding: true,
+					sessionFile: filePath,
+					workspaceDir,
+					cwd,
+					config: cfg,
+					provider: resolvedModel.provider,
+					model: resolvedModel.model,
+					agentHarnessId: entry?.sessionId === sessionId ? entry.agentHarnessId : void 0,
+					thinkLevel: normalizeThinkLevel(entry?.thinkingLevel),
+					reasoningLevel: normalizeReasoningLevel(entry?.reasoningLevel),
+					bashElevated: {
+						enabled: false,
+						allowed: false,
+						defaultLevel: "off"
+					},
+					trigger: "manual"
+				});
+			} catch (err) {
+				emitSessionOperation(context, {
+					operationId,
+					operation: "compact",
+					phase: "end",
+					sessionKey: target.canonicalKey,
+					...target.canonicalKey === "global" && target.agentId ? { agentId: target.agentId } : {},
+					completed: false,
+					reason: formatErrorMessage(err)
+				});
+				throw err;
+			}
+			emitSessionOperation(context, {
+				operationId,
+				operation: "compact",
+				phase: "end",
+				sessionKey: target.canonicalKey,
+				...target.canonicalKey === "global" && target.agentId ? { agentId: target.agentId } : {},
+				completed: result.ok && result.compacted,
+				reason: result.reason
+			});
+			if (result.ok && result.compacted) await updateSessionStore(storePath, (store) => {
+				const entryToUpdate = store[compactTarget.primaryKey];
+				if (!entryToUpdate) return;
+				entryToUpdate.updatedAt = Date.now();
+				entryToUpdate.compactionCount = Math.max(0, entryToUpdate.compactionCount ?? 0) + 1;
+				if (result.result?.sessionId && result.result.sessionId !== entryToUpdate.sessionId) entryToUpdate.sessionId = result.result.sessionId;
+				if (result.result?.sessionFile) entryToUpdate.sessionFile = result.result.sessionFile;
+				delete entryToUpdate.inputTokens;
+				delete entryToUpdate.outputTokens;
+				delete entryToUpdate.contextBudgetStatus;
+				if (typeof result.result?.tokensAfter === "number" && Number.isFinite(result.result.tokensAfter)) {
+					entryToUpdate.totalTokens = result.result.tokensAfter;
+					entryToUpdate.totalTokensFresh = true;
+				} else {
+					delete entryToUpdate.totalTokens;
+					delete entryToUpdate.totalTokensFresh;
+				}
+			});
+			respond(true, {
+				ok: result.ok,
+				key: target.canonicalKey,
+				compacted: result.compacted,
+				reason: result.reason,
+				result: result.result
+			}, void 0);
+			if (result.ok) emitSessionsChanged(context, {
+				sessionKey: target.canonicalKey,
+				...target.canonicalKey === "global" && target.agentId ? { agentId: target.agentId } : {},
+				reason: "compact",
+				compacted: result.compacted
+			});
+			return;
+		}
+		const tail = readRecentSessionTranscriptLines({
+			sessionId,
+			storePath,
+			sessionFile: entry?.sessionFile,
+			agentId: target.agentId,
+			maxLines
+		});
+		const lines = tail?.lines ?? [];
+		const totalLines = tail?.totalLines ?? 0;
+		if (totalLines <= maxLines) {
+			respond(true, {
+				ok: true,
+				key: target.canonicalKey,
+				compacted: false,
+				kept: totalLines
+			}, void 0);
+			return;
+		}
+		const archived = archiveFileOnDisk(filePath, "bak");
+		fs.writeFileSync(filePath, `${lines.join("\n")}\n`, "utf-8");
+		await updateSessionStore(storePath, (store) => {
+			const entryToUpdate = store[compactTarget.primaryKey];
+			if (!entryToUpdate) return;
+			delete entryToUpdate.inputTokens;
+			delete entryToUpdate.outputTokens;
+			delete entryToUpdate.totalTokens;
+			delete entryToUpdate.totalTokensFresh;
+			delete entryToUpdate.contextBudgetStatus;
+			entryToUpdate.updatedAt = Date.now();
+		});
+		respond(true, {
+			ok: true,
+			key: target.canonicalKey,
+			compacted: true,
+			archived,
+			kept: lines.length
+		}, void 0);
+		emitSessionsChanged(context, {
+			sessionKey: target.canonicalKey,
+			...target.canonicalKey === "global" && target.agentId ? { agentId: target.agentId } : {},
+			reason: "compact",
+			compacted: true
+		});
+	}
+};
+//#endregion
+export { sessionsHandlers };