@myagentroam/agent 0.9.158 → 0.9.160

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

@@ -10,12 +10,22 @@ import { createSubagentBackend } from './subagent-backend.js';
 import { discoveredMcpToolNames, rebindMcpToolSearchOutputs } from '../tools/mcp/history.js';
 import { currentExecutionImages } from '../tools/output-projection.js';
 import { createHash, randomUUID } from 'node:crypto';
+import { ExecutionToolSources } from './extension-tools.js';
+import { ExtensionRequestBridge, ExtensionRequestSnapshots } from '../extensions/model-request.js';
+import { normalizeSessionMessagesInput, sessionMessagesPage } from '../extensions/session-messages.js';
+import { transformCoreModelStream } from '../extensions/model-stream.js';
+import { SessionInputCoordinator, recordSessionInputCommit } from '../extensions/session-input.js';
+import { createExtensionSessionBackend } from './extension-session.js';
+import { invokeCorePromptSubmission } from '../extensions/prompt-input.js';
+import { createExtensionAgentsBackend } from './extension-agents.js';
+import { coreMcpCatalog } from '../extensions/mcp.js';
 import { isDeepStrictEqual } from 'node:util';
 import { MarAgentError, describeMarAgentError } from '../error.js';
 import { usesResponsesConfigurationUpdates } from '../model/configuration.js';
 import { buildEnvironmentContext } from '../prompts/core.js';
 import { executionBudgetEnvironmentEntry } from '../prompts/execution-budget.js';
-import { MAR_AGENT_PROMPT_VERSION, buildSystemPrompt } from '../prompts/index.js';
+import { MAR_AGENT_PROMPT_VERSION, buildSystemPromptSections } from '../prompts/index.js';
+import { renderPromptSections } from '../extensions/prompt-composition.js';
 import { retainedSessionResourcesSnapshot } from '../prompts/resources.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { AsyncQueue } from '../runtime/async-queue.js';
@@ -82,6 +92,32 @@ export function createSessionOpener(services) {
                 delete sessionRuntime.subagentsOpening;
             }
         }
