@myagentroam/agent 0.10.68 → 0.11.1

package/dist/agent-core/sdk/session.js

@@ -1,8 +1,6 @@
-import { isProviderContextOverflow, recoverModelStream } from '../model/recovery.js';
-import { estimatedRequestTokens } from '../runtime/context/request-budget.js';
 import { restoreMessages } from '../runtime/context/restore.js';
 import { createNativeSteer } from './native-steer.js';
-import { lastConfigurationEffort, latestModelUsage, reasoningEffortBaseline, shouldUseNativeCompaction } from '../runtime/context/usage.js';
+import { lastConfigurationEffort, latestModelUsage, reasoningEffortBaseline } from '../runtime/context/usage.js';
 import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
 import { contextualInstructionInsertIndex, insertContextualWorldState, latestContextualWorldStateGeneration, parsePersistedContextualWorldState, persistContextualWorldState, resetContextualWorldState, updateContextualWorldState, updatePromptWorldState } from '../runtime/context/world-state.js';
 import { eventForPersistence, publicModelUsage } from '../runtime/event-projection.js';
@@ -35,10 +33,11 @@ import { childSubagentInstruction } from '../prompts/subagent.js';
 import { renderSubagentUpdate } from '../subagent/model-update.js';
 import { AsyncQueue } from '../runtime/async-queue.js';
 import { CompactionOperation } from '../runtime/compaction/operation.js';
+import { generateCompactionCandidate } from '../runtime/compaction/generate.js';
 import { CompactCoordinator } from '../runtime/compaction/coordinator.js';
 import { CompactRequests } from '../runtime/compaction/requests.js';
 import { compactSnapshotAnchor } from '../runtime/compaction/retained-context.js';
-import { DEFAULT_COMPACTION_FOCUS, buildCompactedHistory, buildCompactionInput, buildCompactionMessages, buildNativeCompactionMessages, compactedHistoryMessages } from '../runtime/compaction/history.js';
+import { DEFAULT_COMPACTION_FOCUS, buildCompactedHistory, buildCompactionMessages, compactedHistoryMessages } from '../runtime/compaction/history.js';
 import { currentLocalTimeContext, environmentContextUpdate, restoreEnvironmentState } from '../runtime/context/environment.js';
 import { ContextGcRuntime } from '../runtime/context/gc-runtime.js';
 import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
