@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/agent/background-review/coordinator.d.ts

@@ -15,7 +15,7 @@ export interface BackgroundReviewCoordinatorOptions {
     getConfig: () => Config | undefined;
 }
 export interface ScheduleReviewContext {
-    sessionKey: string;
+    conversationId: string;
     agent: Agent;
     /** Last assistant text — review is skipped when empty. */
     lastAssistantText: string | null;
@@ -29,7 +29,7 @@ export declare class BackgroundReviewCoordinator {
      * Called before the main `agent.prompt` for a user turn — bumps the review
      * counter and arms a review when the cadence interval is hit.
      */
-    beginUserTurn(sessionKey: string): void;
+    beginUserTurn(conversationId: string): void;
     /**
      * Fire-and-forget review after the main user turn. Decides whether to run a
      * understanding sweep based on the counter state + last assistant text,
@@ -37,7 +37,7 @@ export declare class BackgroundReviewCoordinator {
      */
     scheduleAfterUserTurn(ctx: ScheduleReviewContext): void;
     /** Tear down state for a session (called by `AgentManager.removeAgent`). */
-    forgetSession(sessionKey: string): void;
+    forgetSession(conversationId: string): void;
     /** Clear every counter (`AgentManager.dispose` / hot reload). */
     clear(): void;
     private ensureState;

package/dist/src/agent/background-review/coordinator.js

@@ -16,10 +16,10 @@ var BackgroundReviewCoordinator = class {
 	* Called before the main `agent.prompt` for a user turn — bumps the review
 	* counter and arms a review when the cadence interval is hit.
 	*/
-	beginUserTurn(sessionKey) {
+	beginUserTurn(conversationId) {
 		const cfg = resolveBackgroundReviewSettings(this.opts.getConfig());
 		if (!cfg.enabled) return;
-		const state = this.ensureState(sessionKey);
+		const state = this.ensureState(conversationId);
 		const intervalTurns = cfg.reviewIntervalTurns;
 		state.turnsSinceReview += 1;
 		if (state.turnsSinceReview >= intervalTurns) {
@@ -36,30 +36,30 @@ var BackgroundReviewCoordinator = class {
 		this.runReviewIfNeeded(ctx).catch((err) => {
 			log.warn({
 				err,
-				sessionKey: ctx.sessionKey
+				conversationId: ctx.conversationId
 			}, "Background review failed");
 		});
 	}
 	/** Tear down state for a session (called by `AgentManager.removeAgent`). */
-	forgetSession(sessionKey) {
-		this.states.delete(sessionKey);
+	forgetSession(conversationId) {
+		this.states.delete(conversationId);
 	}
 	/** Clear every counter (`AgentManager.dispose` / hot reload). */
 	clear() {
 		this.states.clear();
 	}
-	ensureState(sessionKey) {
-		const existing = this.states.get(sessionKey);
+	ensureState(conversationId) {
+		const existing = this.states.get(conversationId);
 		if (existing) return existing;
 		const state = {
 			turnsSinceReview: 0,
 			pendingReview: false
 		};
-		this.states.set(sessionKey, state);
+		this.states.set(conversationId, state);
 		return state;
 	}
 	async runReviewIfNeeded(ctx) {
-		const state = this.states.get(ctx.sessionKey);
+		const state = this.states.get(ctx.conversationId);
 		if (!state) return;
 		const settings = resolveBackgroundReviewSettings(this.opts.getConfig());
 		if (!settings.enabled) return;
@@ -69,7 +69,7 @@ var BackgroundReviewCoordinator = class {
 		state.pendingReview = false;
 		if (!shouldReview) return;
 		await runBackgroundUserModelReview({
-			sessionKey: ctx.sessionKey,
+			conversationId: ctx.conversationId,
 			mainAgent: ctx.agent,
 			settings,
 			workspaceId: ctx.workspaceId,

package/dist/src/agent/background-review/run-background-review.d.ts

@@ -3,7 +3,7 @@ import type { Config } from '../../config/schema.js';
 import { type UserModelCaptureResult } from '../../user-model/capture/index.js';
 import type { BackgroundReviewSettings } from './settings.js';
 export interface RunUserModelReviewParams {
-    sessionKey: string;
+    conversationId: string;
     mainAgent: Agent;
     settings: BackgroundReviewSettings;
     workspaceId: string;

package/dist/src/agent/background-review/run-background-review.js

@@ -4,10 +4,10 @@ import { finishContextExtractionRun } from "../../storage/sqlite/context-extract
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import { loadCompactionSourceSnapshot } from "../../storage/sqlite/transcript-repository.js";
 import "../../storage/sqlite/index.js";
-import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { getApiKeySync, init_providers, resolveModel } from "../../providers/index.js";
 import { createExtensionAwareStreamFn } from "../../providers/extension-stream-bridge.js";
+import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { extractTextContent } from "../context/workspace.js";
 import { listUserAssertions } from "../../user-model/repository.js";
 import { readAgentMessageContent } from "../memory/agent-message-access.js";
@@ -61,8 +61,8 @@ function tagMessage(entry) {
 	}
 	return copy;
 }
-function loadEvidenceMessages(sessionKey, max) {
-	const snapshot = loadCompactionSourceSnapshot(sessionKey);
+function loadEvidenceMessages(conversationId, max) {
+	const snapshot = loadCompactionSourceSnapshot(conversationId);
 	if (!snapshot) return [];
 	return snapshot.entries.filter((entry) => isReviewMessage(entry.row)).slice(-max).map((entry) => {
 		const message = entry.row;
@@ -96,7 +96,7 @@ function resolveInterpreterRuntime(params) {
 	const processingPolicy = config?.userContext.userModel.processingPolicy ?? "remote_allowed";
 	let model;
 	if (config) {
-		const agentId = extractProfileAgentId(params.sessionKey, config);
+		const agentId = extractProfileAgentId(params.conversationId, config);
 		const ref = resolveModelIntentRef(config, agentId, "understanding");
 		if (ref) try {
 			model = resolveModel(ref);
@@ -111,7 +111,7 @@ function resolveInterpreterRuntime(params) {
 	model ??= params.mainAgent.state.model;
 	if (processingPolicy === "local_only" && !isLocalModel(model)) {
 		log.debug({
-			sessionKey: params.sessionKey,
+			conversationId: params.conversationId,
 			provider: model.provider,
 			modelId: model.id
 		}, "Understanding interpretation skipped because no local model is configured");
@@ -154,7 +154,7 @@ async function interpret(params) {
 	} catch (err) {
 		log.warn({
 			err,
-			sessionKey: params.sessionKey
+			conversationId: params.conversationId
 		}, "User-understanding interpretation failed or timed out");
 		reviewAgent.abort();
 		await reviewAgent.waitForIdle().catch(() => {});
@@ -188,7 +188,7 @@ async function executeReview(params) {
 	}
 	try {
 		const config = params.getConfig();
-		const agentId = config ? extractProfileAgentId(params.sessionKey, config) : "main";
+		const agentId = config ? extractProfileAgentId(params.conversationId, config) : "main";
 		const write = config?.userContext.userModel.writePolicy ?? "deny";
 		const result = executeUserModelInterpretation({
 			interpretation,
@@ -196,10 +196,10 @@ async function executeReview(params) {
 			extractionRunId: extraction.run.id,
 			extractorId: params.extractorId,
 			scopeContext: {
-				sessionId: params.sessionKey,
+				conversationId: params.conversationId,
 				agentId,
 				workspaceId: params.workspaceId,
-				...getSessionMetadata(params.sessionKey)?.projectId ? { projectId: getSessionMetadata(params.sessionKey).projectId } : {}
+				...getSessionMetadata(params.conversationId)?.projectId ? { projectId: getSessionMetadata(params.conversationId).projectId } : {}
 			},
 			policy: {
 				write,
@@ -227,21 +227,21 @@ async function executeReview(params) {
 	}
 }
 async function runTurnUserModelCapture(params) {
-	const evidence = loadEvidenceMessages(params.sessionKey, params.maxHistoryMessages ?? 12);
+	const evidence = loadEvidenceMessages(params.conversationId, params.maxHistoryMessages ?? 12);
 	if (!evidence.length) return emptyUserModelCaptureResult();
 	const availableTargets = listUserAssertions({ limit: 200 }).map((item) => ({
 		id: item.id,
 		statement: item.statement
 	}));
 	return executeReview({
-		sessionKey: params.sessionKey,
+		conversationId: params.conversationId,
 		mainAgent: params.mainAgent,
 		workspaceId: params.workspaceId,
 		getConfig: params.getConfig,
 		evidence,
 		mode: "turn",
 		extractorId: "turn-semantics",
-		sourceRef: `session:${params.sessionKey}:turn:${params.turnId}`,
+		sourceRef: `session:${params.conversationId}:turn:${params.turnId}`,
 		contentForHash: params.userText,
 		availableTargets,
 		timeoutMs: 3e4,
@@ -249,19 +249,19 @@ async function runTurnUserModelCapture(params) {
 	});
 }
 async function runBackgroundUserModelReview(params) {
-	const evidence = loadEvidenceMessages(params.sessionKey, params.settings.maxHistoryMessages);
+	const evidence = loadEvidenceMessages(params.conversationId, params.settings.maxHistoryMessages);
 	if (!evidence.length) return;
 	const first = evidence[0];
 	const last = evidence[evidence.length - 1];
 	await executeReview({
-		sessionKey: params.sessionKey,
+		conversationId: params.conversationId,
 		mainAgent: params.mainAgent,
 		workspaceId: params.workspaceId,
 		getConfig: params.getConfig,
 		evidence,
 		mode: "transcript",
 		extractorId: "transcript-synthesis",
-		sourceRef: `session:${params.sessionKey}:window:${first.ref}:${last.ref}`,
+		sourceRef: `session:${params.conversationId}:window:${first.ref}:${last.ref}`,
 		contentForHash: evidence.map((entry) => entry.ref).join("\n"),
 		availableTargets: [],
 		timeoutMs: params.settings.maxDurationMs

package/dist/src/agent/bootstrap/bootstrap-cache.d.ts

@@ -1,9 +1,9 @@
 import type { WorkspaceBootstrapFile } from './types.js';
-export declare function wasBootstrapContextInjected(sessionKey: string): boolean;
-export declare function markBootstrapContextInjected(sessionKey: string): void;
+export declare function wasBootstrapContextInjected(conversationId: string): boolean;
+export declare function markBootstrapContextInjected(conversationId: string): void;
 export declare function getOrLoadBootstrapFiles(params: {
     profileDir: string;
-    sessionKey: string;
+    conversationId: string;
 }): Promise<WorkspaceBootstrapFile[]>;
-export declare function clearBootstrapSnapshot(sessionKey: string): void;
+export declare function clearBootstrapSnapshot(conversationId: string): void;
 export declare function clearAllBootstrapSnapshots(): void;

package/dist/src/agent/bootstrap/bootstrap-cache.js

@@ -9,25 +9,25 @@ function bootstrapFilesEqual(previous, next) {
 		return updated !== void 0 && file.name === updated.name && file.path === updated.path && file.content === updated.content && file.missing === updated.missing;
 	});
 }
-function wasBootstrapContextInjected(sessionKey) {
-	return bootstrapContextInjected.has(sessionKey);
+function wasBootstrapContextInjected(conversationId) {
+	return bootstrapContextInjected.has(conversationId);
 }
-function markBootstrapContextInjected(sessionKey) {
-	bootstrapContextInjected.add(sessionKey);
+function markBootstrapContextInjected(conversationId) {
+	bootstrapContextInjected.add(conversationId);
 }
 async function getOrLoadBootstrapFiles(params) {
-	const existing = cache.get(params.sessionKey);
+	const existing = cache.get(params.conversationId);
 	const files = loadProfileBootstrapFiles(params.profileDir);
 	if (existing && existing.profileDir === params.profileDir && bootstrapFilesEqual(existing.files, files)) return existing.files;
-	cache.set(params.sessionKey, {
+	cache.set(params.conversationId, {
 		profileDir: params.profileDir,
 		files
 	});
 	return files;
 }
-function clearBootstrapSnapshot(sessionKey) {
-	cache.delete(sessionKey);
-	bootstrapContextInjected.delete(sessionKey);
+function clearBootstrapSnapshot(conversationId) {
+	cache.delete(conversationId);
+	bootstrapContextInjected.delete(conversationId);
 }
 function clearAllBootstrapSnapshots() {
 	cache.clear();

package/dist/src/agent/bootstrap/bootstrap-files.d.ts

@@ -3,19 +3,19 @@ import type { EmbeddedContextFile, WorkspaceBootstrapFile } from './types.js';
 export { clearAllBootstrapSnapshots, clearBootstrapSnapshot } from './bootstrap-cache.js';
 export declare function resolveBootstrapFilesSync(params: {
     profileDir: string;
-    sessionKey?: string;
+    conversationId?: string;
     excludeHeartbeat?: boolean;
 }): WorkspaceBootstrapFile[];
 export declare function resolveBootstrapFilesForRun(params: {
     profileDir: string;
-    sessionKey?: string;
+    conversationId?: string;
     excludeHeartbeat?: boolean;
     warn?: (message: string) => void;
 }): Promise<WorkspaceBootstrapFile[]>;
 export declare function resolveBootstrapContextSync(params: {
     profileDir: string;
     config?: Config;
-    sessionKey?: string;
+    conversationId?: string;
     excludeHeartbeat?: boolean;
     contextInjection?: 'always' | 'continuation-skip' | 'never';
 }): {
@@ -25,7 +25,7 @@ export declare function resolveBootstrapContextSync(params: {
 export declare function resolveBootstrapContextForRun(params: {
     profileDir: string;
     config?: Config;
-    sessionKey?: string;
+    conversationId?: string;
     excludeHeartbeat?: boolean;
     contextInjection?: 'always' | 'continuation-skip' | 'never';
     warn?: (message: string) => void;

package/dist/src/agent/bootstrap/bootstrap-files.js

@@ -9,14 +9,14 @@ function filterHeartbeatBootstrapFile(files, exclude) {
 	return files.filter((file) => file.name !== DEFAULT_HEARTBEAT_FILENAME);
 }
 function resolveBootstrapFilesSync(params) {
-	return filterHeartbeatBootstrapFile(filterBootstrapFilesForSession(loadProfileBootstrapFiles(params.profileDir), params.sessionKey), params.excludeHeartbeat ?? false);
+	return filterHeartbeatBootstrapFile(filterBootstrapFilesForSession(loadProfileBootstrapFiles(params.profileDir), params.conversationId), params.excludeHeartbeat ?? false);
 }
 async function resolveBootstrapFilesForRun(params) {
-	const sessionKey = params.sessionKey;
-	return filterHeartbeatBootstrapFile(filterBootstrapFilesForSession(sessionKey ? await getOrLoadBootstrapFiles({
+	const conversationId = params.conversationId;
+	return filterHeartbeatBootstrapFile(filterBootstrapFilesForSession(conversationId ? await getOrLoadBootstrapFiles({
 		profileDir: params.profileDir,
-		sessionKey
-	}) : loadProfileBootstrapFiles(params.profileDir), sessionKey), params.excludeHeartbeat ?? false);
+		conversationId
+	}) : loadProfileBootstrapFiles(params.profileDir), conversationId), params.excludeHeartbeat ?? false);
 }
 function resolveBootstrapContextSync(params) {
 	const mode = params.contextInjection ?? "always";
@@ -24,7 +24,7 @@ function resolveBootstrapContextSync(params) {
 		bootstrapFiles: [],
 		contextFiles: []
 	};
-	if (mode === "continuation-skip" && params.sessionKey && wasBootstrapContextInjected(params.sessionKey)) return {
+	if (mode === "continuation-skip" && params.conversationId && wasBootstrapContextInjected(params.conversationId)) return {
 		bootstrapFiles: [],
 		contextFiles: []
 	};
@@ -33,7 +33,7 @@ function resolveBootstrapContextSync(params) {
 		maxChars: resolveBootstrapMaxChars(params.config),
 		totalMaxChars: resolveBootstrapTotalMaxChars(params.config)
 	});
-	if (mode === "continuation-skip" && params.sessionKey && contextFiles.length > 0) markBootstrapContextInjected(params.sessionKey);
+	if (mode === "continuation-skip" && params.conversationId && contextFiles.length > 0) markBootstrapContextInjected(params.conversationId);
 	return {
 		bootstrapFiles,
 		contextFiles
@@ -45,7 +45,7 @@ async function resolveBootstrapContextForRun(params) {
 		bootstrapFiles: [],
 		contextFiles: []
 	};
-	if (mode === "continuation-skip" && params.sessionKey && wasBootstrapContextInjected(params.sessionKey)) return {
+	if (mode === "continuation-skip" && params.conversationId && wasBootstrapContextInjected(params.conversationId)) return {
 		bootstrapFiles: [],
 		contextFiles: []
 	};
@@ -55,7 +55,7 @@ async function resolveBootstrapContextForRun(params) {
 		totalMaxChars: resolveBootstrapTotalMaxChars(params.config),
 		warn: params.warn
 	});
-	if (mode === "continuation-skip" && params.sessionKey && contextFiles.length > 0) markBootstrapContextInjected(params.sessionKey);
+	if (mode === "continuation-skip" && params.conversationId && contextFiles.length > 0) markBootstrapContextInjected(params.conversationId);
 	return {
 		bootstrapFiles,
 		contextFiles

package/dist/src/agent/bootstrap/filter-bootstrap-files.d.ts

@@ -1,3 +1,3 @@
 import type { WorkspaceBootstrapFile } from './types.js';
 /** Subagent and cron sessions load only the minimal identity and instruction profile. */
-export declare function filterBootstrapFilesForSession(files: WorkspaceBootstrapFile[], sessionKey?: string): WorkspaceBootstrapFile[];
+export declare function filterBootstrapFilesForSession(files: WorkspaceBootstrapFile[], conversationId?: string): WorkspaceBootstrapFile[];

package/dist/src/agent/bootstrap/filter-bootstrap-files.js

@@ -1,4 +1,4 @@
-import { isCronSessionKey, isSubagentSessionKey } from "../../routing/session-key-utils.js";
+import { isCronConversationId, isSubagentConversationId } from "../../routing/agent-session-key.js";
 import { init_session_key } from "../../routing/session-key.js";
 import { DEFAULT_AGENTS_FILENAME, DEFAULT_IDENTITY_FILENAME, DEFAULT_SOUL_FILENAME, DEFAULT_TOOLS_FILENAME } from "../context/workspace.js";
 //#region src/agent/bootstrap/filter-bootstrap-files.ts
@@ -10,8 +10,8 @@ const MINIMAL_BOOTSTRAP_ALLOWLIST = new Set([
 	DEFAULT_IDENTITY_FILENAME
 ]);
 /** Subagent and cron sessions load only the minimal identity and instruction profile. */
-function filterBootstrapFilesForSession(files, sessionKey) {
-	if (!sessionKey || !isSubagentSessionKey(sessionKey) && !isCronSessionKey(sessionKey)) return files;
+function filterBootstrapFilesForSession(files, conversationId) {
+	if (!conversationId || !isSubagentConversationId(conversationId) && !isCronConversationId(conversationId)) return files;
 	return files.filter((file) => MINIMAL_BOOTSTRAP_ALLOWLIST.has(file.name));
 }
 //#endregion

package/dist/src/agent/child-agent-factory.d.ts

@@ -14,7 +14,7 @@ export interface BuildChildToolsOptions {
     getConfig: () => Config | undefined;
     toolExecutorConfig?: Partial<ToolExecutorConfig>;
     endpointTools?: EndpointToolRuntime;
-    browserSessionKey?: string;
+    browserConversationId?: string;
 }
 export interface DelegateChildProgressHooks {
     mode: 'steps' | 'full';
@@ -33,7 +33,7 @@ export interface DelegateChildHandleOptions {
     workspace: string;
     goal: string;
     context?: string;
-    requesterSessionKey?: string;
+    requesterConversationId?: string;
     allowedToolNames: string[];
     maxIterations: number;
     model: Model<Api>;
@@ -50,7 +50,7 @@ export interface DelegateChildHandleOptions {
     /** Optional live progress for workflow subagents. */
     progressHooks?: DelegateChildProgressHooks;
     transcriptRuntime?: EmbeddedTranscriptRuntime;
-    sessionKey?: string;
+    conversationId?: string;
     timeoutMs?: number;
     verifyChanges?: boolean;
 }

package/dist/src/agent/child-agent-factory.js

@@ -9,9 +9,9 @@ import { randomUUID } from "node:crypto";
 /** Leaf workers use the same execution, transcript and verification harness as foreground turns. */
 function createDelegateChildHandle(options) {
 	const controller = new AbortController();
-	const sessionKey = options.sessionKey ?? `agent:subagent:internal:${randomUUID()}`;
+	const conversationId = options.conversationId ?? randomUUID();
 	const runtime = options.transcriptRuntime ?? new InMemoryTranscriptRuntime({
-		runtimeId: sessionKey,
+		runtimeId: conversationId,
 		cwd: options.workspace
 	});
 	let started = false;
@@ -29,7 +29,7 @@ function createDelegateChildHandle(options) {
 				agentId: options.agentId,
 				getConfig: options.getConfig,
 				toolExecutorConfig: options.toolExecutorConfig,
-				browserSessionKey: options.requesterSessionKey ?? sessionKey
+				browserConversationId: options.requesterConversationId ?? conversationId
 			}).filter((tool) => allow.has(tool.name));
 			const limit = Math.min(60, Math.max(1, Math.floor(options.maxIterations)));
 			let toolIterations = 0, exhausted = false, tokens = 0;
@@ -56,7 +56,7 @@ function createDelegateChildHandle(options) {
 			};
 			try {
 				const result = await runXopcEmbeddedTurn({
-					sessionKey,
+					conversationId,
 					runId: randomUUID(),
 					workspaceDir: options.workspace,
 					userMessage: {
@@ -78,7 +78,7 @@ function createDelegateChildHandle(options) {
 						context: options.context,
 						workspace: options.workspace,
 						toolNames: tools.map((tool) => tool.name),
-						responseLanguage: resolveResponseLanguageForSession(options.getConfig(), options.requesterSessionKey)
+						responseLanguage: resolveResponseLanguageForSession(options.getConfig(), options.requesterConversationId)
 					}),
 					onEvent: (event) => {
 						const progress = options.progressHooks;

package/dist/src/agent/coding/workspace-revision.js

@@ -1,7 +1,7 @@
 import { isAbsolute, relative, resolve } from "node:path";
 import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { createHash } from "node:crypto";
+import { promisify } from "node:util";
 import { lstat, readFile, readlink, realpath } from "node:fs/promises";
 //#region src/agent/coding/workspace-revision.ts
 const exec = promisify(execFile);

package/dist/src/agent/commands/command-registry.js

@@ -1,5 +1,5 @@
 import { resolveStateDir } from "../../config/paths-state.js";
-import { resolveGlobalSingleton } from "../../utils/global-singleton.js";
+import { init_global_singleton, resolveGlobalSingleton } from "../../utils/global-singleton.js";
 import { init_paths } from "../../config/paths.js";
 import { DurableState } from "../../storage/sqlite/durable-state.js";
 import { isolatedCommand, removeCommandContainer } from "./command-isolation.js";
@@ -10,6 +10,7 @@ import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/agent/commands/command-registry.ts
 init_paths();
+init_global_singleton();
 const DEFAULT_COMMAND_TIMEOUT_MS = 30 * 6e4;
 const MAX_COMMAND_TIMEOUT_MS = 240 * 6e4;
 const MAX_LOG_BYTES = 8 * 1024 * 1024;

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

@@ -8,7 +8,7 @@ export interface ExecutionContextAudit {
     runId: string;
     principalId: string;
     turnId: string;
-    sessionId: string;
+    conversationId: string;
     queryHash: string;
     asOf: number;
     budget: ExecutionContextBudget;
@@ -24,7 +24,7 @@ export interface ExecutionContextAudit {
 }
 export declare function recordExecutionContext(context: ExecutionContext, input: {
     turnId: string;
-    sessionId: string;
+    conversationId: string;
     budget: ExecutionContextBudget;
     renderedChars: number;
     includedContext?: ExecutionContext;

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

@@ -1,6 +1,7 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import { createHash } from "node:crypto";
 //#region src/agent/context/audit.ts
+init_transaction();
 function recordExecutionContext(context, input) {
 	const createdAt = Date.now();
 	const included = /* @__PURE__ */ new Set();
@@ -61,9 +62,9 @@ function recordExecutionContext(context, input) {
 	runSqliteWriteTransaction((db) => {
 		if (db.prepare("SELECT 1 FROM execution_context_runs WHERE turn_id = ?").get(input.turnId)) return;
 		db.prepare(`INSERT INTO execution_context_runs (
-      run_id, principal_id, turn_id, session_id, query_hash, as_of,
+      run_id, principal_id, turn_id, conversation_id, query_hash, as_of,
       budget_json, metrics_json, created_at
-    ) VALUES (?, 'local-owner', ?, ?, ?, ?, ?, ?, ?)`).run(context.traceId, input.turnId, input.sessionId, createHash("sha256").update(context.query).digest("hex"), context.asOf, JSON.stringify(input.budget), JSON.stringify(metrics), createdAt);
+    ) VALUES (?, 'local-owner', ?, ?, ?, ?, ?, ?, ?)`).run(context.traceId, input.turnId, input.conversationId, createHash("sha256").update(context.query).digest("hex"), context.asOf, JSON.stringify(input.budget), JSON.stringify(metrics), createdAt);
 		const insert = db.prepare(`INSERT INTO execution_context_items (
       run_id, object_type, object_id, score, reasons_json, included, created_at
     ) VALUES (?, ?, ?, ?, ?, ?, ?)`);
@@ -80,7 +81,7 @@ function getExecutionContextAudit(turnId) {
 		runId: run.run_id,
 		principalId: run.principal_id,
 		turnId: run.turn_id,
-		sessionId: run.session_id,
+		conversationId: run.conversation_id,
 		queryHash: run.query_hash,
 		asOf: run.as_of,
 		budget: JSON.parse(run.budget_json),

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

@@ -12,20 +12,20 @@ export interface ExecutionContextPlan {
 }
 export interface ExecutionContextCoordinatorOptions {
     getConfig: () => Config | undefined;
-    getAccessForSession: (sessionKey: string) => {
+    getAccessForSession: (conversationId: string) => {
         userModel: boolean;
         knowledge: boolean;
         knowledgeSources: readonly KnowledgeSource[];
     };
-    getWorkspaceIdForSession: (sessionKey: string) => string;
-    getProjectIdForSession: (sessionKey: string) => string | undefined;
+    getWorkspaceIdForSession: (conversationId: string) => string;
+    getProjectIdForSession: (conversationId: string) => string | undefined;
 }
 export declare class ExecutionContextCoordinator {
     private readonly options;
     private readonly currentBySession;
     constructor(options: ExecutionContextCoordinatorOptions);
-    forgetSession(sessionKey: string): void;
+    forgetSession(conversationId: string): void;
     clear(): void;
-    getCurrent(sessionKey: string): ExecutionContext | undefined;
-    prepare(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<ExecutionContextPlan>;
+    getCurrent(conversationId: string): ExecutionContext | undefined;
+    prepare(userMessage: AgentMessage, conversationId: string, turnId: string): Promise<ExecutionContextPlan>;
 }

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

@@ -10,16 +10,16 @@ var ExecutionContextCoordinator = class {
 	constructor(options) {
 		this.options = options;
 	}
-	forgetSession(sessionKey) {
-		this.currentBySession.delete(sessionKey);
+	forgetSession(conversationId) {
+		this.currentBySession.delete(conversationId);
 	}
 	clear() {
 		this.currentBySession.clear();
 	}
-	getCurrent(sessionKey) {
-		return this.currentBySession.get(sessionKey);
+	getCurrent(conversationId) {
+		return this.currentBySession.get(conversationId);
 	}
-	async prepare(userMessage, sessionKey, turnId) {
+	async prepare(userMessage, conversationId, turnId) {
 		const empty = () => ({
 			traceId: "",
 			modelMessage: userMessage,
@@ -28,29 +28,29 @@ var ExecutionContextCoordinator = class {
 			contextItemCount: 0
 		});
 		const config = this.options.getConfig();
-		const access = this.options.getAccessForSession(sessionKey);
+		const access = this.options.getAccessForSession(conversationId);
 		if (!config || !config.userContext.contextPlanning.enabled || !access.userModel && !access.knowledge) return empty();
-		const task = assembleTaskContext(sessionKey, extractAgentUserPlainText(userMessage));
+		const task = assembleTaskContext(conversationId, extractAgentUserPlainText(userMessage));
 		const context = buildExecutionContext({
 			query: task.retrievalQuery,
-			agentId: extractProfileAgentId(sessionKey, config),
-			workspaceId: this.options.getWorkspaceIdForSession(sessionKey),
-			projectId: this.options.getProjectIdForSession(sessionKey),
-			sessionId: sessionKey,
+			agentId: extractProfileAgentId(conversationId, config),
+			workspaceId: this.options.getWorkspaceIdForSession(conversationId),
+			projectId: this.options.getProjectIdForSession(conversationId),
+			conversationId,
 			maxAssertions: Math.min(config.userContext.contextPlanning.maxAssertions, task.allocation.maxResults),
 			maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults),
 			includeUserModel: access.userModel,
 			includeKnowledge: access.knowledge,
 			knowledgeSources: access.knowledgeSources
 		});
-		this.currentBySession.set(sessionKey, context);
+		this.currentBySession.set(conversationId, context);
 		const maxChars = Math.min(config.userContext.contextPlanning.maxChars, task.allocation.maxChars);
 		const fitted = fitExecutionContextToChars(context, maxChars);
 		const rendered = fitted.rendered;
 		const contextItemCount = fitted.context.rules.length + fitted.context.assertions.length + fitted.context.goals.length + fitted.context.priorities.length + fitted.context.knowledge.length;
 		recordExecutionContext(context, {
 			turnId,
-			sessionId: sessionKey,
+			conversationId,
 			budget: {
 				maxAssertions: Math.min(config.userContext.contextPlanning.maxAssertions, task.allocation.maxResults),
 				maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults),

package/dist/src/agent/context/execution-context.js

@@ -1,4 +1,4 @@
-import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
 import { listCollaborationRules } from "../../storage/sqlite/collaboration-rule-repository.js";
 import { searchKnowledgeItems } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
@@ -10,13 +10,14 @@ import { getExecutionContextFeedbackScores } from "./audit.js";
 import { buildUserContextBlock } from "../memory/context-fence.js";
 import { randomUUID } from "node:crypto";
 //#region src/agent/context/execution-context.ts
+init_transaction();
 function scopeVisible(scope, context) {
 	if (scope.type === "global") return true;
 	return scope.id === {
 		agent: context.agentId,
 		workspace: context.workspaceId,
 		project: context.projectId,
-		session: context.sessionId
+		session: context.conversationId
 	}[scope.type];
 }
 function applicabilityVisible(applicability, context) {
@@ -27,7 +28,7 @@ function applicabilityVisible(applicability, context) {
 		["agentId", context.agentId],
 		["workspaceId", context.workspaceId],
 		["projectId", context.projectId],
-		["sessionId", context.sessionId]
+		["conversationId", context.conversationId]
 	]) {
 		const expected = applicability[key];
 		if (typeof expected === "string" && expected !== actual) return false;