@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/agent/context/execution-scope.d.ts

@@ -18,13 +18,13 @@ export type ExecutionObjective = {
     status: 'running';
 };
 export interface ExecutionScope {
-    sessionKey: string;
+    conversationId: string;
     projectId?: string;
     objective?: ExecutionObjective;
 }
-export declare function resolveExecutionScope(sessionKey: string): ExecutionScope;
+export declare function resolveExecutionScope(conversationId: string): ExecutionScope;
 export declare function formatCurrentWorkForPrompt(scope: ExecutionScope): string | undefined;
-export declare function buildExecutionScopeContextForPrompt(sessionKey: string, options?: {
+export declare function buildExecutionScopeContextForPrompt(conversationId: string, options?: {
     includeKnowledge?: boolean;
     knowledgeSources?: readonly KnowledgeSource[];
 }): string | undefined;

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

@@ -14,8 +14,8 @@ function bounded(value, max = MAX_OBJECTIVE_TEXT) {
 	if (!text) return void 0;
 	return text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}…`;
 }
-function taskObjective(sessionKey) {
-	const taskId = new TaskConversationRepository().resolveActiveExecutionSession(sessionKey)?.taskId;
+function taskObjective(conversationId) {
+	const taskId = new TaskConversationRepository().resolveActiveExecutionSession(conversationId)?.taskId;
 	const task = taskId ? new TaskRepository().get(taskId) : void 0;
 	if (!task) return void 0;
 	const contract = task.contract;
@@ -30,10 +30,10 @@ function taskObjective(sessionKey) {
 		expectedOutputs: contract?.expectedOutputs.slice(0, MAX_CRITERIA) ?? []
 	};
 }
-function workflowObjective(sessionKey) {
-	const metadata = getSessionMetadata(sessionKey);
+function workflowObjective(conversationId) {
+	const metadata = getSessionMetadata(conversationId);
 	if (!metadata) return void 0;
-	if (metadata.sessionType === "workflow-subagent" && metadata.parentSessionKey) return workflowObjective(metadata.parentSessionKey);
+	if (metadata.sessionType === "workflow-subagent" && metadata.parentConversationId) return workflowObjective(metadata.parentConversationId);
 	if (metadata.sessionType !== "workflow-run") return void 0;
 	const objective = bounded(typeof metadata.customData?.workflowGoal === "string" ? metadata.customData.workflowGoal : void 0);
 	const definitionId = metadata.workflowDefinitionId?.trim() || (typeof metadata.customData?.workflowDefinitionId === "string" ? metadata.customData.workflowDefinitionId.trim() : "workflow");
@@ -45,12 +45,12 @@ function workflowObjective(sessionKey) {
 		status: "running"
 	};
 }
-function resolveExecutionScope(sessionKey) {
-	if (!isXopcDatabaseOpen()) return { sessionKey };
+function resolveExecutionScope(conversationId) {
+	if (!isXopcDatabaseOpen()) return { conversationId };
 	return {
-		sessionKey,
-		projectId: getSessionMetadata(sessionKey)?.projectId,
-		objective: taskObjective(sessionKey) ?? workflowObjective(sessionKey)
+		conversationId,
+		projectId: getSessionMetadata(conversationId)?.projectId,
+		objective: taskObjective(conversationId) ?? workflowObjective(conversationId)
 	};
 }
 function formatCurrentWorkForPrompt(scope) {
@@ -77,9 +77,9 @@ function formatCurrentWorkForPrompt(scope) {
 	lines.push("", "Keep work inside this objective and its project scope. Treat the acceptance criteria and completion evidence as the definition of done.");
 	return lines.join("\n");
 }
-function buildExecutionScopeContextForPrompt(sessionKey, options = {}) {
-	const scope = resolveExecutionScope(sessionKey);
-	return [buildActiveProjectContextForPrompt(sessionKey, {
+function buildExecutionScopeContextForPrompt(conversationId, options = {}) {
+	const scope = resolveExecutionScope(conversationId);
+	return [buildActiveProjectContextForPrompt(conversationId, {
 		knowledgeQuery: scope.objective?.objective,
 		includeKnowledge: options.includeKnowledge,
 		knowledgeSources: options.knowledgeSources

package/dist/src/agent/context/project-context.d.ts

@@ -5,7 +5,7 @@ export interface ProjectTaskContext {
     state: string;
     priority: string;
 }
-export declare function buildActiveProjectContextForPrompt(sessionKey: string, options?: {
+export declare function buildActiveProjectContextForPrompt(conversationId: string, options?: {
     knowledgeQuery?: string;
     includeKnowledge?: boolean;
     knowledgeSources?: readonly KnowledgeSource[];

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

@@ -34,15 +34,15 @@ function selectProjectKnowledge(input) {
 	}
 	return [...selected.values()];
 }
-function buildActiveProjectContextForPrompt(sessionKey, options = {}) {
-	const project = getProjectForSession(sessionKey);
+function buildActiveProjectContextForPrompt(conversationId, options = {}) {
+	const project = getProjectForSession(conversationId);
 	if (!project) return void 0;
 	const localAppStore = new LocalAppStore();
 	const localApp = localAppStore.findByProjectId(project.id);
 	const latestAcceptance = localApp ? localAppStore.listAcceptanceRuns(localApp.id, 1)[0] : void 0;
 	return formatActiveProjectContextForPrompt({
 		project,
-		workspacePath: getProjectWorkspacePathForSession(sessionKey) ?? project.workspaceRoot,
+		workspacePath: getProjectWorkspacePathForSession(conversationId) ?? project.workspaceRoot,
 		activeTasks: new TaskRepository().listByProject(project.id, MAX_TASKS).filter((task) => task.phase !== "closed").map((task) => ({
 			priority: task.priority,
 			title: task.contract?.objective ?? task.title,
@@ -56,7 +56,7 @@ function buildActiveProjectContextForPrompt(sessionKey, options = {}) {
 					agentId: project.defaultAgentId ?? "main",
 					workspaceId: project.workspaceRoot ?? "",
 					projectId: project.id,
-					sessionId: sessionKey
+					conversationId
 				},
 				trustedOnly: true,
 				sources: options.knowledgeSources,

package/dist/src/agent/embedded/execution-context.d.ts

@@ -1,3 +1,3 @@
-export declare function runWithEmbeddedExecutionSession<T>(sessionKey: string, run: () => T, runId?: string): T;
+export declare function runWithEmbeddedExecutionSession<T>(conversationId: string, run: () => T, runId?: string): T;
 export declare function getEmbeddedExecutionSession(): string | undefined;
 export declare function getEmbeddedExecutionRunId(): string | undefined;

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

@@ -1,14 +1,14 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/agent/embedded/execution-context.ts
 const executionSessionStorage = new AsyncLocalStorage();
-function runWithEmbeddedExecutionSession(sessionKey, run, runId) {
+function runWithEmbeddedExecutionSession(conversationId, run, runId) {
 	return executionSessionStorage.run({
-		sessionKey,
+		conversationId,
 		runId
 	}, run);
 }
 function getEmbeddedExecutionSession() {
-	return executionSessionStorage.getStore()?.sessionKey;
+	return executionSessionStorage.getStore()?.conversationId;
 }
 function getEmbeddedExecutionRunId() {
 	return executionSessionStorage.getStore()?.runId;

package/dist/src/agent/embedded/index.d.ts

@@ -9,5 +9,5 @@ export { acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, evictAllE
 export { DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, resolveLiveToolResultMaxChars, truncateToolResultMessage, } from './tool-result-truncation.js';
 export { runXopcEmbeddedTurn, abortEmbeddedRun, queueEmbeddedSteer } from './run-turn.js';
 export { runEmbeddedTurnForSession } from './run-for-session.js';
-export { getEmbeddedRunBySessionKey } from './runs.js';
+export { getEmbeddedRunByConversationId } from './runs.js';
 export type { RunXopcEmbeddedTurnParams, RunXopcEmbeddedTurnResult, EmbeddedStreamEvent } from './types.js';

package/dist/src/agent/embedded/index.js

@@ -1,5 +1,5 @@
 import { getEmbeddedExecutionRunId, getEmbeddedExecutionSession, runWithEmbeddedExecutionSession } from "./execution-context.js";
-import { abortEmbeddedRun, getEmbeddedRunBySessionKey, queueEmbeddedSteer } from "./runs.js";
+import { abortEmbeddedRun, getEmbeddedRunByConversationId, queueEmbeddedSteer } from "./runs.js";
 import { DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, resolveLiveToolResultMaxChars, truncateToolResultMessage } from "./tool-result-truncation.js";
 import { getRawSessionAppendMessage, guardSessionManager, installSessionToolResultGuard } from "./session-tool-result-guard.js";
 import { acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner, getEmbeddedSessionRunnerIdleTtlMs, getEmbeddedSessionRunnerStats, isEmbeddedSessionRunnerEnabled, resetEmbeddedSessionRunnerForTest } from "./session-runner.js";
@@ -9,4 +9,4 @@ import { InMemoryTranscriptRuntime, createSqliteTranscriptRuntime } from "./tran
 import { runXopcEmbeddedTurn } from "./run-turn.js";
 import { runEmbeddedTurnForSession } from "./run-for-session.js";
 import { CURRENT_SESSION_VERSION, PiTranscriptManager } from "./pi-transcript.js";
-export { CURRENT_SESSION_VERSION, DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, InMemoryTranscriptRuntime, PiTranscriptManager, abortEmbeddedRun, acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, createSqliteTranscriptRuntime, evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner, getEmbeddedExecutionRunId, getEmbeddedExecutionSession, getEmbeddedRunBySessionKey, getEmbeddedSessionRunnerIdleTtlMs, getEmbeddedSessionRunnerStats, getRawSessionAppendMessage, guardSessionManager, installSessionToolResultGuard, isEmbeddedSessionRunnerEnabled, openSqliteHydratingSessionManager, queueEmbeddedSteer, repairAssistantUsageInSessionManager, resetEmbeddedSessionRunnerForTest, resolveLiveToolResultMaxChars, runEmbeddedTurnForSession, runWithEmbeddedExecutionSession, runXopcEmbeddedTurn, truncateToolResultMessage };
+export { CURRENT_SESSION_VERSION, DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, InMemoryTranscriptRuntime, PiTranscriptManager, abortEmbeddedRun, acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, createSqliteTranscriptRuntime, evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner, getEmbeddedExecutionRunId, getEmbeddedExecutionSession, getEmbeddedRunByConversationId, getEmbeddedSessionRunnerIdleTtlMs, getEmbeddedSessionRunnerStats, getRawSessionAppendMessage, guardSessionManager, installSessionToolResultGuard, isEmbeddedSessionRunnerEnabled, openSqliteHydratingSessionManager, queueEmbeddedSteer, repairAssistantUsageInSessionManager, resetEmbeddedSessionRunnerForTest, resolveLiveToolResultMaxChars, runEmbeddedTurnForSession, runWithEmbeddedExecutionSession, runXopcEmbeddedTurn, truncateToolResultMessage };

package/dist/src/agent/embedded/model-runtime.js

@@ -1,6 +1,6 @@
 import { init_paths, resolveModelsJsonPath } from "../../config/paths.js";
-import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
+import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { XopcModelCredentialStore, init_model_credential_store } from "../../auth/model-credential-store.js";
 import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "../../providers/register-bundled-oauth-flows.js";
 import { init_register_runtime_providers, registerRuntimeProviders } from "../../providers/register-runtime-providers.js";

package/dist/src/agent/embedded/run-for-session.d.ts

@@ -5,7 +5,7 @@ import type { ModelManager } from '../models/index.js';
 import type { SessionStore } from '../../session/store.js';
 import type { EmbeddedStreamEvent, RunXopcEmbeddedTurnResult } from './types.js';
 export type RunEmbeddedForSessionParams = {
-    sessionKey: string;
+    conversationId: string;
     runId?: string;
     userMessage: AgentMessage;
     llmImages?: import('@earendil-works/pi-ai').ImageContent[];

package/dist/src/agent/embedded/run-for-session.js

@@ -1,36 +1,38 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { parseTurnOutcome } from "../../../packages/gateway-contract/src/turn-outcome.js";
-import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
+import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
-import { evaluateContextBudget } from "../memory/context-budget.js";
-import { runXopcEmbeddedTurn } from "./run-turn.js";
+import { recoverContext } from "../memory/context-recovery.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
+import { runXopcEmbeddedTurn } from "./run-turn.js";
 import { projectTurnOutcome } from "../../session/turn-outcome-projector.js";
 import { voicePresentationPrompt } from "../prompt/voice-presentation.js";
 import { applyStartupContextToUserMessage } from "../reply/apply-turn-user-enrichment.js";
 import { AgentRunSupervisor } from "../orchestration/agent-run-supervisor.js";
 import crypto from "node:crypto";
 //#region src/agent/embedded/run-for-session.ts
+init_src();
 init_logger();
 init_providers();
 const log = createLogger("EmbeddedTurnForSession");
 async function runEmbeddedTurnForSession(params) {
-	const { sessionKey, agentManager, modelManager, sessionStore, userMessage } = params;
+	const { conversationId, agentManager, modelManager, sessionStore, userMessage } = params;
 	const runId = params.runId ?? crypto.randomUUID();
 	const config = params.getConfig?.();
 	const supervisor = new AgentRunSupervisor({
-		timeoutMs: resolveAgentTurnTimeoutMs(config, sessionKey),
+		timeoutMs: resolveAgentTurnTimeoutMs(config, conversationId),
 		deadlineAtMs: params.deadlineAtMs,
 		parentSignal: params.abortSignal
 	});
 	const finish = async (result) => {
 		if (result.stopReason === "connection_required" || result.stopReason === "clarification_required") return result;
 		try {
-			const rows = await sessionStore.loadTranscriptRows(sessionKey);
+			const rows = await sessionStore.loadTranscriptRows(conversationId);
 			const hasTurn = rows.some((source) => {
 				return source.turnId === runId;
 			});
@@ -45,7 +47,7 @@ async function runEmbeddedTurnForSession(params) {
 				runStatus: result.ok ? "success" : result.errorMessage === "aborted" ? "cancelled" : "error",
 				summary: result.errorMessage
 			});
-			await sessionStore.appendTranscriptCustomEntry(sessionKey, {
+			await sessionStore.appendTranscriptCustomEntry(conversationId, {
 				customType: "turn_outcome",
 				data: outcome
 			});
@@ -57,7 +59,7 @@ async function runEmbeddedTurnForSession(params) {
 		} catch (err) {
 			log.warn({
 				err,
-				sessionKey,
+				conversationId,
 				runId
 			}, "Turn outcome persistence failed");
 		}
@@ -69,14 +71,14 @@ async function runEmbeddedTurnForSession(params) {
 			ok: false,
 			errorMessage: "aborted"
 		};
-		const agent = agentManager.getOrCreateAgent(sessionKey);
+		const agent = agentManager.getOrCreateAgent(conversationId);
 		const mm = modelManager;
-		const configuredModelRef = String(mm.getModelForSession(sessionKey));
-		const candidates = typeof mm.getFallbackCandidatesForSession === "function" ? mm.getFallbackCandidatesForSession(sessionKey) : [];
+		const configuredModelRef = String(mm.getModelForSession(conversationId));
+		const candidates = typeof mm.getFallbackCandidatesForSession === "function" ? mm.getFallbackCandidatesForSession(conversationId) : [];
 		const candidateModelRefs = candidates.length > 0 ? candidates.map((candidate) => `${candidate.provider}/${candidate.model}`) : [configuredModelRef];
 		const resolvedCandidates = [];
 		for (const [index, ref] of candidateModelRefs.entries()) try {
-			const resolved = index === 0 && typeof mm.getResolvedModelForSession === "function" ? mm.getResolvedModelForSession(sessionKey) : resolveModel(ref);
+			const resolved = index === 0 && typeof mm.getResolvedModelForSession === "function" ? mm.getResolvedModelForSession(conversationId) : resolveModel(ref);
 			resolvedCandidates.push({
 				ref,
 				model: resolved
@@ -84,7 +86,7 @@ async function runEmbeddedTurnForSession(params) {
 		} catch (err) {
 			log.warn({
 				err,
-				sessionKey,
+				conversationId,
 				runId,
 				modelRef: ref
 			}, "Skipping unavailable model candidate");
@@ -94,19 +96,19 @@ async function runEmbeddedTurnForSession(params) {
 		const modelRef = primary.ref;
 		const model = primary.model;
 		if (typeof mm.applyResolvedModel === "function") mm.applyResolvedModel(agent, model, modelRef);
-		else await mm.applyModelForSession(agent, sessionKey);
-		agentManager.setModelForSession(sessionKey, modelRef);
+		else await mm.applyModelForSession(agent, conversationId);
+		agentManager.setModelForSession(conversationId, modelRef);
 		const tools = agent.state.tools;
-		const turnPolicy = agentManager.createAgentTurnPolicy(sessionKey);
+		const turnPolicy = agentManager.createAgentTurnPolicy(conversationId);
 		const systemPrompt = [agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n");
 		const thinkingLevel = params.thinkingOverride ?? agent.state.thinkingLevel;
-		const workspaceDir = agentManager.getResolvedWorkspaceForSession(sessionKey);
-		const promptCachePolicy = resolvePromptCachePolicy(config ? resolveEffectiveAgentProfileForSession(config, sessionKey).config.runtime.promptCache : void 0);
+		const workspaceDir = agentManager.getResolvedWorkspaceForSession(conversationId);
+		const promptCachePolicy = resolvePromptCachePolicy(config ? resolveEffectiveAgentProfileForSession(config, conversationId).config.runtime.promptCache : void 0);
 		let userMessageForTurn = userMessage;
 		if (params.applyStartupContext !== false) {
 			userMessageForTurn = await applyStartupContextToUserMessage({
 				userMessage,
-				sessionKey,
+				conversationId,
 				workspaceDir,
 				cfg: config,
 				sessionStore,
@@ -120,7 +122,7 @@ async function runEmbeddedTurnForSession(params) {
 		}
 		try {
 			await maybeAutoCompactBeforeTurn({
-				sessionKey,
+				conversationId,
 				sessionStore,
 				agentManager,
 				model,
@@ -145,7 +147,7 @@ async function runEmbeddedTurnForSession(params) {
 			errorMessage: "aborted"
 		};
 		log.info({
-			sessionKey,
+			conversationId,
 			runId,
 			configuredModelRef,
 			primaryModelRef: modelRef,
@@ -169,11 +171,11 @@ async function runEmbeddedTurnForSession(params) {
 				};
 				break;
 			}
-			const rowsBeforeAttempt = hasNextCandidate ? await sessionStore.loadTranscriptRows(sessionKey) : void 0;
+			const rowsBeforeAttempt = hasNextCandidate ? await sessionStore.loadTranscriptRows(conversationId) : void 0;
 			if (typeof mm.applyResolvedModel === "function") mm.applyResolvedModel(agent, candidateModel, candidateModelRef);
-			agentManager.setModelForSession(sessionKey, candidateModelRef);
+			agentManager.setModelForSession(conversationId, candidateModelRef);
 			if (isFallbackAttempt) log.info({
-				sessionKey,
+				conversationId,
 				runId,
 				primaryModelRef,
 				fallbackModelRef: candidateModelRef,
@@ -181,8 +183,9 @@ async function runEmbeddedTurnForSession(params) {
 				total: resolvedCandidates.length
 			}, "Agent model fallback started");
 			try {
-				const turnResult = await runWithEmbeddedExecutionSession(sessionKey, () => runXopcEmbeddedTurn({
-					sessionKey,
+				const turnResult = await runWithEmbeddedExecutionSession(conversationId, () => runXopcEmbeddedTurn({
+					conversationId,
+					verifyChanges: config ? resolveEffectiveAgentProfileForSession(config, conversationId).agentId === "coder" : false,
 					runId,
 					userMessage: userMessageForTurn,
 					images: params.llmImages,
@@ -192,18 +195,19 @@ async function runEmbeddedTurnForSession(params) {
 					systemPrompt,
 					thinkingLevel,
 					promptCachePolicy,
+					compactionPolicy: resolveCompactionPolicy(config),
 					workspaceDir,
 					sessionStore,
 					timeoutMs: attemptPlan.timeoutMs,
 					turnPolicy,
 					abortSignal: supervisor.signal,
 					onEvent: params.onEvent,
-					onAgentEvent: (event) => agentManager.emitRuntimeEvent(sessionKey, event),
+					onAgentEvent: (event) => agentManager.emitRuntimeEvent(conversationId, event),
 					resumeLastUserMessage
 				}), runId);
 				if (turnResult.ok) {
 					if (isFallbackAttempt) log.info({
-						sessionKey,
+						conversationId,
 						runId,
 						primaryModelRef,
 						fallbackModelRef: candidateModelRef,
@@ -215,7 +219,7 @@ async function runEmbeddedTurnForSession(params) {
 				lastResult = turnResult;
 				if (supervisor.signal.aborted || turnResult.retryable === false) break;
 				log.warn({
-					sessionKey,
+					conversationId,
 					runId,
 					modelRef: candidateModelRef,
 					attempt: i + 1,
@@ -234,7 +238,7 @@ async function runEmbeddedTurnForSession(params) {
 				}
 				log.warn({
 					err,
-					sessionKey,
+					conversationId,
 					runId,
 					modelRef: candidateModelRef,
 					attempt: i + 1,
@@ -243,10 +247,10 @@ async function runEmbeddedTurnForSession(params) {
 				}, hasNextCandidate ? "Agent model call threw, trying fallback" : "Agent model call threw, no fallback remains");
 			}
 			if (hasNextCandidate && rowsBeforeAttempt) {
-				const preparation = await sessionStore.prepareModelFallback(sessionKey, rowsBeforeAttempt);
+				const preparation = await sessionStore.prepareModelFallback(conversationId, rowsBeforeAttempt);
 				if (preparation === "unsafe") {
 					log.warn({
-						sessionKey,
+						conversationId,
 						runId,
 						modelRef: candidateModelRef,
 						attempt: i + 1
@@ -273,95 +277,65 @@ async function runEmbeddedTurnForSession(params) {
 		supervisor.dispose();
 	}
 }
-function serializedTranscriptBytes(messages) {
-	return Buffer.byteLength(JSON.stringify(messages), "utf8");
-}
 async function maybeAutoCompactBeforeTurn(opts) {
-	const { sessionKey, sessionStore, agentManager, model, config, systemPrompt, userMessage, tools, imageCount, fallbackModels, abortSignal, onEvent } = opts;
+	const { conversationId, sessionStore, agentManager, model, config, systemPrompt, userMessage, tools, imageCount, fallbackModels, abortSignal, onEvent } = opts;
 	const policy = resolveCompactionPolicy(config);
-	const contextWindow = model.contextWindow ?? 128e3;
-	const messages = await sessionStore.load(sessionKey);
-	const activeTranscriptBytes = serializedTranscriptBytes(messages);
-	const byteLimitExceeded = policy.enabled && activeTranscriptBytes > policy.maxActiveTranscriptBytes;
-	const budget = evaluateContextBudget({
-		messages,
-		contextWindow,
-		systemPrompt,
-		currentUserMessage: userMessage,
-		tools,
-		imageCount,
-		triggerThreshold: policy.triggerThreshold,
-		reserveTokens: policy.reserveTokens,
-		minToolResultKeepChars: policy.minToolResultKeepChars,
-		canCompact: messages.length >= policy.minMessagesBeforeCompact
-	});
-	if (!byteLimitExceeded && (budget.route === "fits" || budget.route === "truncate_tool_results_only")) return;
-	if (!policy.enabled) {
-		if (budget.estimatedTokens <= budget.hardLimitTokens) return;
-		if (budget.estimatedTokens - budget.reducibleToolResultTokens <= budget.hardLimitTokens) return;
-		throw new Error(`Context budget exceeded (${budget.estimatedTokens}/${budget.hardLimitTokens} tokens) and compaction is disabled`);
-	}
-	log.info({
-		sessionKey,
-		route: budget.route,
-		estimatedTokens: budget.estimatedTokens,
-		usagePercent: budget.usagePercent,
-		contextWindow,
-		activeTranscriptBytes,
-		maxActiveTranscriptBytes: policy.maxActiveTranscriptBytes,
-		byteLimitExceeded
-	}, "Pre-turn auto-compaction triggered");
-	onEvent?.({
-		type: "compaction",
-		status: "started",
-		tokensBefore: budget.estimatedTokens
-	});
+	let started = false;
 	try {
-		let summaryModel = model;
-		let summaryFallbackModels = fallbackModels;
-		if (policy.model) {
-			summaryModel = resolveModel(policy.model);
-			const summaryRef = `${summaryModel.provider}/${summaryModel.id}`;
-			summaryFallbackModels = [model, ...fallbackModels].filter((candidate) => `${candidate.provider}/${candidate.id}` !== summaryRef);
-		}
-		const result = await sessionStore.compact(sessionKey, messages, summaryModel, void 0, byteLimitExceeded || budget.estimatedTokens > budget.hardLimitTokens, {
-			fallbackModels: summaryFallbackModels,
-			signal: abortSignal
+		const recovered = await recoverContext({
+			conversationId,
+			policy,
+			budget: {
+				contextWindow: model.contextWindow ?? 128e3,
+				systemPrompt,
+				currentUserMessage: userMessage,
+				tools,
+				imageCount,
+				triggerThreshold: policy.triggerThreshold,
+				reserveTokens: policy.reserveTokens,
+				minToolResultKeepChars: policy.minToolResultKeepChars
+			},
+			summaryModel: () => policy.model ? resolveModel(policy.model) : model,
+			fallbackModels: policy.model ? [model, ...fallbackModels] : fallbackModels,
+			signal: abortSignal,
+			transcript: {
+				loadMessages: () => sessionStore.load(conversationId),
+				compact: (...args) => {
+					if (!started) {
+						started = true;
+						onEvent?.({
+							type: "compaction",
+							status: "started"
+						});
+					}
+					return sessionStore.compact(conversationId, ...args);
+				}
+			},
+			onCompacted: () => agentManager.removeAgent(conversationId)
 		});
-		if (result.compacted) {
-			agentManager.removeAgent(sessionKey);
-			log.info({
-				sessionKey,
-				tokensBefore: result.tokensBefore,
-				tokensAfter: result.tokensAfter
-			}, "Pre-turn auto-compaction completed");
+		if (recovered.status === "compacted" && recovered.result) {
+			const result = recovered.result;
 			onEvent?.({
 				type: "compaction",
 				status: "completed",
 				tokensBefore: result.tokensBefore,
 				tokensAfter: result.tokensAfter,
-				summary: result.summary.length > 200 ? `${result.summary.slice(0, 200)}…` : result.summary
-			});
-		} else {
-			if (byteLimitExceeded || budget.estimatedTokens > budget.hardLimitTokens) throw new Error(byteLimitExceeded ? `Active transcript size exceeded (${activeTranscriptBytes}/${policy.maxActiveTranscriptBytes} bytes) but no safe compaction range was available` : `Context budget exceeded (${budget.estimatedTokens}/${budget.hardLimitTokens} tokens) but no safe compaction range was available`);
-			onEvent?.({
-				type: "compaction",
-				status: "skipped"
+				summary: result.summary.slice(0, 200)
 			});
-		}
+		} else if (started) onEvent?.({
+			type: "compaction",
+			status: "skipped"
+		});
 	} catch (err) {
-		const errorMessage = err instanceof Error ? err.message : String(err);
 		log.warn({
 			err,
-			sessionKey,
-			estimatedTokens: budget.estimatedTokens,
-			activeTranscriptBytes
-		}, `Pre-turn auto-compaction failed: ${errorMessage}`);
-		onEvent?.({
+			conversationId
+		}, "Pre-turn context recovery failed");
+		if (started) onEvent?.({
 			type: "compaction",
 			status: "skipped"
 		});
-		if (byteLimitExceeded || budget.estimatedTokens > budget.hardLimitTokens) throw err;
+		throw err;
 	}
 }
 //#endregion