@@ -195,7 +194,7 @@ export function createSessionOpener(services) {
             }
         };
         const execution = (mode, input, internal = {}) => {
-            services.assertCanStart();
+            services.assertCanStart(sessionId);
             if ([...active.keys()].some((key) => key.startsWith(`${sessionId}:`)))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Session already has an active execution.');
             const { models: executionModels, defaultModelId: executionDefaultModelId, generation: executionModelGeneration } = services.modelState();
@@ -280,6 +279,7 @@ export function createSessionOpener(services) {
             let sequence = 0;
             let emitTail = Promise.resolve();
             let releaseSession;
+            let failedExecution = false;
             let exhaustedModelAttempt;
             // Serialize durable events before either the local stream or Host observes them.
             let persistedTerminal = false;
@@ -393,31 +393,181 @@ export function createSessionOpener(services) {
                     const contextualWorldStateGeneration = latestContextualWorldStateGeneration(contextRecords);
                     const restoredContextualWorldState = sessionRuntime.contextualWorldState;
                     const persistedContextualWorldState = parsePersistedContextualWorldState(await store.readContextualWorldState(sessionId));
-                    let contextualWorldState;
-                    if (restoredContextualWorldState !== undefined &&
-                        restoredContextualWorldState.generation === contextualWorldStateGeneration)
-                        contextualWorldState = restoredContextualWorldState;
-                    else if (persistedContextualWorldState !== undefined &&
-                        persistedContextualWorldState.generation === contextualWorldStateGeneration) {
-                        contextualWorldState = persistedContextualWorldState;
-                        sessionRuntime.contextualWorldState = contextualWorldState;
-                    }
-                    else {
-                        contextualWorldState = {
-                            generation: contextualWorldStateGeneration,
-                            initialized: false,
-                            instructionSnapshot: undefined,
-                            resourceSnapshot: undefined,
-                            entries: []
-                        };
-                        sessionRuntime.contextualWorldState = contextualWorldState;
-                    }
+                    const initialContextualWorldState = restoredContextualWorldState !== undefined &&
+                        restoredContextualWorldState.generation === contextualWorldStateGeneration
+                        ? restoredContextualWorldState
+                        : persistedContextualWorldState !== undefined &&
+                            persistedContextualWorldState.generation === contextualWorldStateGeneration
+                            ? persistedContextualWorldState
+                            : {
+                                generation: contextualWorldStateGeneration,
+                                initialized: false,
+                                instructionSnapshot: undefined,
+                                resourceSnapshot: undefined,
+                                entries: []
+                            };
+                    sessionRuntime.contextualWorldState = initialContextualWorldState;
                     const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
                     const restored = await restoreMessages(store, sessionId, contextRecords, {
                         messageSources,
                         includeImages: mode !== 'compact'
                     });
-                    const messages = restored.messages;
+                    // This execution owns checkpoint adoption, not another copy of the live context.
+                    const modelContext = (() => {
+                        const messages = restored.messages;
+                        let userMessages = [...restored.userMessages];
+                        let recordedEnvironment = restored.environmentState;
+                        let instructionInsertIndex = 0;
+                        let worldState = initialContextualWorldState;
+                        const commitWorldState = async (next) => {
+                            await persistContextualWorldState(store, sessionId, next);
+                            worldState = next;
+                            sessionRuntime.contextualWorldState = next;
+                        };
+                        const resetCompactWorldState = async (generation, committed) => {
+                            instructionInsertIndex = contextualInstructionInsertIndex(messages);
+                            const next = resetContextualWorldState(generation, instructionInsertIndex, {
+                                instructionSnapshot: currentInstructionSnapshot,
+                                instructionContent: renderAgentInstructions(instructionEntries, true),
+                                resourceSnapshot: committed
+                                    ? committed.resources
+                                    : retainedSessionResourcesSnapshot(await loadRetainedSessionResources())
+                            });
+                            if (!committed)
+                                await commitWorldState(next);
+                            else {
+                                // The checkpoint is authoritative; its sidecar is recoverable on restart.
+                                worldState = next;
+                                sessionRuntime.contextualWorldState = next;
+                                try {
+                                    await persistContextualWorldState(store, sessionId, next);
+                                }
+                                catch {
+                                    coreExtensions.diagnose({
+                                        code: 'MAR_AGENT_COMPACT_SIDECAR_PERSIST_FAILED',
+                                        sessionId
+                                    });
+                                }
+                            }
+                        };
+                        const recordEnvironment = async () => {
+                            const message = environmentContextUpdate(executionEnvironment, recordedEnvironment);
+                            if (!message)
+                                return;
+                            await store.append(sessionId, {
+                                type: 'context.environment',
+                                payload: { version: 1, state: executionEnvironment },
+                                executionId,
+                                turnId
+                            });
+                            messages.push(message);
+                            recordedEnvironment = executionEnvironment;
+                        };
+                        const syncMcpWorldState = async (index = instructionInsertIndex) => {
+                            const snapshot = mcpRegistry.navigation();
+                            if (worldState.mcpSnapshot === snapshot)
+                                return;
+                            const next = {
+                                ...worldState,
+                                mcpSnapshot: snapshot,
+                                entries: [
+                                    ...worldState.entries,
+                                    {
+                                        index,
+                                        kind: 'mcp',
+                                        content: snapshot ?? '<mcp_catalog>No deferred MCP tools remain.</mcp_catalog>'
+                                    }
+                                ]
+                            };
+                            await commitWorldState(next);
+                        };
+                        return {
+                            messages,
+                            get worldState() {
+                                return worldState;
+                            },
+                            commitWorldState,
+                            recordEnvironment,
+                            syncMcpWorldState,
+                            rememberInput(input) {
+                                userMessages.push(input);
+                            },
+                            compactInputs(prefix) {
+                                return userMessages.filter((entry) => prefix.some((message) => message.role === 'user' &&
+                                    message.contextKind === undefined &&
+                                    (entry.metadata?.recordId
+                                        ? message.metadata?.recordId === entry.metadata.recordId
+                                        : message.content === entry.content)));
+                            },
+                            async initializeWorldState() {
+                                instructionInsertIndex =
+                                    mode === 'compact' ? contextualInstructionInsertIndex(messages) : messages.length;
+                                // Only the latest Compact may rebuild missing sidecar resources, never a GC boundary.
+                                if (!worldState.initialized &&
+                                    contextRecords.some((record) => record.recordId === contextualWorldStateGeneration &&
+                                        compactSummaryFromCheckpoint(record) !== undefined))
+                                    await resetCompactWorldState(contextualWorldStateGeneration);
+                                const nextInstructionWorldState = updateContextualWorldState(worldState, instructionInsertIndex, {
+                                    instructionSnapshot: currentInstructionSnapshot,
+                                    instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
+                                        worldState.instructionSnapshot !== undefined)
+                                });
+                                if (!isDeepStrictEqual(worldState, nextInstructionWorldState))
+                                    await commitWorldState(nextInstructionWorldState);
+                            },
+                            // Must run inside the existing writer/projection commit window.
+                            replaceCompactMessages(replacementHistory, retainedModelContext) {
+                                messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory), ...retainedModelContext);
+                                pendingAppends.length = 0;
+                                selected.resetContinuation?.();
+                            },
+                            // Derived state follows the committed splice, never delays it past the writer window.
+                            async adoptCompactCheckpoint(recordId, replacementHistory, retainedModelContext, resources) {
+                                contextGc.reset();
+                                restoreMcpDiscovery();
+                                recordedEnvironment = executionEnvironment;
+                                userMessages = replacementHistory
+                                    .filter((message) => message.kind !== 'summary')
+                                    .map((message) => ({
+                                    content: message.content,
+                                    ...(message.metadata ? { metadata: { ...message.metadata } } : {})
+                                }));
+                                userMessages.push(...retainedModelContext
+                                    .filter((message) => message.role === 'user' && message.contextKind === undefined)
+                                    .map((message) => ({
+                                    content: message.content,
+                                    ...(message.metadata ? { metadata: message.metadata } : {})
+                                })));
+                                await resetCompactWorldState(recordId, { resources });
+                            },
+                            async adoptGcCheckpoint(committed, appendBoundary) {
+                                smartContextTokens = undefined;
+                                selected.resetContinuation?.();
+                                const refreshed = await restoreMessages(store, sessionId, committed.records, {
+                                    includeImages: true,
+                                    currentTurnId: turnId,
+                                    messageSources,
+                                    projection: committed.projection
+                                });
+                                const restoredIds = new Set(committed.records.map((record) => record.recordId));
+                                const lateMessages = pendingAppends
+                                    .slice(appendBoundary)
+                                    .filter((entry) => !restoredIds.has(entry.recordId))
+                                    .map((entry) => entry.message);
+                                messages.splice(0, messages.length, ...refreshed.messages, ...lateMessages);
+                                restoreMcpDiscovery();
+                                recordedEnvironment = refreshed.environmentState;
+                                userMessages = [...refreshed.userMessages];
+                                instructionInsertIndex = contextualInstructionInsertIndex(messages);
+                                const next = resetContextualWorldState(latestContextualWorldStateGeneration(committed.records), instructionInsertIndex, {
+                                    instructionSnapshot: currentInstructionSnapshot,
+                                    instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined))
+                                });
+                                await commitWorldState(next);
+                            }
+                        };
+                    })();
+                    const messages = modelContext.messages;
                     const pendingInputs = restored.pendingInputs;
                     const waitInterrupt = createToolWaitInterrupt(() => pendingInputs.size > 0);
                     liveModelMessages = messages;
