@xopcai/xopc 0.0.285 → 0.0.286

package/dist/src/tui/backends/embedded-backend.d.ts

@@ -44,38 +44,38 @@ export declare class EmbeddedBackend implements TuiBackend {
     private getWorkflowRunService;
     private activeConfig;
     private isWorkspaceTrusted;
-    getStartupResources(sessionKey: string): Promise<import("../tui-backend.js").TuiStartupResources>;
+    getStartupResources(conversationId: string): Promise<import("../tui-backend.js").TuiStartupResources>;
     refreshWorkspaceTrust(): void;
     startWorkflowRun(opts: TuiWorkflowRunStartRequest): Promise<TuiWorkflowRunStartResult>;
     resolveStartupProject(opts: {
         workspacePath: string;
-        sessionKey: string;
+        conversationId: string;
         agentId: string;
         autoCreate?: boolean;
     }): Promise<TuiStartupProjectResult>;
-    searchWorkspaceFiles(sessionKey: string, query: string, options?: {
+    searchWorkspaceFiles(conversationId: string, query: string, options?: {
         limit?: number;
     }): Promise<TuiWorkspaceFileSearchEntry[]>;
-    getReviewContext(sessionKey: string): Promise<import("../../review/review-git.js").ReviewContext>;
+    getReviewContext(conversationId: string): Promise<import("../../review/review-git.js").ReviewContext>;
     sendChat(opts: ChatSendOptions): Promise<{
         runId: string;
     }>;
     abortChat(_opts: {
-        sessionKey: string;
+        conversationId: string;
         runId: string;
     }): Promise<{
         ok: boolean;
     }>;
     submitChatInput(opts: {
-        sessionKey: string;
+        conversationId: string;
         message: string;
         delivery: 'next' | 'steer';
     }): Promise<{
         ok: boolean;
         effectiveDelivery?: 'next' | 'steer';
     }>;
-    getChatInputState(sessionKey: string): Promise<{
-        sessionKey: string;
+    getChatInputState(conversationId: string): Promise<{
+        conversationId: string;
         revision: number;
         inputs: {
             id: string;
@@ -83,13 +83,13 @@ export declare class EmbeddedBackend implements TuiBackend {
         }[];
     }>;
     loadHistory(opts: {
-        sessionKey: string;
+        conversationId: string;
         limit?: number;
     }): Promise<{
         messages: HistoryMessage[];
     }>;
     loadHistoryWindow(opts: {
-        sessionKey: string;
+        conversationId: string;
         rowNumber: number;
         before?: number;
         after?: number;
@@ -99,56 +99,57 @@ export declare class EmbeddedBackend implements TuiBackend {
         endRowNumber: number;
         totalRows: number;
     }>;
-    loadTranscriptTree(sessionKey: string): Promise<TuiTranscriptTreeEntry[]>;
-    loadTimeline(sessionKey: string): Promise<SessionTimelineItem[]>;
-    getSessionStats(sessionKey: string): Promise<TuiSessionStats>;
+    loadTranscriptTree(conversationId: string): Promise<TuiTranscriptTreeEntry[]>;
+    loadTimeline(conversationId: string): Promise<SessionTimelineItem[]>;
+    getSessionStats(conversationId: string): Promise<TuiSessionStats>;
     listSessions(): Promise<TuiSessionItem[]>;
     listAgents(): Promise<TuiAgentInfo[]>;
     setTuiDefaultAgent(agentId: string): Promise<{
         agentId: string;
     }>;
-    renameSession(sessionKey: string, name: string): Promise<{
+    renameSession(conversationId: string, name: string): Promise<{
         ok: boolean;
     }>;
-    deleteSession(sessionKey: string): Promise<{
+    deleteSession(conversationId: string): Promise<{
         ok: boolean;
     }>;
-    getSessionInfo(sessionKey: string): Promise<SessionInfo>;
+    createConversation(agentId: string, conversationId?: string): Promise<string>;
+    getSessionInfo(conversationId: string): Promise<SessionInfo>;
     listModels(): Promise<TuiModelChoice[]>;
     refreshModels(): Promise<void>;
-    resetSession(sessionKey: string): Promise<void>;
-    patchSession(sessionKey: string, patch: Record<string, unknown>): Promise<void>;
-    compactSession(sessionKey: string, options?: {
+    resetSession(conversationId: string): Promise<void>;
+    patchSession(conversationId: string, patch: Record<string, unknown>): Promise<void>;
+    compactSession(conversationId: string, options?: {
         force?: boolean;
         instructions?: string;
     }): Promise<TuiCompactionResult>;
-    exportSession(sessionKey: string, format: ExportFormat): Promise<string>;
-    importSession(targetSessionKey: string, jsonContent: string): Promise<{
-        sessionKey: string;
+    exportSession(conversationId: string, format: ExportFormat): Promise<string>;
+    importSession(targetConversationId: string, jsonContent: string): Promise<{
+        conversationId: string;
         rowCount: number;
     }>;
-    createShare(_sessionKey: string, request: TuiShareRequest, _options?: {
+    createShare(_conversationId: string, request: TuiShareRequest, _options?: {
         agentId?: string;
     }): Promise<TuiShareResult>;
-    btwQuery(sessionKey: string, question: string): Promise<{
+    btwQuery(conversationId: string, question: string): Promise<{
         text: string;
         error?: string;
     }>;
-    forkSession(sourceSessionKey: string, targetSessionKey: string): Promise<{
-        sessionKey: string;
+    forkSession(sourceConversationId: string, targetConversationId: string): Promise<{
+        conversationId: string;
         rowCount: number;
     }>;
-    forkSessionAt(sourceSessionKey: string, targetSessionKey: string, entryId: string): Promise<{
-        sessionKey: string;
+    forkSessionAt(sourceConversationId: string, targetConversationId: string, entryId: string): Promise<{
+        conversationId: string;
         rowCount: number;
     }>;
-    setTranscriptLabel(sessionKey: string, entryId: string, label: string | undefined): Promise<{
+    setTranscriptLabel(conversationId: string, entryId: string, label: string | undefined): Promise<{
         ok: boolean;
     }>;
-    appendCustomEntry(sessionKey: string, customType: string, data?: unknown): Promise<{
+    appendCustomEntry(conversationId: string, customType: string, data?: unknown): Promise<{
         ok: boolean;
     }>;
-    appendCustomMessage(sessionKey: string, message: {
+    appendCustomMessage(conversationId: string, message: {
         customType: string;
         content?: string | unknown[];
         display?: boolean;
@@ -156,7 +157,7 @@ export declare class EmbeddedBackend implements TuiBackend {
     }): Promise<{
         ok: boolean;
     }>;
-    appendBashExecution(sessionKey: string, entry: {
+    appendBashExecution(conversationId: string, entry: {
         command: string;
         output?: string;
         exitCode?: number | null;

package/dist/src/tui/backends/embedded-backend.js

@@ -1,12 +1,13 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { openXopcDatabase } from "../../storage/sqlite/connection.js";
-import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
 import { appendComposerInputHistory, listComposerInputHistory } from "../../storage/sqlite/composer-input-history-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import "../../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId } from "../../agent/agent-scope.js";
+import { createConversation, init_conversation_repository } from "../../storage/sqlite/conversation-repository.js";
+import { init_agent_session_key, resolveAgentIdFromConversationId } from "../../routing/agent-session-key.js";
 import { loadConfig, saveConfig } from "../../config/loader.js";
 import { effectiveWorkspacePathForSession } from "../../session/session-workspace.js";
 import { ProjectService } from "../../projects/project-service.js";
@@ -38,6 +39,7 @@ import { computeTuiSessionStats } from "../tui-session-stats.js";
 import { collectTuiStartupResources } from "../tui-startup-resources.js";
 import { isAbsolute, relative, resolve } from "node:path";
 //#region src/tui/backends/embedded-backend.ts
+init_conversation_repository();
 init_agent_scope();
 init_agent_session_key();
 init_schema();
@@ -187,7 +189,7 @@ var EmbeddedBackend = class {
 			currentConfig: this.config,
 			currentWorkspacePath: this.workspace,
 			messageBusInstance: this.bus,
-			agentService: { getModelForSession: (sessionKey) => this.agent.getModelForSession(sessionKey) },
+			agentService: { getModelForSession: (conversationId) => this.agent.getModelForSession(conversationId) },
 			sessionIndexInstance: this.sessionIndex,
 			emit: (event, payload) => {
 				this.onEvent?.({
@@ -213,22 +215,22 @@ var EmbeddedBackend = class {
 		const implicit = this.opts?.implicitTrustedWorkspace;
 		return Boolean(implicit && isPathSameOrInside(implicit, workspaceDir));
 	}
-	async getStartupResources(sessionKey) {
-		return collectTuiStartupResources(this.activeConfig(), sessionKey, { isWorkspaceTrusted: (workspaceDir) => this.isWorkspaceTrusted(workspaceDir) });
+	async getStartupResources(conversationId) {
+		return collectTuiStartupResources(this.activeConfig(), conversationId, { isWorkspaceTrusted: (workspaceDir) => this.isWorkspaceTrusted(workspaceDir) });
 	}
 	refreshWorkspaceTrust() {
 		this.agent?.refreshSkillsAfterTrustChange();
 	}
 	async startWorkflowRun(opts) {
 		await this.sessionIndexReady;
-		const agentId = opts.agentId?.trim() || resolveAgentIdFromSessionKey(opts.sessionKey);
+		const agentId = opts.agentId?.trim() || resolveAgentIdFromConversationId(opts.conversationId);
 		const result = await this.getWorkflowRunService().startWorkflowRun({
 			agentId,
 			definitionId: opts.definitionId,
-			parentSessionKey: opts.sessionKey,
+			parentConversationId: opts.conversationId,
 			source: {
 				kind: "chat",
-				sessionKey: opts.sessionKey
+				conversationId: opts.conversationId
 			},
 			goal: opts.goal,
 			input: opts.input
@@ -236,7 +238,7 @@ var EmbeddedBackend = class {
 		if (result.ok === false) throw new Error(result.message);
 		return {
 			runId: result.runId,
-			sessionKey: result.sessionKey,
+			conversationId: result.conversationId,
 			definitionId: opts.definitionId
 		};
 	}
@@ -261,9 +263,9 @@ var EmbeddedBackend = class {
 			created: match.created,
 			reason: match.reason
 		};
-		if (!getSessionMetadata(opts.sessionKey)) await this.sessionIndex.getStore().resolveTranscriptPath(opts.sessionKey, { metadata: {
+		if (!getSessionMetadata(opts.conversationId)) await this.sessionIndex.getStore().resolveTranscriptPath(opts.conversationId, { metadata: {
 			sourceChannel: "tui",
-			sourceChatId: `default:direct:${opts.sessionKey}`,
+			sourceChatId: `default:direct:${opts.conversationId}`,
 			sessionType: "chat",
 			projectId: match.project.id,
 			routing: {
@@ -271,34 +273,34 @@ var EmbeddedBackend = class {
 				source: "tui",
 				accountId: "default",
 				peerKind: "direct",
-				peerId: opts.sessionKey
+				peerId: opts.conversationId
 			}
 		} });
-		projects.attachSession(opts.sessionKey, match.project.id);
+		projects.attachSession(opts.conversationId, match.project.id);
 		return {
 			project: match.project,
 			created: match.created,
 			reason: match.reason
 		};
 	}
-	async searchWorkspaceFiles(sessionKey, query, options) {
+	async searchWorkspaceFiles(conversationId, query, options) {
 		if (!this.agent) return [];
 		try {
-			return await fuzzySearchWorkspaceFiles(await this.agent.getEffectiveWorkspacePathForSession(sessionKey), query, options?.limit ?? 15);
+			return await fuzzySearchWorkspaceFiles(await this.agent.getEffectiveWorkspacePathForSession(conversationId), query, options?.limit ?? 15);
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `Embedded workspace file search failed: ${errorMessage}`);
 			return [];
 		}
 	}
-	async getReviewContext(sessionKey) {
+	async getReviewContext(conversationId) {
 		const config = this.activeConfig();
-		const metadata = getSessionMetadata(sessionKey);
-		return buildReviewContext(await resolveGitRoot(effectiveWorkspacePathForSession(config, sessionKey, null, metadata?.projectId ? new ProjectService().get(metadata.projectId) : null)));
+		const metadata = getSessionMetadata(conversationId);
+		return buildReviewContext(await resolveGitRoot(effectiveWorkspacePathForSession(config, conversationId, null, metadata?.projectId ? new ProjectService().get(metadata.projectId) : null)));
 	}
 	async sendChat(opts) {
 		const agent = await this.ensureAgent();
@@ -308,7 +310,7 @@ var EmbeddedBackend = class {
 		const signal = this.chatAbort.signal;
 		const mapper = new ChatStreamMapper({
 			runId,
-			sessionKey: opts.sessionKey,
+			conversationId: opts.conversationId,
 			channel: "tui"
 		});
 		for (const event of mapper.start()) this.onEvent?.({
@@ -319,7 +321,7 @@ var EmbeddedBackend = class {
 		(async () => {
 			try {
 				const messageForAgent = opts.message.trimStart().startsWith("/") ? opts.message : prependEnvelopeTimestamp(opts.message);
-				const stream = agent.turnDispatcher.processDirectStreaming(messageForAgent, opts.sessionKey, {
+				const stream = agent.turnDispatcher.processDirectStreaming(messageForAgent, opts.conversationId, {
 					type: "system",
 					source: "cli"
 				}, opts.attachments, opts.thinking, {
@@ -367,14 +369,14 @@ var EmbeddedBackend = class {
 	async submitChatInput(opts) {
 		if (!this.agent) return { ok: false };
 		if (opts.delivery === "steer") {
-			const ok = await this.agent.turnDispatcher.steerWebchatSession(opts.sessionKey, opts.message);
+			const ok = await this.agent.turnDispatcher.steerWebchatSession(opts.conversationId, opts.message);
 			return {
 				ok,
 				effectiveDelivery: ok ? "steer" : void 0
 			};
 		}
-		const { getEmbeddedRunBySessionKey } = await import("../../agent/embedded/runs.js");
-		const handle = getEmbeddedRunBySessionKey(opts.sessionKey);
+		const { getEmbeddedRunByConversationId } = await import("../../agent/embedded/runs.js");
+		const handle = getEmbeddedRunByConversationId(opts.conversationId);
 		if (!handle) return { ok: false };
 		await handle.session.followUp(opts.message);
 		return {
@@ -382,11 +384,11 @@ var EmbeddedBackend = class {
 			effectiveDelivery: "next"
 		};
 	}
-	async getChatInputState(sessionKey) {
-		const { getEmbeddedRunBySessionKey } = await import("../../agent/embedded/runs.js");
-		const handle = getEmbeddedRunBySessionKey(sessionKey);
+	async getChatInputState(conversationId) {
+		const { getEmbeddedRunByConversationId } = await import("../../agent/embedded/runs.js");
+		const handle = getEmbeddedRunByConversationId(conversationId);
 		return {
-			sessionKey,
+			conversationId,
 			revision: 0,
 			inputs: Array.from({ length: handle?.session.pendingMessageCount ?? 0 }, (_, index) => ({
 				id: String(index),
@@ -397,7 +399,7 @@ var EmbeddedBackend = class {
 	async loadHistory(opts) {
 		if (!this.agent) return { messages: [] };
 		try {
-			return { messages: transcriptRowsToClientHistory(await this.agent.sessionStore.loadTranscriptRows(opts.sessionKey), { limit: opts.limit }) };
+			return { messages: transcriptRowsToClientHistory(await this.agent.sessionStore.loadTranscriptRows(opts.conversationId), { limit: opts.limit }) };
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
@@ -415,7 +417,7 @@ var EmbeddedBackend = class {
 			totalRows: 0
 		};
 		try {
-			const rows = await this.agent.sessionStore.loadTranscriptRows(opts.sessionKey);
+			const rows = await this.agent.sessionStore.loadTranscriptRows(opts.conversationId);
 			const totalRows = rows.length;
 			if (totalRows === 0) return {
 				messages: [],
@@ -441,7 +443,7 @@ var EmbeddedBackend = class {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey: opts.sessionKey,
+				conversationId: opts.conversationId,
 				rowNumber: opts.rowNumber,
 				errorMessage
 			}, `Embedded loadHistoryWindow failed: ${errorMessage}`);
@@ -453,44 +455,44 @@ var EmbeddedBackend = class {
 			};
 		}
 	}
-	async loadTranscriptTree(sessionKey) {
+	async loadTranscriptTree(conversationId) {
 		if (!this.agent) return [];
 		try {
-			return buildTuiTranscriptTree(await this.agent.sessionStore.loadTranscriptRows(sessionKey));
+			return buildTuiTranscriptTree(await this.agent.sessionStore.loadTranscriptRows(conversationId));
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `Embedded loadTranscriptTree failed: ${errorMessage}`);
 			return [];
 		}
 	}
-	async loadTimeline(sessionKey) {
+	async loadTimeline(conversationId) {
 		if (!this.agent) return [];
 		try {
-			return buildSessionTimeline(await this.agent.sessionStore.loadTranscriptRows(sessionKey));
+			return buildSessionTimeline(await this.agent.sessionStore.loadTranscriptRows(conversationId));
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `Embedded loadTimeline failed: ${errorMessage}`);
 			return [];
 		}
 	}
-	async getSessionStats(sessionKey) {
+	async getSessionStats(conversationId) {
 		const store = this.agent?.sessionStore ?? this.sessionIndex?.getStore();
 		if (!store) return computeTuiSessionStats([]);
 		try {
-			return computeTuiSessionStats(await store.loadTranscriptRows(sessionKey));
+			return computeTuiSessionStats(await store.loadTranscriptRows(conversationId));
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `Embedded getSessionStats failed: ${errorMessage}`);
 			return computeTuiSessionStats([]);
@@ -533,43 +535,53 @@ var EmbeddedBackend = class {
 		this.config = result.config;
 		return { agentId: result.agentId };
 	}
-	async renameSession(sessionKey, name) {
+	async renameSession(conversationId, name) {
 		if (!this.agent) return { ok: false };
 		try {
-			await this.agent.sessionStore.updateMetadata(sessionKey, { name: name.trim() });
+			await this.agent.sessionStore.updateMetadata(conversationId, { name: name.trim() });
 			return { ok: true };
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `Embedded renameSession failed: ${errorMessage}`);
 			return { ok: false };
 		}
 	}
-	async deleteSession(sessionKey) {
+	async deleteSession(conversationId) {
 		const store = this.agent?.sessionStore ?? this.sessionIndex?.getStore();
 		if (!store) return { ok: false };
 		try {
-			return { ok: await store.deleteSession(sessionKey) };
+			return { ok: await store.deleteSession(conversationId) };
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
 				err: error,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `Embedded deleteSession failed: ${errorMessage}`);
 			return { ok: false };
 		}
 	}
-	async getSessionInfo(sessionKey) {
+	async createConversation(agentId, conversationId) {
+		return createConversation({
+			agentId,
+			sourceChannel: "tui",
+			customData: { genericNewChatShell: true },
+			hiddenFromSessionList: true
+		}, "", conversationId).key;
+	}
+	async getSessionInfo(conversationId) {
 		if (!this.agent) return { model: getAgentDefaultModelRef(this.activeConfig()) ?? void 0 };
 		try {
-			const cfg = await this.agent.sessionInspector.agentConfig(sessionKey);
+			const cfg = await this.agent.sessionInspector.agentConfig(conversationId);
 			const parsed = parseModelRef(cfg.model);
-			const usage = await this.agent.sessionInspector.contextUsage(sessionKey);
+			const usage = await this.agent.sessionInspector.contextUsage(conversationId);
 			return {
+				agentId: getSessionMetadata(conversationId)?.agentId,
+				generatedShell: getSessionMetadata(conversationId)?.customData?.genericNewChatShell === true,
 				model: parsed?.model ?? cfg.model,
 				modelProvider: parsed?.provider,
 				thinkingLevel: cfg.thinkingLevel,
@@ -580,13 +592,13 @@ var EmbeddedBackend = class {
 				contextUsagePercent: usage.usagePercent,
 				effectiveWorkspacePath: cfg.effectiveWorkspacePath,
 				workingDirectoryLocked: cfg.workingDirectoryLocked,
-				projectId: getSessionMetadata(sessionKey)?.projectId
+				projectId: getSessionMetadata(conversationId)?.projectId
 			};
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			log.warn({
 				err,
-				sessionKey,
+				conversationId,
 				errorMessage
 			}, `getSessionInfo failed: ${errorMessage}`);
 			return { model: getAgentDefaultModelRef(this.activeConfig()) ?? void 0 };
@@ -604,15 +616,15 @@ var EmbeddedBackend = class {
 	async refreshModels() {
 		await this.refreshXopcCloudModels();
 	}
-	async resetSession(sessionKey) {
+	async resetSession(conversationId) {
 		if (!this.agent) return;
-		await this.agent.resetSession(sessionKey);
+		await this.agent.resetSession(conversationId);
 	}
-	async patchSession(sessionKey, patch) {
+	async patchSession(conversationId, patch) {
 		const agent = await this.ensureAgent();
 		const hasProjectPatch = Object.prototype.hasOwnProperty.call(patch, "projectId");
 		const projectId = typeof patch.projectId === "string" ? patch.projectId.trim() : "";
-		const result = await agent.sessionConfig.patch(sessionKey, {
+		const result = await agent.sessionConfig.patch(conversationId, {
 			model: typeof patch.model === "string" ? patch.model : void 0,
 			thinkingLevel: typeof patch.thinkingLevel === "string" ? patch.thinkingLevel : void 0,
 			reasoningLevel: typeof patch.reasoningLevel === "string" ? patch.reasoningLevel : void 0,
@@ -622,18 +634,18 @@ var EmbeddedBackend = class {
 		if (!result.ok) throw new Error(result.error);
 		if (projectId) {
 			await this.sessionIndexReady;
-			await this.sessionIndex?.getStore().resolveTranscriptPath(sessionKey);
-			new ProjectService().attachSession(sessionKey, projectId);
-		} else if (hasProjectPatch && patch.projectId === null) new ProjectService().detachSession(sessionKey);
+			await this.sessionIndex?.getStore().resolveTranscriptPath(conversationId);
+			new ProjectService().attachSession(conversationId, projectId);
+		} else if (hasProjectPatch && patch.projectId === null) new ProjectService().detachSession(conversationId);
 		const hiddenFromSessionList = typeof patch.hiddenFromSessionList === "boolean" ? patch.hiddenFromSessionList : void 0;
 		const customData = patch.customData && typeof patch.customData === "object" && !Array.isArray(patch.customData) ? patch.customData : void 0;
 		if (hiddenFromSessionList !== void 0 || customData !== void 0) {
 			await this.sessionIndexReady;
 			const store = this.sessionIndex?.getStore();
 			if (store) {
-				await store.resolveTranscriptPath(sessionKey);
-				const existing = getSessionMetadata(sessionKey);
-				if (existing && existing.messageCount === 0) await store.updateMetadata(sessionKey, {
+				await store.resolveTranscriptPath(conversationId);
+				const existing = getSessionMetadata(conversationId);
+				if (existing && existing.messageCount === 0) await store.updateMetadata(conversationId, {
 					...hiddenFromSessionList !== void 0 ? { hiddenFromSessionList } : {},
 					...customData ? { customData: {
 						...existing.customData ?? {},
@@ -643,13 +655,13 @@ var EmbeddedBackend = class {
 			}
 		}
 	}
-	async compactSession(sessionKey, options) {
+	async compactSession(conversationId, options) {
 		if (!this.agent) return {
 			compacted: false,
 			summary: "Agent not started"
 		};
 		try {
-			const result = await this.agent.sessionInspector.compact(sessionKey, {
+			const result = await this.agent.sessionInspector.compact(conversationId, {
 				force: options?.force ?? true,
 				instructions: options?.instructions
 			});
@@ -671,15 +683,15 @@ var EmbeddedBackend = class {
 			};
 		}
 	}
-	async exportSession(sessionKey, format) {
+	async exportSession(conversationId, format) {
 		if (!this.agent) throw new Error("Agent not started");
-		return this.agent.sessionStore.exportSession(sessionKey, format);
+		return this.agent.sessionStore.exportSession(conversationId, format);
 	}
-	async importSession(targetSessionKey, jsonContent) {
+	async importSession(targetConversationId, jsonContent) {
 		if (!this.agent) throw new Error("Agent not started");
-		return this.agent.sessionStore.importSessionExport(targetSessionKey, jsonContent);
+		return this.agent.sessionStore.importSessionExport(targetConversationId, jsonContent);
 	}
-	async createShare(_sessionKey, request, _options) {
+	async createShare(_conversationId, request, _options) {
 		if (!this.agent) throw new Error("Agent not started");
 		const config = this.activeConfig();
 		if (!isShareToolAvailable(config)) throw new Error("Sharing is disabled in gateway config");
@@ -716,49 +728,49 @@ var EmbeddedBackend = class {
 			routingHint: typeof details.routing?.hint === "string" ? details.routing.hint : void 0
 		};
 	}
-	async btwQuery(sessionKey, question) {
+	async btwQuery(conversationId, question) {
 		if (!this.agent) return {
 			text: "",
 			error: "Agent not started"
 		};
-		return this.agent.sessionInspector.btwQuery(sessionKey, question);
+		return this.agent.sessionInspector.btwQuery(conversationId, question);
 	}
-	async forkSession(sourceSessionKey, targetSessionKey) {
+	async forkSession(sourceConversationId, targetConversationId) {
 		if (!this.agent) throw new Error("Agent not started");
-		return this.agent.sessionStore.forkSession(sourceSessionKey, targetSessionKey);
+		return this.agent.sessionStore.forkSession(sourceConversationId, targetConversationId);
 	}
-	async forkSessionAt(sourceSessionKey, targetSessionKey, entryId) {
+	async forkSessionAt(sourceConversationId, targetConversationId, entryId) {
 		if (!this.agent) throw new Error("Agent not started");
 		const throughRow = transcriptTreeEntryIdToRowNumber(entryId);
 		if (throughRow == null) throw new Error(`Invalid transcript entry: ${entryId}`);
-		return this.agent.sessionStore.forkSessionRows(sourceSessionKey, targetSessionKey, { throughRow });
+		return this.agent.sessionStore.forkSessionRows(sourceConversationId, targetConversationId, { throughRow });
 	}
-	async setTranscriptLabel(sessionKey, entryId, label) {
+	async setTranscriptLabel(conversationId, entryId, label) {
 		if (!this.agent) throw new Error("Agent not started");
-		await this.agent.sessionStore.appendTranscriptLabelEntry(sessionKey, {
+		await this.agent.sessionStore.appendTranscriptLabelEntry(conversationId, {
 			targetId: entryId,
 			label
 		});
 		return { ok: true };
 	}
-	async appendCustomEntry(sessionKey, customType, data) {
+	async appendCustomEntry(conversationId, customType, data) {
 		if (!this.agent) throw new Error("Agent not started");
-		await this.agent.sessionStore.appendTranscriptCustomEntry(sessionKey, {
+		await this.agent.sessionStore.appendTranscriptCustomEntry(conversationId, {
 			customType,
 			data
 		});
 		return { ok: true };
 	}
-	async appendCustomMessage(sessionKey, message) {
+	async appendCustomMessage(conversationId, message) {
 		if (!this.agent) throw new Error("Agent not started");
-		await this.agent.sessionStore.appendTranscriptCustomMessageEntry(sessionKey, message);
-		evictEmbeddedSessionRunner(sessionKey, "tui_custom_message_appended");
+		await this.agent.sessionStore.appendTranscriptCustomMessageEntry(conversationId, message);
+		evictEmbeddedSessionRunner(conversationId, "tui_custom_message_appended");
 		return { ok: true };
 	}
-	async appendBashExecution(sessionKey, entry) {
+	async appendBashExecution(conversationId, entry) {
 		if (!this.agent) throw new Error("Agent not started");
-		await this.agent.sessionStore.appendTranscriptBashExecutionEntry(sessionKey, entry);
-		evictEmbeddedSessionRunner(sessionKey, "tui_bash_execution_appended");
+		await this.agent.sessionStore.appendTranscriptBashExecutionEntry(conversationId, entry);
+		evictEmbeddedSessionRunner(conversationId, "tui_bash_execution_appended");
 		return { ok: true };
 	}
 	processOutbound() {