@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/routing/session-key.js

@@ -1,7 +1,9 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId } from "./account-id.js";
-import { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey } from "./session-key-utils.js";
-import { DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, classifySessionKeyShape, defaultMainSessionKey, init_agent_session_key, isValidAgentId, normalizeAgentId, normalizeMainKey, normalizeSessionKey, resolveAgentIdFromSessionKey, resolveThreadSessionKeys, sanitizeAgentId, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey } from "./agent-session-key.js";
+import { validateConversationId } from "../../packages/gateway-contract/src/conversation-identity.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { getConversationRouting, init_conversation_repository, requireConversation, resolveRoutedConversation } from "../storage/sqlite/conversation-repository.js";
+import { DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentConversationId, defaultMainConversationId, getConversation, init_agent_session_key, isCronConversationId, isSubagentConversationId, isValidAgentId, normalizeAgentId, normalizeMainKey, resolveAgentIdFromConversationId, resolveAgentMainConversationId, resolveAgentPeerConversationId, sanitizeAgentId } from "./agent-session-key.js";
 //#region src/routing/session-key.ts
 function sanitizeSegment(value, options) {
 	const trimmed = (value ?? "").trim();
@@ -17,170 +19,20 @@ function isValidSegment(value) {
 	if (!trimmed || trimmed.length > 64) return false;
 	return VALID_SEGMENT_RE.test(trimmed);
 }
-/** Build an OpenClaw-style agent session key from routing segments. */
-function buildSessionKey(params) {
-	const peerKind = params.peerKind === "dm" ? "direct" : params.peerKind;
-	let key = buildAgentPeerSessionKey({
-		agentId: params.agentId,
-		mainKey: params.mainKey,
-		channel: params.source,
-		accountId: params.accountId,
-		peerKind,
-		peerId: params.peerId,
-		identityLinks: params.identityLinks,
-		dmScope: params.dmScope ?? (peerKind === "direct" ? "per-account-channel-peer" : void 0)
-	});
-	if (params.threadId) key = resolveThreadSessionKeys({
-		baseSessionKey: key,
-		threadId: params.threadId
-	}).sessionKey;
-	if (params.scopeId) key = `${key}:scope:${sanitizeSegment(params.scopeId, { allowLeadingDash: true }) || "default"}`;
-	return key;
+function resolveConversationId(params) {
+	return resolveRoutedConversation(params);
 }
-/** Parse `agent:{agentId}:{rest}` into routing segments. Returns null for invalid keys. */
-function parseSessionKey(sessionKey) {
-	const raw = (sessionKey ?? "").trim();
-	if (!raw) return null;
-	const { baseSessionKey, threadId } = parseThreadSuffix(raw);
-	const agentParsed = parseAgentSessionKey(baseSessionKey);
-	if (!agentParsed) return null;
-	const scopeParts = parseScopeSuffix(agentParsed.rest);
-	const rest = scopeParts.rest;
-	const scopeId = scopeParts.scopeId;
-	const mainKey = normalizeMainKey(void 0);
-	if (rest === mainKey) return {
-		agentId: agentParsed.agentId,
-		source: "cli",
-		accountId: "default",
-		peerKind: "direct",
-		peerId: mainKey,
-		threadId,
-		scopeId
-	};
-	if (rest.startsWith("subagent:")) return parseSubagentRest(agentParsed.agentId, rest, threadId, scopeId);
-	if (rest.startsWith("cron:")) {
-		const parts = rest.split(":");
-		return {
-			agentId: agentParsed.agentId,
-			source: "cron",
-			accountId: "default",
-			peerKind: "direct",
-			peerId: parts.slice(1).join(":") || "cron",
-			threadId,
-			scopeId
-		};
-	}
-	const parts = rest.split(":").filter(Boolean);
-	if (parts.length >= 4 && parts[2] === "direct") return {
-		agentId: agentParsed.agentId,
-		source: parts[0],
-		accountId: parts[1],
-		peerKind: "direct",
-		peerId: parts.slice(3).join(":"),
-		threadId,
-		scopeId
-	};
-	if (parts.length >= 3 && parts[1] === "direct") return {
-		agentId: agentParsed.agentId,
-		source: parts[0],
-		accountId: "default",
-		peerKind: "direct",
-		peerId: parts.slice(2).join(":"),
-		threadId,
-		scopeId
-	};
-	if (parts.length >= 2 && parts[0] === "direct") return {
-		agentId: agentParsed.agentId,
-		source: "cli",
-		accountId: "default",
-		peerKind: "direct",
-		peerId: parts.slice(1).join(":"),
-		threadId,
-		scopeId
-	};
-	if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) return {
-		agentId: agentParsed.agentId,
-		source: parts[0],
-		accountId: "default",
-		peerKind: parts[1],
-		peerId: parts.slice(2).join(":"),
-		threadId,
-		scopeId
-	};
-	return {
-		agentId: agentParsed.agentId,
-		source: "cli",
-		accountId: "default",
-		peerKind: "direct",
-		peerId: rest,
-		threadId,
-		scopeId
-	};
+function getParentConversationId(conversationId) {
+	return conversationId ? requireConversation(conversationId).parentConversationId ?? null : null;
 }
-function parseThreadSuffix(raw) {
-	const idx = raw.toLowerCase().lastIndexOf(":thread:");
-	if (idx === -1) return { baseSessionKey: raw };
-	return {
-		baseSessionKey: raw.slice(0, idx),
-		threadId: raw.slice(idx + 8)
-	};
-}
-function parseScopeSuffix(rest) {
-	const idx = rest.toLowerCase().lastIndexOf(":scope:");
-	if (idx === -1) return { rest };
-	return {
-		rest: rest.slice(0, idx),
-		scopeId: rest.slice(idx + 7)
-	};
-}
-function parseSubagentRest(parentAgentId, rest, threadId, scopeId) {
-	const body = rest.replace(/^subagent:/, "");
-	const parentKey = body ? `agent:${parentAgentId}:${body}` : "";
-	const parentParsed = parentKey ? parseSessionKey(parentKey) : null;
-	if (parentParsed) return {
-		...parentParsed,
-		agentId: "subagent",
-		threadId: threadId ?? parentParsed.threadId,
-		scopeId: scopeId ?? parentParsed.scopeId
-	};
-	return {
-		agentId: "subagent",
-		source: parentAgentId,
-		accountId: "default",
-		peerKind: "direct",
-		peerId: body || "unknown",
-		threadId,
-		scopeId
-	};
-}
-function buildSubagentSessionKey(params) {
-	const parentParsed = parseAgentSessionKey(params.parentSessionKey);
-	if (!parentParsed) throw new Error(`Invalid parent session key: ${params.parentSessionKey}`);
-	const parentRest = parentParsed.rest;
-	let key = `agent:${normalizeAgentId(parentParsed.agentId)}:subagent:${parentRest}`;
-	if (params.threadId) key = resolveThreadSessionKeys({
-		baseSessionKey: key,
-		threadId: params.threadId
-	}).sessionKey;
-	return key;
-}
-function getParentSessionKey(sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
-	if (!parsed?.threadId) return null;
-	return buildSessionKey({
-		agentId: parsed.agentId,
-		source: parsed.source,
-		accountId: parsed.accountId,
-		peerKind: parsed.peerKind,
-		peerId: parsed.peerId,
-		scopeId: parsed.scopeId
-	});
+function normalizeConversationId(conversationId) {
+	return validateConversationId(conversationId);
 }
 var VALID_SEGMENT_RE, INVALID_CHARS_RE, LEADING_DASH_RE, TRAILING_DASH_RE;
 var init_session_key = __esmMin((() => {
+	init_src();
+	init_conversation_repository();
 	init_agent_session_key();
-	init_agent_session_key();
-	init_session_key_utils();
 	VALID_SEGMENT_RE = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/i;
 	INVALID_CHARS_RE = /[^a-z0-9_-]+/g;
 	LEADING_DASH_RE = /^-+/;
@@ -188,4 +40,4 @@ var init_session_key = __esmMin((() => {
 }));
 //#endregion
 init_session_key();
-export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, buildSessionKey, buildSubagentSessionKey, classifySessionKeyShape, defaultMainSessionKey, getParentSessionKey, getSubagentDepth, init_session_key, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, isValidAgentId, isValidSegment, normalizeAccountId, normalizeAgentId, normalizeMainKey, normalizeOptionalAccountId, normalizeSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseSessionKey, parseThreadSessionSuffix, resolveAgentIdFromSessionKey, resolveThreadParentSessionKey, resolveThreadSessionKeys, sanitizeAgentId, sanitizeSegment, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey };
+export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentConversationId, defaultMainConversationId, getConversation, getConversationRouting, getParentConversationId, init_session_key, isCronConversationId, isSubagentConversationId, isValidAgentId, isValidSegment, normalizeAccountId, normalizeAgentId, normalizeConversationId, normalizeMainKey, normalizeOptionalAccountId, resolveAgentIdFromConversationId, resolveAgentMainConversationId, resolveAgentPeerConversationId, resolveConversationId, sanitizeAgentId, sanitizeSegment };

package/dist/src/session/client-history.js

@@ -1,7 +1,9 @@
 import { parseTurnOutcome } from "../../packages/gateway-contract/src/turn-outcome.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { stripRuntimeContextFromUserMessage } from "./user-message-display.js";
 import { buildTranscriptOutline } from "./transcript-outline.js";
 //#region src/session/client-history.ts
+init_src();
 function sourceContextDisplayMetadata(metadata) {
 	if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return void 0;
 	const rows = metadata.sourceContexts;

package/dist/src/session/compaction-types.js

@@ -1,16 +1,5 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 //#region src/session/compaction-types.ts
-const HANDOVER_ITEM_KINDS = [
-	"objective",
-	"decision",
-	"pending_user_ask",
-	"todo",
-	"constraint",
-	"file_change",
-	"tool_outcome",
-	"failure",
-	"current_state",
-	"next_action"
-];
 function isCompactionHandover(value) {
 	if (!value || typeof value !== "object") return false;
 	const handover = value;
@@ -31,5 +20,21 @@ function isCompactionAudit(value) {
 	const audit = value;
 	return (audit.status === "passed" || audit.status === "degraded" || audit.status === "disabled") && (audit.mode === "structural" || audit.mode === "risk" || audit.mode === "full") && Number.isInteger(audit.missingItemsFound) && typeof audit.repaired === "boolean" && (audit.auditModelRef === void 0 || typeof audit.auditModelRef === "string");
 }
+var HANDOVER_ITEM_KINDS;
+var init_compaction_types = __esmMin((() => {
+	HANDOVER_ITEM_KINDS = [
+		"objective",
+		"decision",
+		"pending_user_ask",
+		"todo",
+		"constraint",
+		"file_change",
+		"tool_outcome",
+		"failure",
+		"current_state",
+		"next_action"
+	];
+}));
 //#endregion
-export { HANDOVER_ITEM_KINDS, isCompactionAudit, isCompactionHandover };
+init_compaction_types();
+export { HANDOVER_ITEM_KINDS, init_compaction_types, isCompactionAudit, isCompactionHandover };

package/dist/src/session/config-store.d.ts

@@ -6,14 +6,14 @@ export declare class SessionConfigStore {
     constructor(_agentHomeDir: string, cwd?: string);
     private requireDatabase;
     initialize(): Promise<void>;
-    get(sessionKey: string): Promise<SessionAgentConfig | null>;
-    set(sessionKey: string, config: SessionAgentConfig): Promise<void>;
-    update(sessionKey: string, partial: Partial<SessionAgentConfig>): Promise<SessionAgentConfig>;
-    delete(sessionKey: string): Promise<void>;
-    has(sessionKey: string): Promise<boolean>;
+    get(conversationId: string): Promise<SessionAgentConfig | null>;
+    set(conversationId: string, config: SessionAgentConfig): Promise<void>;
+    update(conversationId: string, partial: Partial<SessionAgentConfig>): Promise<SessionAgentConfig>;
+    delete(conversationId: string): Promise<void>;
+    has(conversationId: string): Promise<boolean>;
     getAll(): Promise<Map<string, SessionAgentConfig>>;
     clear(): Promise<void>;
 }
-export declare function resolveThinkingLevel(sessionConfigStore: SessionConfigStore, sessionKey: string, agentDefault?: ThinkLevel): Promise<ThinkLevel | undefined>;
-export declare function resolveReasoningLevel(sessionConfigStore: SessionConfigStore, sessionKey: string, agentDefault?: ReasoningLevel): Promise<ReasoningLevel | undefined>;
-export declare function resolveVerboseLevel(sessionConfigStore: SessionConfigStore, sessionKey: string, agentDefault?: VerboseLevel): Promise<VerboseLevel | undefined>;
+export declare function resolveThinkingLevel(sessionConfigStore: SessionConfigStore, conversationId: string, agentDefault?: ThinkLevel): Promise<ThinkLevel | undefined>;
+export declare function resolveReasoningLevel(sessionConfigStore: SessionConfigStore, conversationId: string, agentDefault?: ReasoningLevel): Promise<ReasoningLevel | undefined>;
+export declare function resolveVerboseLevel(sessionConfigStore: SessionConfigStore, conversationId: string, agentDefault?: VerboseLevel): Promise<VerboseLevel | undefined>;

package/dist/src/session/config-store.js

@@ -18,29 +18,29 @@ var SessionConfigStore = class {
 		this.requireDatabase();
 		log.debug("Session config store initialized (SQLite)");
 	}
-	async get(sessionKey) {
+	async get(conversationId) {
 		this.requireDatabase();
-		return getSessionConfig(sessionKey);
+		return getSessionConfig(conversationId);
 	}
-	async set(sessionKey, config) {
+	async set(conversationId, config) {
 		this.requireDatabase();
-		setSessionConfig(sessionKey, config, this.cwd);
-		log.debug({ sessionKey }, "Session config saved");
+		setSessionConfig(conversationId, config, this.cwd);
+		log.debug({ conversationId }, "Session config saved");
 	}
-	async update(sessionKey, partial) {
+	async update(conversationId, partial) {
 		this.requireDatabase();
-		const updated = updateSessionConfig(sessionKey, partial, this.cwd);
-		log.debug({ sessionKey }, "Session config updated");
+		const updated = updateSessionConfig(conversationId, partial, this.cwd);
+		log.debug({ conversationId }, "Session config updated");
 		return updated;
 	}
-	async delete(sessionKey) {
+	async delete(conversationId) {
 		this.requireDatabase();
-		deleteSessionConfig(sessionKey);
-		log.debug({ sessionKey }, "Session config deleted");
+		deleteSessionConfig(conversationId);
+		log.debug({ conversationId }, "Session config deleted");
 	}
-	async has(sessionKey) {
+	async has(conversationId) {
 		this.requireDatabase();
-		return hasSessionConfig(sessionKey);
+		return hasSessionConfig(conversationId);
 	}
 	async getAll() {
 		this.requireDatabase();
@@ -61,14 +61,14 @@ var SessionConfigStore = class {
 		log.debug("All session configs cleared");
 	}
 };
-async function resolveThinkingLevel(sessionConfigStore, sessionKey, agentDefault) {
-	return (await sessionConfigStore.get(sessionKey))?.thinkingLevel ?? agentDefault;
+async function resolveThinkingLevel(sessionConfigStore, conversationId, agentDefault) {
+	return (await sessionConfigStore.get(conversationId))?.thinkingLevel ?? agentDefault;
 }
-async function resolveReasoningLevel(sessionConfigStore, sessionKey, agentDefault) {
-	return (await sessionConfigStore.get(sessionKey))?.reasoningLevel ?? agentDefault;
+async function resolveReasoningLevel(sessionConfigStore, conversationId, agentDefault) {
+	return (await sessionConfigStore.get(conversationId))?.reasoningLevel ?? agentDefault;
 }
-async function resolveVerboseLevel(sessionConfigStore, sessionKey, agentDefault) {
-	return (await sessionConfigStore.get(sessionKey))?.verboseLevel ?? agentDefault;
+async function resolveVerboseLevel(sessionConfigStore, conversationId, agentDefault) {
+	return (await sessionConfigStore.get(conversationId))?.verboseLevel ?? agentDefault;
 }
 //#endregion
 export { SessionConfigStore, resolveReasoningLevel, resolveThinkingLevel, resolveVerboseLevel };

package/dist/src/session/index.d.ts

@@ -10,12 +10,12 @@ export { SessionStatus, type SessionMetadata, type SessionDetail, type SessionLi
 export { DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, DEFAULT_IDLE_MINUTES, evaluateSessionFreshness, resolveDailyResetAtMs, resolveSessionResetPolicy, type SessionFreshness, type SessionResetConfig, type SessionResetMode, type SessionResetPolicy, type SessionResetType, } from './reset-policy.js';
 export { resolveChannelResetConfig, resolveSessionResetType, } from './reset-type.js';
 export { resolveSessionLifecycleTimestamps, type SessionLifecycleEntry } from './lifecycle-timestamps.js';
-export { resolveSession, resolveSessionKeyForRequest, type SessionKeyResolution, type SessionResolution, } from './resolve-session.js';
+export { resolveSession, resolveConversationIdForRequest, type ConversationIdResolution, type SessionResolution, } from './resolve-session.js';
 export { initSessionTurn, type InitSessionTurnOptions, type InitSessionTurnResult, type SessionResetFn, } from './init-session-turn.js';
 export { DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, bareResetAckMessage, matchResetTriggers, resolveResetTriggers, shouldSkipResetOverlapCommand, stripLeadingEnvelopeTimestamp, type ResetTriggerMatch, } from './reset-triggers.js';
 export type { CompactionConfig, CompactionResult } from '../agent/memory/compaction.js';
 export type { WindowConfig } from '../agent/memory/window.js';
-export { maybeSetProvisionalSessionTitle, maybeRefineSessionTitleWithLlm, generateSessionTitleFromMessages, sanitizeSessionTitle, sanitizeGeneratedSessionTitle, provisionalTitleFromUserText, fallbackTitleFromMessages, getSessionTitleSource, shouldRefineSessionTitleWithLlm, isWebchatSessionKey, shouldAutoTitleSessionKey, type SessionTitleSource, } from './session-title.js';
+export { maybeSetProvisionalSessionTitle, maybeRefineSessionTitleWithLlm, generateSessionTitleFromMessages, sanitizeSessionTitle, sanitizeGeneratedSessionTitle, provisionalTitleFromUserText, fallbackTitleFromMessages, getSessionTitleSource, shouldRefineSessionTitleWithLlm, isWebchatConversationId, shouldAutoTitleConversationId, type SessionTitleSource, } from './session-title.js';
 export { messagesToClientHistory, flattenMessageContent, type ClientHistoryMessage } from './client-history.js';
 export { XOPC_SESSION_TRANSCRIPT_TYPE, CURRENT_SESSION_TRANSCRIPT_VERSION, } from './transcript-format.js';
 export { buildSessionContextForLlm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray, type TranscriptStoredRow, type XopcTranscriptContextEntry, } from './session-context-for-llm.js';

package/dist/src/session/index.js

@@ -1,9 +1,9 @@
-import { buildSessionContextForLlm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
-import { SessionStatus } from "./types.js";
+import { buildSessionContextForLlm, init_session_context_for_llm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
+import { SessionStatus, init_types } from "./types.js";
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "./session-workspace.js";
 import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { emitSessionTranscriptUpdate, onSessionTranscriptUpdate } from "./transcript-events.js";
-import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatSessionKey, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm } from "./session-title.js";
+import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatConversationId, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleConversationId, shouldRefineSessionTitleWithLlm } from "./session-title.js";
 import { SessionStore } from "./store.js";
 import { applySessionPatchToMetadata } from "./patch-metadata.js";
 import { SessionIndex } from "./manager.js";
@@ -12,8 +12,12 @@ import { DEFAULT_ACTIVITY_DETAIL_LEVEL, resolveConfiguredActivityDetailDefault,
 import { DEFAULT_IDLE_MINUTES, DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, evaluateSessionFreshness, resolveDailyResetAtMs, resolveSessionResetPolicy } from "./reset-policy.js";
 import { resolveChannelResetConfig, resolveSessionResetType } from "./reset-type.js";
 import { resolveSessionLifecycleTimestamps } from "./lifecycle-timestamps.js";
-import { resolveSession, resolveSessionKeyForRequest } from "./resolve-session.js";
+import { resolveConversationIdForRequest, resolveSession } from "./resolve-session.js";
 import { DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, bareResetAckMessage, matchResetTriggers, resolveResetTriggers, shouldSkipResetOverlapCommand, stripLeadingEnvelopeTimestamp } from "./reset-triggers.js";
 import { initSessionTurn } from "./init-session-turn.js";
 import { CURRENT_SESSION_TRANSCRIPT_VERSION, XOPC_SESSION_TRANSCRIPT_TYPE } from "./transcript-format.js";
-export { CURRENT_SESSION_TRANSCRIPT_VERSION, DEFAULT_ACTIVITY_DETAIL_LEVEL, DEFAULT_IDLE_MINUTES, DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, SessionConfigStore, SessionIndex, SessionStatus, SessionStore, XOPC_SESSION_TRANSCRIPT_TYPE, applySessionPatchToMetadata, bareResetAckMessage, buildSessionContextForLlm, effectiveWorkspacePathForSession, emitSessionTranscriptUpdate, evaluateSessionFreshness, fallbackTitleFromMessages, flattenMessageContent, generateSessionTitleFromMessages, getSessionTitleSource, initSessionTurn, isTranscriptContextEntry, isWebchatSessionKey, matchResetTriggers, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, mergeLlmMessagesPreservingContextRows, messagesToClientHistory, normalizeWorkingDirectoryInput, onSessionTranscriptUpdate, projectWorkspacePath, provisionalTitleFromUserText, resolveChannelResetConfig, resolveConfiguredActivityDetailDefault, resolveDailyResetAtMs, resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel, resolveReasoningLevel, resolveResetTriggers, resolveSession, resolveSessionKeyForRequest, resolveSessionLifecycleTimestamps, resolveSessionResetPolicy, resolveSessionResetType, resolveThinkingLevel, resolveVerboseLevel, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm, shouldSkipResetOverlapCommand, stripLeadingEnvelopeTimestamp, transcriptRowsFromJsonArray };
+//#region src/session/index.ts
+init_types();
+init_session_context_for_llm();
+//#endregion
+export { CURRENT_SESSION_TRANSCRIPT_VERSION, DEFAULT_ACTIVITY_DETAIL_LEVEL, DEFAULT_IDLE_MINUTES, DEFAULT_RESET_AT_HOUR, DEFAULT_RESET_MODE, DEFAULT_RESET_TRIGGERS, RESET_OVERLAP_COMMANDS, SessionConfigStore, SessionIndex, SessionStatus, SessionStore, XOPC_SESSION_TRANSCRIPT_TYPE, applySessionPatchToMetadata, bareResetAckMessage, buildSessionContextForLlm, effectiveWorkspacePathForSession, emitSessionTranscriptUpdate, evaluateSessionFreshness, fallbackTitleFromMessages, flattenMessageContent, generateSessionTitleFromMessages, getSessionTitleSource, initSessionTurn, isTranscriptContextEntry, isWebchatConversationId, matchResetTriggers, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, mergeLlmMessagesPreservingContextRows, messagesToClientHistory, normalizeWorkingDirectoryInput, onSessionTranscriptUpdate, projectWorkspacePath, provisionalTitleFromUserText, resolveChannelResetConfig, resolveConfiguredActivityDetailDefault, resolveConversationIdForRequest, resolveDailyResetAtMs, resolveEffectiveReasoningLevel, resolveEffectiveThinkingLevel, resolveReasoningLevel, resolveResetTriggers, resolveSession, resolveSessionLifecycleTimestamps, resolveSessionResetPolicy, resolveSessionResetType, resolveThinkingLevel, resolveVerboseLevel, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleConversationId, shouldRefineSessionTitleWithLlm, shouldSkipResetOverlapCommand, stripLeadingEnvelopeTimestamp, transcriptRowsFromJsonArray };

package/dist/src/session/init-session-turn.d.ts

@@ -1,12 +1,12 @@
 import { type Config } from '../config/schema.js';
-export type SessionResetFn = (sessionKey: string) => Promise<{
-    sessionId: string;
-    previousSessionId: string;
+export type SessionResetFn = (conversationId: string) => Promise<{
+    transcriptId: string;
+    previousTranscriptId: string;
 } | null>;
 export type InitSessionTurnResult = {
-    sessionKey: string;
-    sessionId?: string;
-    previousSessionId?: string;
+    conversationId: string;
+    transcriptId?: string;
+    previousTranscriptId?: string;
     isNewSession: boolean;
     resetTriggered: boolean;
     staleRollover: boolean;
@@ -16,7 +16,7 @@ export type InitSessionTurnResult = {
 };
 export type InitSessionTurnOptions = {
     cfg: Config;
-    sessionKey: string;
+    conversationId: string;
     body?: string;
     resetSession: SessionResetFn;
 };

package/dist/src/session/init-session-turn.js

@@ -6,7 +6,7 @@ import { SessionConfigSchema, init_schema } from "../config/schema.js";
 import { evaluateSessionFreshness, resolveSessionResetPolicy } from "./reset-policy.js";
 import { resolveChannelResetConfig, resolveSessionResetType } from "./reset-type.js";
 import { resolveSessionLifecycleTimestamps } from "./lifecycle-timestamps.js";
-import { resolveSessionKeyForRequest } from "./resolve-session.js";
+import { resolveConversationIdForRequest } from "./resolve-session.js";
 import { bareResetAckMessage, matchResetTriggers, resolveResetTriggers } from "./reset-triggers.js";
 import { randomUUID } from "node:crypto";
 //#region src/session/init-session-turn.ts
@@ -19,11 +19,11 @@ async function initSessionTurn(opts) {
 	const triggers = resolveResetTriggers(sessionCfg.resetTriggers);
 	const rawBody = opts.body ?? "";
 	const triggerMatch = matchResetTriggers(rawBody, triggers);
-	const { sessionKey, sessionMetadata } = await resolveSessionKeyForRequest({
+	const { conversationId, sessionMetadata } = await resolveConversationIdForRequest({
 		cfg: opts.cfg,
-		sessionKey: opts.sessionKey
+		conversationId: opts.conversationId
 	});
-	const key = sessionKey?.trim() ?? opts.sessionKey.trim();
+	const key = conversationId?.trim() ?? opts.conversationId.trim();
 	const routing = sessionMetadata?.routing;
 	const peerKind = routing?.peerKind;
 	const resetType = resolveSessionResetType({
@@ -52,38 +52,38 @@ async function initSessionTurn(opts) {
 	}) : { fresh: false };
 	const staleRollover = Boolean(sessionMetadata && resetPolicy.configured === true && !freshness.fresh);
 	const needsRollover = triggerMatch.resetTriggered || staleRollover;
-	let sessionId = sessionMetadata?.sessionId;
-	let previousSessionId;
+	let transcriptId = sessionMetadata?.transcriptId;
+	let previousTranscriptId;
 	let isNewSession = false;
-	if (needsRollover && sessionMetadata?.sessionId) {
+	if (needsRollover && sessionMetadata?.transcriptId) {
 		const task = await opts.resetSession(key);
 		if (task) {
-			previousSessionId = task.previousSessionId;
-			sessionId = task.sessionId;
+			previousTranscriptId = task.previousTranscriptId;
+			transcriptId = task.transcriptId;
 			isNewSession = true;
 			log.info({
-				sessionKey: key,
-				sessionId: task.sessionId,
-				previousSessionId: task.previousSessionId,
+				conversationId: key,
+				transcriptId: task.transcriptId,
+				previousTranscriptId: task.previousTranscriptId,
 				resetTriggered: triggerMatch.resetTriggered,
 				staleRollover,
 				resetType
 			}, triggerMatch.resetTriggered ? "Session reset via reset trigger" : "Session rolled over (stale freshness)");
 		} else {
-			log.warn({ sessionKey: key }, "Session rollover requested but resetSession returned null");
-			sessionId = randomUUID();
+			log.warn({ conversationId: key }, "Session rollover requested but resetSession returned null");
+			transcriptId = randomUUID();
 			isNewSession = true;
 		}
 	} else if (!sessionMetadata) {
 		isNewSession = true;
-		sessionId = randomUUID();
+		transcriptId = randomUUID();
 	}
 	const bareReset = triggerMatch.resetTriggered && triggerMatch.bareReset;
 	const ackMessage = bareReset ? bareResetAckMessage(triggerMatch.matchedTrigger) : void 0;
 	return {
-		sessionKey: key,
-		sessionId,
-		previousSessionId,
+		conversationId: key,
+		transcriptId,
+		previousTranscriptId,
 		isNewSession,
 		resetTriggered: triggerMatch.resetTriggered,
 		staleRollover,

package/dist/src/session/manager.d.ts

@@ -55,7 +55,7 @@ export declare class SessionIndex extends EventEmitter {
         error: string;
     }>;
     getSessionMetadata(key: string): Promise<SessionMetadata | null>;
-    resolveSessionKeyBySessionId(sessionId: string): Promise<string | null>;
+    resolveConversationIdByTranscriptId(transcriptId: string): Promise<string | null>;
     deleteSession(key: string): Promise<boolean>;
     deleteSessions(keys: string[]): Promise<{
         success: string[];
@@ -76,17 +76,17 @@ export declare class SessionIndex extends EventEmitter {
     searchInSession(key: string, keyword: string): Promise<Message[]>;
     exportSession(key: string, format: ExportFormat): Promise<string>;
     importSessionExport(targetKey: string, jsonContent: string): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
     }>;
     forkSession(sourceKey: string, targetKey: string): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
     }>;
     forkSessionRows(sourceKey: string, targetKey: string, options?: {
         throughRow?: number;
     }): Promise<{
-        sessionKey: string;
+        conversationId: string;
         rowCount: number;
     }>;
     forkSessionAtTurn(sourceKey: string, options: import('./store.js').ForkSessionAtTurnOptions): Promise<import('./store.js').ForkSessionResult>;
@@ -149,7 +149,7 @@ export declare class SessionIndex extends EventEmitter {
         data?: unknown;
     }): Promise<void>;
     appendTranscriptCustomMessageEntry(key: string, entry: {
-        expectedSessionId?: string;
+        expectedTranscriptId?: string;
         customType: string;
         content?: string | unknown[];
         display?: boolean;
@@ -168,8 +168,8 @@ export declare class SessionIndex extends EventEmitter {
     delete(key: string): Promise<void>;
     /** Archive transcript and start a new session id for the same key. */
     resetSession(key: string): Promise<{
-        sessionId: string;
-        previousSessionId: string;
+        transcriptId: string;
+        previousTranscriptId: string;
     } | null>;
     /** Token/window stats for a message list */
     getWindowStats(messages: any[]): {

package/dist/src/session/manager.js

@@ -58,8 +58,8 @@ var SessionIndex = class extends EventEmitter$1 {
 	async getSessionMetadata(key) {
 		return this.store.getMetadata(key);
 	}
-	async resolveSessionKeyBySessionId(sessionId) {
-		return this.store.resolveKeyBySessionId(sessionId);
+	async resolveConversationIdByTranscriptId(transcriptId) {
+		return this.store.resolveKeyByTranscriptId(transcriptId);
 	}
 	async deleteSession(key) {
 		const result = await this.store.delete(key);
@@ -155,25 +155,25 @@ var SessionIndex = class extends EventEmitter$1 {
 	}
 	async importSessionExport(targetKey, jsonContent) {
 		const result = await this.store.importSessionExport(targetKey, jsonContent);
-		const metadata = await this.store.getMetadata(result.sessionKey);
+		const metadata = await this.store.getMetadata(result.conversationId);
 		if (metadata) this.emit("sessionCreated", metadata);
 		return result;
 	}
 	async forkSession(sourceKey, targetKey) {
 		const result = await this.store.forkSession(sourceKey, targetKey);
-		const metadata = await this.store.getMetadata(result.sessionKey);
+		const metadata = await this.store.getMetadata(result.conversationId);
 		if (metadata) this.emit("sessionCreated", metadata);
 		return result;
 	}
 	async forkSessionRows(sourceKey, targetKey, options = {}) {
 		const result = await this.store.forkSessionRows(sourceKey, targetKey, options);
-		const metadata = await this.store.getMetadata(result.sessionKey);
+		const metadata = await this.store.getMetadata(result.conversationId);
 		if (metadata) this.emit("sessionCreated", metadata);
 		return result;
 	}
 	async forkSessionAtTurn(sourceKey, options) {
 		const result = await this.store.forkSessionAtTurn(sourceKey, options);
-		const metadata = await this.store.getMetadata(result.sessionKey);
+		const metadata = await this.store.getMetadata(result.conversationId);
 		if (metadata) this.emit("sessionCreated", metadata);
 		return result;
 	}

package/dist/src/session/model-config-lock.d.ts

@@ -1,2 +1,2 @@
 /** Serialize configuration changes with input acceptance for one conversation. */
-export declare function withModelConfigLock<T>(sessionKey: string, operation: () => Promise<T>): Promise<T>;
+export declare function withModelConfigLock<T>(conversationId: string, operation: () => Promise<T>): Promise<T>;

package/dist/src/session/model-config-lock.js

@@ -1,13 +1,13 @@
 //#region src/session/model-config-lock.ts
 const pending = /* @__PURE__ */ new Map();
 /** Serialize configuration changes with input acceptance for one conversation. */
-async function withModelConfigLock(sessionKey, operation) {
-	const next = (pending.get(sessionKey) ?? Promise.resolve()).catch(() => void 0).then(operation);
-	pending.set(sessionKey, next);
+async function withModelConfigLock(conversationId, operation) {
+	const next = (pending.get(conversationId) ?? Promise.resolve()).catch(() => void 0).then(operation);
+	pending.set(conversationId, next);
 	try {
 		return await next;
 	} finally {
-		if (pending.get(sessionKey) === next) pending.delete(sessionKey);
+		if (pending.get(conversationId) === next) pending.delete(conversationId);
 	}
 }
 //#endregion

package/dist/src/session/resolve-session.d.ts

@@ -2,26 +2,26 @@ import { type Config } from '../config/schema.js';
 import { type ThinkLevel, type VerboseLevel } from '../agent/transcript/thinking-types.js';
 import type { SessionMetadata } from './types.js';
 export type SessionResolution = {
-    sessionId: string;
-    sessionKey?: string;
+    transcriptId: string;
+    conversationId?: string;
     sessionMetadata?: SessionMetadata | null;
     isNewSession: boolean;
     persistedThinking?: ThinkLevel;
     persistedVerbose?: VerboseLevel;
 };
-export type SessionKeyResolution = {
-    sessionKey?: string;
+export type ConversationIdResolution = {
+    conversationId?: string;
     sessionMetadata?: SessionMetadata | null;
 };
-export declare function resolveSessionKeyForRequest(opts: {
+export declare function resolveConversationIdForRequest(opts: {
     cfg: Config;
-    sessionKey?: string;
-    sessionId?: string;
+    conversationId?: string;
+    transcriptId?: string;
     agentId?: string;
-}): Promise<SessionKeyResolution>;
+}): Promise<ConversationIdResolution>;
 export declare function resolveSession(opts: {
     cfg: Config;
-    sessionKey?: string;
-    sessionId?: string;
+    conversationId?: string;
+    transcriptId?: string;
     agentId?: string;
 }): Promise<SessionResolution>;