@@ -427,7 +577,6 @@ export function createSessionOpener(services) {
                             messages.push(pending.message);
                     pendingAppends.length = 0;
                     immediateTarget = messages;
-                    let recordedEnvironment = restored.environmentState;
                     let smartInput;
                     let compactContext;
                     let startCompact;
@@ -472,7 +621,7 @@ export function createSessionOpener(services) {
                                 eligible: smartCompaction,
                                 requested: false
                             };
-                            compactionUserMessages.push({
+                            modelContext.rememberInput({
                                 content: content.modelText ?? content.text,
                                 metadata: inputMetadata
                             });
@@ -545,7 +694,7 @@ export function createSessionOpener(services) {
                                 };
                                 messages.push(message);
                                 messageSources.set(message, applied);
-                                compactionUserMessages.push({ content, metadata });
+                                modelContext.rememberInput({ content, metadata });
                                 smartInput = { recordId: received.recordId, eligible, requested: false };
                                 for (const text of (payload.modelContext ?? payload.context ?? []))
                                     messages.push({ role: 'user', content: text, contextKind: 'contextual' });
@@ -600,20 +749,6 @@ export function createSessionOpener(services) {
                         signal: controller.signal,
                         ...(restoring ? { restoring: true } : {})
                     }, inputs.boundarySize);
-                    const recordEnvironment = async () => {
-                        const message = environmentContextUpdate(executionEnvironment, recordedEnvironment);
-                        if (!message)
-                            return;
-                        await store.append(sessionId, {
-                            type: 'context.environment',
-                            payload: { version: 1, state: executionEnvironment },
-                            executionId,
-                            turnId
-                        });
-                        messages.push(message);
-                        recordedEnvironment = executionEnvironment;
-                    };
-                    let compactionUserMessages = [...restored.userMessages];
                     const hasRestoredUserImages = messages.some((message) => message.role === 'user' && Boolean(message.images?.length));
                     let modelInputImages;
                     const currentExecutionToolImages = [];
@@ -854,7 +989,6 @@ export function createSessionOpener(services) {
                     });
                     const instructionEntries = instructionContext?.entries ?? [];
                     const currentInstructionSnapshot = renderAgentInstructions(instructionEntries, false);
-                    let agentInstructionInsertIndex = mode === 'compact' ? contextualInstructionInsertIndex(messages) : messages.length;
                     const baseTools = () => [...captureTools().values()]
                         .filter((binding) => binding.mcp === undefined)
                         .map((binding) => binding.definition)
@@ -880,49 +1014,7 @@ export function createSessionOpener(services) {
                             subagents: subagents?.listSessionResources() ?? []
                         };
                     };
