@xopcai/xopc 0.0.285 → 0.0.286

package/dist/src/gateway/service/session-input-coordinator.js

@@ -1,15 +1,17 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { SessionInstanceChangedError, cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "../../storage/sqlite/session-input-repository.js";
+import { SessionInstanceChangedError, cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, init_session_input_repository, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "../../storage/sqlite/session-input-repository.js";
 import { consumeClarificationResume, supersedeActiveClarification } from "../../storage/sqlite/clarification-wait-repository.js";
 import { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget } from "../../storage/sqlite/session-turn-replace-repository.js";
-import { cancelConnectionObjective, consumeConnectionResume, invalidateConnectionResumeIntent, publishConnectionWait } from "../../storage/sqlite/connection-wait-repository.js";
+import { cancelConnectionObjective, consumeConnectionResume, init_connection_wait_repository, invalidateConnectionResumeIntent, publishConnectionWait } from "../../storage/sqlite/connection-wait-repository.js";
 import "../../storage/sqlite/index.js";
 import { summarizeSourceContext } from "../../agent/source-context/types.js";
 import { deleteMediaUrisNoLongerReferenced } from "../../media/session-references.js";
 import { fitSourceContextsToBudget } from "../../agent/source-context/budget.js";
 import crypto from "node:crypto";
 //#region src/gateway/service/session-input-coordinator.ts
+init_connection_wait_repository();
+init_session_input_repository();
 init_logger();
 const log = createLogger("SessionInputCoordinator");
 const MAX_PENDING_INPUTS = 10;
@@ -26,36 +28,36 @@ var SessionInputCoordinator = class {
 	constructor(deps) {
 		this.deps = deps;
 	}
-	snapshot(sessionKey) {
-		return getSessionInputState(sessionKey);
+	snapshot(conversationId) {
+		return getSessionInputState(conversationId);
 	}
-	publish(sessionKey) {
-		const state = this.snapshot(sessionKey);
+	publish(conversationId) {
+		const state = this.snapshot(conversationId);
 		this.deps.emit("session.input-state", state);
 		return state;
 	}
-	async runSubmissionExclusive(sessionKey, operation) {
-		const previous = this.submissionTails.get(sessionKey) ?? Promise.resolve();
+	async runSubmissionExclusive(conversationId, operation) {
+		const previous = this.submissionTails.get(conversationId) ?? Promise.resolve();
 		let release = () => {};
 		const current = new Promise((resolve) => {
 			release = resolve;
 		});
 		const tail = previous.then(() => current);
-		this.submissionTails.set(sessionKey, tail);
+		this.submissionTails.set(conversationId, tail);
 		await previous;
 		try {
 			return await operation();
 		} finally {
 			release();
-			if (this.submissionTails.get(sessionKey) === tail) this.submissionTails.delete(sessionKey);
+			if (this.submissionTails.get(conversationId) === tail) this.submissionTails.delete(conversationId);
 		}
 	}
 	async submit(input) {
-		const sessionKey = input.sessionKey.trim();
+		const conversationId = input.conversationId.trim();
 		try {
-			return await this.runSubmissionExclusive(sessionKey, () => this.submitLocked({
+			return await this.runSubmissionExclusive(conversationId, () => this.submitLocked({
 				...input,
-				sessionKey
+				conversationId
 			}));
 		} catch (error) {
 			if (error instanceof SessionInstanceChangedError) return {
@@ -66,35 +68,35 @@ var SessionInputCoordinator = class {
 		}
 	}
 	async replaceLatestTurn(input, beforeReplace) {
-		const sessionKey = input.sessionKey.trim();
-		return this.runSubmissionExclusive(sessionKey, async () => {
+		const conversationId = input.conversationId.trim();
+		return this.runSubmissionExclusive(conversationId, async () => {
 			const clientMessageId = input.clientMessageId.trim();
 			const content = input.content.trim();
 			const targetTurnId = input.targetTurnId.trim();
-			if (!sessionKey || !clientMessageId || !targetTurnId || !content && !input.attachments?.length && !input.sourceContexts?.length) return {
+			if (!conversationId || !clientMessageId || !targetTurnId || !content && !input.attachments?.length && !input.sourceContexts?.length) return {
 				ok: false,
 				code: "BAD_REQUEST"
 			};
-			if (!await this.deps.sessionExists(sessionKey)) return {
+			if (!await this.deps.sessionExists(conversationId)) return {
 				ok: false,
 				code: "BAD_REQUEST"
 			};
-			if (findSessionInput(sessionKey, clientMessageId)) return {
+			if (findSessionInput(conversationId, clientMessageId)) return {
 				ok: true,
 				effectiveDelivery: "next",
-				state: this.snapshot(sessionKey)
+				state: this.snapshot(conversationId)
 			};
-			const target = validateLatestSessionTurnTarget(sessionKey, targetTurnId);
+			const target = validateLatestSessionTurnTarget(conversationId, targetTurnId);
 			if (target.ok === false) return target;
 			await beforeReplace();
-			const attachments = await this.deps.prepareAttachments(sessionKey, input.attachments);
+			const attachments = await this.deps.prepareAttachments(conversationId, input.attachments);
 			let sourceContexts;
 			try {
 				sourceContexts = fitSourceContextsToBudget([...await this.deps.prepareContexts(input.contextRefs) ?? [], ...input.sourceContexts ?? []]);
 			} catch (err) {
 				log.warn({
 					err,
-					sessionKey
+					conversationId
 				}, "Session input context preparation failed");
 				return {
 					ok: false,
@@ -102,7 +104,7 @@ var SessionInputCoordinator = class {
 				};
 			}
 			const result = replaceLatestSessionTurnAndQueueInput({
-				sessionKey,
+				conversationId,
 				targetTurnId,
 				clientMessageId,
 				content,
@@ -114,8 +116,8 @@ var SessionInputCoordinator = class {
 			});
 			if (result.ok === false) return result;
 			if (!result.idempotent) {
-				cancelConnectionObjective(sessionKey);
-				supersedeActiveClarification(sessionKey);
+				cancelConnectionObjective(conversationId);
+				supersedeActiveClarification(conversationId);
 				const replacement = {
 					role: "user",
 					content,
@@ -126,57 +128,57 @@ var SessionInputCoordinator = class {
 					remaining: [...result.remainingMessages, replacement]
 				});
 			}
-			this.drain(sessionKey);
+			this.drain(conversationId);
 			return {
 				ok: true,
 				effectiveDelivery: "next",
-				state: this.publish(sessionKey)
+				state: this.publish(conversationId)
 			};
 		});
 	}
 	async submitLocked(input) {
-		const sessionKey = input.sessionKey;
+		const conversationId = input.conversationId;
 		const clientMessageId = input.clientMessageId.trim();
 		const content = input.content.trim();
-		if (!sessionKey || !clientMessageId || !content && !input.attachments?.length && !input.sourceContexts?.length) return {
+		if (!conversationId || !clientMessageId || !content && !input.attachments?.length && !input.sourceContexts?.length) return {
 			ok: false,
 			code: "BAD_REQUEST"
 		};
-		if (!await this.deps.sessionExists(sessionKey)) return {
+		if (!await this.deps.sessionExists(conversationId)) return {
 			ok: false,
 			code: "BAD_REQUEST"
 		};
-		const existing = findSessionInput(sessionKey, clientMessageId);
+		const existing = findSessionInput(conversationId, clientMessageId);
 		if (existing) return {
 			ok: true,
 			effectiveDelivery: existing.effectiveDelivery,
-			state: this.snapshot(sessionKey)
+			state: this.snapshot(conversationId)
 		};
-		if (this.snapshot(sessionKey).inputs.length >= MAX_PENDING_INPUTS) return {
+		if (this.snapshot(conversationId).inputs.length >= MAX_PENDING_INPUTS) return {
 			ok: false,
 			code: "QUEUE_FULL"
 		};
-		const attachments = await this.deps.prepareAttachments(sessionKey, input.attachments);
+		const attachments = await this.deps.prepareAttachments(conversationId, input.attachments);
 		let sourceContexts;
 		try {
 			sourceContexts = fitSourceContextsToBudget([...await this.deps.prepareContexts(input.contextRefs) ?? [], ...input.sourceContexts ?? []]);
 		} catch (err) {
 			log.warn({
 				err,
-				sessionKey
+				conversationId
 			}, "Session input context preparation failed");
 			return {
 				ok: false,
 				code: "CONTEXT_UNAVAILABLE"
 			};
 		}
-		const runtime = this.snapshot(sessionKey);
+		const runtime = this.snapshot(conversationId);
 		const canSteer = input.origin.type !== "endpoint" && input.delivery === "steer" && runtime.activeRunId !== void 0 && !attachments?.length && !sourceContexts?.length;
 		const effectiveDelivery = canSteer ? "steer" : "next";
 		const row = insertSessionInput({
-			expectedSessionId: input.expectedSessionId,
+			expectedTranscriptId: input.expectedTranscriptId,
 			id: crypto.randomUUID(),
-			sessionKey,
+			conversationId,
 			clientMessageId,
 			requestedDelivery: input.delivery,
 			effectiveDelivery,
@@ -189,55 +191,55 @@ var SessionInputCoordinator = class {
 			origin: input.origin,
 			targetRunId: canSteer ? runtime.activeRunId : void 0
 		});
-		invalidateConnectionResumeIntent(sessionKey);
-		supersedeActiveClarification(sessionKey);
+		invalidateConnectionResumeIntent(conversationId);
+		supersedeActiveClarification(conversationId);
 		if (canSteer) {
-			if (!await this.deps.steer(sessionKey, content)) {
+			if (!await this.deps.steer(conversationId, content)) {
 				setSessionInputStatus(row.id, "queued", {
 					effectiveDelivery: "next",
 					targetRunId: null
 				});
-				this.drain(sessionKey);
+				this.drain(conversationId);
 				return {
 					ok: true,
 					effectiveDelivery: "next",
-					state: this.publish(sessionKey)
+					state: this.publish(conversationId)
 				};
 			}
 			return {
 				ok: true,
 				effectiveDelivery: "steer",
-				state: this.publish(sessionKey)
+				state: this.publish(conversationId)
 			};
 		}
-		this.drain(sessionKey);
+		this.drain(conversationId);
 		return {
 			ok: true,
 			effectiveDelivery: "next",
-			state: this.publish(sessionKey)
+			state: this.publish(conversationId)
 		};
 	}
-	async drain(sessionKey) {
-		if (this.draining.has(sessionKey)) return;
-		this.draining.add(sessionKey);
+	async drain(conversationId) {
+		if (this.draining.has(conversationId)) return;
+		this.draining.add(conversationId);
 		try {
 			while (true) {
 				const runId = crypto.randomUUID();
-				const input = claimNextSessionInput(sessionKey, runId);
+				const input = claimNextSessionInput(conversationId, runId);
 				if (!input) return;
 				if (this.deps.beforeExecute && !await this.deps.beforeExecute(input) || !consumeConnectionResume(input) || !consumeClarificationResume(input)) {
-					finishSessionInputRun(sessionKey, runId, "cancelled");
-					this.publish(sessionKey);
+					finishSessionInputRun(conversationId, runId, "cancelled");
+					this.publish(conversationId);
 					continue;
 				}
-				if (input.kind === "connection_resume") publishConnectionWait(sessionKey);
-				this.publish(sessionKey);
+				if (input.kind === "connection_resume") publishConnectionWait(conversationId);
+				this.publish(conversationId);
 				let result;
 				try {
 					result = await this.deps.execute({
 						runId,
 						taskRunId: input.taskRunId,
-						sessionKey,
+						conversationId,
 						content: input.content,
 						attachments: input.attachments,
 						sourceContexts: input.contextSnapshots,
@@ -251,41 +253,41 @@ var SessionInputCoordinator = class {
 					};
 					log.warn({
 						err: error,
-						sessionKey,
+						conversationId,
 						runId,
 						inputId: input.id
 					}, "Session input execution failed");
 				}
 				const terminal = result.status === "suspended" ? "suspended" : result.status === "ok" ? "completed" : result.status === "aborted" ? "cancelled" : "failed";
-				finishSessionInputRun(sessionKey, runId, terminal, terminal === "failed" ? result.summary : void 0);
-				this.publish(sessionKey);
+				finishSessionInputRun(conversationId, runId, terminal, terminal === "failed" ? result.summary : void 0);
+				this.publish(conversationId);
 			}
 		} finally {
-			this.draining.delete(sessionKey);
+			this.draining.delete(conversationId);
 		}
 	}
-	async update(sessionKey, id, body) {
-		const attachments = body.attachments === void 0 ? void 0 : await this.deps.prepareAttachments(sessionKey, body.attachments);
+	async update(conversationId, id, body) {
+		const attachments = body.attachments === void 0 ? void 0 : await this.deps.prepareAttachments(conversationId, body.attachments);
 		let sourceContexts;
 		if (body.contextRefs !== void 0) {
-			const existing = getSessionInputById(sessionKey, id);
+			const existing = getSessionInputById(conversationId, id);
 			if (!contextRefsMatchFrozenSnapshot(body.contextRefs, existing?.contextRefs)) try {
 				sourceContexts = await this.deps.prepareContexts(body.contextRefs) ?? [];
 			} catch (err) {
 				log.warn({
 					err,
-					sessionKey,
+					conversationId,
 					inputId: id
 				}, "Queued input context preparation failed");
 				return {
 					ok: false,
 					contextUnavailable: true,
-					state: this.snapshot(sessionKey)
+					state: this.snapshot(conversationId)
 				};
 			}
 		}
 		const ok = mutateQueuedSessionInput({
-			sessionKey,
+			conversationId,
 			id,
 			...body,
 			attachments,
@@ -294,19 +296,19 @@ var SessionInputCoordinator = class {
 		});
 		return {
 			ok,
-			state: ok ? this.publish(sessionKey) : this.snapshot(sessionKey)
+			state: ok ? this.publish(conversationId) : this.snapshot(conversationId)
 		};
 	}
-	remove(sessionKey, id, version) {
-		const ok = cancelQueuedSessionInput(sessionKey, id, version);
+	remove(conversationId, id, version) {
+		const ok = cancelQueuedSessionInput(conversationId, id, version);
 		return {
 			ok,
-			state: ok ? this.publish(sessionKey) : this.snapshot(sessionKey)
+			state: ok ? this.publish(conversationId) : this.snapshot(conversationId)
 		};
 	}
-	async waitForCompletion(sessionKey, clientMessageId) {
+	async waitForCompletion(conversationId, clientMessageId) {
 		while (true) {
-			const row = findSessionInput(sessionKey, clientMessageId);
+			const row = findSessionInput(conversationId, clientMessageId);
 			if (!row) throw new Error("Session input disappeared before completion");
 			if (row.status === "completed" || row.status === "suspended") return;
 			if (row.status === "failed" || row.status === "cancelled" || row.status === "interrupted") throw new Error(row.error ?? `Session input ended with status ${row.status}`);
@@ -314,9 +316,9 @@ var SessionInputCoordinator = class {
 		}
 	}
 	recover() {
-		for (const sessionKey of recoverSessionInputState()) {
-			this.publish(sessionKey);
-			this.drain(sessionKey);
+		for (const conversationId of recoverSessionInputState()) {
+			this.publish(conversationId);
+			this.drain(conversationId);
 		}
 	}
 };

package/dist/src/gateway/service/sessions-api.d.ts

@@ -9,10 +9,10 @@ export interface GatewaySessionsApiOptions {
     /** Resolves the live agent service (created lazily; throws if gateway is starting). */
     getAgentService: () => AgentService;
     /** Read-only view of in-flight webchat runs (per session key → run id). */
-    getActiveWebchatRunId: (sessionKey: string) => string | undefined;
+    getActiveWebchatRunId: (conversationId: string) => string | undefined;
     /** Snapshot of all in-flight webchat runs for workspace briefing surfaces. */
     listActiveWebchatRuns: () => Array<{
-        sessionKey: string;
+        conversationId: string;
         runId: string;
     }>;
 }
@@ -20,28 +20,27 @@ export declare class GatewaySessionsApi {
     private readonly opts;
     constructor(opts: GatewaySessionsApiOptions);
     listSessions(query?: SessionListQuery): Promise<import("../../session/types.js").PaginatedResult<import("../../session/types.js").SessionMetadata>>;
-    /** Subagent sessions have keys starting with `subagent:`. */
+    /** List conversations whose stored type is workflow-subagent. */
     listSubagents(query?: SessionListQuery): Promise<import("../../session/types.js").PaginatedResult<import("../../session/types.js").SessionMetadata>>;
     getSession(key: string, options?: {
         includeTranscriptSummary?: boolean;
         includeTranscriptRows?: boolean;
     }): Promise<import("../../session/types.js").SessionDetail>;
     resolveSession(input: {
-        key?: string;
-        sessionKey?: string;
-        sessionId?: string;
+        conversationId?: string;
+        transcriptId?: string;
     }): Promise<{
-        sessionKey: string;
-        sessionId: string;
+        conversationId: string;
+        transcriptId: string;
         session: Awaited<ReturnType<GatewaySessionsApi['getSession']>>;
     } | null>;
     /** Read-only: in-flight webchat agent run for this session key, if any. */
-    getActiveRun(sessionKey: string): {
+    getActiveRun(conversationId: string): {
         active: boolean;
         runId?: string;
     };
     listActiveRuns(): Array<{
-        sessionKey: string;
+        conversationId: string;
         runId: string;
     }>;
     getMessagePage(key: string, options?: {
@@ -79,12 +78,12 @@ export declare class GatewaySessionsApi {
         ok: false;
         error: string;
     }>;
-    getAgentConfig(sessionKey: string): Promise<import("../../agent/session/session-inspector.js").SessionAgentConfigView>;
-    getFixedAgentConfig(sessionKey: string): Promise<import("../../agent/session/session-inspector.js").SessionAgentConfigView>;
-    initializeChatModel(sessionKey: string, model: string, thinkingLevel?: string): Promise<import("../../agent/session/session-config-service.js").PatchSessionAgentConfigResult>;
+    getAgentConfig(conversationId: string): Promise<import("../../agent/session/session-inspector.js").SessionAgentConfigView>;
+    getFixedAgentConfig(conversationId: string): Promise<import("../../agent/session/session-inspector.js").SessionAgentConfigView>;
+    initializeChatModel(conversationId: string, model: string, thinkingLevel?: string): Promise<import("../../agent/session/session-config-service.js").PatchSessionAgentConfigResult>;
     /** Resolved markdown workspace for a session (after hydration / mkdir). */
-    getEffectiveWorkspacePath(sessionKey: string): Promise<string>;
-    patchAgentConfig(sessionKey: string, body: {
+    getEffectiveWorkspacePath(conversationId: string): Promise<string>;
+    patchAgentConfig(conversationId: string, body: {
         thinkingLevel?: string;
         fixedModel?: boolean;
         configVersion?: number;
@@ -138,26 +137,26 @@ export declare class GatewaySessionsApi {
         content: string;
     }>;
     importExport(targetKey: string, jsonContent: string): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
     }>;
     fork(key: string, targetKey: string): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
     }>;
     forkRows(key: string, targetKey: string, options?: {
         throughRow?: number;
     }): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
     }>;
     forkAtTurn(sourceKey: string, lastTurnId: string): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
         lastTurnId: string;
         session: NonNullable<Awaited<ReturnType<GatewaySessionsApi['getSession']>>>;
     }>;
-    btwQuery(sessionKey: string, question: string): Promise<{
+    btwQuery(conversationId: string, question: string): Promise<{
         text: string;
         error?: string;
     }>;

package/dist/src/gateway/service/sessions-api.js

@@ -1,6 +1,5 @@
-import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
-import { buildSessionKey, init_session_key } from "../../routing/session-key.js";
-import { retireSessionMcpRuntimeForSessionKey } from "../../agent/mcp/bundle-mcp-runtime.js";
+import { init_agent_session_key, resolveAgentIdFromConversationId } from "../../routing/agent-session-key.js";
+import { retireSessionMcpRuntimeForConversationId } from "../../agent/mcp/bundle-mcp-runtime.js";
 import { buildSessionTimeline } from "../../session/transcript-outline.js";
 import { transcriptRowsToClientHistory } from "../../session/client-history.js";
 import "../../agent/mcp/bundle-mcp-tools.js";
@@ -22,7 +21,6 @@ import { randomUUID } from "node:crypto";
 * `GatewayService`, and keeps the gateway composition root focused on
 * lifecycle + wiring.
 */
-init_session_key();
 init_agent_session_key();
 function clampWindowSpan(value, fallback) {
 	const parsed = Math.trunc(value ?? fallback);
@@ -37,7 +35,7 @@ var GatewaySessionsApi = class {
 	listSessions(query) {
 		return this.opts.sessionIndex.listSessions(query);
 	}
-	/** Subagent sessions have keys starting with `subagent:`. */
+	/** List conversations whose stored type is workflow-subagent. */
 	listSubagents(query) {
 		return this.opts.sessionIndex.listSubagents(query);
 	}
@@ -45,19 +43,19 @@ var GatewaySessionsApi = class {
 		return this.opts.sessionIndex.getSession(key, options);
 	}
 	async resolveSession(input) {
-		const resolvedKey = input.sessionKey?.trim() || input.key?.trim() || (input.sessionId?.trim() ? await this.opts.sessionIndex.resolveSessionKeyBySessionId(input.sessionId.trim()) : null);
+		const resolvedKey = input.conversationId?.trim() || (input.transcriptId?.trim() ? await this.opts.sessionIndex.resolveConversationIdByTranscriptId(input.transcriptId.trim()) : null);
 		if (!resolvedKey) return null;
 		const session = await this.getSession(resolvedKey);
-		if (!session?.sessionId) return null;
+		if (!session?.transcriptId) return null;
 		return {
-			sessionKey: resolvedKey,
-			sessionId: session.sessionId,
+			conversationId: resolvedKey,
+			transcriptId: session.transcriptId,
 			session
 		};
 	}
 	/** Read-only: in-flight webchat agent run for this session key, if any. */
-	getActiveRun(sessionKey) {
-		const key = sessionKey.trim();
+	getActiveRun(conversationId) {
+		const key = conversationId.trim();
 		if (!key) return { active: false };
 		const runId = this.opts.getActiveWebchatRunId(key)?.trim();
 		if (!runId) return { active: false };
@@ -104,27 +102,27 @@ var GatewaySessionsApi = class {
 	patch(key, body) {
 		return this.opts.sessionIndex.patchSession(key, body);
 	}
-	async getAgentConfig(sessionKey) {
-		return this.opts.getAgentService().sessionInspector.agentConfig(sessionKey);
+	async getAgentConfig(conversationId) {
+		return this.opts.getAgentService().sessionInspector.agentConfig(conversationId);
 	}
-	async getFixedAgentConfig(sessionKey) {
-		return withModelConfigLock(sessionKey, async () => {
-			const config = await this.getAgentConfig(sessionKey);
-			if (!config.fixedModel && !this.getActiveRun(sessionKey).active) {
-				if ((await this.opts.getAgentService().sessionConfig.initializeModelSelection(sessionKey, config.model, config.thinkingLevel, config.configVersion)).ok) return this.getAgentConfig(sessionKey);
+	async getFixedAgentConfig(conversationId) {
+		return withModelConfigLock(conversationId, async () => {
+			const config = await this.getAgentConfig(conversationId);
+			if (!config.fixedModel && !this.getActiveRun(conversationId).active) {
+				if ((await this.opts.getAgentService().sessionConfig.initializeModelSelection(conversationId, config.model, config.thinkingLevel, config.configVersion)).ok) return this.getAgentConfig(conversationId);
 			}
 			return config;
 		});
 	}
-	initializeChatModel(sessionKey, model, thinkingLevel) {
-		return this.opts.getAgentService().sessionConfig.initializeModelSelection(sessionKey, model, thinkingLevel);
+	initializeChatModel(conversationId, model, thinkingLevel) {
+		return this.opts.getAgentService().sessionConfig.initializeModelSelection(conversationId, model, thinkingLevel);
 	}
 	/** Resolved markdown workspace for a session (after hydration / mkdir). */
-	getEffectiveWorkspacePath(sessionKey) {
-		return this.opts.getAgentService().getEffectiveWorkspacePathForSession(sessionKey);
+	getEffectiveWorkspacePath(conversationId) {
+		return this.opts.getAgentService().getEffectiveWorkspacePathForSession(conversationId);
 	}
-	patchAgentConfig(sessionKey, body) {
-		return this.opts.getAgentService().sessionConfig.patch(sessionKey, body);
+	patchAgentConfig(conversationId, body) {
+		return this.opts.getAgentService().sessionConfig.patch(conversationId, body);
 	}
 	listCompactionBoundaries(key) {
 		return this.opts.sessionIndex.listCompactionBoundaries(key);
@@ -152,8 +150,8 @@ var GatewaySessionsApi = class {
 		if (result) {
 			await deleteMediaUris(collectMediaUrisFromValues(transcriptRows));
 			this.opts.getAgentService().evictSessionAgent(key);
-			await retireSessionMcpRuntimeForSessionKey({
-				sessionKey: key,
+			await retireSessionMcpRuntimeForConversationId({
+				conversationId: key,
 				reason: "session-delete"
 			});
 		}
@@ -222,15 +220,9 @@ var GatewaySessionsApi = class {
 		const normalizedTurnId = lastTurnId.trim();
 		if (!normalizedTurnId) throw new Error("lastTurnId is required");
 		if (this.opts.getActiveWebchatRunId(sourceKey)?.trim() === normalizedTurnId) throw new Error("Cannot fork a turn that is still running");
-		const agentId = source.routing?.agentId?.trim() || resolveAgentIdFromSessionKey(sourceKey);
+		const agentId = source.routing?.agentId?.trim() || resolveAgentIdFromConversationId(sourceKey);
 		const chatId = `chat_${randomUUID()}`;
-		const targetKey = buildSessionKey({
-			agentId,
-			source: "webchat",
-			accountId: "default",
-			peerKind: "direct",
-			peerId: chatId
-		});
+		const targetKey = randomUUID();
 		const result = await this.opts.sessionIndex.forkSessionAtTurn(sourceKey, {
 			targetKey,
 			lastTurnId: normalizedTurnId,
@@ -247,16 +239,16 @@ var GatewaySessionsApi = class {
 				}
 			}
 		});
-		const session = await this.getSession(result.sessionKey);
-		if (!session) throw new Error(`Forked session not found: ${result.sessionKey}`);
+		const session = await this.getSession(result.conversationId);
+		if (!session) throw new Error(`Forked session not found: ${result.conversationId}`);
 		return {
 			...result,
 			lastTurnId: normalizedTurnId,
 			session
 		};
 	}
-	btwQuery(sessionKey, question) {
-		return this.opts.getAgentService().sessionInspector.btwQuery(sessionKey, question);
+	btwQuery(conversationId, question) {
+		return this.opts.getAgentService().sessionInspector.btwQuery(conversationId, question);
 	}
 	stats() {
 		return this.opts.sessionIndex.getStats();

package/dist/src/gateway/service/task-conversation-query-service.d.ts

@@ -16,6 +16,7 @@ export declare class TaskConversationQueryService {
             transcriptSummary?: import("../../session/types.js").SessionTranscriptSummary;
             transcriptRows?: import("../../session/session-context-for-llm.js").TranscriptStoredRow[];
             key: string;
+            agentId: string;
             name?: string;
             status: import("../../session/types.js").SessionStatus;
             tags: string[];
@@ -35,12 +36,12 @@ export declare class TaskConversationQueryService {
             stats?: import("../../session/types.js").SessionStats;
             sessionType: import("../../session/types.js").SessionType;
             hiddenFromSessionList?: boolean;
-            parentSessionKey?: string;
+            parentConversationId?: string;
             workflowRunId?: string;
             workflowDefinitionId?: string;
             workflowAgentId?: string;
             workflowAgentLabel?: string;
-            sessionId?: string;
+            transcriptId?: string;
             cwd?: string;
             sessionStartedAt?: string;
             lastInteractionAt?: string;

package/dist/src/gateway/service/task-conversation-query-service.js

@@ -8,7 +8,7 @@ var TaskConversationQueryService = class {
 	async getMessagePage(taskId, options) {
 		const links = this.#executionSessions(taskId);
 		if (links.length === 0) return null;
-		const probes = await Promise.all(links.map((link) => this.sessions.getMessagePage(link.sessionKey, { limit: 1 })));
+		const probes = await Promise.all(links.map((link) => this.sessions.getMessagePage(link.conversationId, { limit: 1 })));
 		if (probes.some((page) => !page)) return null;
 		const pages = probes;
 		const total = pages.reduce((sum, page) => sum + page.pagination.total, 0);
@@ -21,7 +21,7 @@ var TaskConversationQueryService = class {
 			const localStart = Math.max(0, start - cursor);
 			const localEnd = Math.min(sessionTotal, end - cursor);
 			if (localStart < localEnd) {
-				const page = await this.sessions.getMessagePage(links[index].sessionKey, {
+				const page = await this.sessions.getMessagePage(links[index].conversationId, {
 					offset: sessionTotal - localEnd,
 					limit: localEnd - localStart
 				});
@@ -53,7 +53,7 @@ var TaskConversationQueryService = class {
 		let displayOffset = 0;
 		let turnOffset = 0;
 		for (const [index, link] of links.entries()) {
-			const [items, page] = await Promise.all([this.sessions.getTimeline(link.sessionKey), this.sessions.getMessagePage(link.sessionKey, { limit: 1 })]);
+			const [items, page] = await Promise.all([this.sessions.getTimeline(link.conversationId), this.sessions.getMessagePage(link.conversationId, { limit: 1 })]);
 			if (!items || !page) return null;
 			if (index > 0) output.push({
 				id: `assignment:${link.id}`,