+        const buildSessionPromptSections = (availableTools, promptMode, selectedModel, executionSystemInstruction, skillCatalog) => buildSystemPromptSections({
+            mode: promptMode,
+            platform: description.platform,
+            ...(description.architecture ? { architecture: description.architecture } : {}),
+            ...(description.shell ? { shell: description.shell } : {}),
+            ...(description.guaranteedCommands
+                ? { guaranteedCommands: description.guaranteedCommands }
+                : {}),
+            workspace: logicalWorkspace,
+            tools: availableTools
+                .filter((tool) => !tool.name.startsWith('mcp__'))
+                .map((tool) => tool.name),
+            directTools: availableTools
+                .filter((tool) => !tool.name.startsWith('mcp__') &&
+                allowsDirectTool(tool, availableTools.some((candidate) => candidate.name === 'code_exec')))
+                .map((tool) => tool.name),
+            highDensityCompaction: selectedModel.highDensityCompaction,
+            extension: [
+                executionSystemInstruction,
+                skillCatalog,
+                sessionSource.type === 'subagent' ? childSubagentInstruction : undefined
+            ]
+                .filter(Boolean)
+                .join('\n\n')
+        });
+        let promptDefaults;
         const sessionAdapter = (modelId, configuredModels) => {
             let selected = sessionRuntime.adapters.get(modelId);
             if (selected === undefined) {
@@ -99,27 +135,133 @@ export function createSessionOpener(services) {
             sessionRuntime.adapters.clear();
             sessionRuntime.adapterGeneration = generation;
         };
+        const sessionInputs = () => (sessionRuntime.inputs ??= new SessionInputCoordinator((receipt) => services.extensions.session(sessionId)?.diagnose({
+            code: receipt.errorCode ?? 'MAR_AGENT_SESSION_INPUT_FAILED',
+            operationId: receipt.operationId,
+            sessionId
+        })));
+        // Only physical record commits and projection replacement enter this lane, never Hooks.
+        const withRecordProjection = async (action) => {
+            const pending = (sessionRuntime.recordProjection ?? Promise.resolve())
+                .catch(() => undefined)
+                .then(action);
+            sessionRuntime.recordProjection = pending;
+            try {
+                return await pending;
+            }
+            finally {
+                if (sessionRuntime.recordProjection === pending)
+                    delete sessionRuntime.recordProjection;
+            }
+        };
+        const appendExtensionMessage = async (entry, request, call) => {
+            call.signal.throwIfAborted();
+            const release = await store.acquireSessionWriteLease(sessionId, sessionWriterOwner);
+            try {
+                return await withRecordProjection(async () => {
+                    call.signal.throwIfAborted();
+                    const message = projectAppendedModelMessage(request.input);
+                    const record = await store.append(sessionId, {
+                        type: message ? 'model.context' : 'session.notice',
+                        payload: {
+                            ...(message ?? {
+                                content: request.input.content,
+                                textBlocks: request.input.textBlocks
+                            }),
+                            source: extensionInputSource(call, request.input.attribution)
+                        },
+                        ...(call.executionId ? { executionId: call.executionId } : {}),
+                        ...(call.turnId ? { turnId: call.turnId } : {})
+                    }, { signal: call.signal });
+                    const result = {
+                        changed: true,
+                        modelChanged: !!message,
+                        recordId: record.recordId,
+                        ...(call.executionId ? { executionId: call.executionId } : {})
+                    };
+                    recordSessionInputCommit(entry, result);
+                    if (message)
+                        sessionRuntime.appendedMessages?.append(record.recordId, message);
+                    return result;
+                });
+            }
+            finally {
+                await release();
+            }
+        };
         const execution = (mode, input, internal = {}) => {
             services.assertCanStart();
             if ([...active.keys()].some((key) => key.startsWith(`${sessionId}:`)))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Session already has an active execution.');
             const executionId = randomUUID(), turnId = internal.turnId ?? randomUUID(), queue = new AsyncQueue(), controller = new AbortController();
+            const abortSource = () => controller.abort(internal.signal?.reason);
+            internal.signal?.addEventListener('abort', abortSource, { once: true });
+            if (internal.signal?.aborted)
+                abortSource();
             let executionEnvironment = {
                 ...currentEnvironment,
                 ...currentLocalTimeContext()
             };
             const { models: executionModels, defaultModelId: executionDefaultModelId, generation: executionModelGeneration } = services.modelState();
             const executionSystemInstruction = settings.systemInstruction;
+            promptDefaults = {
+                executionId,
+                modelId: input.modelId ?? executionDefaultModelId,
+                mode: mode === 'compact' ? 'run' : mode,
+                models: executionModels,
+                instruction: executionSystemInstruction
+            };
             const manualCompactionId = mode === 'compact' ? randomUUID() : undefined;
             active.set(`${sessionId}:${executionId}`, controller);
-            const mailbox = [...(internal.initialMailbox ?? [])];
+            const inputs = sessionInputs();
+            const acceptParent = (message) => {
+                const origin = message.delivery?.origin;
+                const signal = AbortSignal.any([
+                    controller.signal,
+                    ...(message.delivery?.signal === undefined ? [] : [message.delivery.signal])
+                ]);
+                if (signal.aborted) {
+                    message.delivery?.settled?.('cancelled');
+                    return;
+                }
+                const accept = (call) => {
+                    const entry = inputs.accept({ kind: 'submit', input: { text: message.text } }, call, (request, call, leaf) => leaf(request, call), 'accepted', message);
+                    void entry.terminal.then(() => {
+                        if (entry.receipt.status === 'cancelled' || entry.receipt.status === 'failed')
+                            message.delivery?.settled?.(entry.receipt.status);
+                    });
+                };
+                if (origin) {
+                    accept(Object.freeze({
+                        ...origin,
+                        sessionId,
+                        sessionEpoch: services.extensions.session(sessionId)?.epoch ?? 0,
+                        signal,
+                        executionId,
+                        turnId
+                    }));
+                    return;
+                }
+                services.extensions.operations.enter({
+                    sessionId,
+                    sessionEpoch: services.extensions.session(sessionId)?.epoch ?? 0,
+                    actor: 'sdk',
+                    entry: 'native-api',
+                    signal,
+                    executionId,
+                    turnId
+                }, accept);
+            };
+            for (const message of internal.initialMailbox ?? [])
+                acceptParent(message);
             let acceptsMailbox = sessionSource.type === 'subagent' && mode !== 'compact';
             let sequence = 0;
             let manualCompactionStarted = false;
             let emitTail = Promise.resolve();
             let exhaustedModelAttempt;
             // Serialize durable events before either the local stream or Host observes them.
-            const emit = (event) => {
+            const emit = (event, assertLive) => {
+                assertLive?.();
                 const full = {
                     ...event,
                     eventId: randomUUID(),
@@ -130,7 +272,7 @@ export function createSessionOpener(services) {
                     turnId
                 };
                 const operation = emitTail.then(async () => {
-                    // Transport-only progress events never become recoverable history.
+                    assertLive?.();
                     const persistent = eventForPersistence(full);
                     if (persistent !== undefined)
                         await store.append(sessionId, {
@@ -170,7 +312,7 @@ export function createSessionOpener(services) {
                 emitTail = operation.catch(() => undefined);
                 return operation;
             };
-            const createCompactionOperation = (compactionId) => new CompactionOperation(controller.signal, (progress) => {
+            const createCompactionOperation = (compactionId, signal = controller.signal) => new CompactionOperation(signal, (progress) => {
                 const operation = emitTail.then(async () => {
                     await store.append(sessionId, {
                         type: 'compact.progress',
@@ -190,13 +332,30 @@ export function createSessionOpener(services) {
                     (rolloutBudgetOptions ? new RolloutBudget(rolloutBudgetOptions) : undefined);
                 const ownsRolloutBudget = rolloutBudget !== undefined && internal.sharedRolloutBudget === undefined;
                 let releaseSession;
+                let executionToolSources;
                 let selectedTurn;
                 const contextGc = new ContextGcRuntime();
                 let selectedAdapter;
                 const executionScopedAdapters = new Set();
                 const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
                 try {
+                    controller.signal.throwIfAborted();
                     releaseSession = await store.acquireSessionLease(sessionId, sessionWriterOwner);
+                    if (!inputs.executing)
+                        await inputs.idle();
+                    let immediateTarget;
+                    const pendingAppends = [];
+                    sessionRuntime.appendedMessages = {
+                        executionId,
+                        append(recordId, message) {
+                            pendingAppends.push({
+                                recordId,
+                                message
+                            });
+                            if (immediateTarget)
+                                immediateTarget.push(message);
+                        }
+                    };
                     await refreshSessionAdapters(executionModelGeneration);
                     const sessionState = await store.readExecutionState(sessionId);
                     if (!store.hasRetainedSessionLease(sessionId, sessionWriterOwner))
@@ -231,6 +390,12 @@ export function createSessionOpener(services) {
                         includeImages: mode !== 'compact'
                     });
                     const messages = restored.messages;
+                    const restoredRecordIds = new Set(contextRecords.map((record) => record.recordId));
+                    for (const pending of pendingAppends)
+                        if (!restoredRecordIds.has(pending.recordId))
+                            messages.push(pending.message);
+                    pendingAppends.length = 0;
+                    immediateTarget = messages;
                     let recordedEnvironment = restored.environmentState;
                     let projectedExecutionBudgetStage;
                     const appendExecutionBudgetEnvironment = () => {
@@ -249,28 +414,86 @@ export function createSessionOpener(services) {
                         const entry = executionBudgetEnvironmentEntry(currentStage === 'normal' ? 'inactive' : currentStage);
                         messages.push(environmentContextUpdate(executionEnvironment, executionEnvironment, [entry]));
                     };
-                    const appendMailboxMessages = async () => {
-                        let appended = false;
-                        while (mailbox.length > 0) {
-                            const pending = mailbox.splice(0);
-                            for (const { text: prompt, delivery } of pending) {
-                                await store.append(sessionId, {
-                                    type: 'turn.user',
-                                    payload: {
-                                        prompt,
-                                        inputSource: 'parent_agent',
-                                        ...(delivery ? { messageId: delivery.messageId } : {})
-                                    },
-                                    executionId,
-                                    turnId
-                                });
-                                messages.push({ role: 'user', content: prompt });
-                                delivery?.applied();
-                                appended = true;
-                            }
-                        }
-                        return appended;
+                    let compactContext;
+                    const writeInputRecord = async (content, type, metadata, call, committed) => {
+                        call.signal.throwIfAborted();
+                        if (content.images?.length && !selectedModel.inputCapabilities.includes('IMAGE'))
+                            throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
+                        await withRecordProjection(async () => {
+                            call.signal.throwIfAborted();
+                            const images = content.images?.length
+                                ? await store.persistInputImages(sessionId, content.images)
+                                : [];
+                            const record = await store.append(sessionId, {
+                                type,
+                                payload: {
+                                    ...metadata,
+                                    prompt: content.text,
+                                    ...(content.modelText === undefined ? {} : { modelText: content.modelText }),
+                                    ...(content.context === undefined ? {} : { context: content.context }),
+                                    ...(content.modelContext === undefined
+                                        ? {}
+                                        : { modelContext: content.modelContext }),
+                                    ...(images.length ? { images } : {})
+                                },
+                                executionId,
+                                turnId
+                            }, { signal: call.signal });
+                            committed(content, record.recordId);
+                            for (const text of content.modelContext ?? content.context ?? [])
+                                messages.push({ role: 'user', content: text });
+                        });
                     };
+                    const appendMailboxMessages = async () => inputs.drain(async (entry, request, call) => {
+                        call.signal.throwIfAborted();
+                        if (request.kind === 'compact')
+                            return { changed: await compactContext(request.input), executionId };
+                        if (request.kind === 'append') {
+                            const result = await appendExtensionMessage(entry, request, call);
+                            return { ...result, executionId };
+                        }
+                        const parent = entry.parentMessage;
+                        let outcome;
+                        const content = {
+                            text: request.input.text,
+                            ...(request.input.modelText === undefined
+                                ? {}
+                                : { modelText: request.input.modelText }),
+                            ...(request.input.context === undefined
+                                ? {}
+                                : { context: request.input.context }),
+                            ...(request.input.modelContext === undefined
+                                ? {}
+                                : { modelContext: request.input.modelContext }),
+                            ...(request.input.images === undefined ? {} : { images: request.input.images })
+                        };
+                        await writeInputRecord(content, parent && !parent.delivery?.origin ? 'turn.user' : 'extension.input', parent && !parent.delivery?.origin
+                            ? {
+                                inputSource: 'parent_agent',
+                                ...(parent.delivery ? { messageId: parent.delivery.messageId } : {})
+                            }
+                            : {
+                                source: extensionInputSource(call, request.input.provenance, request.input.modelAttribution),
+                                ...(parent?.delivery ? { messageId: parent.delivery.messageId } : {})
+                            }, call, (actual, recordId) => {
+                            outcome = { changed: true, executionId, recordId };
+                            recordSessionInputCommit(entry, outcome);
+                            messages.push({
+                                role: 'user',
+                                content: actual.modelText ?? actual.text,
+                                ...(actual.images?.length
+                                    ? {
+                                        images: actual.images.map(({ mimeType, dataBase64 }) => ({
+                                            mimeType,
+                                            dataBase64
+                                        }))
+                                    }
+                                    : {})
+                            });
+                            parent?.delivery?.applied();
+                        });
+                        return outcome;
+                    }, { executionId, turnId, signal: controller.signal });
                     const recordEnvironment = async () => {
                         const message = environmentContextUpdate(executionEnvironment, recordedEnvironment);
                         if (!message)
@@ -284,44 +507,11 @@ export function createSessionOpener(services) {
                         messages.push(message);
                         recordedEnvironment = executionEnvironment;
                     };
-                    let compactionUserMessages = [
-                        ...restored.userMessages,
-                        ...(mode === 'compact' ? [] : [input.prompt])
-                    ];
+                    let compactionUserMessages = [...restored.userMessages];
                     const hasRestoredUserImages = messages.some((message) => message.role === 'user' && Boolean(message.images?.length));
-                    const modelInputImages = mode === 'compact'
-                        ? undefined
-                        : input.images?.map(({ mimeType, dataBase64 }) => ({
-                            mimeType,
-                            dataBase64
-                        }));
+                    let modelInputImages;
                     const currentExecutionToolImages = [];
                     let currentExecutionUserIndex;
-                    if (mode !== 'compact') {
-                        await recordEnvironment();
-                        const inputImageMetadata = input.images?.length
-                            ? await store.persistInputImages(sessionId, input.images)
-                            : [];
-                        // A failed sync can still leave a complete record; lease recovery decides image ownership.
-                        await store.append(sessionId, {
-                            type: 'turn.user',
-                            payload: {
-                                prompt: input.prompt,
-                                ...(internal.delivery ? { messageId: internal.delivery.messageId } : {}),
-                                ...(internal.inputSource === undefined
-                                    ? {}
-                                    : { inputSource: internal.inputSource }),
-                                ...(input.clientMessageId ? { clientMessageId: input.clientMessageId } : {}),
-                                ...(inputImageMetadata.length ? { images: inputImageMetadata } : {})
-                            },
-                            executionId,
-                            turnId
-                        });
-                        messages.push({ role: 'user', content: input.prompt });
-                        currentExecutionUserIndex = messages.length - 1;
-                        internal.delivery?.applied();
-                        await appendMailboxMessages();
-                    }
                     await emit({ type: 'execution.started', mode });
                     if (restored.ignoredImages > 0)
                         await store.append(sessionId, {
@@ -357,25 +547,6 @@ export function createSessionOpener(services) {
                             ? requestReasoningEffort
                             : (lastConfigurationEffort(messages, selectedModel.id) ?? requestReasoningEffort)
                         : undefined;
-                    if (mode !== 'compact' &&
-                        useEffortUpdates &&
-                        effectiveReasoningEffort !== reasoningEffort) {
-                        const update = {
-                            role: 'provider',
-                            content: '',
-                            provider: 'OPENAI_RESPONSES',
-                            providerModelId: selectedModel.id,
-                            item: { type: 'configuration_update', reasoning: { effort: reasoningEffort } }
-                        };
-                        messages.push(update);
-                        await store.append(sessionId, {
-                            type: 'model.context',
-                            payload: update,
-                            executionId,
-                            turnId
-                        });
-                        effectiveReasoningEffort = reasoningEffort;
-                    }
                     if (mode !== 'compact' && subagents)
                         await subagents.beginParentExecution({
                             executionId,
@@ -410,16 +581,13 @@ export function createSessionOpener(services) {
                                     role: turn.role,
                                     initialMailbox: turn.initialMailbox,
                                     turnId: turn.turnId,
+                                    ...(turn.origin === undefined ? {} : { origin: turn.origin }),
                                     mcpExecutionScopeId: executionId,
                                     ...(turn.delivery ? { delivery: turn.delivery } : {}),
                                     ...(rolloutBudget === undefined ? {} : { sharedRolloutBudget: rolloutBudget })
                                 });
                             }
                         });
-                    if (mode !== 'compact' &&
-                        (input.images?.length || hasRestoredUserImages) &&
-                        !selectedModel.inputCapabilities.includes('IMAGE'))
-                        throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
                     const catalogContext = {
                         sessionId,
                         executionId,
@@ -470,6 +638,49 @@ export function createSessionOpener(services) {
                     const combinedTools = [...builtinTools, ...(extensions.tools ?? []), ...mcpTools];
                     if (new Set(combinedTools.map((tool) => tool.name)).size !== combinedTools.length)
                         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Tool names conflict.');
+                    const executionSourceNames = new Set(combinedTools.map((tool) => tool.name));
+                    const supplementalBindings = services.extensions.options
+                        .baseTools?.(sessionId, { executionId })
+                        ?.filter((binding) => !executionSourceNames.has(binding.definition.name)) ?? [];
+                    const sources = (executionToolSources = new ExecutionToolSources(executionId, sessionId, combinedTools, builtinTools, mcpCatalog, supplementalBindings));
+                    const sourceBindings = sources.bindings;
+                    const coreExtensions = await services.extensions.prepare(sessionId, controller.signal, sourceBindings, sessionSource.type === 'user' &&
+                        (mode === 'run' || mode === 'plan') &&
+                        !internal.automaticInput);
+                    sessionRuntime.toolSources = sources;
+                    const operation = (run) => services.extensions.operations.run({
+                        sessionId,
+                        sessionEpoch: coreExtensions.epoch,
+                        executionId,
+                        turnId,
+                        actor: 'sdk',
+                        entry: 'native-api',
+                        signal: controller.signal
+                    }, run);
+                    await operation((call) => coreExtensions.ready(call));
+                    const captureTools = () => operation((call) => {
+                        return coreExtensions.capture(call, false, sourceBindings.filter((binding) => !supplementalBindings.includes(binding) || binding.available?.(call) !== false));
+                    });
+                    const streamModel = (start, signal = controller.signal) => transformCoreModelStream(start, signal, (event, signal) => operation((call) => coreExtensions.modelEvent(event, Object.freeze({ ...call, signal }))), () => coreExtensions.diagnose({
+                        code: 'MAR_AGENT_MODEL_STREAM_CLEANUP_FAILED',
+                        sessionId
+                    }));
+                    const transformModelRequest = async (candidate, bindings = captureTools(), modelId = selectedModel.id) => {
+                        let lowered = candidate;
+                        if (coreExtensions.hooks.hasInterceptors('model.request')) {
+                            const bridge = new ExtensionRequestBridge(modelId, candidate);
+                            const request = await operation((call) => coreExtensions.hooks.invoke('model.request', bridge.view, call, async (view) => view));
+                            lowered = bridge.lower(request);
+                        }
+                        for (const definition of lowered.tools) {
+                            const binding = bindings.get(definition.name);
+                            const { description: _description, ...contract } = definition;
+                            const { description: _capturedDescription, ...capturedContract } = binding?.definition ?? {};
+                            if (!binding || !isDeepStrictEqual(contract, capturedContract))
+                                throw new MarAgentError('MAR_AGENT_EXTENSION_MODEL_REQUEST_INVALID', 'Request tools do not match captured sources.');
+                        }
+                        return lowered;
+                    };
                     const toolEligible = (tool) => {
                         toolCallers(tool);
                         if (sessionSource.type === 'subagent' && tool.agentScope === 'ROOT_ONLY')
@@ -486,9 +697,12 @@ export function createSessionOpener(services) {
                                 : tool.name !== 'view_image' ||
                                     selectedModelForTools.inputCapabilities.includes('IMAGE');
                     };
-                    mcpRegistry.update(mcpCatalog, (tool) => toolEligible(tool.definition));
+                    const updateMcpRegistry = () => mcpRegistry.update(coreMcpCatalog([...mcpCatalog.servers, ...coreExtensions.mcp.servers()], captureTools()), (tool) => toolEligible(tool.definition), { nativeToolNames: true });
+                    updateMcpRegistry();
                     rebindMcpToolSearchOutputs(messages, mcpRegistry);
-                    const availableTools = combinedTools.filter(toolEligible);
+                    const availableTools = [...captureTools().values()]
+                        .map((binding) => binding.definition)
+                        .filter(toolEligible);
                     const instructionContext = await loadAgentInstructions({
                         home: description.homeDirectory,
                         workspace: instructionWorkspace,
@@ -500,14 +714,11 @@ export function createSessionOpener(services) {
                     });
                     const instructionEntries = instructionContext?.entries ?? [];
                     const currentInstructionSnapshot = renderAgentInstructions(instructionEntries, false);
-                    let agentInstructionInsertIndex = mode === 'compact'
-                        ? contextualInstructionInsertIndex(messages)
-                        : (currentExecutionUserIndex ?? Math.max(0, messages.length - 1));
-                    if (mode !== 'compact' &&
-                        agentInstructionInsertIndex &&
-                        messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
-                        agentInstructionInsertIndex--;
-                    const baseTools = () => [...builtinTools, ...(extensions.tools ?? [])].filter((tool) => toolEligible(tool) &&
+                    let agentInstructionInsertIndex = mode === 'compact' ? contextualInstructionInsertIndex(messages) : messages.length;
+                    const baseTools = () => [...captureTools().values()]
+                        .filter((binding) => binding.mcp === undefined)
+                        .map((binding) => binding.definition)
+                        .filter((tool) => toolEligible(tool) &&
                         (tool.name !== 'skill' || (instructionContext?.skills.size ?? 0) > 0));
                     let executionTools = mcpRegistry.project(baseTools());
                     const restoreMcpDiscovery = () => {
@@ -547,30 +758,15 @@ export function createSessionOpener(services) {
                     sessionRuntime.contextualWorldState = contextualWorldState;
                     if (!isDeepStrictEqual(previousContextualWorldState, contextualWorldState))
                         await persistContextualWorldState(store, sessionId, contextualWorldState);
-                    const buildExecutionSystemPrompt = (availableTools = executionTools, promptMode = mode) => buildSystemPrompt({
-                        mode: promptMode,
-                        platform: description.platform,
-                        ...(description.architecture ? { architecture: description.architecture } : {}),
-                        ...(description.shell ? { shell: description.shell } : {}),
-                        ...(description.guaranteedCommands
-                            ? { guaranteedCommands: description.guaranteedCommands }
-                            : {}),
-                        workspace: logicalWorkspace,
-                        tools: availableTools
-                            .filter((tool) => !tool.name.startsWith('mcp__'))
-                            .map((tool) => tool.name),
-                        directTools: availableTools
-                            .filter((tool) => !tool.name.startsWith('mcp__') &&
-                            allowsDirectTool(tool, availableTools.some((candidate) => candidate.name === 'code_exec')))
-                            .map((tool) => tool.name),
-                        highDensityCompaction: selectedModel.highDensityCompaction,
-                        extension: [
-                            executionSystemInstruction,
-                            instructionContext?.skillCatalog,
-                            sessionSource.type === 'subagent' ? childSubagentInstruction : undefined
-                        ]
-                            .filter(Boolean)
-                            .join('\n\n')
+                    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) => ({
+                        sections: buildExecutionPromptSections(availableTools, promptMode),
+                        facts: {
+                            modelId: selectedModel.id,
+                            mode: promptMode,
+                            tools: availableTools.map((tool) => tool.name)
+                        }
                     });
                     const syncMcpWorldState = async (index) => {
                         const snapshot = mcpRegistry.navigation();
@@ -593,302 +789,487 @@ export function createSessionOpener(services) {
                     };
                     if (mode !== 'compact')
                         await syncMcpWorldState(agentInstructionInsertIndex);
-                    const initialSystemPrompt = mode === 'compact'
-                        ? buildExecutionSystemPrompt(executionTools, 'run')
-                        : buildExecutionSystemPrompt();
-                    let useManualCompactionFallback;
-                    if (mode === 'compact') {
-                        const compactSystemPrompt = initialSystemPrompt;
-                        const compactHistory = [...messages];
-                        const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
-                        const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
-                            focus: input.prompt,
-                            highDensityCompaction: selectedModel.highDensityCompaction
-                        });
-                        const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
-                        const compactInputTokens = selectedModel.contextWindowTokens - compactOverheadTokens;
-                        if (compactInputTokens <= 0)
-                            throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
-                        const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
-                            focus: input.prompt,
-                            maxTokens: compactInputTokens
-                        }), selectedModel.highDensityCompaction);
-                        const useNative = shouldUseNativeCompaction({
-                            estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeMessages, executionTools),
-                            contextWindowTokens: selectedModel.contextWindowTokens,
-                            latestUsage: lastServerUsage,
-                            historyMessages: compactHistory,
-                            appendedMessages: nativeMessages.slice(projectedHistory.length)
-                        });
-                        messages.splice(0, messages.length, ...(useNative ? nativeMessages : fallbackMessages()));
-                        if (useNative) {
-                            let available = true;
-                            useManualCompactionFallback = () => {
-                                if (!available)
-                                    return false;
-                                available = false;
-                                messages.splice(0, messages.length, ...fallbackMessages());
-                                return true;
-                            };
-                        }
-                    }
-                    await store.append(sessionId, {
-                        type: 'execution.header',
-                        payload: {
-                            promptVersion: MAR_AGENT_PROMPT_VERSION,
-                            promptHash: createHash('sha256').update(initialSystemPrompt).digest('hex'),
-                            modelId: selectedModel.id,
-                            modelName: selectedModel.name,
-                            reasoningEffort,
-                            contextWindowTokens: selectedModel.contextWindowTokens,
-                            mode
-                        },
-                        executionId,
-                        turnId
+                    const writeCompactionRecord = async (summary, _automatic, signal, write) => withRecordProjection(async () => {
+                        signal.throwIfAborted();
+                        const stored = await write(summary, { signal });
+                        inputs.recordCompactCommit({ changed: true, recordId: stored.recordId, executionId });
+                        return stored;
                     });
-                    let lastServerContextTokens = lastServerUsage?.contextInputTokens;
-                    const compactContext = async () => {
-                        const current = messages.at(-1);
-                        if (!current || messages.length < 2)
-                            return false;
-                        const retainCurrent = current.role === 'user' && current.contextKind !== 'environment';
-                        let compactSummary = '';
-                        const compactSystemPrompt = buildExecutionSystemPrompt(executionTools, 'run');
-                        const compactHistory = retainCurrent ? messages.slice(0, -1) : messages;
-                        const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
-                        const nativeCompactMessages = buildNativeCompactionMessages(projectedHistory, {
-                            highDensityCompaction: selectedModel.highDensityCompaction
-                        });
-                        const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
-                        const compactInputTokens = Math.max(0, selectedModel.contextWindowTokens - compactOverheadTokens);
-                        if (compactInputTokens === 0)
-                            throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
-                        let usingNativeMessages = shouldUseNativeCompaction({
-                            estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, executionTools),
-                            contextWindowTokens: selectedModel.contextWindowTokens,
-                            latestUsage: lastServerUsage,
-                            historyMessages: compactHistory,
-                            appendedMessages: nativeCompactMessages.slice(projectedHistory.length)
-                        });
-                        const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
-                            maxTokens: Math.max(1, compactInputTokens)
-                        }), selectedModel.highDensityCompaction);
-                        let compactMessages = usingNativeMessages ? nativeCompactMessages : fallbackMessages();
-                        const compactionId = randomUUID();
-                        await emit({ type: 'context.compacting', compactionId });
-                        let latestUsage;
-                        const compactionRetryState = { attempts: 0 };
-                        const operation = createCompactionOperation(compactionId);
-                        try {
-                            while (true) {
-                                compactSummary = '';
-                                latestUsage = undefined;
-                                try {
-                                    for await (const event of operation.start(selected, {
-                                        retryState: compactionRetryState,
-                                        system: compactSystemPrompt,
-                                        messages: compactMessages,
-                                        tools: executionTools,
-                                        toolChoice: 'none',
-                                        promptCacheKey: sessionId,
-                                        reasoningEffort: requestReasoningEffort ?? reasoningEffort,
-                                        onAttemptDiagnostic: recordModelAttempt('COMPACTION')
-                                    })) {
-                                        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', ...publicModelUsage(event.usage) });
+                    const performCompact = (input, leaf) => operation((call) => inputs.performCompact(input, call, (commit) => coreExtensions.hooks.invoke('session.compact', input, call, async (input, effective) => {
+                        effective.signal.throwIfAborted();
+                        if (input.focus !== undefined && typeof input.focus !== 'string')
+                            throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Compaction focus is invalid.');
+                        const outcome = await leaf(input, effective);
+                        commit(outcome);
+                        return outcome;
+                    })));
+                    const captureRoundToolScope = () => {
+                        const roundTools = executionTools;
+                        const availableBindings = captureTools();
+                        const roundBindings = new Map(roundTools.map((tool) => [tool.name, availableBindings.get(tool.name)]));
+                        const defaultComposition = promptComposition(roundTools, mode === 'compact' ? 'run' : mode);
+                        const defaultSystemPrompt = renderPromptSections(defaultComposition.sections);
+                        let systemPrompt = defaultSystemPrompt;
+                        const roundMcpExpectations = new Map(roundTools
+                            .filter((tool) => roundBindings.get(tool.name)?.mcp !== undefined)
+                            .map((tool) => [tool.name, mcpRegistry.expectedTool(tool.name)]));
+                        const parentFrame = subagents === undefined || mode === 'compact'
+                            ? undefined
+                            : subagents.captureParentFrame(executionId);
+                        const toolContext = {
+                            host: host,
+                            todo,
+                            ...(subagents === undefined || mode === 'compact'
+                                ? {}
+                                : {
+                                    subagents: coreExtensions.bindAgents(subagents.captureExecution(executionId))
+                                }),
+                            mode,
+                            sessionId,
+                            executionId,
+                            modelId: selectedModel.id,
+                            signal: controller.signal,
+                            emit,
+                            skills: instructionContext?.skills ?? new Map(),
+                            invokeTool: (call, context, caller) => {
+                                const invoke = () => coreExtensions.withTools(roundBindings, sessionRuntime.scheduleTool, () => services.extensions.operations.enter({
+                                    sessionId,
+                                    sessionEpoch: coreExtensions.epoch,
+                                    executionId,
+                                    turnId,
+                                    actor: caller === 'programmatic' ? 'code-mode' : 'model',
+                                    entry: caller,
+                                    signal: context.signal
+                                }, (operation) => coreExtensions.invoke(call, operation, roundBindings)));
+                                return sources.withFrame(context, () => parentFrame === undefined ? invoke() : parentFrame(invoke));
+                            }
+                        };
+                        const recentImages = () => currentExecutionImages(modelInputImages, currentExecutionToolImages);
+                        const toolScope = {
+                            context: toolContext,
+                            tools: roundTools,
+                            expectations: roundMcpExpectations,
+                            extensionToolNames: new Set([...roundBindings.values()]
+                                .filter((binding) => binding.source.kind === 'host' || binding.source.kind === 'extension')
+                                .map((binding) => binding.definition.name)),
+                            schedule: sessionRuntime.scheduleTool,
+                            assertLive: () => coreExtensions.assertLive(),
+                            assertExecutionLive: () => sources.assertActive(),
+                            emit: (event, assertLive) => emit(event, () => {
+                                coreExtensions.assertLive();
+                                assertLive?.();
+                            }),
+                            searchMcpTools: (arguments_, searchSignal) => mcpRegistry.expose(arguments_, {
+                                signal: searchSignal,
+                                base: baseTools(),
+                                window: selectedModel.contextWindowTokens,
+                                system: systemPrompt
+                            }),
+                            recentImages,
+                            captureCodeContext: () => ({
+                                ...toolContext,
+                                recentImages: recentImages()
+                            }),
+                            codeModeContext: async (call) => {
+                                const stateSnapshot = call.name === 'code_exec' ? await store.readCodeModeState(sessionId) : [];
+                                return {
+                                    retainSession: async () => {
+                                        coreExtensions.assertLive();
+                                        const release = await store.retainSessionLease(sessionId, sessionWriterOwner);
+                                        let unpin;
+                                        try {
+                                            unpin = coreExtensions.pin();
                                         }
-                                        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, operation.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;
-                                }
+                                        catch (error) {
+                                            try {
+                                                await release();
+                                            }
+                                            catch {
+                                                coreExtensions.diagnose({
+                                                    code: 'MAR_AGENT_EXTENSION_CLEANUP_FAILED',
+                                                    sessionId
+                                                });
+                                            }
+                                            throw error;
+                                        }
+                                        return async () => {
+                                            try {
+                                                await release();
+                                            }
+                                            finally {
+                                                unpin();
+                                            }
+                                        };
+                                    },
+                                    onSettled: async (result) => {
+                                        await store.append(sessionId, {
+                                            type: 'code.cell.completed',
+                                            payload: { ...result, callId: call.callId },
+                                            executionId,
+                                            turnId
+                                        });
+                                    },
+                                    supportsImages: selectedModel.inputCapabilities.includes('IMAGE'),
+                                    tools: roundTools.filter((tool) => allowsToolCaller(tool, 'programmatic')),
+                                    state: stateSnapshot,
+                                    commitState: (mutations) => store.commitCodeModeState(sessionId, mutations, {
+                                        executionId,
+                                        turnId,
+                                        expectedState: stateSnapshot
+                                    })
+                                };
                             }
+                        };
+                        return {
+                            roundTools,
+                            roundBindings,
+                            toolScope,
+                            async composeSystemPrompt() {
+                                const composed = await operation((call) => coreExtensions.composeModelSystem(defaultComposition, call));
+                                systemPrompt = composed.text;
+                                return composed;
+                            }
+                        };
+                    };
+                    sources.bind(captureRoundToolScope().toolScope);
+                    sessionRuntime.requestMessages = {
+                        executionId,
+                        read: () => 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'))
+                    };
+                    if (mode !== 'compact') {
+                        let entered = false;
+                        const writeInput = async (content, call) => {
+                            call.signal.throwIfAborted();
+                            if ((content.images?.length || hasRestoredUserImages) &&
+                                !selectedModel.inputCapabilities.includes('IMAGE'))
+                                throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
+                            if (entered) {
+                                await sessionRuntime.sessionBackend.enqueue({ kind: 'submit', input: { ...content, delivery: 'idle' } }, call, (request, effective, next) => next(request, effective));
+                                return {};
+                            }
+                            await recordEnvironment();
+                            call.signal.throwIfAborted();
+                            await writeInputRecord(content, internal.inputSource === 'extension' ? 'extension.input' : 'turn.user', {
+                                ...(internal.extensionSource ? { source: internal.extensionSource } : {}),
+                                ...(internal.delivery ? { messageId: internal.delivery.messageId } : {}),
+                                ...(internal.inputSource === undefined
+                                    ? {}
+                                    : { inputSource: internal.inputSource }),
+                                ...(input.clientMessageId ? { clientMessageId: input.clientMessageId } : {})
+                            }, call, (actual, recordId) => {
+                                entered = true;
+                                compactionUserMessages.push(actual.text);
+                                modelInputImages = actual.images?.map(({ mimeType, dataBase64 }) => ({
+                                    mimeType,
+                                    dataBase64
+                                }));
+                                messages.push({ role: 'user', content: actual.modelText ?? actual.text });
+                                currentExecutionUserIndex = messages.length - 1;
+                                internal.inputCommitted?.(recordId);
+                                internal.delivery?.applied();
+                            });
+                            return {};
+                        };
+                        const content = {
+                            text: input.prompt,
+                            ...(internal.modelText === undefined ? {} : { modelText: internal.modelText }),
+                            ...(internal.inputContext === undefined ? {} : { context: internal.inputContext }),
+                            ...(internal.modelContext === undefined
+                                ? {}
+                                : { modelContext: internal.modelContext }),
+                            ...(input.images === undefined ? {} : { images: input.images })
+                        };
+                        await operation((call) => internal.promptAdmitted
+                            ? writeInput(content, call)
+                            : invokeCorePromptSubmission(coreExtensions.hooks, content, call, writeInput));
+                        if (!entered) {
+                            await emit({ type: 'execution.completed' });
+                            return { executionId, status: 'completed', finalAnswer: '', inputHandled: true };
                         }
-                        finally {
-                            await operation.dispose();
-                        }
-                        if (!compactSummary)
-                            throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Automatic compact failed.');
-                        rolloutBudget?.recordUsage(latestUsage);
-                        const replacementHistory = buildCompactedHistory(compactSummary, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent ? current.content : undefined);
-                        const compactRecord = await store.compact(sessionId, {
-                            summary: compactSummary,
-                            replacementHistory,
-                            automatic: true,
-                            environment: executionEnvironment,
-                            modelId: selectedModel.id,
-                            contextWindowTokens: selectedModel.contextWindowTokens,
-                            ...(latestUsage === undefined ? {} : { usage: latestUsage }),
+                    }
+                    if (mode !== 'compact' &&
+                        useEffortUpdates &&
+                        effectiveReasoningEffort !== reasoningEffort) {
+                        const update = {
+                            role: 'provider',
+                            content: '',
+                            provider: 'OPENAI_RESPONSES',
+                            providerModelId: selectedModel.id,
+                            item: { type: 'configuration_update', reasoning: { effort: reasoningEffort } }
+                        };
+                        messages.push(update);
+                        await store.append(sessionId, {
+                            type: 'model.context',
+                            payload: update,
                             executionId,
                             turnId
                         });
-                        contextGc.reset();
-                        messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory));
-                        restoreMcpDiscovery();
-                        projectedExecutionBudgetStage = undefined;
-                        recordedEnvironment = executionEnvironment;
-                        compactionUserMessages = replacementHistory
-                            .filter((message) => message.kind === 'user_input')
-                            .map((message) => message.content);
-                        agentInstructionInsertIndex = Math.max(0, messages.length - 1);
-                        currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
-                        contextualWorldState = resetContextualWorldState(compactRecord.recordId, agentInstructionInsertIndex, {
-                            instructionSnapshot: currentInstructionSnapshot,
-                            instructionContent: renderAgentInstructions(instructionEntries, true),
-                            resourceSnapshot: currentResourceSnapshot,
-                            previousMayContainResources: compactSummary.includes('# Retained Session resources')
-                        });
-                        sessionRuntime.contextualWorldState = contextualWorldState;
-                        await persistContextualWorldState(store, sessionId, contextualWorldState);
-                        lastServerContextTokens = undefined;
-                        lastServerUsage = undefined;
-                        requestReasoningEffort = reasoningEffort;
                         effectiveReasoningEffort = reasoningEffort;
-                        await emit({ type: 'context.compacted', compactionId });
-                        return true;
-                    };
-                    const ensureContextBudget = async () => {
-                        if (mode === 'compact' || lastServerContextTokens === undefined)
-                            return;
-                        const hardLimit = selectedModel.contextWindowTokens;
-                        const compactLimit = Math.floor((hardLimit * AGENT_EXECUTION_POLICY.automaticCompactionPercent) / 100);
-                        if (lastServerContextTokens < compactLimit)
-                            return;
-                        if (!(await compactContext()))
-                            throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Provider usage reached the compaction threshold but no history can be compacted.');
-                    };
-                    executionLoop = new ExecutionLoop({
-                        mode,
-                        sourceType: sessionSource.type,
-                        signal: controller.signal,
-                        model: selectedModel,
-                        messages,
-                        toolImages: currentExecutionToolImages,
-                        rolloutBudget,
-                        publish: emit,
-                        appendContext: async (message) => {
-                            await store.append(sessionId, {
-                                type: 'model.context',
-                                payload: message,
-                                executionId,
-                                turnId
+                    }
+                    const runPreparedExecution = async (compactFocus = input.prompt, compactSignal = controller.signal) => {
+                        const initialSystemPrompt = mode === 'compact'
+                            ? buildExecutionSystemPrompt(executionTools, 'run')
+                            : buildExecutionSystemPrompt();
+                        let useManualCompactionFallback;
+                        const manualAppendBoundary = pendingAppends.length;
+                        if (mode === 'compact') {
+                            const compactSystemPrompt = initialSystemPrompt;
+                            const compactHistory = [...messages];
+                            const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
+                            const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
+                                focus: compactFocus,
+                                highDensityCompaction: selectedModel.highDensityCompaction
                             });
-                        },
-                        prepareRound: async (pendingOutputContinuation) => {
-                            await appendMailboxMessages();
-                            appendExecutionBudgetEnvironment();
-                            executionTools = mcpRegistry.project(baseTools());
-                            if (mode !== 'compact')
-                                await syncMcpWorldState(messages.length);
-                            await ensureContextBudget();
-                            if (mode !== 'compact')
-                                await syncMcpWorldState(messages.length);
-                            appendExecutionBudgetEnvironment();
-                            if (mode !== 'compact') {
-                                executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
-                                await recordEnvironment();
+                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
+                            const compactInputTokens = selectedModel.contextWindowTokens - compactOverheadTokens;
+                            if (compactInputTokens <= 0)
+                                throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
+                            const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
+                                focus: compactFocus,
+                                maxTokens: compactInputTokens
+                            }), selectedModel.highDensityCompaction);
+                            const useNative = shouldUseNativeCompaction({
+                                estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeMessages, executionTools),
+                                contextWindowTokens: selectedModel.contextWindowTokens,
+                                latestUsage: lastServerUsage,
+                                historyMessages: compactHistory,
+                                appendedMessages: nativeMessages.slice(projectedHistory.length)
+                            });
+                            messages.splice(0, messages.length, ...(useNative ? nativeMessages : fallbackMessages()));
+                            if (useNative) {
+                                let available = true;
+                                useManualCompactionFallback = () => {
+                                    if (!available)
+                                        return false;
+                                    available = false;
+                                    messages.splice(0, messages.length, ...fallbackMessages(), ...pendingAppends.slice(manualAppendBoundary).map((entry) => entry.message));
+                                    return true;
+                                };
                             }
-                            const roundTools = executionTools;
-                            const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
-                            const residentTools = mcpRegistry.projectDirect(baseTools());
-                            const requestTools = (() => {
-                                if (selectedModel.protocol !== 'OPENAI_RESPONSES')
-                                    return projectCodeModeTools(roundTools, residentTools);
-                                const directNames = new Set(residentTools.map((tool) => tool.name));
-                                // Discovery and caller policy are independent: keep nested declarations for active tools.
-                                return projectCodeModeTools(roundTools, residentTools).filter((tool) => directNames.has(tool.name));
-                            })();
-                            const systemPrompt = mode === 'compact'
-                                ? buildExecutionSystemPrompt(roundTools, 'run')
-                                : buildExecutionSystemPrompt(roundTools);
-                            const requestContextMessages = pendingOutputContinuation === undefined
-                                ? messages
-                                : [...messages, pendingOutputContinuation];
-                            const modelMessages = mode === 'compact'
-                                ? normalizeMessagesForModel(requestContextMessages, { supportsImages: false })
-                                : normalizeMessagesForModel(insertContextualWorldState(requestContextMessages, contextualWorldState.entries), {
-                                    supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
-                                });
-                            const roundMcpExpectations = new Map(roundTools
-                                .filter((tool) => tool.name.startsWith('mcp__'))
-                                .map((tool) => [tool.name, mcpRegistry.expectedTool(tool.name)]));
-                            const toolContext = {
-                                host: host,
-                                todo,
-                                ...(subagents === undefined ? {} : { subagents }),
-                                mode,
-                                sessionId,
-                                executionId,
+                        }
+                        await store.append(sessionId, {
+                            type: 'execution.header',
+                            payload: {
+                                promptVersion: MAR_AGENT_PROMPT_VERSION,
+                                promptHash: createHash('sha256').update(initialSystemPrompt).digest('hex'),
                                 modelId: selectedModel.id,
-                                signal: controller.signal,
-                                emit,
-                                skills: instructionContext?.skills ?? new Map()
-                            };
-                            const recentImages = () => currentExecutionImages(modelInputImages, currentExecutionToolImages);
-                            const toolScope = {
-                                context: toolContext,
-                                tools: roundTools,
-                                expectations: roundMcpExpectations,
-                                extensionToolNames: new Set((extensions.tools ?? []).map((tool) => tool.name)),
-                                schedule: sessionRuntime.scheduleTool,
-                                emit,
-                                searchMcpTools: (arguments_, searchSignal) => mcpRegistry.expose(arguments_, {
-                                    signal: searchSignal,
-                                    base: baseTools(),
-                                    window: selectedModel.contextWindowTokens,
-                                    system: systemPrompt
-                                }),
-                                recentImages,
-                                captureCodeContext: () => ({
-                                    ...toolContext,
-                                    ...(subagents ? { subagents: subagents.captureExecution() } : {}),
-                                    recentImages: recentImages()
-                                }),
-                                codeModeContext: async (call) => {
-                                    const stateSnapshot = call.name === 'code_exec' ? await store.readCodeModeState(sessionId) : [];
-                                    return {
-                                        retainSession: () => store.retainSessionLease(sessionId, sessionWriterOwner),
-                                        onSettled: async (result) => {
-                                            await store.append(sessionId, {
-                                                type: 'code.cell.completed',
-                                                payload: { ...result, callId: call.callId },
-                                                executionId,
-                                                turnId
-                                            });
-                                        },
-                                        supportsImages: selectedModel.inputCapabilities.includes('IMAGE'),
-                                        tools: roundTools.filter((tool) => allowsToolCaller(tool, 'programmatic')),
-                                        state: stateSnapshot,
-                                        commitState: (mutations) => store.commitCodeModeState(sessionId, mutations, {
-                                            executionId,
-                                            turnId,
-                                            expectedState: stateSnapshot
-                                        })
-                                    };
+                                modelName: selectedModel.name,
+                                reasoningEffort,
+                                contextWindowTokens: selectedModel.contextWindowTokens,
+                                mode
+                            },
+                            executionId,
+                            turnId
+                        });
+                        let lastServerContextTokens = lastServerUsage?.contextInputTokens;
+                        const compactLeaf = async (input = {}, signal = controller.signal) => {
+                            if (messages.length < 2)
+                                return false;
+                            let compactSummary = '';
+                            const current = messages.at(-1);
+                            const retainCurrent = current.role === 'user' && current.contextKind !== 'environment';
+                            const compactHistory = retainCurrent ? messages.slice(0, -1) : [...messages];
+                            const appendBoundary = pendingAppends.length;
+                            const compactSystemPrompt = await operation((call) => coreExtensions.compose(promptComposition(executionTools, 'run'), call));
+                            const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
+                            const nativeCompactMessages = buildNativeCompactionMessages(projectedHistory, {
+                                ...(input.focus === undefined ? {} : { focus: input.focus }),
+                                highDensityCompaction: selectedModel.highDensityCompaction
+                            });
+                            const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
+                            const compactInputTokens = Math.max(0, selectedModel.contextWindowTokens - compactOverheadTokens);
+                            if (compactInputTokens === 0)
+                                throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
+                            let usingNativeMessages = shouldUseNativeCompaction({
+                                estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, executionTools),
+                                contextWindowTokens: selectedModel.contextWindowTokens,
+                                latestUsage: lastServerUsage,
+                                historyMessages: compactHistory,
+                                appendedMessages: nativeCompactMessages.slice(projectedHistory.length)
+                            });
+                            const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
+                                ...(input.focus === undefined ? {} : { focus: input.focus }),
+                                maxTokens: Math.max(1, compactInputTokens)
+                            }), selectedModel.highDensityCompaction);
+                            let compactMessages = usingNativeMessages
+                                ? nativeCompactMessages
+                                : fallbackMessages();
+                            const compactionId = randomUUID();
+                            await emit({ type: 'context.compacting', compactionId });
+                            let latestUsage;
+                            const compactionRetryState = { attempts: 0 };
+                            const compaction = createCompactionOperation(compactionId, signal);
+                            try {
+                                while (true) {
+                                    compactSummary = '';
+                                    latestUsage = undefined;
+                                    try {
+                                        const request = await transformModelRequest({
+                                            retryState: compactionRetryState,
+                                            system: compactSystemPrompt,
+                                            messages: compactMessages,
+                                            tools: executionTools,
+                                            toolChoice: 'none',
+                                            promptCacheKey: sessionId,
+                                            reasoningEffort: requestReasoningEffort ?? reasoningEffort,
+                                            onAttemptDiagnostic: recordModelAttempt('COMPACTION')
+                                        });
+                                        for await (const event of streamModel((signal) => compaction.start({ start: (request) => selected.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', ...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;
+                                    }
                                 }
-                            };
-                            return {
-                                request: {
+                            }
+                            finally {
+                                await compaction.dispose();
+                            }
+                            if (!compactSummary)
+                                throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Automatic compact failed.');
+                            rolloutBudget?.recordUsage(latestUsage);
+                            let replacementHistory = buildCompactedHistory(compactSummary, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent ? current.content : undefined);
+                            signal.throwIfAborted();
+                            const compactRecord = await writeCompactionRecord(compactSummary, true, signal, async (actual, options) => {
+                                compactSummary = actual;
+                                replacementHistory = buildCompactedHistory(actual, retainCurrent ? compactionUserMessages.slice(0, -1) : compactionUserMessages, compactUserTokenLimit, retainCurrent ? current.content : undefined);
+                                const retainedModelContext = pendingAppends
+                                    .slice(appendBoundary)
+                                    .map((entry) => entry.message);
+                                const record = await store.compact(sessionId, {
+                                    summary: compactSummary,
+                                    replacementHistory,
+                                    retainedModelContext,
+                                    automatic: true,
+                                    environment: executionEnvironment,
+                                    modelId: selectedModel.id,
+                                    contextWindowTokens: selectedModel.contextWindowTokens,
+                                    ...(latestUsage === undefined ? {} : { usage: latestUsage }),
+                                    executionId,
+                                    turnId
+                                }, options);
+                                messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory), ...retainedModelContext);
+                                pendingAppends.length = 0;
+                                return record;
+                            });
+                            contextGc.reset();
+                            restoreMcpDiscovery();
+                            projectedExecutionBudgetStage = undefined;
+                            recordedEnvironment = executionEnvironment;
+                            compactionUserMessages = replacementHistory
+                                .filter((message) => message.kind === 'user_input')
+                                .map((message) => message.content);
+                            agentInstructionInsertIndex = Math.max(0, messages.length - 1);
+                            currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                            contextualWorldState = resetContextualWorldState(compactRecord.recordId, agentInstructionInsertIndex, {
+                                instructionSnapshot: currentInstructionSnapshot,
+                                instructionContent: renderAgentInstructions(instructionEntries, true),
+                                resourceSnapshot: currentResourceSnapshot,
+                                previousMayContainResources: compactSummary.includes('# Retained Session resources')
+                            });
+                            sessionRuntime.contextualWorldState = contextualWorldState;
+                            await persistContextualWorldState(store, sessionId, contextualWorldState);
+                            lastServerContextTokens = undefined;
+                            lastServerUsage = undefined;
+                            requestReasoningEffort = reasoningEffort;
+                            effectiveReasoningEffort = reasoningEffort;
+                            await emit({ type: 'context.compacted', compactionId });
+                            return true;
+                        };
+                        compactContext = async (input = {}) => {
+                            sources.bind(captureRoundToolScope().toolScope);
+                            return (await performCompact(input, async (effective, call) => ({
+                                changed: await compactLeaf(effective, call.signal),
+                                executionId
+                            }))).changed;
+                        };
+                        const ensureContextBudget = async () => {
+                            if (mode === 'compact' || lastServerContextTokens === undefined)
+                                return;
+                            const hardLimit = selectedModel.contextWindowTokens;
+                            const compactLimit = Math.floor((hardLimit * AGENT_EXECUTION_POLICY.automaticCompactionPercent) / 100);
+                            if (lastServerContextTokens < compactLimit)
+                                return;
+                            if (!(await compactContext()))
+                                throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Provider usage reached the compaction threshold but no history can be compacted.');
+                        };
+                        executionLoop = new ExecutionLoop({
+                            mode,
+                            sourceType: sessionSource.type,
+                            signal: controller.signal,
+                            model: selectedModel,
+                            messages,
+                            toolImages: currentExecutionToolImages,
+                            rolloutBudget,
+                            publish: emit,
+                            appendContext: (message) => withRecordProjection(async () => {
+                                await store.append(sessionId, {
+                                    type: 'model.context',
+                                    payload: message,
+                                    executionId,
+                                    turnId
+                                });
+                            }),
+                            prepareRound: async (pendingOutputContinuation) => {
+                                if (mode !== 'compact')
+                                    await appendMailboxMessages();
+                                appendExecutionBudgetEnvironment();
+                                updateMcpRegistry();
+                                executionTools = mcpRegistry.project(baseTools());
+                                if (mode !== 'compact')
+                                    await syncMcpWorldState(messages.length);
+                                await ensureContextBudget();
+                                if (mode !== 'compact')
+                                    await syncMcpWorldState(messages.length);
+                                appendExecutionBudgetEnvironment();
+                                if (mode !== 'compact') {
+                                    executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
+                                    await recordEnvironment();
+                                }
+                                const { roundTools, roundBindings, toolScope, composeSystemPrompt } = captureRoundToolScope();
+                                const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
+                                const residentTools = mcpRegistry.projectDirect(baseTools());
+                                const requestTools = (() => {
+                                    if (selectedModel.protocol !== 'OPENAI_RESPONSES')
+                                        return projectCodeModeTools(roundTools, residentTools);
+                                    const directNames = new Set(residentTools.map((tool) => tool.name));
+                                    // Discovery and caller policy are independent: keep nested declarations for active tools.
+                                    return projectCodeModeTools(roundTools, residentTools).filter((tool) => directNames.has(tool.name));
+                                })();
+                                const requestContextMessages = pendingOutputContinuation === undefined
+                                    ? messages
+                                    : [...messages, pendingOutputContinuation];
+                                const modelMessages = projectSessionRequestMessages(requestContextMessages, mode === 'compact' ? [] : contextualWorldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), codeModeEnabled);
+                                sources.bind(toolScope);
+                                const composedSystem = await composeSystemPrompt();
+                                const systemPrompt = composedSystem.text;
+                                const candidateRequest = {
                                     system: systemPrompt,
-                                    messages: modelMessages.map((message) => projectCodeModeSearchResult(message, codeModeEnabled)),
+                                    ...(composedSystem.blocks ? { systemBlocks: composedSystem.blocks } : {}),
+                                    messages: modelMessages,
                                     tools: requestTools,
                                     ...(mode === 'compact' ? { toolChoice: 'none' } : {}),
                                     promptCacheKey: sessionId,
@@ -896,114 +1277,152 @@ export function createSessionOpener(services) {
                                     ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),
                                     ...(modelInputImages?.length ? { images: modelInputImages } : {}),
                                     onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
-                                },
-                                toolScope
-                            };
-                        },
-                        startModel: async function* (request) {
-                            if (manualCompactionId !== undefined && !manualCompactionStarted) {
-                                manualCompactionStarted = true;
-                                manualCompaction = createCompactionOperation(manualCompactionId);
-                                await emit({ type: 'context.compacting', compactionId: manualCompactionId });
-                            }
-                            yield* manualCompaction
-                                ? manualCompaction.start(selected, request)
-                                : selected.start(request, controller.signal);
-                        },
-                        recoverySignal: () => manualCompaction?.signal ?? controller.signal,
-                        compactContext,
-                        compactionFallback: useManualCompactionFallback,
-                        observeContextTokens: (tokens) => {
-                            lastServerContextTokens = tokens;
-                        },
-                        observeUsage: (usage) => {
-                            if (usage !== undefined) {
-                                lastServerContextTokens = usage.contextInputTokens;
-                                lastServerUsage = { ...usage, historyMessages: [...messages] };
-                            }
-                        },
-                        checkpoint: async (round, latestUsage) => {
-                            if (mode !== 'compact' &&
-                                sessionSource.type !== 'subagent' &&
-                                latestUsage !== undefined) {
-                                // Only a committed GC checkpoint may replace active context and invalidate continuation.
-                                const committed = await contextGc.run({
-                                    store,
-                                    sessionId,
-                                    system: round.request.system,
-                                    tools: round.toolScope.tools,
-                                    modelId: selectedModel.id,
-                                    contextWindowTokens: selectedModel.contextWindowTokens,
-                                    usage: latestUsage,
-                                    modelProtocol: selectedModel.protocol,
-                                    responsesConfigurationUpdates: usesResponsesConfigurationUpdates(selectedModel),
-                                    workspace: logicalWorkspace,
-                                    platform: description.platform,
-                                    getActiveProcessIds: async () => {
-                                        const resources = await host
-                                            .listSessionResources?.(sessionId)
-                                            .catch(() => undefined);
-                                        return new Set((resources?.processes ?? [])
-                                            .filter((process) => process.status === 'running')
-                                            .map((process) => process.processId));
+                                };
+                                return {
+                                    request: await transformModelRequest(candidateRequest, roundBindings),
+                                    toolScope
+                                };
+                            },
+                            startModel: async function* (request) {
+                                const snapshots = mode === 'compact'
+                                    ? undefined
+                                    : (sessionRuntime.requestSnapshots ??= new ExtensionRequestSnapshots());
+                                const snapshot = snapshots?.record(selectedModel.id, request);
+                                if (manualCompactionId !== undefined && !manualCompactionStarted) {
+                                    manualCompactionStarted = true;
+                                    manualCompaction = createCompactionOperation(manualCompactionId, compactSignal);
+                                    await emit({ type: 'context.compacting', compactionId: manualCompactionId });
+                                }
+                                const compaction = manualCompaction;
+                                yield* streamModel(async function* (nativeSignal) {
+                                    const events = compaction
+                                        ? compaction.start({ start: (value) => selected.start(value, nativeSignal) }, request)
+                                        : selected.start(request, nativeSignal);
+                                    for await (const event of events) {
+                                        if (snapshot && event.type === 'completed' && event.reason !== 'cancelled')
+                                            snapshots.complete(snapshot);
+                                        yield event;
                                     }
-                                });
-                                if (committed) {
-                                    selected.resetContinuation?.();
-                                    const refreshed = await restoreMessages(store, sessionId, committed.records, {
-                                        includeImages: true,
-                                        currentTurnId: turnId,
-                                        projection: committed.projection
-                                    });
-                                    messages.splice(0, messages.length, ...refreshed.messages);
-                                    restoreMcpDiscovery();
-                                    projectedExecutionBudgetStage = undefined;
-                                    recordedEnvironment = refreshed.environmentState;
-                                    compactionUserMessages = [...refreshed.userMessages];
-                                    agentInstructionInsertIndex =
-                                        refreshed.currentTurnUserIndex ?? Math.max(0, messages.length - 1);
-                                    if (agentInstructionInsertIndex &&
-                                        messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
-                                        agentInstructionInsertIndex--;
-                                    currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
-                                    contextualWorldState = resetContextualWorldState(latestContextualWorldStateGeneration(committed.records), agentInstructionInsertIndex, {
-                                        instructionSnapshot: currentInstructionSnapshot,
-                                        instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined)),
-                                        resourceSnapshot: currentResourceSnapshot,
-                                        previousMayContainResources: compactHistoryMayContainRetainedResources(committed.records)
+                                }, compaction?.signal ?? controller.signal);
+                            },
+                            recoverySignal: () => manualCompaction?.signal ?? controller.signal,
+                            compactContext,
+                            compactionFallback: useManualCompactionFallback,
+                            observeContextTokens: (tokens) => {
+                                lastServerContextTokens = tokens;
+                            },
+                            observeUsage: (usage) => {
+                                if (usage !== undefined) {
+                                    lastServerContextTokens = usage.contextInputTokens;
+                                    lastServerUsage = { ...usage, historyMessages: [...messages] };
+                                }
+                            },
+                            checkpoint: async (round, latestUsage) => {
+                                if (mode !== 'compact' &&
+                                    sessionSource.type !== 'subagent' &&
+                                    latestUsage !== undefined) {
+                                    // Only a committed GC checkpoint may replace active context and invalidate continuation.
+                                    const appendBoundary = pendingAppends.length;
+                                    const committed = await contextGc.run({
+                                        store,
+                                        sessionId,
+                                        system: round.request.system,
+                                        tools: round.toolScope.tools,
+                                        modelId: selectedModel.id,
+                                        contextWindowTokens: selectedModel.contextWindowTokens,
+                                        usage: latestUsage,
+                                        modelProtocol: selectedModel.protocol,
+                                        responsesConfigurationUpdates: usesResponsesConfigurationUpdates(selectedModel),
+                                        workspace: logicalWorkspace,
+                                        platform: description.platform,
+                                        getActiveProcessIds: async () => {
+                                            const resources = await host
+                                                .listSessionResources?.(sessionId)
+                                                .catch(() => undefined);
+                                            return new Set((resources?.processes ?? [])
+                                                .filter((process) => process.status === 'running')
+                                                .map((process) => process.processId));
+                                        }
                                     });
-                                    sessionRuntime.contextualWorldState = contextualWorldState;
-                                    await persistContextualWorldState(store, sessionId, contextualWorldState);
+                                    if (committed) {
+                                        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();
+                                        projectedExecutionBudgetStage = undefined;
+                                        recordedEnvironment = refreshed.environmentState;
+                                        compactionUserMessages = [...refreshed.userMessages];
+                                        agentInstructionInsertIndex =
+                                            refreshed.currentTurnUserIndex ?? Math.max(0, messages.length - 1);
+                                        if (agentInstructionInsertIndex &&
+                                            messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
+                                            agentInstructionInsertIndex--;
+                                        currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                                        contextualWorldState = resetContextualWorldState(latestContextualWorldStateGeneration(committed.records), agentInstructionInsertIndex, {
+                                            instructionSnapshot: currentInstructionSnapshot,
+                                            instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined)),
+                                            resourceSnapshot: currentResourceSnapshot,
+                                            previousMayContainResources: compactHistoryMayContainRetainedResources(committed.records)
+                                        });
+                                        sessionRuntime.contextualWorldState = contextualWorldState;
+                                        await persistContextualWorldState(store, sessionId, contextualWorldState);
+                                    }
+                                }
+                            },
+                            mailbox: {
+                                hasPending: () => inputs.hasBoundaryPending && !inputs.executing && mode !== 'compact',
+                                append: appendMailboxMessages,
+                                close: () => {
+                                    acceptsMailbox = false;
                                 }
                             }
-                        },
-                        mailbox: {
-                            hasPending: () => mailbox.length > 0,
-                            append: appendMailboxMessages,
-                            close: () => {
-                                acceptsMailbox = false;
-                            }
+                        });
+                        const completed = await executionLoop.run();
+                        finalAnswer = completed.finalAnswer;
+                        const compactSummary = mode === 'compact' ? finalAnswer.trim() : '';
+                        if (manualCompaction) {
+                            manualCompaction.signal.throwIfAborted();
+                            await manualCompaction.dispose();
                         }
-                    });
-                    const completed = await executionLoop.run();
-                    finalAnswer = completed.finalAnswer;
-                    const compactSummary = mode === 'compact' ? finalAnswer.trim() : '';
-                    if (manualCompaction) {
-                        manualCompaction.signal.throwIfAborted();
-                        await manualCompaction.dispose();
-                    }
+                        if (mode === 'compact')
+                            await writeCompactionRecord(compactSummary, false, compactSignal, async (actual, options) => {
+                                const retainedModelContext = pendingAppends
+                                    .slice(manualAppendBoundary)
+                                    .map((entry) => entry.message);
+                                const replacementHistory = buildCompactedHistory(actual, compactionUserMessages, compactUserTokenLimit);
+                                const record = await store.compact(sessionId, {
+                                    summary: actual,
+                                    retainedModelContext,
+                                    replacementHistory,
+                                    modelId: selectedModel.id,
+                                    contextWindowTokens: selectedModel.contextWindowTokens,
+                                    ...(completed.usage === undefined ? {} : { usage: completed.usage }),
+                                    executionId,
+                                    turnId
+                                }, options);
+                                messages.splice(0, messages.length, ...compactedHistoryMessages(replacementHistory), ...retainedModelContext);
+                                pendingAppends.length = 0;
+                                return record;
+                            });
+                        if (mode === 'compact' && manualCompactionId !== undefined)
+                            await emit({ type: 'context.compacted', compactionId: manualCompactionId });
+                    };
                     if (mode === 'compact')
-                        await store.compact(sessionId, {
-                            summary: compactSummary,
-                            replacementHistory: buildCompactedHistory(compactSummary, compactionUserMessages, compactUserTokenLimit),
-                            modelId: selectedModel.id,
-                            contextWindowTokens: selectedModel.contextWindowTokens,
-                            ...(completed.usage === undefined ? {} : { usage: completed.usage }),
-                            executionId,
-                            turnId
+                        await performCompact({ focus: input.prompt }, async (effective, call) => {
+                            await runPreparedExecution(effective.focus ?? DEFAULT_COMPACTION_FOCUS, call.signal);
+                            return { changed: true, executionId };
                         });
-                    if (mode === 'compact' && manualCompactionId !== undefined)
-                        await emit({ type: 'context.compacted', compactionId: manualCompactionId });
+                    else
+                        await runPreparedExecution();
                     subagents?.endParentExecution(executionId);
                     await emit({ type: 'execution.completed' });
                     return {
@@ -1036,7 +1455,17 @@ export function createSessionOpener(services) {
                     };
                 }
                 finally {
+                    if (sessionRuntime.requestMessages?.executionId === executionId)
+                        delete sessionRuntime.requestMessages;
+                    if (sessionRuntime.appendedMessages?.executionId === executionId)
+                        delete sessionRuntime.appendedMessages;
+                    if (promptDefaults?.executionId === executionId)
+                        promptDefaults = undefined;
                     acceptsMailbox = false;
+                    executionToolSources?.close();
+                    if (sessionRuntime.toolSources === executionToolSources)
+                        delete sessionRuntime.toolSources;
+                    internal.signal?.removeEventListener('abort', abortSource);
                     if (ownsRolloutBudget)
                         rolloutBudget.discard();
                     await manualCompaction?.dispose();
@@ -1054,12 +1483,19 @@ export function createSessionOpener(services) {
                     subagents?.endParentExecution(executionId);
                     await releaseSession?.();
                     active.delete(`${sessionId}:${executionId}`);
+                    sessionRuntime.sessionBackend?.kick();
                     queue.close();
                 }
             })();
             const executionKey = `${sessionId}:${executionId}`;
             executionResults.set(executionKey, result);
-            void result.then(() => executionResults.delete(executionKey), () => executionResults.delete(executionKey));
+            void result.then((outcome) => {
+                inputs.settleExecution(executionId, outcome.status);
+                executionResults.delete(executionKey);
+            }, () => {
+                inputs.settleExecution(executionId, 'failed');
+                executionResults.delete(executionKey);
+            });
             return {
                 executionId,
                 turnId,
@@ -1072,11 +1508,251 @@ export function createSessionOpener(services) {
                 enqueueMessage: (message, delivery) => {
                     if (!acceptsMailbox || controller.signal.aborted)
                         return false;
-                    mailbox.push({ text: message, ...(delivery ? { delivery } : {}) });
+                    acceptParent({ text: message, ...(delivery ? { delivery } : {}) });
                     return true;
                 }
             };
         };
+        sessionRuntime.sessionBackend ??= createExtensionSessionBackend({
+            describe: async (call) => {
+                call.signal.throwIfAborted();
+                const current = await store.getSession(sessionId);
+                const records = await store.read(sessionId);
+                call.signal.throwIfAborted();
+                const state = promptDefaults ?? services.modelState();
+                const modelId = promptDefaults?.modelId ?? services.modelState().defaultModelId;
+                const model = state.models.get(modelId);
+                if (!model)
+                    throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
+                const userTurns = records.filter((record) => {
+                    if (record.type !== 'turn.user')
+                        return false;
+                    const payload = record.payload;
+                    return payload.inputSource === undefined;
+                }).length;
+                return {
+                    sessionId,
+                    ...(logicalWorkspace ? { cwd: logicalWorkspace, root: logicalWorkspace } : {}),
+                    modelId,
+                    modelName: model.name,
+                    startedAt: Date.parse(current.createdAt),
+                    source: structuredClone(sessionSource),
+                    userTurns
+                };
+            },
+            composePrompt: async (facts, call) => {
+                call.signal.throwIfAborted();
+                const defaults = promptDefaults;
+                const state = defaults ?? services.modelState();
+                const modelId = facts.modelId ?? defaults?.modelId ?? services.modelState().defaultModelId;
+                const model = state.models.get(modelId);
+                if (!model)
+                    throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
+                const mode = facts.mode ?? defaults?.mode ?? 'run';
+                const bindings = services.extensions.session(sessionId)?.capture(call);
+                if (!bindings)
+                    throw new MarAgentError('MAR_AGENT_EXTENSION_PROMPT_UNAVAILABLE', 'Session prompt tool sources are unavailable.');
+                const definitions = [...bindings.values()]
+                    .filter((binding) => binding.available?.(call) !== false)
+                    .map((binding) => binding.definition)
+                    .filter((tool) => !(sessionSource.type === 'subagent' &&
+                    (tool.agentScope === 'ROOT_ONLY' ||
+                        tool.name.startsWith('agent_') ||
+                        tool.name === 'question')) &&
+                    !(tool.name === 'question' && mode !== 'plan') &&
+                    !(tool.name === 'view_image' && !model.inputCapabilities.includes('IMAGE')) &&
+                    !(['code_exec', 'code_exec_wait'].includes(tool.name) &&
+                        (!model.codeMode || !description.capabilities.includes('code.execute'))));
+                const byName = new Map(definitions.map((tool) => [tool.name, tool]));
+                const tools = facts.tools === undefined
+                    ? definitions
+                    : facts.tools.flatMap((name) => {
+                        const tool = byName.get(name);
+                        return tool ? [tool] : [];
+                    });
+                const executionId = call.executionId ?? defaults?.executionId;
+                if (executionId === undefined && host.listExecutionExtensions && !host.listSessionSkills)
+                    throw new MarAgentError('MAR_AGENT_EXTENSION_PROMPT_UNAVAILABLE', 'The Host does not provide an idle Session Skill catalog.');
+                const hostSkills = executionId !== undefined
+                    ? ((await host.listExecutionExtensions?.({ sessionId, modelId, executionId }))
+                        ?.skills ?? [])
+                    : ((await host.listSessionSkills?.({ sessionId, modelId })) ?? []);
+                call.signal.throwIfAborted();
+                const instructions = await loadAgentInstructions({
+                    home: description.homeDirectory,
+                    workspace: instructionWorkspace,
+                    availableTools: new Set(tools.map((tool) => tool.name)),
+                    hostSkills,
+                    ...(settings.workspaceMapping === undefined
+                        ? {}
+                        : { workspaceDisplayPath: logicalWorkspace })
+                });
+                call.signal.throwIfAborted();
+                return {
+                    sections: buildSessionPromptSections(tools, mode, model, defaults?.instruction ?? settings.systemInstruction, instructions?.skillCatalog),
+                    facts: { modelId, mode, tools: tools.map((tool) => tool.name) }
+                };
+            },
+            captureRequest: async (call, input) => {
+                call.signal.throwIfAborted();
+                return sessionRuntime.requestSnapshots?.capture(input);
+            },
+            sessionId,
+            coordinator: sessionInputs,
+            activeExecutionId: () => [...active.keys()]
+                .find((key) => key.startsWith(`${sessionId}:`))
+                ?.slice(sessionId.length + 1),
+            append: appendExtensionMessage,
+            messages: async (input, call) => {
+                const selection = normalizeSessionMessagesInput(input);
+                call.signal.throwIfAborted();
+                let target = sessionId;
+                let targetModelId;
+                if (selection.agentId !== undefined) {
+                    if (!sessionRuntime.agentsBackend)
+                        throw new MarAgentError('MAR_AGENT_SESSION_INPUT_UNAVAILABLE', 'Session child message access is unavailable.');
+                    const child = await sessionRuntime.agentsBackend.inspect({ agentId: selection.agentId }, call);
+                    target = child.agentId;
+                    targetModelId = child.modelId;
+                }
+                call.signal.throwIfAborted();
+                const targetRuntime = sessionRuntimes.get(target);
+                if (selection.view === 'request' && targetRuntime?.requestMessages)
+                    return sessionMessagesPage(targetRuntime.requestMessages.read(), selection);
+                const modelState = services.modelState();
+                const requestModel = selection.view === 'request'
+                    ? modelState.models.get(targetModelId ?? modelState.defaultModelId)
+                    : undefined;
+                if (selection.view === 'request' && !requestModel)
+                    throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
+                const includeImages = selection.includeImages &&
+                    (requestModel === undefined || requestModel.inputCapabilities.includes('IMAGE'));
+                const state = await store.readExecutionState(target);
+                call.signal.throwIfAborted();
+                const restored = await restoreMessages(store, target, state.contextRecords, {
+                    includeImages,
+                    strictImages: includeImages
+                });
+                call.signal.throwIfAborted();
+                if (requestModel) {
+                    const generation = latestContextualWorldStateGeneration(state.contextRecords);
+                    const cachedWorld = targetRuntime?.contextualWorldState;
+                    const world = cachedWorld?.generation === generation
+                        ? cachedWorld
+                        : parsePersistedContextualWorldState(await store.readContextualWorldState(target));
+                    call.signal.throwIfAborted();
+                    return sessionMessagesPage(projectSessionRequestMessages(restored.messages, world?.generation === generation ? (world?.entries ?? []) : [], requestModel.inputCapabilities.includes('IMAGE'), requestModel.codeMode), selection);
+                }
+                return sessionMessagesPage(restored.messages, selection, restored.toolOutcomes);
+            },
+            launch: async (entry, request, call) => {
+                if (sessionSource.type !== 'user')
+                    throw new MarAgentError('MAR_AGENT_SESSION_INPUT_UNAVAILABLE', 'Idle subagent input must use its task controller.');
+                let resolveInput;
+                let rejectInput;
+                const inputCommitted = new Promise((resolve, reject) => {
+                    resolveInput = resolve;
+                    rejectInput = reject;
+                });
+                void inputCommitted.catch(() => undefined);
+                const handle = execution(request.kind === 'compact' ? 'compact' : 'run', {
+                    prompt: request.kind === 'compact'
+                        ? (request.input.focus ?? DEFAULT_COMPACTION_FOCUS)
+                        : request.input.text,
+                    ...(request.kind === 'submit' && request.input.images !== undefined
+                        ? { images: request.input.images }
+                        : {})
+                }, {
+                    automaticInput: true,
+                    inputCommitted: (recordId) => {
+                        const outcome = { changed: true, recordId, executionId: handle.executionId };
+                        recordSessionInputCommit(entry, outcome);
+                        resolveInput(outcome);
+                    },
+                    ...(request.kind === 'submit' ? { promptAdmitted: true } : {}),
+                    ...(call.actor === 'sdk' && call.extensionId === undefined
+                        ? {}
+                        : { inputSource: 'extension' }),
+                    ...(request.kind === 'submit' && request.input.modelText !== undefined
+                        ? { modelText: request.input.modelText }
+                        : {}),
+                    ...(request.kind === 'submit' && request.input.context !== undefined
+                        ? { inputContext: request.input.context }
+                        : {}),
+                    ...(request.kind === 'submit' && request.input.modelContext !== undefined
+                        ? { modelContext: request.input.modelContext }
+                        : {}),
+                    ...(call.actor === 'sdk' && call.extensionId === undefined
+                        ? {}
+                        : {
+                            extensionSource: extensionInputSource(call, request.kind === 'submit' ? request.input.provenance : undefined, request.kind === 'submit' ? request.input.modelAttribution : undefined)
+                        })
+                });
+                void handle.result().then((result) => {
+                    if (request.kind === 'compact')
+                        resolveInput({
+                            changed: result.status === 'completed',
+                            executionId: handle.executionId
+                        });
+                    else
+                        rejectInput(new MarAgentError(result.errorCode ??
+                            (result.status === 'cancelled'
+                                ? 'MAR_AGENT_EXECUTION_CANCELLED'
+                                : 'MAR_AGENT_SESSION_INPUT_FAILED'), 'Execution ended before its input record was committed.'));
+                }, rejectInput);
+                return Object.assign(handle, { inputCommitted });
+            },
+            diagnose: (code, operationId) => services.extensions.session(sessionId)?.diagnose({ code, operationId, sessionId })
+        });
+        if (sessionSource.type === 'user')
+            sessionRuntime.agentsBackend ??= createExtensionAgentsBackend({
+                existingController: () => sessionRuntime.subagents,
+                controller: async () => {
+                    services.assertCanStart();
+                    if (sessionRuntime.subagents === undefined)
+                        await openSession(sessionId);
+                    if (!sessionRuntime.subagents)
+                        throw new MarAgentError('MAR_AGENT_SUBAGENT_FAILED', 'Session task controller is unavailable.');
+                    return sessionRuntime.subagents;
+                },
+                parent: (controller, call) => {
+                    const current = call.executionId === undefined
+                        ? undefined
+                        : controller.parentExecution(call.executionId);
+                    if (call.executionId !== undefined && !current)
+                        throw new MarAgentError('MAR_AGENT_SUBAGENT_FAILED', 'Parent Execution source is unavailable.');
+                    const state = services.modelState();
+                    const selected = state.models.get(state.defaultModelId);
+                    return {
+                        ...(current ?? {
+                            modelId: selected.id,
+                            reasoningEffort: selected.defaultReasoningEffort,
+                            models: state.models,
+                            emitTerminal: async () => { },
+                            startTurn: async (turn) => {
+                                const child = await openSession(turn.sessionId);
+                                return child.startSubagentTurn({
+                                    prompt: turn.prompt,
+                                    modelId: turn.modelId,
+                                    reasoningEffort: turn.reasoningEffort,
+                                    role: turn.role,
+                                    initialMailbox: turn.initialMailbox,
+                                    turnId: turn.turnId,
+                                    ...(turn.origin === undefined ? {} : { origin: turn.origin }),
+                                    ...(turn.delivery === undefined ? {} : { delivery: turn.delivery })
+                                });
+                            }
+                        }),
+                        operationId: call.operationId,
+                        origin: call,
+                        signal: call.signal,
+                        ...(call.ownerInstanceId === undefined
+                            ? {}
+                            : { ownerInstanceId: call.ownerInstanceId }),
+                        ...(call.extensionId === undefined ? {} : { extensionId: call.extensionId })
+                    };
+                }
+            });
         return {
             id: sessionId,
             run: (input) => execution('run', input),
@@ -1092,10 +1768,16 @@ export function createSessionOpener(services) {
                 reasoningEffort: turn.reasoningEffort
             }, {
                 publishHostEvents: false,
-                inputSource: 'parent_agent',
+                ...(turn.origin === undefined ? {} : { signal: turn.origin.signal }),
+                inputSource: turn.origin === undefined ? 'parent_agent' : 'extension',
+                ...(turn.origin === undefined
+                    ? {}
+                    : { extensionSource: extensionInputSource(turn.origin) }),
                 initialMailbox: turn.initialMailbox,
                 turnId: turn.turnId,
-                mcpExecutionScopeId: turn.mcpExecutionScopeId,
+                ...(turn.mcpExecutionScopeId === undefined
+                    ? {}
+                    : { mcpExecutionScopeId: turn.mcpExecutionScopeId }),
                 ...(turn.delivery ? { delivery: turn.delivery } : {}),
                 ...(turn.sharedRolloutBudget === undefined
                     ? {}
@@ -1105,6 +1787,16 @@ export function createSessionOpener(services) {
     };
     return openSession;
 }
+function extensionInputSource(call, provenance, modelAttribution) {
+    return {
+        operationId: call.operationId,
+        actor: call.actor,
+        ...(call.extensionId ? { extensionId: call.extensionId } : {}),
+        ...(call.ownerInstanceId ? { ownerInstanceId: call.ownerInstanceId } : {}),
+        ...(provenance !== undefined ? { provenance } : {}),
+        ...(modelAttribution === undefined ? {} : { modelAttribution })
+    };
+}
 function modelAttemptFailureDiagnostic(diagnostic, summary) {
     if (summary === undefined)
         return diagnostic;
@@ -1115,3 +1807,20 @@ function modelAttemptFailureDiagnostic(diagnostic, summary) {
         message: `${prefix}${[...diagnostic.message].slice(0, availableCharacters).join('')}`
     };
 }
+/** Shared, side-effect-free projection for the real request and current Session request view. */
+function projectSessionRequestMessages(messages, entries, supportsImages, codeMode) {
+    return normalizeMessagesForModel(insertContextualWorldState(messages, entries), {
+        supportsImages
+    }).map((message) => projectCodeModeSearchResult(message, codeMode));
+}
+function projectAppendedModelMessage(input) {
+    if (input.visibility === 'transcript')
+        return undefined;
+    return {
+        role: 'user',
+        content: input.content,
+        ...(input.textBlocks === undefined
+            ? {}
+            : { textBlocks: input.textBlocks.map((block) => ({ text: block.text })) })
+    };
+}