-                    const commitWorldState = async (next) => {
-                        await persistContextualWorldState(store, sessionId, next);
-                        contextualWorldState = next;
-                        sessionRuntime.contextualWorldState = next;
-                    };
-                    const resetCompactWorldState = async (generation, committed) => {
-                        agentInstructionInsertIndex = contextualInstructionInsertIndex(messages);
-                        const next = resetContextualWorldState(generation, agentInstructionInsertIndex, {
-                            instructionSnapshot: currentInstructionSnapshot,
-                            instructionContent: renderAgentInstructions(instructionEntries, true),
-                            resourceSnapshot: committed
-                                ? committed.resources
-                                : retainedSessionResourcesSnapshot(await loadRetainedSessionResources())
-                        });
-                        if (!committed)
-                            await commitWorldState(next);
-                        else {
-                            // The checkpoint is authoritative; its sidecar is recoverable on restart.
-                            contextualWorldState = next;
-                            sessionRuntime.contextualWorldState = next;
-                            try {
-                                await persistContextualWorldState(store, sessionId, next);
-                            }
-                            catch {
-                                coreExtensions.diagnose({
-                                    code: 'MAR_AGENT_COMPACT_SIDECAR_PERSIST_FAILED',
-                                    sessionId
-                                });
-                            }
-                        }
-                    };
-                    // A missing sidecar is rebuilt only for the latest Compact, never for a GC boundary.
-                    if (!contextualWorldState.initialized &&
-                        contextRecords.some((record) => record.recordId === contextualWorldStateGeneration &&
-                            compactSummaryFromCheckpoint(record) !== undefined))
-                        await resetCompactWorldState(contextualWorldStateGeneration);
-                    const nextInstructionWorldState = updateContextualWorldState(contextualWorldState, agentInstructionInsertIndex, {
-                        instructionSnapshot: currentInstructionSnapshot,
-                        instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
-                            contextualWorldState.instructionSnapshot !== undefined)
-                    });
-                    if (!isDeepStrictEqual(contextualWorldState, nextInstructionWorldState))
-                        await commitWorldState(nextInstructionWorldState);
+                    await modelContext.initializeWorldState();
                     const buildExecutionPromptSections = (availableTools = executionTools, promptMode = mode) => buildSessionPromptSections(availableTools, promptMode, selectedModel, executionSystemInstruction, instructionContext?.skillCatalog);
                     const buildExecutionSystemPrompt = (availableTools = executionTools, promptMode = mode) => renderPromptSections(buildExecutionPromptSections(availableTools, promptMode));
                     const promptComposition = (availableTools, promptMode) => ({
@@ -933,26 +1025,8 @@ export function createSessionOpener(services) {
                             tools: availableTools.map((tool) => tool.name)
                         }
                     });
-                    const syncMcpWorldState = async (index) => {
-                        const snapshot = mcpRegistry.navigation();
-                        if (contextualWorldState.mcpSnapshot === snapshot)
-                            return;
-                        const next = {
-                            ...contextualWorldState,
-                            mcpSnapshot: snapshot,
-                            entries: [
-                                ...contextualWorldState.entries,
-                                {
-                                    index,
-                                    kind: 'mcp',
-                                    content: snapshot ?? '<mcp_catalog>No deferred MCP tools remain.</mcp_catalog>'
-                                }
-                            ]
-                        };
-                        await commitWorldState(next);
-                    };
                     if (mode !== 'compact')
