@xopcai/xopc 0.0.284 → 0.0.286

package/dist/src/agent/memory/turn-provenance.js

@@ -1,23 +1,27 @@
-import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
+import { getSessionMetadata, init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { getConversationRouting } from "../../storage/sqlite/conversation-repository.js";
+import { init_session_key } from "../../routing/session-key.js";
 //#region src/agent/memory/turn-provenance.ts
+init_session_repository();
 init_session_key();
 const turnStates = /* @__PURE__ */ new Map();
 const RECALL_TOOL_RE = /^(?:memory_(?:search|get)|session_(?:search|recall))$/;
 const MAX_TRACKED_TURNS = 1e3;
-function stateKey(sessionKey, turnId) {
-	return `${sessionKey}\u0000${turnId}`;
+function stateKey(conversationId, turnId) {
+	return `${conversationId}\u0000${turnId}`;
 }
-function resolveMemorySessionKind(sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
+function resolveMemorySessionKind(conversationId) {
+	const parsed = getConversationRouting(conversationId);
 	if (!parsed) return "unknown";
-	if (parsed.agentId === "subagent" || sessionKey.includes(":subagent:")) return "subagent";
+	const kind = getSessionMetadata(conversationId)?.sessionType;
+	if (kind === "workflow-subagent") return "subagent";
 	if (parsed.source === "cron") return "automation";
-	if (sessionKey.includes(":workflow:") || parsed.scopeId?.startsWith("workflow")) return "workflow";
+	if (kind === "workflow-run") return "workflow";
 	if (parsed.peerKind === "group" || parsed.peerKind === "channel") return "group";
 	return "interactive";
 }
-function markTurnToolResult(sessionKey, turnId, toolName) {
-	const key = stateKey(sessionKey, turnId);
+function markTurnToolResult(conversationId, turnId, toolName) {
+	const key = stateKey(conversationId, turnId);
 	const state = turnStates.get(key) ?? {
 		toolNames: /* @__PURE__ */ new Set(),
 		recalled: false,
@@ -28,8 +32,8 @@ function markTurnToolResult(sessionKey, turnId, toolName) {
 	turnStates.set(key, state);
 	if (turnStates.size > MAX_TRACKED_TURNS) turnStates.delete(turnStates.keys().next().value);
 }
-function markTurnRecalledContext(sessionKey, turnId) {
-	const key = stateKey(sessionKey, turnId);
+function markTurnRecalledContext(conversationId, turnId) {
+	const key = stateKey(conversationId, turnId);
 	const state = turnStates.get(key) ?? {
 		toolNames: /* @__PURE__ */ new Set(),
 		recalled: false,
@@ -39,22 +43,22 @@ function markTurnRecalledContext(sessionKey, turnId) {
 	state.automaticRecall = true;
 	turnStates.set(key, state);
 }
-function consumeTurnMemoryProvenance(sessionKey, turnId) {
-	const key = stateKey(sessionKey, turnId);
+function consumeTurnMemoryProvenance(conversationId, turnId) {
+	const key = stateKey(conversationId, turnId);
 	const state = turnStates.get(key);
 	turnStates.delete(key);
 	const toolNames = [...state?.toolNames ?? []].sort();
 	return {
 		originClass: toolNames.length > 0 ? "untrusted" : "agent",
-		sessionKind: resolveMemorySessionKind(sessionKey),
-		sourceSessionId: sessionKey,
+		sessionKind: resolveMemorySessionKind(conversationId),
+		sourceSessionId: conversationId,
 		sourceTurnId: turnId,
 		derivedFromRecalledContext: state?.recalled ?? false,
 		taintReasons: [...toolNames.map((name) => `tool:${name}`), ...state?.automaticRecall ? ["recall:automatic"] : []]
 	};
 }
-function clearTurnMemoryProvenance(sessionKey, turnId) {
-	turnStates.delete(stateKey(sessionKey, turnId));
+function clearTurnMemoryProvenance(conversationId, turnId) {
+	turnStates.delete(stateKey(conversationId, turnId));
 }
 //#endregion
 export { clearTurnMemoryProvenance, consumeTurnMemoryProvenance, markTurnRecalledContext, markTurnToolResult, resolveMemorySessionKind };

package/dist/src/agent/memory/types.d.ts

@@ -21,7 +21,7 @@ export interface MemoryEvidence {
     evidenceId?: string;
     sourceItemId?: string;
     relation?: MemoryEvidenceRelation;
-    sessionKey?: string;
+    conversationId?: string;
     turnId?: string;
     toolCallId?: string;
     sourceText?: string;
@@ -31,7 +31,7 @@ export interface MemoryEvidence {
 export interface MemoryScope {
     userId: string;
     workspaceId?: string;
-    sessionKey?: string;
+    conversationId?: string;
     projectId?: string;
 }
 export interface MemoryCitation {

package/dist/src/agent/messaging/command-handler.d.ts

@@ -13,7 +13,7 @@ import { type BtwQueryOptions, type CommandStreamEvent } from '../../chat-comman
 import type { WorkflowRunServiceLike } from '../../workflows/service/workflow-run-service.types.js';
 import type { SkillInstallToolOptions, SkillInstallToolResult } from '../tools/skill-install-tool.js';
 export interface CommandContext {
-    sessionKey: string;
+    conversationId: string;
     channel: string;
     chatId: string;
     senderId: string;
@@ -28,31 +28,31 @@ export interface CommandHandlerConfig {
     sessionStore: SessionStore;
     sessionConfigStore?: SessionConfigStore;
     /** After /think persists, sync pi-agent */
-    applySessionThinkingLevel?: (sessionKey: string, level: ThinkLevel) => void;
+    applySessionThinkingLevel?: (conversationId: string, level: ThinkLevel) => void;
     getCurrentModel: () => string;
-    switchModelForSession: (sessionKey: string, modelId: string) => Promise<boolean>;
+    switchModelForSession: (conversationId: string, modelId: string) => Promise<boolean>;
     /** Drop in-memory agent after session file is cleared (e.g. /new) */
-    invalidateAgentSession?: (sessionKey: string) => void;
+    invalidateAgentSession?: (conversationId: string) => void;
     /** Reset session in place (archive transcript, new session id; preserve overrides) */
-    resetSession?: (sessionKey: string) => Promise<{
-        sessionId: string;
-        previousSessionId: string;
+    resetSession?: (conversationId: string) => Promise<{
+        transcriptId: string;
+        previousTranscriptId: string;
     } | null>;
     /** Cancel streaming preview + in-flight LLM work for this session (e.g. /abort) */
-    abortSessionTurn?: (sessionKey: string) => Promise<void>;
+    abortSessionTurn?: (conversationId: string) => Promise<void>;
     /** Reload skills from disk and refresh active agent prompts. */
     reloadSkills?: () => void | Promise<void>;
     /** Install a managed skill from an explicit source and refresh active agent prompts. */
     installSkillFromSource?: (opts: SkillInstallToolOptions) => Promise<SkillInstallToolResult>;
-    compactSession?: (sessionKey: string, options?: {
+    compactSession?: (conversationId: string, options?: {
         instructions?: string;
         force?: boolean;
     }) => Promise<CompactionResult>;
-    btwQuery?: (sessionKey: string, question: string, options?: BtwQueryOptions) => Promise<{
+    btwQuery?: (conversationId: string, question: string, options?: BtwQueryOptions) => Promise<{
         text: string;
         error?: string;
     }>;
-    getSessionContextReport?: (sessionKey: string, mode: 'list' | 'detail' | 'json') => Promise<string>;
+    getSessionContextReport?: (conversationId: string, mode: 'list' | 'detail' | 'json') => Promise<string>;
     getWorkflowRunService?: () => WorkflowRunServiceLike | undefined;
 }
 export declare class CommandHandler {

package/dist/src/agent/messaging/command-handler.js

@@ -58,7 +58,7 @@ var CommandHandler = class {
 	buildCommandContext(context, recorder, emitEvent) {
 		const skipBusOutbound = shouldSkipBusOutboundForChannel(context.channel);
 		const commandContext = createCommandContext({
-			sessionKey: context.sessionKey,
+			conversationId: context.conversationId,
 			source: context.channel,
 			channelId: context.channel,
 			chatId: context.chatId,
@@ -90,7 +90,7 @@ var CommandHandler = class {
 			supportedFeatures: ["markdown", "typing"],
 			getCurrentModel: this.getCurrentModel,
 			switchModel: async (modelId) => {
-				return this.switchModelForSession(context.sessionKey, modelId);
+				return this.switchModelForSession(context.conversationId, modelId);
 			},
 			listModels: async () => {
 				const providers = getAllProviders();
@@ -106,7 +106,7 @@ var CommandHandler = class {
 				return models;
 			},
 			getUsage: async () => {
-				const messages = await this.sessionStore.load(context.sessionKey);
+				const messages = await this.sessionStore.load(context.conversationId);
 				let promptTokens = 0;
 				let completionTokens = 0;
 				for (const msg of messages) if ("usage" in msg && msg.usage) {
@@ -126,14 +126,14 @@ var CommandHandler = class {
 				await this.resetSession(sk);
 			} : void 0,
 			abortCurrentTurn: this.abortSessionTurn ? async () => {
-				await this.abortSessionTurn(context.sessionKey);
+				await this.abortSessionTurn(context.conversationId);
 			} : void 0,
 			reloadSkills: this.reloadSkills ? async () => {
 				await this.reloadSkills();
 			} : void 0,
 			installSkillFromSource: this.installSkillFromSource ? (opts) => this.installSkillFromSource({
 				...opts,
-				sessionKey: context.sessionKey
+				conversationId: context.conversationId
 			}) : void 0,
 			compactSession: this.compactSession,
 			btwQuery: this.btwQuery,
@@ -151,7 +151,7 @@ var CommandHandler = class {
 		if (!commandRegistry.has(commandName)) return false;
 		log.info({
 			command: commandName,
-			sessionKey: context.sessionKey
+			conversationId: context.conversationId
 		}, "Executing command via new system");
 		const cmdCtx = this.buildCommandContext(context);
 		const result = await commandRegistry.execute(commandName, cmdCtx, args);
@@ -174,7 +174,7 @@ var CommandHandler = class {
 		};
 		log.info({
 			command: commandName,
-			sessionKey: context.sessionKey
+			conversationId: context.conversationId
 		}, "Executing command (aggregate reply)");
 		const segments = [];
 		const wrapped = this.buildCommandContext(context, (text) => segments.push(text), options?.emitEvent);

package/dist/src/agent/messaging/message-router.d.ts

@@ -19,5 +19,5 @@ export declare class MessageRouter {
     /**
      * Resolve session key from message metadata or derive from channel/chat_id
      */
-    private resolveSessionKey;
+    private resolveConversationId;
 }

package/dist/src/agent/messaging/message-router.js

@@ -5,11 +5,11 @@ var MessageRouter = class {
 	* Route an inbound message and determine handling strategy
 	*/
 	async routeMessage(msg) {
-		const sessionKey = this.resolveSessionKey(msg);
+		const conversationId = this.resolveConversationId(msg);
 		const context = {
 			channel: msg.channel,
 			chatId: msg.chat_id,
-			sessionKey,
+			conversationId,
 			senderId: msg.metadata?.senderId || msg.sender_id,
 			isGroup: msg.metadata?.isGroup || false
 		};
@@ -24,8 +24,8 @@ var MessageRouter = class {
 	/**
 	* Resolve session key from message metadata or derive from channel/chat_id
 	*/
-	resolveSessionKey(msg) {
-		if (msg.metadata?.sessionKey) return msg.metadata.sessionKey;
+	resolveConversationId(msg) {
+		if (msg.metadata?.conversationId) return msg.metadata.conversationId;
 		if (msg.channel === "system") {
 			if (msg.chat_id.includes(":")) {
 				const [ch, ...rest] = msg.chat_id.split(":");

package/dist/src/agent/messaging/outbound-coordinator.d.ts

@@ -25,11 +25,11 @@ export interface OutboundCoordinatorConfig {
     /** Reads the effective config snapshot (honours runtime overrides). */
     getConfig: () => Config | undefined;
     /** Resolves the last visible assistant text for a session (in-memory + agent fallback). */
-    getLastAssistantPlainText: (sessionKey: string) => string;
+    getLastAssistantPlainText: (conversationId: string) => string;
     reviewTaskTurn: (payload: SessionTurnCompletePayload) => Promise<void>;
 }
 export interface SessionTurnCompletePayload {
-    sessionKey: string;
+    conversationId: string;
     channel: string;
     chatId: string;
     inboundUserText: string;

package/dist/src/agent/messaging/outbound-coordinator.js

@@ -68,10 +68,10 @@ var OutboundCoordinator = class {
 	*/
 	async sendFinalResponse(msg, sessionContext) {
 		if (this.streamManager.consumeSkipFinalOutbound()) return;
-		const finalContent = this.getLastAssistantPlainText(sessionContext.sessionKey);
+		const finalContent = this.getLastAssistantPlainText(sessionContext.conversationId);
 		if (!finalContent?.trim()) return;
 		if (shouldSilence(finalContent, this.getConfig()?.gateway?.heartbeat?.ackMaxChars ?? 300) || finalContent.trim() === "NO_REPLY") {
-			log.debug({ sessionKey: sessionContext.sessionKey }, "Silent reply — skipping outbound");
+			log.debug({ conversationId: sessionContext.conversationId }, "Silent reply — skipping outbound");
 			return;
 		}
 		const hookResult = await this.hookHandler.runMessageSending(sessionContext.chatId, finalContent, sessionContext.channel);
@@ -93,8 +93,8 @@ var OutboundCoordinator = class {
 	}
 	/** Run extension completion hooks and independently review an attached Task. */
 	async emitSessionTurnComplete(payload) {
-		await this.hookHandler.triggerWithSessionKey(payload.sessionKey, "webchat_turn_complete", {
-			sessionKey: payload.sessionKey,
+		await this.hookHandler.triggerWithConversationId(payload.conversationId, "webchat_turn_complete", {
+			conversationId: payload.conversationId,
 			channel: payload.channel,
 			chatId: payload.chatId,
 			inboundUserText: payload.inboundUserText,

package/dist/src/agent/middleware/context.d.ts

@@ -8,7 +8,7 @@
  */
 import type { LogContext } from '../../utils/logger.js';
 export interface RequestContext {
-    sessionKey: string;
+    conversationId: string;
     userId?: string;
     channel?: string;
     chatId?: string;
@@ -18,7 +18,6 @@ export declare class ContextMiddleware {
     private currentContext;
     private contextDepth;
     private generateRequestId;
-    private extractSessionId;
     onRequest(context: RequestContext): string;
     onResponse(): void;
     getContext(): LogContext;

package/dist/src/agent/middleware/context.js

@@ -18,15 +18,12 @@ var ContextMiddleware = class {
 	generateRequestId() {
 		return `req_${Date.now().toString(36)}_${randomBytes(4).toString("hex")}`;
 	}
-	extractSessionId(sessionKey) {
-		return sessionKey.split(":").slice(0, 2).join(":");
-	}
 	onRequest(context) {
 		this.contextDepth++;
 		const requestId = this.generateRequestId();
 		this.currentContext = {
 			requestId,
-			sessionId: this.extractSessionId(context.sessionKey),
+			conversationId: context.conversationId,
 			userId: context.userId,
 			module: context.channel,
 			service: "xopc",
@@ -34,7 +31,7 @@ var ContextMiddleware = class {
 		};
 		log.debug({
 			requestId,
-			sessionId: this.currentContext.sessionId,
+			conversationId: this.currentContext.conversationId,
 			userId: context.userId,
 			depth: this.contextDepth
 		}, "Request context started");

package/dist/src/agent/models/manager.d.ts

@@ -31,13 +31,13 @@ export declare class ModelManager {
      * Set the config-derived default model for a session (from effective agent profile).
      * Cleared by {@link updateFromConfig} or {@link clearSessionProfileDefault}.
      */
-    setSessionProfileDefault(sessionKey: string, modelRef: string, fallbacks?: string[]): void;
+    setSessionProfileDefault(conversationId: string, modelRef: string, fallbacks?: string[]): void;
     /**
      * Register the profile model and return the model that should initialize the
      * session agent. An existing per-session override always wins.
      */
-    resolveInitialModelForSession(sessionKey: string, profileModelRef: string, fallbacks?: string[]): string;
-    clearSessionProfileDefault(sessionKey: string): void;
+    resolveInitialModelForSession(conversationId: string, profileModelRef: string, fallbacks?: string[]): string;
+    clearSessionProfileDefault(conversationId: string): void;
     /**
      * Get current model name
      */
@@ -49,27 +49,27 @@ export declare class ModelManager {
     /**
      * Switch model for a specific session
      */
-    switchModelForSession(sessionKey: string, modelId: string): Promise<boolean>;
+    switchModelForSession(conversationId: string, modelId: string): Promise<boolean>;
     /** Restore persisted identity even if its provider is temporarily unavailable. */
-    restoreSessionModel(sessionKey: string, modelRef: string, fixed: boolean): void;
+    restoreSessionModel(conversationId: string, modelRef: string, fixed: boolean): void;
     /** Drop in-memory session override so the global default is used again. */
-    clearSessionModelOverride(sessionKey: string): void;
+    clearSessionModelOverride(conversationId: string): void;
     /**
      * Resolved pi-ai model for session (for transcript policy, tools, etc.)
      */
-    getResolvedModelForSession(sessionKey: string): Model<Api>;
+    getResolvedModelForSession(conversationId: string): Model<Api>;
     /**
      * Get model for session, checking session override first
      */
-    getModelForSession(sessionKey: string): string;
+    getModelForSession(conversationId: string): string;
     /**
      * Apply model to agent if different from current
      */
-    applyModelForSession(agent: Agent, sessionKey: string): Promise<void>;
+    applyModelForSession(agent: Agent, conversationId: string): Promise<void>;
     /**
      * Ordered model candidates for the session.
      */
-    getFallbackCandidatesForSession(sessionKey: string): ModelCandidate[];
+    getFallbackCandidatesForSession(conversationId: string): ModelCandidate[];
     /**
      * Apply a resolved pi-ai model and sync {@link currentModelName} / {@link currentProvider}.
      */

package/dist/src/agent/models/manager.js

@@ -39,23 +39,23 @@ var ModelManager = class {
 	* Set the config-derived default model for a session (from effective agent profile).
 	* Cleared by {@link updateFromConfig} or {@link clearSessionProfileDefault}.
 	*/
-	setSessionProfileDefault(sessionKey, modelRef, fallbacks = []) {
-		this.sessionProfileDefaults.set(sessionKey, modelRef);
+	setSessionProfileDefault(conversationId, modelRef, fallbacks = []) {
+		this.sessionProfileDefaults.set(conversationId, modelRef);
 		const cleanFallbacks = fallbacks.map((ref) => ref.trim()).filter(Boolean);
-		if (cleanFallbacks.length > 0) this.sessionProfileFallbacks.set(sessionKey, cleanFallbacks);
-		else this.sessionProfileFallbacks.delete(sessionKey);
+		if (cleanFallbacks.length > 0) this.sessionProfileFallbacks.set(conversationId, cleanFallbacks);
+		else this.sessionProfileFallbacks.delete(conversationId);
 	}
 	/**
 	* Register the profile model and return the model that should initialize the
 	* session agent. An existing per-session override always wins.
 	*/
-	resolveInitialModelForSession(sessionKey, profileModelRef, fallbacks = []) {
-		this.setSessionProfileDefault(sessionKey, profileModelRef, fallbacks);
-		return this.getModelForSession(sessionKey);
+	resolveInitialModelForSession(conversationId, profileModelRef, fallbacks = []) {
+		this.setSessionProfileDefault(conversationId, profileModelRef, fallbacks);
+		return this.getModelForSession(conversationId);
 	}
-	clearSessionProfileDefault(sessionKey) {
-		this.sessionProfileDefaults.delete(sessionKey);
-		this.sessionProfileFallbacks.delete(sessionKey);
+	clearSessionProfileDefault(conversationId) {
+		this.sessionProfileDefaults.delete(conversationId);
+		this.sessionProfileFallbacks.delete(conversationId);
 	}
 	/**
 	* Get current model name
@@ -72,63 +72,63 @@ var ModelManager = class {
 	/**
 	* Switch model for a specific session
 	*/
-	async switchModelForSession(sessionKey, modelId) {
+	async switchModelForSession(conversationId, modelId) {
 		try {
 			resolveModel(modelId);
-			this.sessionModels.set(sessionKey, modelId);
+			this.sessionModels.set(conversationId, modelId);
 			log.info({
-				sessionKey,
+				conversationId,
 				modelId
 			}, "Model switched for session");
 			return true;
 		} catch (err) {
 			log.error({
 				err,
-				sessionKey,
+				conversationId,
 				modelId
 			}, "Failed to switch model");
 			return false;
 		}
 	}
 	/** Restore persisted identity even if its provider is temporarily unavailable. */
-	restoreSessionModel(sessionKey, modelRef, fixed) {
-		this.sessionModels.set(sessionKey, modelRef);
-		if (fixed) this.fixedSessionModels.add(sessionKey);
-		else this.fixedSessionModels.delete(sessionKey);
+	restoreSessionModel(conversationId, modelRef, fixed) {
+		this.sessionModels.set(conversationId, modelRef);
+		if (fixed) this.fixedSessionModels.add(conversationId);
+		else this.fixedSessionModels.delete(conversationId);
 	}
 	/** Drop in-memory session override so the global default is used again. */
-	clearSessionModelOverride(sessionKey) {
-		this.sessionModels.delete(sessionKey);
-		this.fixedSessionModels.delete(sessionKey);
+	clearSessionModelOverride(conversationId) {
+		this.sessionModels.delete(conversationId);
+		this.fixedSessionModels.delete(conversationId);
 	}
 	/**
 	* Resolved pi-ai model for session (for transcript policy, tools, etc.)
 	*/
-	getResolvedModelForSession(sessionKey) {
-		return resolveModel(this.getModelForSession(sessionKey));
+	getResolvedModelForSession(conversationId) {
+		return resolveModel(this.getModelForSession(conversationId));
 	}
 	/**
 	* Get model for session, checking session override first
 	*/
-	getModelForSession(sessionKey) {
-		const sessionModel = this.sessionModels.get(sessionKey);
+	getModelForSession(conversationId) {
+		const sessionModel = this.sessionModels.get(conversationId);
 		if (sessionModel) return sessionModel;
-		const profileDefault = this.sessionProfileDefaults.get(sessionKey);
+		const profileDefault = this.sessionProfileDefaults.get(conversationId);
 		if (profileDefault) return profileDefault;
 		return this.defaultModel;
 	}
 	/**
 	* Apply model to agent if different from current
 	*/
-	async applyModelForSession(agent, sessionKey) {
-		const targetModelId = this.getModelForSession(sessionKey);
+	async applyModelForSession(agent, conversationId) {
+		const targetModelId = this.getModelForSession(conversationId);
 		let found;
 		try {
 			found = resolveModel(targetModelId);
 		} catch (err) {
 			log.error({
 				err,
-				sessionKey,
+				conversationId,
 				modelId: targetModelId
 			}, "Failed to apply model");
 			return;
@@ -143,22 +143,22 @@ var ModelManager = class {
 		this.currentModelName = targetModelId;
 		this.currentProvider = found.provider || "unknown";
 		log.info({
-			sessionKey,
+			conversationId,
 			modelId: targetModelId
 		}, "Applied model for session");
 	}
 	/**
 	* Ordered model candidates for the session.
 	*/
-	getFallbackCandidatesForSession(sessionKey) {
-		const parsed = parseModelRef(this.getModelForSession(sessionKey));
+	getFallbackCandidatesForSession(conversationId) {
+		const parsed = parseModelRef(this.getModelForSession(conversationId));
 		if (!parsed) return [];
-		if (this.fixedSessionModels.has(sessionKey)) return [parsed];
+		if (this.fixedSessionModels.has(conversationId)) return [parsed];
 		return resolveFallbackCandidates({
 			cfg: this.config,
 			provider: parsed.provider,
 			model: parsed.model,
-			fallbacksOverride: this.sessionModels.has(sessionKey) ? void 0 : this.sessionProfileFallbacks.get(sessionKey)
+			fallbacksOverride: this.sessionModels.has(conversationId) ? void 0 : this.sessionProfileFallbacks.get(conversationId)
 		});
 	}
 	/**

package/dist/src/agent/orchestration/agent-event-handler.js

@@ -36,7 +36,7 @@ var SessionEventBus = class {
 function installRequestLimitListener(bus, deps) {
 	bus.on("agent_start", (_event, context) => {
 		const result = deps.requestLimiter.recordRequest();
-		deps.lifecycleManager.emit("llm_request", context.sessionKey, {
+		deps.lifecycleManager.emit("llm_request", context.conversationId, {
 			requestNumber: result.count,
 			maxRequests: result.limit
 		}, context).catch((err) => {
@@ -44,7 +44,7 @@ function installRequestLimitListener(bus, deps) {
 			log.warn({
 				err,
 				errorMessage: em,
-				sessionKey: context.sessionKey,
+				conversationId: context.conversationId,
 				requestNumber: result.count,
 				maxRequests: result.limit
 			}, `Lifecycle emit llm_request failed: ${em}`);
@@ -52,7 +52,7 @@ function installRequestLimitListener(bus, deps) {
 		if (result.shouldStop) log.error({
 			count: result.count,
 			limit: result.limit,
-			sessionKey: context.sessionKey
+			conversationId: context.conversationId
 		}, `Request limit reached (${result.count}/${result.limit}) for session`);
 	});
 	bus.on("turn_end", () => {
@@ -66,7 +66,7 @@ function installLifecycleHookListener(bus, lifecycleManager) {
 		const content = e.message.content;
 		const text = Array.isArray(content) ? extractTextContent(content) : String(content);
 		log.debug({ contentLength: text.length }, "Assistant response complete");
-		lifecycleManager.emit("llm_response", context.sessionKey, {
+		lifecycleManager.emit("llm_response", context.conversationId, {
 			response: text,
 			usage: e.message.usage
 		}, context).catch((err) => {
@@ -74,14 +74,14 @@ function installLifecycleHookListener(bus, lifecycleManager) {
 			log.warn({
 				err,
 				errorMessage: em,
-				sessionKey: context.sessionKey,
+				conversationId: context.conversationId,
 				responseChars: text.length
 			}, `Lifecycle emit llm_response failed: ${em}`);
 		});
 	});
 	bus.on("tool_execution_start", (event, context) => {
 		const e = event;
-		lifecycleManager.emit("tool_call_start", context.sessionKey, {
+		lifecycleManager.emit("tool_call_start", context.conversationId, {
 			toolName: e.toolName,
 			arguments: e.args || {},
 			attemptNumber: 1,
@@ -91,7 +91,7 @@ function installLifecycleHookListener(bus, lifecycleManager) {
 			log.warn({
 				err,
 				errorMessage: em,
-				sessionKey: context.sessionKey,
+				conversationId: context.conversationId,
 				tool: e.toolName
 			}, `Lifecycle emit tool_call_start failed: ${em}`);
 		});
@@ -99,7 +99,7 @@ function installLifecycleHookListener(bus, lifecycleManager) {
 	bus.on("tool_execution_end", (event, context) => {
 		const e = event;
 		const durationMs = e.durationMs || 0;
-		lifecycleManager.emit("tool_call_end", context.sessionKey, {
+		lifecycleManager.emit("tool_call_end", context.conversationId, {
 			toolName: e.toolName,
 			success: !e.isError,
 			result: e.result,
@@ -110,7 +110,7 @@ function installLifecycleHookListener(bus, lifecycleManager) {
 			log.warn({
 				err,
 				errorMessage: em,
-				sessionKey: context.sessionKey,
+				conversationId: context.conversationId,
 				tool: e.toolName
 			}, `Lifecycle hook tool_call_end failed: ${em}`);
 		});
@@ -124,22 +124,22 @@ function installSystemReminderListener(bus, systemReminder) {
 }
 function installToolChainListener(bus, toolChainTracker) {
 	bus.on("turn_start", (_event, context) => {
-		toolChainTracker.startChain(context.sessionKey);
+		toolChainTracker.startChain(context.conversationId);
 	});
 	bus.on("tool_execution_start", (event, context) => {
 		const e = event;
-		toolChainTracker.recordCall(context.sessionKey, e.toolName, e.args || {}, 0);
+		toolChainTracker.recordCall(context.conversationId, e.toolName, e.args || {}, 0);
 	});
 	bus.on("tool_execution_end", (event, context) => {
 		const e = event;
 		const durationMs = e.durationMs || 0;
-		const chain = toolChainTracker.getCurrentChain(context.sessionKey);
+		const chain = toolChainTracker.getCurrentChain(context.conversationId);
 		if (!chain) return;
 		const lastNode = chain.nodes[chain.nodes.length - 1];
-		if (lastNode && lastNode.toolName === e.toolName) toolChainTracker.recordResult(context.sessionKey, lastNode.id, e.result, e.isError ? "Tool execution failed" : void 0, durationMs);
+		if (lastNode && lastNode.toolName === e.toolName) toolChainTracker.recordResult(context.conversationId, lastNode.id, e.result, e.isError ? "Tool execution failed" : void 0, durationMs);
 	});
 	bus.on("turn_end", (_event, context) => {
-		toolChainTracker.endChain(context.sessionKey);
+		toolChainTracker.endChain(context.conversationId);
 	});
 }
 function installToolUsageListener(bus, toolUsageAnalyzer) {