@xopcai/xopc 0.0.284 → 0.0.286

package/dist/src/gateway/service.d.ts

@@ -124,12 +124,13 @@ export declare class GatewayService {
     private ensureHeartbeatService;
     private createTaskRunDispatcher;
     private createNotificationService;
+    private readonly taskRunDispatch;
     dispatchTaskRuns(): void;
     ensureTaskConversation(taskId: string, options?: {
         runId?: string;
         requestedAgentId?: string;
     }): Promise<{
-        sessionKey: string;
+        conversationId: string;
         agentId: string;
         created: boolean;
         conversation: ReturnType<TaskConversationRepository['requireState']>;
@@ -167,9 +168,9 @@ export declare class GatewayService {
         aborted: boolean;
         idle: boolean;
     }>;
-    getActiveWebchatRunId(sessionKey: string): string | undefined;
+    getActiveWebchatRunId(conversationId: string): string | undefined;
     answerEphemeralClarification(requestId: string, answer: string): boolean;
-    getClarificationState(sessionKey: string): import("@xopcai/gateway-contract/src/clarifications.js").ClarificationWaitSnapshot;
+    getClarificationState(conversationId: string): import("@xopcai/gateway-contract/src/clarifications.js").ClarificationWaitSnapshot;
     resolveClarificationResponse(input: Parameters<GatewayAgentRunner['resolveClarificationResponse']>[0]): import("../storage/sqlite/clarification-wait-repository.js").ResolveClarificationResult;
     private initializeExtensionLoader;
     private registerExtensionChannelPlugins;
@@ -255,6 +256,12 @@ export declare class GatewayService {
         manageable: boolean;
         order: number;
     }>;
+    heartbeatStatus(): {
+        enabled: boolean;
+        checksAllowed: boolean;
+        nextCheckAt: string;
+        recent: import("./heartbeat/check-store.js").HeartbeatCheck[];
+    };
     /**
      * Request an immediate heartbeat run (coalesced like interval/cron wakes).
      */
@@ -327,7 +334,7 @@ export declare class GatewayService {
     private reconcileInterruptedWorkflowRuns;
     private collectWorkflowAgentIds;
     /** Process a message directly through the agent (for CLI mode). */
-    processDirect(content: string, sessionKey?: string): Promise<string>;
+    processDirect(content: string, conversationId?: string): Promise<string>;
     emit(type: string, payload: unknown): void;
     private handleAutomationRunCompleted;
     private startAutomationProductEventBridge;

package/dist/src/gateway/service.js

@@ -6,13 +6,15 @@ import { getRuntimeLogStats } from "../utils/logger/stats.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { closeXopcDatabase, openXopcDatabase } from "../storage/sqlite/connection.js";
-import { findSessionInput, insertSessionInput } from "../storage/sqlite/session-input-repository.js";
-import { notifyUserContextChange } from "../user-context/changes.js";
+import { findSessionInput, init_session_input_repository, insertSessionInput } from "../storage/sqlite/session-input-repository.js";
+import { init_changes, notifyUserContextChange } from "../user-context/changes.js";
+import { getSessionMetadata, init_session_repository, patchSessionMetadata } from "../storage/sqlite/session-repository.js";
 import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
-import { buildSessionKey, init_session_key, sanitizeSegment } from "../routing/session-key.js";
+import { init_agent_session_key, resolveAgentMainConversationId } from "../routing/agent-session-key.js";
+import { init_session_key, resolveConversationId, sanitizeSegment } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { init_paths, resolveConfigPath, resolveExtensionsDir } from "../config/paths.js";
@@ -56,13 +58,6 @@ import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
-import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
-import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
-import "../knowledge/index.js";
-import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
-import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
-import { ConnectedSourceChangePublisher } from "../connectors/source-change-publisher.js";
-import { startConnectorSupervisor } from "../connectors/supervisor.js";
 import { DiscussionService } from "../discussions/service.js";
 import { DiscussionOrganizer } from "../discussions/organizer.js";
 import { DiscussionLiveWorker } from "../discussions/live-worker.js";
@@ -71,9 +66,17 @@ import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
+import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
+import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
+import "../knowledge/index.js";
+import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
+import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
+import { ConnectedSourceChangePublisher } from "../connectors/source-change-publisher.js";
+import { startConnectorSupervisor } from "../connectors/supervisor.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
+import { createBackgroundTask } from "../infra/background-task.js";
 import { buildTaskAgentContext } from "../agent/source-context/task-context.js";
 import { deliverProactiveCard } from "../proactive/inbox/delivery.js";
 import { WorkDiscoveryService } from "../work-discovery/service.js";
@@ -134,6 +137,10 @@ import { createGatewayStartupTrace } from "./startup-trace.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
 import crypto from "node:crypto";
 //#region src/gateway/service.ts
+init_session_repository();
+init_agent_session_key();
+init_session_input_repository();
+init_changes();
 init_agent_scope();
 init_channel_catalog_service();
 init_schema();
@@ -179,15 +186,15 @@ var GatewayService = class {
 	realtime = new RealtimeRuntime(this.endpointTools, this.isRealtimePrincipalActive);
 	voiceRealtime = new VoiceRealtimeRuntime({
 		isPrincipalActive: this.isRealtimePrincipalActive,
-		getConversationContext: async (sessionKey, expectedSessionId) => {
-			if ((await this.sessionIndex.getSessionMetadata(sessionKey))?.sessionId !== expectedSessionId) throw new Error("Conversation changed before voice connection");
-			const messages = await this.sessionIndex.loadMessages(sessionKey);
-			const after = await this.sessionIndex.getSessionMetadata(sessionKey);
-			if (after?.sessionId !== expectedSessionId) throw new Error("Conversation changed while loading voice context");
-			const profile = resolveEffectiveAgentProfileForSession(this.config, sessionKey);
+		getConversationContext: async (conversationId, expectedTranscriptId) => {
+			if ((await this.sessionIndex.getSessionMetadata(conversationId))?.transcriptId !== expectedTranscriptId) throw new Error("Conversation changed before voice connection");
+			const messages = await this.sessionIndex.loadMessages(conversationId);
+			const after = await this.sessionIndex.getSessionMetadata(conversationId);
+			if (after?.transcriptId !== expectedTranscriptId) throw new Error("Conversation changed while loading voice context");
+			const profile = resolveEffectiveAgentProfileForSession(this.config, conversationId);
 			const persona = buildVoicePersonaContext({
 				getConfig: () => this.config,
-				sessionKey,
+				conversationId,
 				maxChars: voicePersonaBudget(this.config.voice.realtime.omni.instructions)
 			});
 			const context = {
@@ -197,8 +204,8 @@ var GatewayService = class {
 			};
 			const memory = buildVoiceMemoryContext({
 				getConfig: () => this.config,
-				sessionKey,
-				workspaceId: getSessionConfig(sessionKey)?.workingDirectoryOverride ?? profile.resolvedWorkspacePath,
+				conversationId,
+				workspaceId: getSessionConfig(conversationId)?.workingDirectoryOverride ?? profile.resolvedWorkspacePath,
 				projectId: after?.projectId,
 				history: messages,
 				maxChars: voiceMemoryBudget(this.config.voice.realtime.omni.instructions, context)
@@ -208,10 +215,10 @@ var GatewayService = class {
 				...memory ? { memory } : {}
 			};
 		},
-		getSessionIdentity: async (sessionKey) => (await this.sessionIndex.getSessionMetadata(sessionKey))?.sessionId,
-		recordOmniTranscript: async (sessionKey, callId, entry, expectedSessionId) => {
-			await this.sessionIndex.appendTranscriptCustomMessageEntry(sessionKey, {
-				expectedSessionId,
+		getSessionIdentity: async (conversationId) => (await this.sessionIndex.getSessionMetadata(conversationId))?.transcriptId,
+		recordOmniTranscript: async (conversationId, callId, entry, expectedTranscriptId) => {
+			await this.sessionIndex.appendTranscriptCustomMessageEntry(conversationId, {
+				expectedTranscriptId,
 				customType: "voice_omni_transcript",
 				content: entry.text,
 				display: true,
@@ -223,12 +230,12 @@ var GatewayService = class {
 					engine: "omni"
 				}
 			});
-			this.emit("session.transcript_updated", { key: sessionKey });
+			this.emit("session.transcript_updated", { key: conversationId });
 		},
 		getConfig: () => this.config,
-		sessionExists: async (sessionKey) => Boolean(await this.sessionIndex.getSessionMetadata(sessionKey)),
-		sessionBusy: (sessionKey) => Boolean(this.agentRunner.getActiveRunId(sessionKey)) || this.agentRunner.inputs.snapshot(sessionKey).inputs.some((input) => input.status === "queued"),
-		recordInterruption: (entry) => this.sessionIndex.appendTranscriptContextEntry(entry.sessionKey, {
+		sessionExists: async (conversationId) => Boolean(await this.sessionIndex.getSessionMetadata(conversationId)),
+		sessionBusy: (conversationId) => Boolean(this.agentRunner.getActiveRunId(conversationId)) || this.agentRunner.inputs.snapshot(conversationId).inputs.some((input) => input.status === "queued"),
+		recordInterruption: (entry) => this.sessionIndex.appendTranscriptContextEntry(entry.conversationId, {
 			text: "Voice response was interrupted before playback completed.",
 			data: {
 				type: "voice_response_interrupted",
@@ -241,7 +248,7 @@ var GatewayService = class {
 		agentBroker: new DurableVoiceAgentBroker({
 			submit: (input) => this.agentRunner.submitSessionInput(input),
 			find: findSessionInput,
-			snapshot: (sessionKey) => this.agentRunner.inputs.snapshot(sessionKey),
+			snapshot: (conversationId) => this.agentRunner.inputs.snapshot(conversationId),
 			currentSequence: (topic) => this.realtime.broker.currentSequence(topic),
 			subscribe: (topic, afterSeq, listener) => this.realtime.broker.subscribe(topic, afterSeq, listener),
 			cancelRun: async (runId) => {
@@ -492,10 +499,10 @@ var GatewayService = class {
 		});
 		let sideChatRuns;
 		this.sideChats = new EphemeralSideChatManager({
-			getParentMetadata: (sessionKey) => this.sessionIndex.getSessionMetadata(sessionKey),
-			loadParentMessages: (sessionKey) => this.sessionIndex.getStore().load(sessionKey),
-			getDefaultModelRef: (sessionKey) => this.ensureAgentService().getModelForSession(sessionKey),
-			getDefaultThinkingLevel: (sessionKey) => this.ensureAgentService().getThinkingLevelForSession(sessionKey),
+			getParentMetadata: (conversationId) => this.sessionIndex.getSessionMetadata(conversationId),
+			loadParentMessages: (conversationId) => this.sessionIndex.getStore().load(conversationId),
+			getDefaultModelRef: (conversationId) => this.ensureAgentService().getModelForSession(conversationId),
+			getDefaultThinkingLevel: (conversationId) => this.ensureAgentService().getThinkingLevelForSession(conversationId),
 			getWorkspacePath: (metadata) => metadata.cwd || this.currentWorkspacePath,
 			onBeforeDispose: async (sideChatId, clientInstanceId, messages) => {
 				await sideChatRuns?.cancelRun(sideChatId, clientInstanceId);
@@ -563,18 +570,18 @@ var GatewayService = class {
 			model: getAgentDefaultModelRef(this.config),
 			config: this.config,
 			sessionStore: this.sessionIndex.getStore(),
-			onSessionMetadataUpdated: (sessionKey, patch) => {
+			onSessionMetadataUpdated: (conversationId, patch) => {
 				this.sessionIndex.emit("sessionUpdated", {
-					key: sessionKey,
+					key: conversationId,
 					name: patch?.name
 				});
 				this.emit("session.updated", {
-					key: sessionKey,
+					key: conversationId,
 					name: patch?.name
 				});
 			},
-			onSessionTranscriptUpdated: (sessionKey) => {
-				this.emit("session.transcript_updated", { key: sessionKey });
+			onSessionTranscriptUpdated: (conversationId) => {
+				this.emit("session.transcript_updated", { key: conversationId });
 			},
 			onSkillsUpdated: (payload) => {
 				this.emit("config.reload", {
@@ -606,14 +613,14 @@ var GatewayService = class {
 				return null;
 			},
 			gatewayClarify: { requestClarification: (context, request) => {
-				const executionSessionKey = getEmbeddedExecutionSession() ?? context.sessionKey;
+				const executionConversationId = getEmbeddedExecutionSession() ?? context.conversationId;
 				return this.agentRunner.requestClarification({
-					sessionKey: executionSessionKey,
+					conversationId: executionConversationId,
 					runId: context.runId,
 					toolCallId: context.toolCallId,
 					request,
 					publishStreamFor: (_runId) => (event) => {
-						this._agentService.turnDispatcher.enqueueWebchatStreamEvent(executionSessionKey, event);
+						this._agentService.turnDispatcher.enqueueWebchatStreamEvent(executionConversationId, event);
 					}
 				});
 			} }
@@ -665,7 +672,8 @@ var GatewayService = class {
 			agentService: this.ensureAgentService(),
 			messageBus: this.bus,
 			sessionStore: this.sessionIndex.getStore(),
-			getConfig: () => this.config
+			getConfig: () => this.config,
+			getWorkspace: () => this.workspacePath
 		});
 		return this.heartbeatService;
 	}
@@ -676,17 +684,17 @@ var GatewayService = class {
 				return (await this.ensureTaskConversation(taskId, {
 					runId,
 					requestedAgentId
-				})).sessionKey;
+				})).conversationId;
 			},
-			runAgent: async (runId, sessionKey, message) => {
+			runAgent: async (runId, conversationId, message) => {
 				const clientMessageId = `task:${runId}`;
-				const session = await this.sessionIndex.getSessionMetadata(sessionKey);
+				const session = await this.sessionIndex.getSessionMetadata(conversationId);
 				if (!session) throw new Error("Task session is unavailable");
 				insertSessionInput({
 					id: crypto.randomUUID(),
-					sessionKey,
+					conversationId,
 					clientMessageId,
-					expectedSessionId: session.sessionId,
+					expectedTranscriptId: session.transcriptId,
 					requestedDelivery: "next",
 					effectiveDelivery: "next",
 					status: "queued",
@@ -697,8 +705,8 @@ var GatewayService = class {
 					},
 					taskRunId: runId
 				});
-				this.agentRunner.inputs.drain(sessionKey);
-				await this.agentRunner.inputs.waitForCompletion(sessionKey, clientMessageId);
+				this.agentRunner.inputs.drain(conversationId);
+				await this.agentRunner.inputs.waitForCompletion(conversationId, clientMessageId);
 			}
 		});
 		return this.taskRunDispatcher;
@@ -721,11 +729,21 @@ var GatewayService = class {
 		});
 		return this.notificationService;
 	}
-	dispatchTaskRuns() {
+	taskRunDispatch = createBackgroundTask(async () => {
 		new TaskSignalService().tick();
 		this.dispatchTaskEvents();
 		this.createTaskRunDispatcher().dispatch();
-		this.createWorkflowRunService().dispatchTaskRuns();
+		await this.createWorkflowRunService().dispatchTaskRuns();
+	}, (err) => {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		log.error({
+			err,
+			errorMessage,
+			phase: "task_run_dispatch"
+		}, `Task dispatch failed: ${errorMessage}`);
+	});
+	dispatchTaskRuns() {
+		this.taskRunDispatch();
 	}
 	async ensureTaskConversation(taskId, options = {}) {
 		const task = new TaskRepository().require(taskId);
@@ -741,26 +759,26 @@ var GatewayService = class {
 			if (active.agentId && active.agentId !== agentId) throw new Error("Task executor differs from the active conversation");
 			const conversation = conversations.activateExecutionSession({
 				taskId: task.id,
-				sessionKey: active.sessionKey,
+				conversationId: active.conversationId,
 				agentId,
 				runId: options.runId
 			});
 			return {
-				sessionKey: active.sessionKey,
+				conversationId: active.conversationId,
 				agentId,
 				created: false,
 				conversation
 			};
 		}
 		const peerId = `task-${sanitizeSegment(task.id) || Date.now()}`;
-		const sessionKey = buildSessionKey({
+		const conversationId = resolveConversationId({
 			agentId,
 			source: "webchat",
 			accountId: "default",
 			peerKind: "direct",
 			peerId
 		});
-		if (!await this.sessionIndex.getSessionMetadata(sessionKey)) await this.sessionIndex.saveMessages(sessionKey, [], { metadata: {
+		patchSessionMetadata(conversationId, {
 			sourceChannel: "webchat",
 			sourceChatId: `default:direct:${peerId}`,
 			sessionType: "chat",
@@ -777,15 +795,15 @@ var GatewayService = class {
 				triggerKind: "user",
 				...options.runId ? { taskRunId: options.runId } : {}
 			}
-		} });
-		if (task.projectId) this.projects.attachSession(sessionKey, task.projectId);
+		});
+		if (task.projectId) this.projects.attachSession(conversationId, task.projectId);
 		return {
-			sessionKey,
+			conversationId,
 			agentId,
 			created: true,
 			conversation: conversations.activateExecutionSession({
 				taskId: task.id,
-				sessionKey,
+				conversationId,
 				agentId,
 				runId: options.runId
 			})
@@ -800,8 +818,8 @@ var GatewayService = class {
 	connectionRecovery = new ConnectionRecoveryService({
 		getConfig: () => this.config,
 		saveConfig: (config) => this.saveConfig(config),
-		drain: (sessionKey) => {
-			this.agentRunner.inputs.drain(sessionKey);
+		drain: (conversationId) => {
+			this.agentRunner.inputs.drain(conversationId);
 		}
 	});
 	submitSessionInput(...args) {
@@ -822,14 +840,14 @@ var GatewayService = class {
 	abortAgentRun(runId) {
 		return this.agentRunner.abortAgentRun(runId);
 	}
-	getActiveWebchatRunId(sessionKey) {
-		return this.agentRunner.getActiveRunId(sessionKey);
+	getActiveWebchatRunId(conversationId) {
+		return this.agentRunner.getActiveRunId(conversationId);
 	}
 	answerEphemeralClarification(requestId, answer) {
 		return this.agentRunner.answerEphemeralClarification(requestId, answer);
 	}
-	getClarificationState(sessionKey) {
-		return this.agentRunner.getClarificationState(sessionKey);
+	getClarificationState(conversationId) {
+		return this.agentRunner.getClarificationState(conversationId);
 	}
 	resolveClarificationResponse(input) {
 		return this.agentRunner.resolveClarificationResponse(input);
@@ -984,7 +1002,7 @@ var GatewayService = class {
 		}
 		registerClarificationChannelRuntime({
 			answerChoice: (requestId, choiceIndex, idempotencyKey) => this.agentRunner.answerClarificationChoice(requestId, choiceIndex, idempotencyKey),
-			answerText: (sessionKey, text, idempotencyKey) => this.agentRunner.answerClarificationText(sessionKey, text, idempotencyKey)
+			answerText: (conversationId, text, idempotencyKey) => this.agentRunner.answerClarificationText(conversationId, text, idempotencyKey)
 		});
 		this.ensureAgentService();
 		this.agentRunner.recoverSessionInputs();
@@ -997,9 +1015,9 @@ var GatewayService = class {
 		if (this.extensionLoader) this.extensionLoader.setRuntimeContext({
 			bus: this.bus,
 			sessionManager: this.sessionIndex,
-			scheduleWebchatContinuation: (sessionKey, continuationMessage) => {
+			scheduleWebchatContinuation: (conversationId, continuationMessage) => {
 				queueMicrotask(() => {
-					this.agentRunner.drainScheduledWebchatContinuation(sessionKey, continuationMessage);
+					this.agentRunner.drainScheduledWebchatContinuation(conversationId, continuationMessage);
 				});
 			}
 		});
@@ -1431,6 +1449,9 @@ var GatewayService = class {
 			return a.id.localeCompare(b.id);
 		});
 	}
+	heartbeatStatus() {
+		return this.heartbeatService?.status() ?? null;
+	}
 	/**
 	* Request an immediate heartbeat run (coalesced like interval/cron wakes).
 	*/
@@ -1610,8 +1631,8 @@ var GatewayService = class {
 		return [...ids];
 	}
 	/** Process a message directly through the agent (for CLI mode). */
-	async processDirect(content, sessionKey = "agent:main:main") {
-		return this.agentService.turnDispatcher.processDirect(content, sessionKey, {
+	async processDirect(content, conversationId = resolveAgentMainConversationId({ agentId: getDefaultAgentId(this.config) })) {
+		return this.agentService.turnDispatcher.processDirect(content, conversationId, {
 			type: "system",
 			source: "internal"
 		});
@@ -1669,12 +1690,12 @@ var GatewayService = class {
 			});
 		});
 		this.stopSessionTranscriptAutomationEvents = onSessionTranscriptUpdate((update) => {
-			if (!update.sessionKey || update.sessionKey.includes(":automation:")) return;
+			if (!update.conversationId || getSessionMetadata(update.conversationId)?.sourceChannel === "automation") return;
 			publishAutomationProductEvent({
 				type: "session.transcript.updated",
 				source: "sessions",
 				payload: {
-					sessionKey: update.sessionKey,
+					conversationId: update.conversationId,
 					messageId: update.messageId,
 					hasMessage: update.message !== void 0
 				}

package/dist/src/gateway/session-context-summary.d.ts

@@ -2,4 +2,4 @@ import type { SessionContextSummary } from '@xopcai/gateway-contract';
 import type { Config } from '../config/schema.js';
 import { type GatewayScope } from './security/gateway-scopes.js';
 /** A bounded metadata-only query. It never prepares Note context or starts an agent. */
-export declare function getSessionContextSummary(config: Config, sessionKey: string, scopes: readonly GatewayScope[]): Promise<SessionContextSummary | null>;
+export declare function getSessionContextSummary(config: Config, conversationId: string, scopes: readonly GatewayScope[]): Promise<SessionContextSummary | null>;

package/dist/src/gateway/session-context-summary.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
 import { hasGatewayScope } from "./security/gateway-scopes.js";
-import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { getSessionMetadata, init_session_repository } from "../storage/sqlite/session-repository.js";
 import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
@@ -13,13 +13,15 @@ import { runExec } from "../infra/exec.js";
 import { isSessionSourceBinding } from "../agent/source-context/types.js";
 import { realpath, stat } from "node:fs/promises";
 //#region src/gateway/session-context-summary.ts
+init_session_repository();
+init_transaction();
 init_logger();
 const log = createLogger("SessionContextSummary");
 const SOURCE_LIMIT = 20;
-async function readEnvironment(config, sessionKey, projectId) {
-	const bound = getExecutionEnvironmentForSession(sessionKey);
+async function readEnvironment(config, conversationId, projectId) {
+	const bound = getExecutionEnvironmentForSession(conversationId);
 	const project = projectId ? new ProjectStore().get(projectId) : void 0;
-	const rootPath = bound?.rootPath ?? effectiveWorkspacePathForSession(config, sessionKey, getSessionConfig(sessionKey), project);
+	const rootPath = bound?.rootPath ?? effectiveWorkspacePathForSession(config, conversationId, getSessionConfig(conversationId), project);
 	const available = (!bound || bound.status === "ready") && await stat(rootPath).then((info) => info.isDirectory(), () => false);
 	const environment = {
 		kind: bound?.kind ?? "local_checkout",
@@ -59,11 +61,11 @@ async function readEnvironment(config, sessionKey, projectId) {
 	return environment;
 }
 /** A bounded metadata-only query. It never prepares Note context or starts an agent. */
-async function getSessionContextSummary(config, sessionKey, scopes) {
-	const metadata = getSessionMetadata(sessionKey);
+async function getSessionContextSummary(config, conversationId, scopes) {
+	const metadata = getSessionMetadata(conversationId);
 	if (!metadata) return null;
 	const summary = {
-		sessionKey,
+		conversationId,
 		observedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		work: {},
 		sources: [],
@@ -76,7 +78,7 @@ async function getSessionContextSummary(config, sessionKey, scopes) {
 		if (!summary.unavailableSections.includes(section)) summary.unavailableSections.push(section);
 		if (err) log.warn({
 			err,
-			sessionKey,
+			conversationId,
 			section
 		}, "Context summary section unavailable");
 	};
@@ -92,7 +94,7 @@ async function getSessionContextSummary(config, sessionKey, scopes) {
 	}
 	else unavailable("work");
 	if (canReadTasks) try {
-		const taskId = new TaskConversationRepository().resolveActiveExecutionSession(sessionKey)?.taskId;
+		const taskId = new TaskConversationRepository().resolveActiveExecutionSession(conversationId)?.taskId;
 		const task = taskId ? new TaskRepository().get(taskId) : void 0;
 		if (task) summary.work.task = {
 			id: task.id,
@@ -136,7 +138,7 @@ async function getSessionContextSummary(config, sessionKey, scopes) {
 			unavailable("sources", err);
 		}
 		try {
-			summary.environment = await readEnvironment(config, sessionKey, metadata.projectId);
+			summary.environment = await readEnvironment(config, conversationId, metadata.projectId);
 		} catch (err) {
 			unavailable("environment", err);
 		}

package/dist/src/gateway/session-reset-service.d.ts

@@ -6,15 +6,15 @@ export type SessionResetDeps = {
 };
 export type SessionResetResult = {
     ok: true;
-    sessionId: string;
-    previousSessionId?: string;
+    transcriptId: string;
+    previousTranscriptId?: string;
 } | {
     ok: false;
     error: string;
 };
 /**
  * Reset a session in place: archive the current transcript, assign a new
- * `sessionId`, keep the session key and persisted overrides (model/thinking in
+ * `transcriptId`, keep the session key and persisted overrides (model/thinking in
  * SQLite `session_config`, thinking/verbose on the session row).
  */
-export declare function performSessionReset(sessionKey: string, deps: SessionResetDeps): Promise<SessionResetResult>;
+export declare function performSessionReset(conversationId: string, deps: SessionResetDeps): Promise<SessionResetResult>;

package/dist/src/gateway/session-reset-service.js

@@ -1,6 +1,6 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { retireSessionMcpRuntimeForSessionKey } from "../agent/mcp/bundle-mcp-runtime.js";
+import { retireSessionMcpRuntimeForConversationId } from "../agent/mcp/bundle-mcp-runtime.js";
 import { abortEmbeddedRun } from "../agent/embedded/runs.js";
 import "../agent/mcp/bundle-mcp-tools.js";
 //#region src/gateway/session-reset-service.ts
@@ -8,11 +8,11 @@ init_logger();
 const log = createLogger("SessionReset");
 /**
 * Reset a session in place: archive the current transcript, assign a new
-* `sessionId`, keep the session key and persisted overrides (model/thinking in
+* `transcriptId`, keep the session key and persisted overrides (model/thinking in
 * SQLite `session_config`, thinking/verbose on the session row).
 */
-async function performSessionReset(sessionKey, deps) {
-	const key = sessionKey.trim();
+async function performSessionReset(conversationId, deps) {
+	const key = conversationId.trim();
 	if (!key) return {
 		ok: false,
 		error: "Session key required"
@@ -25,27 +25,27 @@ async function performSessionReset(sessionKey, deps) {
 	};
 	try {
 		deps.getAgentService().evictSessionAgent(key);
-		await retireSessionMcpRuntimeForSessionKey({
-			sessionKey: key,
+		await retireSessionMcpRuntimeForConversationId({
+			conversationId: key,
 			reason: "session-reset"
 		});
 	} catch (err) {
 		const em = err instanceof Error ? err.message : String(err);
 		log.warn({
 			err,
-			sessionKey: key,
+			conversationId: key,
 			errorMessage: em
 		}, `Session reset runtime cleanup failed: ${em}`);
 	}
 	log.info({
-		sessionKey: key,
-		sessionId: task.sessionId,
-		previousSessionId: task.previousSessionId
+		conversationId: key,
+		transcriptId: task.transcriptId,
+		previousTranscriptId: task.previousTranscriptId
 	}, "Session reset completed");
 	return {
 		ok: true,
-		sessionId: task.sessionId,
-		previousSessionId: task.previousSessionId
+		transcriptId: task.transcriptId,
+		previousTranscriptId: task.previousTranscriptId
 	};
 }
 //#endregion

package/dist/src/gateway/side-chat/context-snapshot.d.ts

@@ -2,8 +2,8 @@ import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { SideChatContextSnapshot, SideChatSelection } from './types.js';
 export declare function validateSideChatSelections(value: unknown): SideChatSelection[];
 export declare function createSideChatContextSnapshot(params: {
-    parentSessionKey: string;
-    parentSessionId: string;
+    parentConversationId: string;
+    parentTranscriptId: string;
     parentMessages: readonly AgentMessage[];
     selections: readonly SideChatSelection[];
     createdAt: string;

package/dist/src/gateway/side-chat/context-snapshot.js

@@ -75,8 +75,8 @@ function createSideChatContextSnapshot(params) {
 		selections
 	})).digest("hex");
 	return {
-		parentSessionKey: params.parentSessionKey,
-		parentSessionId: params.parentSessionId,
+		parentConversationId: params.parentConversationId,
+		parentTranscriptId: params.parentTranscriptId,
 		parentMessageCount: params.parentMessages.length,
 		createdAt: params.createdAt,
 		selections,

package/dist/src/gateway/side-chat/manager.d.ts

@@ -8,10 +8,10 @@ export declare class SideChatError extends Error {
     constructor(message: string, code: 'INVALID_REQUEST' | 'NOT_FOUND' | 'PARENT_NOT_FOUND' | 'LIMIT_REACHED' | 'CAPACITY_REACHED' | 'CONFLICT' | 'EXPIRED', reason?: 'idle' | 'waiting');
 }
 export interface EphemeralSideChatManagerOptions {
-    getParentMetadata: (sessionKey: string) => Promise<SessionMetadata | null>;
-    loadParentMessages: (sessionKey: string) => Promise<AgentMessage[]>;
-    getDefaultModelRef: (sessionKey: string) => string;
-    getDefaultThinkingLevel?: (sessionKey: string) => ThinkingLevel;
+    getParentMetadata: (conversationId: string) => Promise<SessionMetadata | null>;
+    loadParentMessages: (conversationId: string) => Promise<AgentMessage[]>;
+    getDefaultModelRef: (conversationId: string) => string;
+    getDefaultThinkingLevel?: (conversationId: string) => ThinkingLevel;
     getWorkspacePath: (metadata: SessionMetadata) => string;
     idleTtlMs?: number;
     maxPerClient?: number;