-                        await syncMcpWorldState(agentInstructionInsertIndex);
+                        await modelContext.syncMcpWorldState();
                     const writeCompactionRecord = async (summary, _automatic, signal, write) => withRecordProjection(async () => {
                         signal.throwIfAborted();
                         const stored = await write(summary, { signal });
@@ -1138,7 +1212,7 @@ export function createSessionOpener(services) {
                             ? normalizeMessagesForModel([...preparingRequestMessages, ...messages.slice(preparingRequestBaseLength)], { supportsImages: selectedModel.inputCapabilities.includes('IMAGE') })
                             : projectSessionRequestMessages(messages.map((message, index) => index === currentExecutionUserIndex && modelInputImages?.length
                                 ? { ...message, images: modelInputImages }
-                                : message), mode === 'compact' ? [] : contextualWorldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), baseTools().some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto')
+                                : message), mode === 'compact' ? [] : modelContext.worldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), baseTools().some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto')
                     };
                     if (mode !== 'compact') {
                         if (pendingInputs.size)
@@ -1153,7 +1227,7 @@ export function createSessionOpener(services) {
                                 await sessionRuntime.sessionBackend.enqueue({ kind: 'submit', input: { ...content, delivery: 'idle' } }, call, (request, effective, next) => next(request, effective));
                                 return {};
                             }
-                            await recordEnvironment();
+                            await modelContext.recordEnvironment();
                             call.signal.throwIfAborted();
                             await writeInputRecord(content, internal.inputSource === 'extension' ? 'extension.input' : 'turn.user', {
                                 ...(internal.extensionSource ? { source: internal.extensionSource } : {}),
@@ -1325,10 +1399,16 @@ export function createSessionOpener(services) {
                         });
                         let lastServerContextTokens = lastServerUsage?.contextInputTokens;
                         let compactBoundary = messages.length;
+                        const invalidateCompactUsage = () => {
+                            lastServerContextTokens = undefined;
+                            lastServerUsage = undefined;
+                            smartContextTokens = undefined;
+                            requestReasoningEffort = reasoningEffort;
+                            effectiveReasoningEffort = reasoningEffort;
+                        };
                         const compactLeaf = async (input, signal, prepare, compactionId) => {
                             if (messages.length < 2)
                                 return false;
-                            let compactSummary = '';
                             const cutoff = Math.min(compactBoundary, messages.length);
                             const current = messages[cutoff - 1];
                             const retainCurrent = mode !== 'compact' && current.role === 'user' && current.contextKind === undefined;
@@ -1338,13 +1418,9 @@ export function createSessionOpener(services) {
                                 message.contextKind === 'summary'))
                                 return false;
                             const compactHistory = structuredClone(prefix);
-                            const prefixInputs = compactionUserMessages.filter((entry) => prefix.some((message) => message.role === 'user' &&
-                                message.contextKind === undefined &&
-                                (entry.metadata?.recordId
-                                    ? message.metadata?.recordId === entry.metadata.recordId
-                                    : message.content === entry.content)));
+                            const prefixInputs = modelContext.compactInputs(prefix);
                             const snapshotTools = structuredClone(projectTools(executionTools));
-                            const generation = contextualWorldState.generation;
+                            const generation = modelContext.worldState.generation;
                             const snapshotUsage = lastServerUsage;
                             const snapshotEffort = requestReasoningEffort ?? reasoningEffort;
                             const anchorRecordId = prefix
@@ -1356,29 +1432,6 @@ export function createSessionOpener(services) {
                                 ...(visibleAnchor ? { anchor: visibleAnchor } : {})
                             };
                             const compactComposition = splitContextualPrompt(await operation((call) => coreExtensions.composeModelSystem(promptComposition(snapshotTools, 'run'), call)));
-                            const compactSystemPrompt = compactComposition.system;
-                            const projectedHistory = normalizeMessagesForModel(compactHistory, {
-                                supportsImages: false
-                            }).map(projectSmartCompactionMessage);
-                            const nativeCompactMessages = buildNativeCompactionMessages(projectedHistory, {
-                                ...(input.focus === undefined ? {} : { focus: input.focus })
-                            });
-                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages(''), snapshotTools);
-                            const compactInputTokens = Math.max(0, selectedModel.contextWindowTokens - compactOverheadTokens);
-                            let usingNativeMessages = shouldUseNativeCompaction({
-                                estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, snapshotTools),
-                                contextWindowTokens: selectedModel.contextWindowTokens,
-                                latestUsage: snapshotUsage,
-                                historyMessages: compactHistory,
-                                appendedMessages: nativeCompactMessages.slice(projectedHistory.length)
-                            });
-                            const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
-                                ...(input.focus === undefined ? {} : { focus: input.focus }),
-                                maxTokens: Math.max(1, compactInputTokens)
-                            }));
-                            let compactMessages = usingNativeMessages
-                                ? nativeCompactMessages
-                                : fallbackMessages();
                             await emit({
                                 type: 'context.compacting',
                                 compactionId,
@@ -1387,79 +1440,43 @@ export function createSessionOpener(services) {
                                 ...anchor
                             });
                             let latestUsage;
-                            const compactionRetryState = { attempts: 0 };
+                            let compactSummary;
                             const compaction = createCompactionOperation(compactionId, signal);
                             const compactTurn = createModelTurnSession(selectedAdapter);
                             try {
-                                const extensionResult = await generateCompactExtension(compactHistory, mode === 'compact' ? 'manual' : 'automatic', input.focus, compaction);
-                                if (extensionResult) {
-                                    compactSummary = extensionResult.summary;
-                                    latestUsage = extensionResult.usage;
-                                    if (latestUsage)
-                                        await emit({
-                                            type: 'usage.updated',
-                                            purpose: 'compact',
-                                            ...publicModelUsage(latestUsage)
-                                        });
-                                }
-                                while (extensionResult === undefined) {
-                                    if (compactInputTokens === 0)
-                                        throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
-                                    compactSummary = '';
-                                    latestUsage = undefined;
-                                    try {
-                                        const request = await transformModelRequest({
-                                            retryState: compactionRetryState,
-                                            system: compactSystemPrompt,
-                                            ...(compactComposition.systemBlocks === undefined
-                                                ? {}
-                                                : { systemBlocks: compactComposition.systemBlocks }),
-                                            messages: compactMessages,
-                                            tools: snapshotTools,
-                                            toolChoice: 'none',
-                                            promptCacheKey: sessionId,
-                                            reasoningEffort: snapshotEffort,
-                                            onAttemptDiagnostic: recordModelAttempt('COMPACTION')
-                                        }, undefined, selectedModel.id, 'compact');
-                                        for await (const event of streamModel((signal) => compaction.start({ start: (request) => compactTurn.start(request, signal) }, request), compaction.signal)) {
-                                            if (event.type === 'text.completed' &&
-                                                (event.phase ?? 'final_answer') === 'final_answer')
-                                                compactSummary = event.text.trim();
-                                            else if (event.type === 'usage') {
-                                                latestUsage = event.usage;
-                                                await emit({
-                                                    type: 'usage.updated',
-                                                    purpose: 'compact',
-                                                    ...publicModelUsage(event.usage)
-                                                });
-                                            }
-                                            else if (event.type === 'client_tool.call')
-                                                throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
-                                        }
-                                        break;
-                                    }
-                                    catch (error) {
-                                        if (await recoverModelStream(error, compactionRetryState, compaction.signal)) {
-                                            continue;
-                                        }
-                                        if (isProviderContextOverflow(error) && usingNativeMessages) {
-                                            usingNativeMessages = false;
-                                            compactMessages = fallbackMessages();
-                                            compactionRetryState.attempts = 0;
-                                            continue;
-                                        }
-                                        if (isProviderContextOverflow(error))
-                                            throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'The compaction request exceeds the model context window.', { cause: error });
-                                        throw error;
-                                    }
-                                }
+                                const candidate = await generateCompactionCandidate({
+                                    history: compactHistory,
+                                    system: compactComposition.system,
+                                    ...(compactComposition.systemBlocks === undefined
+                                        ? {}
+                                        : { systemBlocks: compactComposition.systemBlocks }),
+                                    tools: snapshotTools,
+                                    contextWindowTokens: selectedModel.contextWindowTokens,
+                                    latestUsage: snapshotUsage,
+                                    reasoningEffort: snapshotEffort,
+                                    ...(input.focus === undefined ? {} : { focus: input.focus }),
+                                    reason: mode === 'compact' ? 'manual' : 'automatic',
+                                    promptCacheKey: sessionId
+                                }, {
+                                    operation: compaction,
+                                    turn: compactTurn,
+                                    generateExtension: generateCompactExtension,
+                                    transformRequest: (request) => transformModelRequest(request, undefined, selectedModel.id, 'compact'),
+                                    stream: streamModel,
+                                    observeUsage: (usage) => emit({
+                                        type: 'usage.updated',
+                                        purpose: 'compact',
+                                        ...publicModelUsage(usage)
+                                    }),
+                                    onAttemptDiagnostic: recordModelAttempt('COMPACTION')
+                                });
+                                compactSummary = candidate.summary;
+                                latestUsage = candidate.usage;
                             }
                             finally {
                                 await compaction.dispose();
                                 await compactTurn.close();
                             }
