@pixelzx/genesis 2026.6.27 → 2026.6.28

package/dist/sessions-history-http-Bee2KxDh.js

@@ -1,371 +0,0 @@
-import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
-import { t as createSubsystemLogger } from "./subsystem-CNq69MoE.js";
-import { a as loadConfig } from "./io-Cy5vajWd.js";
-import "./config-DYHZ3jG1.js";
-import { n as authorizeOperatorScopesForMethod } from "./method-scopes-BkN09VAs.js";
-import { t as loadSessionStore } from "./store-load-DLkfg3iM.js";
-import "./sessions-kO7Dit6B.js";
-import { n as onSessionTranscriptUpdate } from "./transcript-events-fSaEyJxo.js";
-import { c as stripEnvelopeFromMessages, i as readSessionMessages, t as attachGenesisTranscriptMeta } from "./session-utils.fs-moBTdnuM.js";
-import { a as resolveSessionTranscriptCandidates } from "./session-transcript-files.fs-BoE3WpUU.js";
-import { d as resolveGatewaySessionStoreTarget, l as resolveFreshestSessionEntryFromStoreKeys } from "./session-utils-Dkaj_4dZ.js";
-import { S as sendMethodNotAllowed, a as checkGatewayHttpRequestAuth, b as sendInvalidRequest, h as resolveTrustedHttpOperatorScopes, i as authorizeScopedGatewayHttpRequestOrReply, s as getHeader, w as setSseHeaders, x as sendJson } from "./http-utils-C7CfxCac.js";
-import { c as sanitizeChatHistoryMessages, n as DEFAULT_CHAT_HISTORY_TEXT_MAX_CHARS } from "./chat-0aqpRXk7.js";
-import fs from "node:fs";
-import path from "node:path";
-//#region src/gateway/session-history-state.ts
-function asRoleContentMessage(message) {
-	const role = typeof message.role === "string" ? message.role.toLowerCase() : "";
-	if (!role) return null;
-	return {
-		role,
-		...message.content !== void 0 ? { content: message.content } : message.text !== void 0 ? { content: message.text } : {}
-	};
-}
-function isEmptyTextOnlyContent(content) {
-	if (typeof content === "string") return content.trim().length === 0;
-	if (!Array.isArray(content)) return false;
-	if (content.length === 0) return true;
-	let sawText = false;
-	for (const block of content) {
-		if (!block || typeof block !== "object") return false;
-		const entry = block;
-		if (entry.type !== "text") return false;
-		sawText = true;
-		if (typeof entry.text !== "string" || entry.text.trim().length > 0) return false;
-	}
-	return sawText;
-}
-function shouldHideSanitizedHistoryMessage(message) {
-	const roleContent = asRoleContentMessage(message);
-	if (!roleContent) return false;
-	if (roleContent.role === "user" && isEmptyTextOnlyContent(message.content ?? message.text)) return true;
-	return false;
-}
-function filterVisibleSessionHistoryMessages(messages) {
-	if (messages.length === 0) return messages;
-	let changed = false;
-	const visible = [];
-	for (const current of messages) {
-		if (!current) continue;
-		if (shouldHideSanitizedHistoryMessage(current)) {
-			changed = true;
-			continue;
-		}
-		visible.push(current);
-	}
-	return changed ? visible : messages;
-}
-function resolveCursorSeq(cursor) {
-	if (!cursor) return;
-	const normalized = cursor.startsWith("seq:") ? cursor.slice(4) : cursor;
-	const value = Number.parseInt(normalized, 10);
-	return Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function toSessionHistoryMessages(messages) {
-	return messages.filter((message) => Boolean(message) && typeof message === "object" && !Array.isArray(message));
-}
-function buildPaginatedSessionHistory(params) {
-	return {
-		items: params.messages,
-		messages: params.messages,
-		hasMore: params.hasMore,
-		...params.nextCursor ? { nextCursor: params.nextCursor } : {}
-	};
-}
-function resolveMessageSeq(message) {
-	const seq = message?.__genesis?.seq;
-	return typeof seq === "number" && Number.isFinite(seq) && seq > 0 ? seq : void 0;
-}
-function paginateSessionMessages(messages, limit, cursor) {
-	const cursorSeq = resolveCursorSeq(cursor);
-	let endExclusive = messages.length;
-	if (typeof cursorSeq === "number") {
-		endExclusive = messages.findIndex((message, index) => {
-			const seq = resolveMessageSeq(message);
-			if (typeof seq === "number") return seq >= cursorSeq;
-			return index + 1 >= cursorSeq;
-		});
-		if (endExclusive < 0) endExclusive = messages.length;
-	}
-	const start = typeof limit === "number" && limit > 0 ? Math.max(0, endExclusive - limit) : 0;
-	const paginatedMessages = messages.slice(start, endExclusive);
-	const firstSeq = resolveMessageSeq(paginatedMessages[0]);
-	return buildPaginatedSessionHistory({
-		messages: paginatedMessages,
-		hasMore: start > 0,
-		...start > 0 && typeof firstSeq === "number" ? { nextCursor: String(firstSeq) } : {}
-	});
-}
-function buildSessionHistorySnapshot(params) {
-	const history = paginateSessionMessages(filterVisibleSessionHistoryMessages(toSessionHistoryMessages(sanitizeChatHistoryMessages(stripEnvelopeFromMessages(params.rawMessages), params.maxChars ?? 8e3))), params.limit, params.cursor);
-	const rawHistoryMessages = toSessionHistoryMessages(params.rawMessages);
-	return {
-		history,
-		rawTranscriptSeq: resolveMessageSeq(rawHistoryMessages.at(-1)) ?? rawHistoryMessages.length
-	};
-}
-var SessionHistorySseState = class SessionHistorySseState {
-	static fromRawSnapshot(params) {
-		return new SessionHistorySseState({
-			target: params.target,
-			maxChars: params.maxChars,
-			limit: params.limit,
-			cursor: params.cursor,
-			initialRawMessages: params.rawMessages
-		});
-	}
-	constructor(params) {
-		this.target = params.target;
-		this.maxChars = params.maxChars ?? 8e3;
-		this.limit = params.limit;
-		this.cursor = params.cursor;
-		const snapshot = buildSessionHistorySnapshot({
-			rawMessages: params.initialRawMessages ?? this.readRawMessages(),
-			maxChars: this.maxChars,
-			limit: this.limit,
-			cursor: this.cursor
-		});
-		this.sentHistory = snapshot.history;
-		this.rawTranscriptSeq = snapshot.rawTranscriptSeq;
-	}
-	snapshot() {
-		return this.sentHistory;
-	}
-	appendInlineMessage(update) {
-		if (this.limit !== void 0 || this.cursor !== void 0) return null;
-		this.rawTranscriptSeq += 1;
-		const sanitized = sanitizeChatHistoryMessages(stripEnvelopeFromMessages([attachGenesisTranscriptMeta(update.message, {
-			...typeof update.messageId === "string" ? { id: update.messageId } : {},
-			seq: this.rawTranscriptSeq
-		})]), this.maxChars);
-		if (sanitized.length === 0) return null;
-		const [sanitizedMessage] = toSessionHistoryMessages(sanitized);
-		if (!sanitizedMessage) return null;
-		if (shouldHideSanitizedHistoryMessage(sanitizedMessage)) return null;
-		const nextMessages = [...this.sentHistory.messages, sanitizedMessage];
-		this.sentHistory = buildPaginatedSessionHistory({
-			messages: nextMessages,
-			hasMore: false
-		});
-		return {
-			message: sanitizedMessage,
-			messageSeq: resolveMessageSeq(sanitizedMessage)
-		};
-	}
-	refresh() {
-		const snapshot = buildSessionHistorySnapshot({
-			rawMessages: this.readRawMessages(),
-			maxChars: this.maxChars,
-			limit: this.limit,
-			cursor: this.cursor
-		});
-		this.rawTranscriptSeq = snapshot.rawTranscriptSeq;
-		this.sentHistory = snapshot.history;
-		return snapshot.history;
-	}
-	readRawMessages() {
-		return readSessionMessages(this.target.sessionId, this.target.storePath, this.target.sessionFile);
-	}
-};
-//#endregion
-//#region src/gateway/sessions-history-http.ts
-const log = createSubsystemLogger("gateway/sessions-history-sse");
-const MAX_SESSION_HISTORY_LIMIT = 1e3;
-function resolveSessionHistoryPath(req) {
-	const match = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).pathname.match(/^\/sessions\/([^/]+)\/history$/);
-	if (!match) return null;
-	try {
-		return normalizeOptionalString(decodeURIComponent(match[1] ?? "")) ?? null;
-	} catch {
-		return "";
-	}
-}
-function shouldStreamSse(req) {
-	return normalizeLowercaseStringOrEmpty(getHeader(req, "accept")).includes("text/event-stream");
-}
-function getRequestUrl(req) {
-	return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-}
-function resolveLimit(req) {
-	const raw = getRequestUrl(req).searchParams.get("limit");
-	if (raw == null || raw.trim() === "") return;
-	const value = Number.parseInt(raw, 10);
-	if (!Number.isFinite(value) || value < 1) return 1;
-	return Math.min(MAX_SESSION_HISTORY_LIMIT, Math.max(1, value));
-}
-function canonicalizePath(value) {
-	const trimmed = normalizeOptionalString(value);
-	if (!trimmed) return;
-	const resolved = path.resolve(trimmed);
-	try {
-		return fs.realpathSync(resolved);
-	} catch {
-		return resolved;
-	}
-}
-function sseWrite(res, event, payload) {
-	res.write(`event: ${event}\n`);
-	res.write(`data: ${JSON.stringify(payload)}\n\n`);
-}
-async function handleSessionHistoryHttpRequest(req, res, opts) {
-	const sessionKey = resolveSessionHistoryPath(req);
-	if (sessionKey === null) return false;
-	if (!sessionKey) {
-		sendInvalidRequest(res, "invalid session key");
-		return true;
-	}
-	if (req.method !== "GET") {
-		sendMethodNotAllowed(res, "GET");
-		return true;
-	}
-	const authResult = await authorizeScopedGatewayHttpRequestOrReply({
-		req,
-		res,
-		auth: opts.auth,
-		trustedProxies: opts.trustedProxies,
-		allowRealIpFallback: opts.allowRealIpFallback,
-		rateLimiter: opts.rateLimiter,
-		operatorMethod: "chat.history",
-		resolveOperatorScopes: resolveTrustedHttpOperatorScopes
-	});
-	if (!authResult) return true;
-	const { cfg } = authResult;
-	const target = resolveGatewaySessionStoreTarget({
-		cfg,
-		key: sessionKey
-	});
-	const entry = resolveFreshestSessionEntryFromStoreKeys(loadSessionStore(target.storePath), target.storeKeys);
-	if (!entry?.sessionId) {
-		sendJson(res, 404, {
-			ok: false,
-			error: {
-				type: "not_found",
-				message: `Session not found: ${sessionKey}`
-			}
-		});
-		return true;
-	}
-	const limit = resolveLimit(req);
-	const cursor = normalizeOptionalString(getRequestUrl(req).searchParams.get("cursor"));
-	const effectiveMaxChars = typeof cfg.gateway?.webchat?.chatHistoryMaxChars === "number" ? cfg.gateway.webchat.chatHistoryMaxChars : DEFAULT_CHAT_HISTORY_TEXT_MAX_CHARS;
-	const rawSnapshot = entry?.sessionId ? readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile) : [];
-	const history = buildSessionHistorySnapshot({
-		rawMessages: rawSnapshot,
-		maxChars: effectiveMaxChars,
-		limit,
-		cursor
-	}).history;
-	if (!shouldStreamSse(req)) {
-		sendJson(res, 200, {
-			sessionKey: target.canonicalKey,
-			...history
-		});
-		return true;
-	}
-	const transcriptCandidates = entry?.sessionId ? new Set(resolveSessionTranscriptCandidates(entry.sessionId, target.storePath, entry.sessionFile, target.agentId).map((candidate) => canonicalizePath(candidate)).filter((candidate) => typeof candidate === "string")) : /* @__PURE__ */ new Set();
-	let sentHistory = history;
-	const sseState = SessionHistorySseState.fromRawSnapshot({
-		target: {
-			sessionId: entry.sessionId,
-			storePath: target.storePath,
-			sessionFile: entry.sessionFile
-		},
-		rawMessages: rawSnapshot,
-		maxChars: effectiveMaxChars,
-		limit,
-		cursor
-	});
-	sentHistory = sseState.snapshot();
-	setSseHeaders(res);
-	res.write("retry: 1000\n\n");
-	sseWrite(res, "history", {
-		sessionKey: target.canonicalKey,
-		...sentHistory
-	});
-	let cleanedUp = false;
-	let streamQueue = Promise.resolve();
-	let heartbeat;
-	let unsubscribe;
-	const cleanup = () => {
-		if (cleanedUp) return;
-		cleanedUp = true;
-		if (heartbeat) clearInterval(heartbeat);
-		if (unsubscribe) unsubscribe();
-	};
-	const closeStream = () => {
-		cleanup();
-		if (!res.writableEnded) res.end();
-	};
-	const queueStreamWork = (work) => {
-		streamQueue = streamQueue.then(async () => {
-			if (cleanedUp || res.writableEnded) return;
-			await work();
-		}).catch((error) => {
-			log.warn("session history SSE stream work failed; closing stream", { error });
-			closeStream();
-		});
-	};
-	const isStreamStillAuthorized = async () => {
-		const cfg = loadConfig();
-		const currentRequestAuth = await checkGatewayHttpRequestAuth({
-			req,
-			auth: opts.getResolvedAuth?.() ?? opts.auth,
-			trustedProxies: cfg.gateway?.trustedProxies,
-			allowRealIpFallback: cfg.gateway?.allowRealIpFallback,
-			rateLimiter: opts.rateLimiter,
-			cfg
-		});
-		if (!currentRequestAuth.ok) return false;
-		return authorizeOperatorScopesForMethod("chat.history", resolveTrustedHttpOperatorScopes(req, currentRequestAuth.requestAuth)).allowed;
-	};
-	heartbeat = setInterval(() => {
-		queueStreamWork(async () => {
-			if (!await isStreamStillAuthorized()) {
-				closeStream();
-				return;
-			}
-			if (!res.writableEnded) res.write(": keepalive\n\n");
-		});
-	}, 15e3);
-	unsubscribe = onSessionTranscriptUpdate((update) => {
-		if (!entry?.sessionId) return;
-		const updatePath = canonicalizePath(update.sessionFile);
-		if (!updatePath || !transcriptCandidates.has(updatePath)) return;
-		queueStreamWork(async () => {
-			if (res.writableEnded) return;
-			if (!await isStreamStillAuthorized()) {
-				closeStream();
-				return;
-			}
-			if (update.message !== void 0) {
-				if (limit === void 0 && cursor === void 0) {
-					const nextEvent = sseState.appendInlineMessage({
-						message: update.message,
-						messageId: update.messageId
-					});
-					if (!nextEvent) return;
-					sentHistory = sseState.snapshot();
-					sseWrite(res, "message", {
-						sessionKey: target.canonicalKey,
-						message: nextEvent.message,
-						...typeof update.messageId === "string" ? { messageId: update.messageId } : {},
-						messageSeq: nextEvent.messageSeq
-					});
-					return;
-				}
-			}
-			sentHistory = sseState.refresh();
-			sseWrite(res, "history", {
-				sessionKey: target.canonicalKey,
-				...sentHistory
-			});
-		});
-	});
-	req.on("close", cleanup);
-	res.on("close", cleanup);
-	res.on("finish", cleanup);
-	return true;
-}
-//#endregion
-export { handleSessionHistoryHttpRequest };

