@agimon-ai/po-web-dashboard 0.0.0-alpha.0

package/dist/web/stores/sessionStore.cjs

@@ -0,0 +1,610 @@
+const require_commands = require("../lib/commands.cjs");
+const require_hub = require("../../types/hub.cjs");
+const require_transport = require("../lib/transport.cjs");
+const require_sessionModel = require("../lib/sessionModel.cjs");
+const require_sessionsStore = require("./sessionsStore.cjs");
+let _tanstack_store = require("@tanstack/store");
+let _tanstack_react_store = require("@tanstack/react-store");
+//#region src/web/stores/sessionStore.ts
+/**
+* One store per session, created on first touch.
+*
+* The heavyweight timeline state only exists for sessions this page has
+* subscribed to; the rail runs on hub summaries alone.
+*/
+const stores = /* @__PURE__ */ new Map();
+const MAX_CACHED_ENTRIES = 500;
+function setHasNewerHistory(sessionId, value) {
+	sessionStoreFor(sessionId).setState((state) => state.hasNewerHistory === value ? state : {
+		...state,
+		hasNewerHistory: value
+	});
+}
+/** Sessions whose visible transcript is currently supplied by Pi's protocol. */
+const protocolTranscripts = /* @__PURE__ */ new Set();
+/** Projection keys changed after a subscription snapshot was requested. */
+const replayGuards = /* @__PURE__ */ new Map();
+const PROTOCOL_ENTRY_KINDS = /* @__PURE__ */ new Set([
+	"user",
+	"assistant",
+	"tool"
+]);
+/** Read-only stand-in while no session is focused, so hooks stay unconditional. */
+const detachedStore = new _tanstack_store.Store(require_sessionModel.initialSessionState);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sessionStoreFor(sessionId) {
+	if (sessionId === null) return detachedStore;
+	const existing = stores.get(sessionId);
+	if (existing) return existing;
+	const created = new _tanstack_store.Store(require_sessionModel.initialSessionState);
+	stores.set(sessionId, created);
+	return created;
+}
+/** Reads the focused session's state; components stay on the useStore idiom. */
+function useActiveSession(selector) {
+	const activeId = (0, _tanstack_react_store.useStore)(require_sessionsStore.sessionsStore, (state) => state.activeId);
+	return (0, _tanstack_react_store.useStore)(sessionStoreFor(activeId), selector);
+}
+function projectionKey(frame) {
+	const projected = frame.type === "replay" && isRecord(frame.frame) ? frame.frame : frame;
+	if (projected.type !== "extension_ui_request") return void 0;
+	if (typeof projected.statusKey === "string" && projected.method === "setStatus") return {
+		kind: "status",
+		key: projected.statusKey
+	};
+	if (typeof projected.widgetKey === "string" && projected.method === "setWidget") return {
+		kind: "widget",
+		key: projected.widgetKey
+	};
+}
+/** Presentation frames from the Pi protocol, or from bounded replay when replay is true. */
+function applySessionFrame(sessionId, frame, options = {}) {
+	const projection = projectionKey(frame);
+	const guard = replayGuards.get(sessionId);
+	if (projection !== void 0 && guard !== void 0) {
+		const keys = projection.kind === "status" ? guard.statuses : guard.widgets;
+		if (options.replay && keys.has(projection.key)) return;
+		if (!options.replay) keys.add(projection.key);
+	}
+	const transcriptFromProtocol = protocolTranscripts.has(sessionId) || options.source === "hub" && hasReadyHistoryReader(sessionId);
+	sessionStoreFor(sessionId).setState((state) => {
+		const next = require_sessionModel.reduceSession(state, frame, { transcriptFromProtocol });
+		if (!historyReaders.has(sessionId)) return next;
+		return {
+			...next,
+			entries: next.entries.length > MAX_CACHED_ENTRIES ? next.entries.slice(-500) : next.entries,
+			restoredIds: next.restoredIds.length > MAX_CACHED_ENTRIES ? next.restoredIds.slice(-500) : next.restoredIds
+		};
+	});
+}
+/** Lets the presentation stream resume transcript ownership after a typed service failure. */
+function releaseProtocolTranscript(sessionId) {
+	protocolTranscripts.delete(sessionId);
+}
+/** A thread has no protocol session, so its journal remains its authoritative transcript. */
+function applyThreadFrame(threadKey, frame) {
+	sessionStoreFor(threadKey).setState((state) => require_sessionModel.reduceSession(state, frame));
+}
+const history = /* @__PURE__ */ new Map();
+const historyReaders = /* @__PURE__ */ new Map();
+function hasReadyHistoryReader(sessionId) {
+	return historyReaders.get(sessionId)?.ready() === true;
+}
+function bindHistoryReader(sessionId, reader, ready = () => false) {
+	const binding = {
+		read: reader,
+		ready
+	};
+	historyReaders.set(sessionId, binding);
+	return () => {
+		if (historyReaders.get(sessionId) === binding) historyReaders.delete(sessionId);
+	};
+}
+function requestNewerHistory(sessionId) {
+	return sessionId !== null && (historyReaders.get(sessionId)?.read("newer") ?? false);
+}
+function requestLatestHistory(sessionId) {
+	return sessionId !== null && (historyReaders.get(sessionId)?.read("latest") ?? false);
+}
+const historyStore = new _tanstack_store.Store({});
+const NO_HISTORY = {
+	cursor: null,
+	hasMore: true,
+	loading: false,
+	pages: 0
+};
+function historyFor(sessionId) {
+	return history.get(sessionId) ?? NO_HISTORY;
+}
+function setHistory(sessionId, next) {
+	history.set(sessionId, next);
+	historyStore.setState((state) => ({
+		...state,
+		[sessionId]: next
+	}));
+}
+/** Whether more transcript exists above what this session's page holds. */
+function useHasOlderHistory(sessionId) {
+	return (0, _tanstack_react_store.useStore)(historyStore, (state) => sessionId === null ? false : (state[sessionId] ?? NO_HISTORY).hasMore);
+}
+/**
+* Asks the hub for the window above what this page holds.
+*
+* One request at a time: a reader flicking upwards would otherwise ask for the
+* same window repeatedly before the first answer lands, and every copy would
+* be prepended.
+*/
+function requestOlderHistory(sessionId) {
+	if (sessionId === null) return false;
+	const reader = historyReaders.get(sessionId);
+	if (reader) return reader.read("older");
+	const current = historyFor(sessionId);
+	if (current.loading || !current.hasMore) return false;
+	setHistory(sessionId, {
+		...current,
+		loading: true
+	});
+	require_transport.sendHubFrame({
+		type: require_hub.HISTORY_REQUEST_TYPE,
+		sessionId,
+		...current.cursor === null ? {} : { before: current.cursor }
+	});
+	return true;
+}
+/** Folds one answered window above the timeline and records how far back it reached. */
+function applyHistoryPage(sessionId, frames, next) {
+	const pages = historyFor(sessionId).pages + 1;
+	sessionStoreFor(sessionId).setState((state) => require_sessionModel.prependHistory(state, frames, pages));
+	setHistory(sessionId, {
+		cursor: next.cursor,
+		hasMore: next.hasMore,
+		loading: false,
+		pages
+	});
+}
+/** The oldest entry the page holds, which is where the next window ends. */
+function seedHistoryCursor(sessionId, cursor) {
+	setHistory(sessionId, {
+		...NO_HISTORY,
+		cursor
+	});
+}
+/** Keeps Po-only and optimistic entries beside the protocol items that preceded them. */
+function mergeProtocolEntries(previous, protocol, pendingUserIds, reconciledUserIds) {
+	const localByAnchor = /* @__PURE__ */ new Map();
+	let anchor = null;
+	for (const entry of previous) {
+		if ((PROTOCOL_ENTRY_KINDS.has(entry.kind) || reconciledUserIds.has(entry.id)) && !pendingUserIds.has(entry.id)) {
+			anchor = entry.id;
+			continue;
+		}
+		const local = localByAnchor.get(anchor) ?? [];
+		local.push(entry);
+		localByAnchor.set(anchor, local);
+	}
+	const merged = [...localByAnchor.get(null) ?? []];
+	const used = /* @__PURE__ */ new Set([null]);
+	for (const entry of protocol) {
+		merged.push(entry, ...localByAnchor.get(entry.id) ?? []);
+		used.add(entry.id);
+	}
+	for (const [entryAnchor, local] of localByAnchor) if (!used.has(entryAnchor)) merged.push(...local);
+	return merged;
+}
+/**
+* Replaces protocol-owned transcript items with the authoritative snapshot.
+*
+* Local echoes disappear when the protocol publishes them. Po-only entries,
+* such as notices, queued messages, and run dividers, retain their place beside
+* the protocol item that preceded them.
+*/
+function applyProtocolTranscript(sessionId, entries, streaming) {
+	protocolTranscripts.add(sessionId);
+	sessionStoreFor(sessionId).setState((state) => {
+		const pendingUserEntries = [...state.pendingUserEntries];
+		const pendingUserIdsBeforeReconciliation = new Set(pendingUserEntries.map((pending) => pending.id));
+		const knownProtocolIds = new Set(state.entries.filter((entry) => PROTOCOL_ENTRY_KINDS.has(entry.kind) && !pendingUserIdsBeforeReconciliation.has(entry.id)).map((entry) => entry.id));
+		const protocolUserEntryIds = { ...state.protocolUserEntryIds };
+		const normalizedEntries = [...entries];
+		const reconciledUserEntries = [...state.reconciledUserEntries];
+		for (let index = entries.length - 1; index >= 0; index -= 1) {
+			const entry = entries[index];
+			if (entry?.kind !== "user") continue;
+			const localId = protocolUserEntryIds[entry.id];
+			if (localId !== void 0) {
+				normalizedEntries[index] = {
+					...entry,
+					id: localId
+				};
+				continue;
+			}
+			if (knownProtocolIds.has(entry.id)) continue;
+			const pendingIndex = pendingUserEntries.findLastIndex((pending) => pending.text === entry.text);
+			if (pendingIndex === -1) continue;
+			const [pending] = pendingUserEntries.splice(pendingIndex, 1);
+			if (pending === void 0) continue;
+			protocolUserEntryIds[entry.id] = pending.id;
+			reconciledUserEntries.push(pending);
+			normalizedEntries[index] = {
+				...entry,
+				id: pending.id
+			};
+		}
+		const pendingUserIds = new Set(pendingUserEntries.map((pending) => pending.id));
+		const reconciledUserIds = new Set(Object.values(protocolUserEntryIds));
+		return {
+			...state,
+			entries: mergeProtocolEntries(state.entries, normalizedEntries, pendingUserIds, reconciledUserIds),
+			streaming: state.lifecycle === null ? streaming : state.lifecycle.operation !== null,
+			settled: state.lifecycle === null ? !streaming : state.lifecycle.operation === null,
+			pendingUserEntries,
+			reconciledUserEntries,
+			protocolUserEntryIds
+		};
+	});
+}
+function protocolQueueMatches(state, queue) {
+	const current = state.entries.filter((entry) => entry.kind === "queued");
+	return current.length === queue.length && current.every((entry, index) => {
+		const next = queue[index];
+		if (next === void 0 || entry.id !== next.id || entry.text !== next.text || entry.delivery !== next.delivery || entry.scheduling !== next.scheduling || entry.disposition !== next.disposition) return false;
+		const images = entry.images ?? [];
+		const nextImages = next.images ?? [];
+		return images.length === nextImages.length && images.every((image, imageIndex) => {
+			const nextImage = nextImages[imageIndex];
+			return nextImage !== void 0 && image.data === nextImage.data && image.mimeType === nextImage.mimeType;
+		});
+	});
+}
+/** Applies execution and retained-input state from the server, never from replayed history. */
+function applySessionLifecycle(sessionId, lifecycle, newBinding = false) {
+	sessionStoreFor(sessionId).setState((state) => {
+		const current = state.lifecycle;
+		if (!newBinding && current !== null && lifecycle.revision < current.revision) return state;
+		const queue = lifecycle.queue.map(({ id, text, images, delivery, scheduling, disposition }) => ({
+			kind: "queued",
+			id,
+			text,
+			delivery,
+			scheduling,
+			disposition,
+			...images === void 0 ? {} : { images: images.map(({ data, mimeType }) => ({
+				data,
+				mimeType
+			})) }
+		}));
+		const streaming = lifecycle.operation !== null;
+		return {
+			...protocolQueueMatches(state, queue) ? state : require_sessionModel.replaceQueuedEntries(state, queue),
+			lifecycle,
+			streaming,
+			settled: !streaming,
+			...state.agent === null ? {} : { agent: {
+				...state.agent,
+				isStreaming: streaming
+			} }
+		};
+	});
+}
+/** Replaces composer queue rows with the protocol server's authoritative queue. */
+function applyProtocolQueue(sessionId, queue) {
+	sessionStoreFor(sessionId).setState((state) => protocolQueueMatches(state, queue) ? state : require_sessionModel.replaceQueuedEntries(state, queue));
+}
+/** Marks the start of a subscription replay, so live projections beat an older snapshot. */
+function beginSessionReplay(sessionId) {
+	replayGuards.set(sessionId, {
+		statuses: /* @__PURE__ */ new Set(),
+		widgets: /* @__PURE__ */ new Set()
+	});
+}
+function endSessionReplay(sessionId) {
+	replayGuards.delete(sessionId);
+}
+function resetSessionStore(sessionId, options = {}) {
+	const guard = replayGuards.get(sessionId);
+	const preservePages = options.source === "hub" && hasReadyHistoryReader(sessionId);
+	sessionStoreFor(sessionId).setState((state) => {
+		const reset = {
+			...require_sessionModel.initialSessionState,
+			agent: state.agent,
+			lifecycle: state.lifecycle,
+			stats: state.stats,
+			commands: state.commands,
+			models: state.models,
+			thinkingLevels: state.thinkingLevels
+		};
+		const preservedStatuses = guard === void 0 ? {} : Object.fromEntries(Object.entries(state.statuses).filter(([key]) => guard.statuses.has(key)));
+		const preservedWidgets = guard === void 0 ? [] : state.widgets.filter((key) => guard.widgets.has(key));
+		if (preservePages) return {
+			...state,
+			statuses: preservedStatuses,
+			widgets: preservedWidgets
+		};
+		if (!protocolTranscripts.has(sessionId)) return {
+			...reset,
+			statuses: preservedStatuses,
+			widgets: preservedWidgets
+		};
+		const entries = state.entries.filter((entry) => PROTOCOL_ENTRY_KINDS.has(entry.kind));
+		return {
+			...reset,
+			entries,
+			statuses: preservedStatuses,
+			widgets: preservedWidgets,
+			streaming: state.streaming,
+			settled: state.settled,
+			pendingUserEntries: state.pendingUserEntries,
+			reconciledUserEntries: state.reconciledUserEntries,
+			protocolUserEntryIds: state.protocolUserEntryIds
+		};
+	});
+	if (preservePages) return;
+	history.delete(sessionId);
+	historyStore.setState((state) => {
+		const { [sessionId]: _dropped, ...rest } = state;
+		return rest;
+	});
+}
+function dropSessionStore(sessionId) {
+	stores.delete(sessionId);
+	protocolTranscripts.delete(sessionId);
+	replayGuards.delete(sessionId);
+}
+function resetSessionStores() {
+	stores.clear();
+	protocolTranscripts.clear();
+	replayGuards.clear();
+	detachedStore.setState(() => require_sessionModel.initialSessionState);
+}
+/** Asks for the facts the cockpit shows but Pi only reports on request. */
+function refreshSessionFacts(sessionId) {
+	require_transport.sendFrame(sessionId, require_commands.getStateCommand());
+	require_transport.sendFrame(sessionId, require_commands.getSessionStatsCommand());
+	require_transport.sendFrame(sessionId, require_commands.getCommandsCommand());
+}
+/**
+* Asks only for the usage figures, cheap enough to run once per message.
+*
+* `refreshSessionFacts` costs three round trips because it also re-reads the
+* state and the command list, and neither of those changes mid-turn.
+*/
+function refreshSessionStats(sessionId) {
+	require_transport.sendFrame(sessionId, require_commands.getSessionStatsCommand());
+}
+/** Asks what the model picker lists; Pi's answer depends on the current model. */
+function loadModelChoices(sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.getAvailableModelsCommand());
+	require_transport.sendFrame(sessionId, require_commands.getAvailableThinkingLevelsCommand());
+}
+/**
+* Switches the model, then re-reads the facts Pi adjusts alongside it: the
+* thinking level gets clamped to what the new model accepts, and the level
+* list changes with it.
+*/
+function selectModel(provider, modelId, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.setModelCommand(provider, modelId));
+	require_transport.sendFrame(sessionId, require_commands.getStateCommand());
+	require_transport.sendFrame(sessionId, require_commands.getAvailableThinkingLevelsCommand());
+}
+/** Read back server state rather than optimistically enabling priority. */
+function selectFastMode(enabled, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	if (sessionStoreFor(sessionId).state.agent?.provider !== "openai-codex") return;
+	require_transport.sendFrame(sessionId, {
+		type: "set_fast_mode",
+		enabled
+	});
+	require_transport.sendFrame(sessionId, require_commands.getStateCommand());
+}
+/** Locking aborts a running local turn; the snapshot reports the new state back. */
+function setAgentLock(locked, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, {
+		type: "set_agent_lock",
+		locked
+	});
+	require_transport.sendFrame(sessionId, require_commands.getStateCommand());
+}
+/** The set reply carries nothing back, so get_state is what updates the chip. */
+function selectThinkingLevel(level, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.setThinkingLevelCommand(level));
+	require_transport.sendFrame(sessionId, require_commands.getStateCommand());
+}
+/**
+* Sends a prompt, or steers the run when one is already in flight.
+*
+* Pi rejects a prompt while the agent is working, so the composer picks the
+* verb from the run state rather than making the reader remember which is
+* legal. Every action defaults to the focused session and is a no-op when
+* nothing is focused.
+*/
+function submitMessage(text, images = [], sessionId = require_sessionsStore.activeSessionId()) {
+	const trimmed = text.trim();
+	if (!trimmed || sessionId === null) return;
+	const store = sessionStoreFor(sessionId);
+	const builtin = require_commands.builtinCommandFrame(trimmed);
+	if (builtin) {
+		store.setState((state) => require_sessionModel.appendUserPrompt(state, trimmed));
+		require_transport.sendFrame(sessionId, builtin);
+		return;
+	}
+	const streaming = store.state.streaming;
+	const userImages = images.filter((image) => require_sessionModel.isSupportedImageMimeType(image.mimeType)).map(({ data, mimeType }) => ({
+		data,
+		mimeType
+	}));
+	store.setState((state) => require_sessionModel.appendUserPrompt(state, trimmed, userImages));
+	require_transport.sendFrame(sessionId, streaming ? require_commands.steerCommand(trimmed, images) : require_commands.promptCommand(trimmed, images));
+}
+/** The composer retains its draft until the server acknowledges admission. */
+async function submitMessageWithAck(text, images = [], sessionId = require_sessionsStore.activeSessionId()) {
+	const trimmed = text.trim();
+	if (!trimmed || sessionId === null) return false;
+	const store = sessionStoreFor(sessionId);
+	const builtin = require_commands.builtinCommandFrame(trimmed);
+	const active = store.state.lifecycle === null ? store.state.streaming : store.state.lifecycle.operation !== null;
+	const userImages = (builtin ? [] : images).filter((image) => require_sessionModel.isSupportedImageMimeType(image.mimeType)).map(({ data, mimeType }) => ({
+		data,
+		mimeType
+	}));
+	const localId = `u${store.state.nextId}`;
+	store.setState((state) => require_sessionModel.appendUserPrompt(state, trimmed, userImages));
+	let accepted = false;
+	try {
+		const response = await require_transport.sendFrameWithAck(sessionId, builtin ?? (active ? require_commands.steerCommand(trimmed, images) : require_commands.promptCommand(trimmed, images)));
+		accepted = response.success;
+		if (!accepted && response.error?.includes("uncertain")) store.setState((state) => require_sessionModel.reduceSession(state, {
+			type: "error",
+			message: response.error
+		}));
+		return accepted;
+	} finally {
+		if (!accepted) store.setState((state) => state.pendingUserEntries.some(({ id }) => id === localId) ? {
+			...state,
+			entries: state.entries.filter(({ id }) => id !== localId),
+			pendingUserEntries: state.pendingUserEntries.filter(({ id }) => id !== localId)
+		} : state);
+	}
+}
+function rewindToMessage(itemId, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null || itemId === "") return;
+	require_transport.sendFrame(sessionId, require_commands.rewindCommand(itemId));
+}
+function queueFollowUp(text, images = [], sessionId = require_sessionsStore.activeSessionId()) {
+	const trimmed = text.trim();
+	if (!trimmed || sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.enqueueAutomaticCommand(trimmed, images));
+}
+/** A queued submission is acknowledged by the server; consumption is a later lifecycle event. */
+async function queueFollowUpWithAck(text, images = [], sessionId = require_sessionsStore.activeSessionId()) {
+	const trimmed = text.trim();
+	if (!trimmed || sessionId === null) return false;
+	const response = await require_transport.sendFrameWithAck(sessionId, require_commands.enqueueAutomaticCommand(trimmed, images));
+	if (!response.success && response.error?.includes("uncertain")) sessionStoreFor(sessionId).setState((state) => require_sessionModel.reduceSession(state, {
+		type: "error",
+		message: response.error
+	}));
+	return response.success;
+}
+async function clearQueuedMessages(sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) throw new Error("The session protocol is not connected.");
+	const response = await require_transport.sendFrameWithAck(sessionId, require_commands.clearQueueCommand());
+	if (!response.success) throw new Error(response.error ?? "Could not clear queued messages.");
+}
+/** Requests server-owned removal; the authoritative snapshot removes the row on success. */
+async function deleteQueuedMessage(id, _knownQueueCount, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) throw new Error("The session protocol is not connected.");
+	const response = await require_transport.sendFrameWithAck(sessionId, require_commands.removeQueuedCommand(id));
+	if (!response.success) throw new Error(response.error ?? "Could not delete the queued message.");
+	switch (response.data) {
+		case "removed": return;
+		case "in_flight": throw new Error("This message is already being delivered and cannot be deleted.");
+		case "already_consumed": throw new Error("This message has already been sent.");
+		case "not_found": throw new Error("This message is no longer queued. Refresh the session.");
+		default: throw new Error("Deletion uncertain. Check the queue before trying again.");
+	}
+}
+/** The caller captures the active target at click time; absent means expected idle. */
+async function promoteQueuedMessage(id, operationId, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) throw new Error("The session protocol is not connected.");
+	const response = await require_transport.sendFrameWithAck(sessionId, require_commands.promoteQueuedCommand(id, operationId));
+	if (!response.success) throw new Error(response.error ?? "Could not send the queued message.");
+	switch (response.data) {
+		case "promoted": return;
+		case "target_changed": throw new Error("The active run changed. Check the session before sending this message.");
+		case "in_flight": throw new Error("This message is already being delivered.");
+		case "not_found": throw new Error("This message is no longer queued. Refresh the session.");
+		default: throw new Error("Delivery uncertain. Check the conversation before trying again.");
+	}
+}
+async function resumeQueuedMessages(sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) throw new Error("The session protocol is not connected.");
+	const response = await require_transport.sendFrameWithAck(sessionId, require_commands.resumeQueueCommand());
+	if (!response.success) throw new Error(response.error ?? "Could not resume queued messages.");
+}
+/**
+* Renames the session where the name actually lives: in the agent. Pi keeps
+* it in the session file and reports it back through get_state, which is
+* what the hub folds into every page's rail card.
+*/
+function renameSession(name, sessionId = require_sessionsStore.activeSessionId()) {
+	const trimmed = name.trim();
+	if (!trimmed || sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.setSessionNameCommand(trimmed));
+	require_transport.sendFrame(sessionId, require_commands.getStateCommand());
+}
+function abortRun(sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.abortCommand(sessionStoreFor(sessionId).state.lifecycle?.operation?.id));
+}
+function runCommand(name, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	const slashed = name.startsWith("/") ? name : `/${name}`;
+	require_transport.sendFrame(sessionId, require_commands.builtinCommandFrame(slashed) ?? require_commands.promptCommand(slashed));
+}
+function answerDialogValue(id, value, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.dialogValue(id, value));
+	sessionStoreFor(sessionId).setState(require_sessionModel.clearDialog);
+}
+function answerDialogConfirm(id, confirmed, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.dialogConfirmed(id, confirmed));
+	sessionStoreFor(sessionId).setState(require_sessionModel.clearDialog);
+}
+function cancelDialog(id, sessionId = require_sessionsStore.activeSessionId()) {
+	if (sessionId === null) return;
+	require_transport.sendFrame(sessionId, require_commands.dialogCancelled(id));
+	sessionStoreFor(sessionId).setState(require_sessionModel.clearDialog);
+}
+//#endregion
+exports.abortRun = abortRun;
+exports.answerDialogConfirm = answerDialogConfirm;
+exports.answerDialogValue = answerDialogValue;
+exports.applyHistoryPage = applyHistoryPage;
+exports.applyProtocolQueue = applyProtocolQueue;
+exports.applyProtocolTranscript = applyProtocolTranscript;
+exports.applySessionFrame = applySessionFrame;
+exports.applySessionLifecycle = applySessionLifecycle;
+exports.applyThreadFrame = applyThreadFrame;
+exports.beginSessionReplay = beginSessionReplay;
+exports.bindHistoryReader = bindHistoryReader;
+exports.cancelDialog = cancelDialog;
+exports.clearQueuedMessages = clearQueuedMessages;
+exports.deleteQueuedMessage = deleteQueuedMessage;
+exports.dropSessionStore = dropSessionStore;
+exports.endSessionReplay = endSessionReplay;
+exports.loadModelChoices = loadModelChoices;
+exports.promoteQueuedMessage = promoteQueuedMessage;
+exports.queueFollowUp = queueFollowUp;
+exports.queueFollowUpWithAck = queueFollowUpWithAck;
+exports.refreshSessionFacts = refreshSessionFacts;
+exports.refreshSessionStats = refreshSessionStats;
+exports.releaseProtocolTranscript = releaseProtocolTranscript;
+exports.renameSession = renameSession;
+exports.requestLatestHistory = requestLatestHistory;
+exports.requestNewerHistory = requestNewerHistory;
+exports.requestOlderHistory = requestOlderHistory;
+exports.resetSessionStore = resetSessionStore;
+exports.resetSessionStores = resetSessionStores;
+exports.resumeQueuedMessages = resumeQueuedMessages;
+exports.rewindToMessage = rewindToMessage;
+exports.runCommand = runCommand;
+exports.seedHistoryCursor = seedHistoryCursor;
+exports.selectFastMode = selectFastMode;
+exports.selectModel = selectModel;
+exports.selectThinkingLevel = selectThinkingLevel;
+exports.sessionStoreFor = sessionStoreFor;
+exports.setAgentLock = setAgentLock;
+exports.setHasNewerHistory = setHasNewerHistory;
+exports.submitMessage = submitMessage;
+exports.submitMessageWithAck = submitMessageWithAck;
+exports.useActiveSession = useActiveSession;
+exports.useHasOlderHistory = useHasOlderHistory;
+
+//# sourceMappingURL=sessionStore.cjs.map