-                            if (!compactSummary)
-                                throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Automatic compact failed.');
                             await emit({
                                 type: 'context.compacting',
                                 compactionId,
@@ -1473,7 +1490,7 @@ export function createSessionOpener(services) {
                             const replacementHistory = buildCompactedHistory(compactSummary, prefixInputs, compactUserTokenLimit);
                             let retainedModelContext = [];
                             const compactRecord = await writeCompactionRecord(compactSummary, true, signal, async (actual, options) => {
-                                if (contextualWorldState.generation !== generation ||
+                                if (modelContext.worldState.generation !== generation ||
                                     prefix.some((message, index) => messages[index] !== message))
                                     throw new MarAgentError('MAR_AGENT_COMPACT_STALE', 'The compaction prefix has changed.');
                                 retainedModelContext = messages
@@ -1508,32 +1525,11 @@ export function createSessionOpener(services) {
                                     executionId,
                                     turnId
                                 }, options);
-                                messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory), ...retainedModelContext);
-                                pendingAppends.length = 0;
-                                selected.resetContinuation?.();
+                                modelContext.replaceCompactMessages(replacementHistory, retainedModelContext);
                                 return record;
                             });
-                            contextGc.reset();
-                            restoreMcpDiscovery();
-                            recordedEnvironment = executionEnvironment;
-                            compactionUserMessages = replacementHistory
-                                .filter((message) => message.kind !== 'summary')
-                                .map((message) => ({
-                                content: message.content,
-                                ...(message.metadata ? { metadata: { ...message.metadata } } : {})
-                            }));
-                            compactionUserMessages.push(...retainedModelContext
-                                .filter((message) => message.role === 'user' && message.contextKind === undefined)
-                                .map((message) => ({
-                                content: message.content,
-                                ...(message.metadata ? { metadata: message.metadata } : {})
-                            })));
-                            await resetCompactWorldState(compactRecord.recordId, { resources: compactResources });
-                            lastServerContextTokens = undefined;
-                            lastServerUsage = undefined;
-                            smartContextTokens = undefined;
-                            requestReasoningEffort = reasoningEffort;
-                            effectiveReasoningEffort = reasoningEffort;
+                            await modelContext.adoptCompactCheckpoint(compactRecord.recordId, replacementHistory, retainedModelContext, compactResources);
+                            invalidateCompactUsage();
                             await emit({
                                 type: 'context.compacted',
                                 compactionId,
@@ -1679,7 +1675,7 @@ export function createSessionOpener(services) {
                                     });
                                 updateMcpRegistry();
                                 executionTools = mcpRegistry.project(baseTools());
-                                await syncMcpWorldState(messages.length);
+                                await modelContext.syncMcpWorldState(messages.length);
                                 compactBoundary = messages.length;
                                 const blocking = compactRequests.drain((input) => startCompact({
                                     ...(input.prompt === undefined ? {} : { focus: input.prompt }),
@@ -1688,9 +1684,9 @@ export function createSessionOpener(services) {
                                 if (blocking)
                                     await compactCoordinator.checkpoint(true);
                                 await ensureContextBudget();
-                                await syncMcpWorldState(messages.length);
+                                await modelContext.syncMcpWorldState(messages.length);
                                 executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
-                                await recordEnvironment();
+                                await modelContext.recordEnvironment();
                                 const { roundTools, roundBindings, toolScope, composeSystemPrompt } = captureRoundToolScope();
                                 const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
                                 const residentTools = projectTools(mcpRegistry.projectDirect(baseTools()));
@@ -1706,7 +1702,7 @@ export function createSessionOpener(services) {
                                     : [...messages, pendingOutputContinuation];
                                 sources.bind(toolScope);
                                 const composedSystem = splitContextualPrompt(await composeSystemPrompt());
-                                const candidateWorld = updatePromptWorldState(contextualWorldState, messages.length, composedSystem.parts);
+                                const candidateWorld = updatePromptWorldState(modelContext.worldState, messages.length, composedSystem.parts);
                                 const modelMessages = projectSessionRequestMessages(requestContextMessages, candidateWorld.entries, selectedModel.inputCapabilities.includes('IMAGE'), codeModeEnabled, permissionPolicy.mode === 'auto');
                                 const systemPrompt = composedSystem.system;
                                 const candidateRequest = {
@@ -1732,9 +1728,9 @@ export function createSessionOpener(services) {
                                     preparingRequestMessages = undefined;
                                 }
                                 controller.signal.throwIfAborted();
-                                if (candidateWorld !== contextualWorldState) {
+                                if (candidateWorld !== modelContext.worldState) {
                                     // Commit only after request middleware accepts the entire candidate.
-                                    await commitWorldState(candidateWorld);
+                                    await modelContext.commitWorldState(candidateWorld);
                                 }
                                 const lateCoreChange = inputs.hasBoundaryCompactPending && (await appendMailboxMessages());
                                 const lateBlocking = compactRequests.drain((input) => startCompact({
@@ -1821,28 +1817,7 @@ export function createSessionOpener(services) {
                                         }
                                     });
                                     if (committed) {
-                                        smartContextTokens = undefined;
-                                        selected.resetContinuation?.();
-                                        const refreshed = await restoreMessages(store, sessionId, committed.records, {
-                                            includeImages: true,
-                                            currentTurnId: turnId,
-                                            projection: committed.projection
-                                        });
-                                        const restoredIds = new Set(committed.records.map((record) => record.recordId));
-                                        const lateMessages = pendingAppends
-                                            .slice(appendBoundary)
-                                            .filter((entry) => !restoredIds.has(entry.recordId))
-                                            .map((entry) => entry.message);
-                                        messages.splice(0, messages.length, ...refreshed.messages, ...lateMessages);
-                                        restoreMcpDiscovery();
-                                        recordedEnvironment = refreshed.environmentState;
-                                        compactionUserMessages = [...refreshed.userMessages];
-                                        agentInstructionInsertIndex = contextualInstructionInsertIndex(messages);
-                                        const next = resetContextualWorldState(latestContextualWorldStateGeneration(committed.records), agentInstructionInsertIndex, {
-                                            instructionSnapshot: currentInstructionSnapshot,
-                                            instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined))
-                                        });
-                                        await commitWorldState(next);
+                                        await modelContext.adoptGcCheckpoint(committed, appendBoundary);
                                     }
                                 }
                             },
@@ -1886,6 +1861,7 @@ export function createSessionOpener(services) {
                     };
                 }
                 catch (error) {
+                    failedExecution = true;
                     finalAnswer = executionLoop?.finalAnswer ?? finalAnswer;
                     acceptsMailbox = false;
                     acceptsSteer = false;
@@ -1897,7 +1873,8 @@ export function createSessionOpener(services) {
                         delete executionContext.compactRequests;
                     if (controller.signal.aborted) {
                         subagents?.endParentExecution(executionId);
-                        await emit({ type: 'execution.cancelled' });
+                        // A faulted Store must not prevent result settlement or lease release.
+                        await emit({ type: 'execution.cancelled' }).catch(() => undefined);
                         return {
                             executionId,
                             status: 'cancelled',
@@ -1906,7 +1883,8 @@ export function createSessionOpener(services) {
                     }
                     const diagnostic = modelAttemptFailureDiagnostic(describeMarAgentError(error, 'MAR_AGENT_EXECUTION_FAILED'), exhaustedModelAttempt);
                     subagents?.endParentExecution(executionId);
-                    await emit({ type: 'execution.failed', ...diagnostic });
+                    // Keep the original diagnostic if persisting the failure terminal also fails.
+                    await emit({ type: 'execution.failed', ...diagnostic }).catch(() => undefined);
                     return {
                         executionId,
                         status: 'failed',
@@ -1940,12 +1918,21 @@ export function createSessionOpener(services) {
                             activeExecutionAdapters.delete(adapter);
                     }
                     subagents?.endParentExecution(executionId);
-                    await releaseSession?.();
-                    if (sessionRuntime.execution === executionContext)
-                        delete sessionRuntime.execution;
-                    active.delete(`${sessionId}:${executionId}`);
-                    sessionRuntime.sessionBackend?.kick();
-                    queue.close();
+                    try {
+                        await releaseSession?.();
+                    }
+                    catch (error) {
+                        // Preserve the first failure/cancellation; successful executions still report release errors.
+                        if (!failedExecution)
+                            throw error;
+                    }
+                    finally {
+                        if (sessionRuntime.execution === executionContext)
+                            delete sessionRuntime.execution;
+                        active.delete(`${sessionId}:${executionId}`);
+                        sessionRuntime.sessionBackend?.kick();
+                        queue.close();
+                    }
                 }
             });
             const executionKey = `${sessionId}:${executionId}`;
@@ -2169,6 +2156,7 @@ export function createSessionOpener(services) {
             sessionRuntime.agentsBackend ??= createExtensionAgentsBackend({
                 existingController: () => sessionRuntime.subagents,
                 controller: async () => {
+                    // Access to managed children is not a new Execution admission for their parent.
                     services.assertCanStart();
                     if (sessionRuntime.subagents === undefined)
                         await openSession(sessionId);
@@ -2219,11 +2207,17 @@ export function createSessionOpener(services) {
             run: (input) => execution('run', input),
             plan: (input) => execution('plan', input),
             steer: (input) => sessionRuntime.execution?.steer?.(input) ?? Promise.resolve({ status: 'notAccepted' }),
-            compact: (input = {}) => sessionRuntime.execution?.compactRequests?.request(input) ??
-                execution('compact', {
+            compact: (input = {}) => {
+                const requests = sessionRuntime.execution?.compactRequests;
+                if (requests) {
+                    services.assertSessionAdmission(sessionId);
+                    return requests.request(input);
+                }
+                return execution('compact', {
                     prompt: input.prompt ?? DEFAULT_COMPACTION_FOCUS,
                     ...input
-                }),
+                });
+            },
             cancel: async (executionId) => active.get(`${sessionId}:${executionId}`)?.abort(),
             startSubagentTurn: (turn) => execution(turn.role === 'explore' ? 'plan' : 'run', {
                 prompt: turn.prompt,