package/dist/sessions-patch-yHBQNF3A.js

@@ -1,309 +0,0 @@
-import { c as normalizeOptionalString, i as normalizeFastMode, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
-import { n as isAcpSessionKey, o as isSubagentSessionKey, s as parseAgentSessionKey } from "./session-key-utils-DDwuwYKT.js";
-import { c as normalizeAgentId } from "./session-key-CI3KvTQC.js";
-import { x as resolveDefaultAgentId } from "./agent-scope-BUYwVohk.js";
-import { Dn as errorShape, En as ErrorCodes, kn as parseSessionLabel } from "./protocol-zDWsuAk7.js";
-import { d as normalizeReasoningLevel, f as normalizeThinkLevel, m as normalizeUsageDisplay, n as isThinkingLevelSupported, o as resolveSupportedThinkingLevel, t as formatThinkingLevels, u as normalizeElevatedLevel } from "./thinking-BxrysYYp.js";
-import { d as resolveSubagentConfiguredModelSelection, i as resolveAllowedModelRef, o as resolveDefaultModelForAgent } from "./model-selection-D-mV4REq.js";
-import { _ as normalizeExecTarget } from "./exec-approvals-D0DTIzDT.js";
-import { t as applyModelOverrideToSessionEntry } from "./model-overrides-Khx4T6LU.js";
-import { t as normalizeSendPolicy } from "./send-policy-C8y0VpxH.js";
-import { t as normalizeGroupActivation } from "./group-activation-BiaHgDAZ.js";
-import { i as parseVerboseOverride, n as applyVerboseOverride, r as parseTraceOverride, t as applyTraceOverride } from "./level-overrides-DJW-pWzj.js";
-import { randomUUID } from "node:crypto";
-//#region src/gateway/sessions-patch.ts
-function invalid(message) {
-	return {
-		ok: false,
-		error: errorShape(ErrorCodes.INVALID_REQUEST, message)
-	};
-}
-function normalizeExecSecurity(raw) {
-	const normalized = normalizeOptionalLowercaseString(raw);
-	if (normalized === "deny" || normalized === "allowlist" || normalized === "full") return normalized;
-}
-function normalizeExecAsk(raw) {
-	const normalized = normalizeOptionalLowercaseString(raw);
-	if (normalized === "off" || normalized === "on-miss" || normalized === "always") return normalized;
-}
-function supportsSpawnLineage(storeKey) {
-	return isSubagentSessionKey(storeKey) || isAcpSessionKey(storeKey);
-}
-function normalizeSubagentRole(raw) {
-	const normalized = normalizeOptionalLowercaseString(raw);
-	if (normalized === "orchestrator" || normalized === "leaf") return normalized;
-}
-function normalizeSubagentControlScope(raw) {
-	const normalized = normalizeOptionalLowercaseString(raw);
-	if (normalized === "children" || normalized === "none") return normalized;
-}
-async function applySessionsPatchToStore(params) {
-	const { cfg, store, storeKey, patch } = params;
-	const now = Date.now();
-	const sessionAgentId = normalizeAgentId(parseAgentSessionKey(storeKey)?.agentId ?? resolveDefaultAgentId(cfg));
-	const resolvedDefault = resolveDefaultModelForAgent({
-		cfg,
-		agentId: sessionAgentId
-	});
-	const subagentModelHint = isSubagentSessionKey(storeKey) ? resolveSubagentConfiguredModelSelection({
-		cfg,
-		agentId: sessionAgentId
-	}) : void 0;
-	const existing = store[storeKey];
-	const next = existing ? {
-		...existing,
-		updatedAt: Math.max(existing.updatedAt ?? 0, now)
-	} : {
-		sessionId: randomUUID(),
-		updatedAt: now
-	};
-	if ("spawnedBy" in patch) {
-		const raw = patch.spawnedBy;
-		if (raw === null) {
-			if (existing?.spawnedBy) return invalid("spawnedBy cannot be cleared once set");
-		} else if (raw !== void 0) {
-			const trimmed = normalizeOptionalString(raw) ?? "";
-			if (!trimmed) return invalid("invalid spawnedBy: empty");
-			if (!supportsSpawnLineage(storeKey)) return invalid("spawnedBy is only supported for subagent:* or acp:* sessions");
-			if (existing?.spawnedBy && existing.spawnedBy !== trimmed) return invalid("spawnedBy cannot be changed once set");
-			next.spawnedBy = trimmed;
-		}
-	}
-	if ("spawnedWorkspaceDir" in patch) {
-		const raw = patch.spawnedWorkspaceDir;
-		if (raw === null) {
-			if (existing?.spawnedWorkspaceDir) return invalid("spawnedWorkspaceDir cannot be cleared once set");
-		} else if (raw !== void 0) {
-			if (!supportsSpawnLineage(storeKey)) return invalid("spawnedWorkspaceDir is only supported for subagent:* or acp:* sessions");
-			const trimmed = normalizeOptionalString(raw) ?? "";
-			if (!trimmed) return invalid("invalid spawnedWorkspaceDir: empty");
-			if (existing?.spawnedWorkspaceDir && existing.spawnedWorkspaceDir !== trimmed) return invalid("spawnedWorkspaceDir cannot be changed once set");
-			next.spawnedWorkspaceDir = trimmed;
-		}
-	}
-	if ("spawnDepth" in patch) {
-		const raw = patch.spawnDepth;
-		if (raw === null) {
-			if (typeof existing?.spawnDepth === "number") return invalid("spawnDepth cannot be cleared once set");
-		} else if (raw !== void 0) {
-			if (!supportsSpawnLineage(storeKey)) return invalid("spawnDepth is only supported for subagent:* or acp:* sessions");
-			const numeric = raw;
-			if (!Number.isInteger(numeric) || numeric < 0) return invalid("invalid spawnDepth (use an integer >= 0)");
-			const normalized = numeric;
-			if (typeof existing?.spawnDepth === "number" && existing.spawnDepth !== normalized) return invalid("spawnDepth cannot be changed once set");
-			next.spawnDepth = normalized;
-		}
-	}
-	if ("subagentRole" in patch) {
-		const raw = patch.subagentRole;
-		if (raw === null) {
-			if (existing?.subagentRole) return invalid("subagentRole cannot be cleared once set");
-		} else if (raw !== void 0) {
-			if (!supportsSpawnLineage(storeKey)) return invalid("subagentRole is only supported for subagent:* or acp:* sessions");
-			const normalized = normalizeSubagentRole(raw);
-			if (!normalized) return invalid("invalid subagentRole (use \"orchestrator\" or \"leaf\")");
-			if (existing?.subagentRole && existing.subagentRole !== normalized) return invalid("subagentRole cannot be changed once set");
-			next.subagentRole = normalized;
-		}
-	}
-	if ("subagentControlScope" in patch) {
-		const raw = patch.subagentControlScope;
-		if (raw === null) {
-			if (existing?.subagentControlScope) return invalid("subagentControlScope cannot be cleared once set");
-		} else if (raw !== void 0) {
-			if (!supportsSpawnLineage(storeKey)) return invalid("subagentControlScope is only supported for subagent:* or acp:* sessions");
-			const normalized = normalizeSubagentControlScope(raw);
-			if (!normalized) return invalid("invalid subagentControlScope (use \"children\" or \"none\")");
-			if (existing?.subagentControlScope && existing.subagentControlScope !== normalized) return invalid("subagentControlScope cannot be changed once set");
-			next.subagentControlScope = normalized;
-		}
-	}
-	if ("label" in patch) {
-		const raw = patch.label;
-		if (raw === null) delete next.label;
-		else if (raw !== void 0) {
-			const parsed = parseSessionLabel(raw);
-			if (!parsed.ok) return invalid(parsed.error);
-			for (const [key, entry] of Object.entries(store)) {
-				if (key === storeKey) continue;
-				if (entry?.label === parsed.label) return invalid(`label already in use: ${parsed.label}`);
-			}
-			next.label = parsed.label;
-		}
-	}
-	if ("thinkingLevel" in patch) {
-		const raw = patch.thinkingLevel;
-		if (raw === null) delete next.thinkingLevel;
-		else if (raw !== void 0) {
-			const normalized = normalizeThinkLevel(raw);
-			if (!normalized) return invalid(`invalid thinkingLevel (use ${formatThinkingLevels(normalizeOptionalString(existing?.providerOverride) || resolvedDefault.provider, normalizeOptionalString(existing?.modelOverride) || resolvedDefault.model, "|")})`);
-			next.thinkingLevel = normalized;
-		}
-	}
-	if ("fastMode" in patch) {
-		const raw = patch.fastMode;
-		if (raw === null) delete next.fastMode;
-		else if (raw !== void 0) {
-			const normalized = normalizeFastMode(raw);
-			if (normalized === void 0) return invalid("invalid fastMode (use true or false)");
-			next.fastMode = normalized;
-		}
-	}
-	if ("verboseLevel" in patch) {
-		const raw = patch.verboseLevel;
-		const parsed = parseVerboseOverride(raw);
-		if (!parsed.ok) return invalid(parsed.error);
-		applyVerboseOverride(next, parsed.value);
-	}
-	if ("traceLevel" in patch) {
-		const raw = patch.traceLevel;
-		const parsed = parseTraceOverride(raw);
-		if (!parsed.ok) return invalid(parsed.error);
-		applyTraceOverride(next, parsed.value);
-	}
-	if ("reasoningLevel" in patch) {
-		const raw = patch.reasoningLevel;
-		if (raw === null) delete next.reasoningLevel;
-		else if (raw !== void 0) {
-			const normalized = normalizeReasoningLevel(raw);
-			if (!normalized) return invalid("invalid reasoningLevel (use \"on\"|\"off\"|\"stream\")");
-			next.reasoningLevel = normalized;
-		}
-	}
-	if ("responseUsage" in patch) {
-		const raw = patch.responseUsage;
-		if (raw === null) delete next.responseUsage;
-		else if (raw !== void 0) {
-			const normalized = normalizeUsageDisplay(raw);
-			if (!normalized) return invalid("invalid responseUsage (use \"off\"|\"tokens\"|\"full\")");
-			if (normalized === "off") delete next.responseUsage;
-			else next.responseUsage = normalized;
-		}
-	}
-	if ("elevatedLevel" in patch) {
-		const raw = patch.elevatedLevel;
-		if (raw === null) delete next.elevatedLevel;
-		else if (raw !== void 0) {
-			const normalized = normalizeElevatedLevel(raw);
-			if (!normalized) return invalid("invalid elevatedLevel (use \"on\"|\"off\"|\"ask\"|\"full\")");
-			next.elevatedLevel = normalized;
-		}
-	}
-	if ("execHost" in patch) {
-		const raw = patch.execHost;
-		if (raw === null) delete next.execHost;
-		else if (raw !== void 0) {
-			const normalized = normalizeExecTarget(raw) ?? void 0;
-			if (!normalized) return invalid("invalid execHost (use \"auto\"|\"sandbox\"|\"gateway\"|\"node\")");
-			next.execHost = normalized;
-		}
-	}
-	if ("execSecurity" in patch) {
-		const raw = patch.execSecurity;
-		if (raw === null) delete next.execSecurity;
-		else if (raw !== void 0) {
-			const normalized = normalizeExecSecurity(raw);
-			if (!normalized) return invalid("invalid execSecurity (use \"deny\"|\"allowlist\"|\"full\")");
-			next.execSecurity = normalized;
-		}
-	}
-	if ("execAsk" in patch) {
-		const raw = patch.execAsk;
-		if (raw === null) delete next.execAsk;
-		else if (raw !== void 0) {
-			const normalized = normalizeExecAsk(raw);
-			if (!normalized) return invalid("invalid execAsk (use \"off\"|\"on-miss\"|\"always\")");
-			next.execAsk = normalized;
-		}
-	}
-	if ("execNode" in patch) {
-		const raw = patch.execNode;
-		if (raw === null) delete next.execNode;
-		else if (raw !== void 0) {
-			const trimmed = normalizeOptionalString(raw) ?? "";
-			if (!trimmed) return invalid("invalid execNode: empty");
-			next.execNode = trimmed;
-		}
-	}
-	if ("model" in patch) {
-		const raw = patch.model;
-		if (raw === null) applyModelOverrideToSessionEntry({
-			entry: next,
-			selection: {
-				provider: resolvedDefault.provider,
-				model: resolvedDefault.model,
-				isDefault: true
-			},
-			markLiveSwitchPending: true
-		});
-		else if (raw !== void 0) {
-			const trimmed = normalizeOptionalString(raw) ?? "";
-			if (!trimmed) return invalid("invalid model: empty");
-			if (!params.loadGatewayModelCatalog) return {
-				ok: false,
-				error: errorShape(ErrorCodes.UNAVAILABLE, "model catalog unavailable")
-			};
-			const resolved = resolveAllowedModelRef({
-				cfg,
-				catalog: await params.loadGatewayModelCatalog(),
-				raw: trimmed,
-				defaultProvider: resolvedDefault.provider,
-				defaultModel: subagentModelHint ?? resolvedDefault.model
-			});
-			if ("error" in resolved) return invalid(resolved.error);
-			const isDefault = resolved.ref.provider === resolvedDefault.provider && resolved.ref.model === resolvedDefault.model;
-			applyModelOverrideToSessionEntry({
-				entry: next,
-				selection: {
-					provider: resolved.ref.provider,
-					model: resolved.ref.model,
-					isDefault
-				},
-				markLiveSwitchPending: true
-			});
-		}
-	}
-	if (next.thinkingLevel) {
-		const effectiveProvider = next.providerOverride ?? resolvedDefault.provider;
-		const effectiveModel = next.modelOverride ?? resolvedDefault.model;
-		const thinkingLevel = normalizeThinkLevel(next.thinkingLevel);
-		if (!thinkingLevel) delete next.thinkingLevel;
-		else if (!isThinkingLevelSupported({
-			provider: effectiveProvider,
-			model: effectiveModel,
-			level: thinkingLevel
-		})) {
-			if ("thinkingLevel" in patch) return invalid(`thinkingLevel "${thinkingLevel}" is not supported for ${effectiveProvider}/${effectiveModel} (use ${formatThinkingLevels(effectiveProvider, effectiveModel, "|")})`);
-			next.thinkingLevel = resolveSupportedThinkingLevel({
-				provider: effectiveProvider,
-				model: effectiveModel,
-				level: thinkingLevel
-			});
-		}
-	}
-	if ("sendPolicy" in patch) {
-		const raw = patch.sendPolicy;
-		if (raw === null) delete next.sendPolicy;
-		else if (raw !== void 0) {
-			const normalized = normalizeSendPolicy(raw);
-			if (!normalized) return invalid("invalid sendPolicy (use \"allow\"|\"deny\")");
-			next.sendPolicy = normalized;
-		}
-	}
-	if ("groupActivation" in patch) {
-		const raw = patch.groupActivation;
-		if (raw === null) delete next.groupActivation;
-		else if (raw !== void 0) {
-			const normalized = normalizeGroupActivation(raw);
-			if (!normalized) return invalid("invalid groupActivation (use \"mention\"|\"always\")");
-			next.groupActivation = normalized;
-		}
-	}
-	store[storeKey] = next;
-	return {
-		ok: true,
-		entry: next
-	};
-}
-//#endregion
-export { applySessionsPatchToStore as t };