@myagentroam/agent 0.11.33 → 0.11.35

package/dist/sdk/session-execution-factory.js

@@ -0,0 +1,937 @@
+import { restoreMessages } from '../runtime/context/restore.js';
+import { latestModelUsage, reasoningEffortBaseline } from '../runtime/context/usage.js';
+import { publicModelUsage } from '../runtime/event-projection.js';
+import { executeRoundTools } from '../tools/execution.js';
+import { rebindMcpToolSearchOutputs } from '../tools/mcp/history.js';
+import { ExecutionToolPermissions, projectPermissionTool, resolvePermissionMode, withToolPermissions } from '../tools/permissions.js';
+import { createToolWaitInterrupt } from '../tools/wait.js';
+import { createExecutionCompactExtension } from './execution-compact-extension.js';
+import { generateExecutionCompaction } from './execution-compact-generation.js';
+import { createExecutionCompactionFlight } from './execution-compaction-flight.js';
+import { createExecutionCompaction } from './execution-compaction.js';
+import { ExecutionContextCoordinator } from './execution-context-coordinator.js';
+import { createExecutionInput } from './execution-input.js';
+import { createExecutionModelContext } from './execution-model-context.js';
+import { ExecutionModelLifecycle } from './execution-model-lifecycle.js';
+import { createExecutionModelRequest } from './execution-model-request.js';
+import { createExecutionRoundPreparer } from './execution-round-preparation.js';
+import { prepareExecutionRoundRequest } from './execution-round-request.js';
+import { ExecutionToolCatalog, initializeExecutionToolCatalog } from './execution-tool-catalog.js';
+import { createExecutionToolScope } from './execution-tool-scope.js';
+import { createNativeSteer } from './native-steer.js';
+import { projectSessionRequestMessages } from './request-preparation.js';
+import { ResourceInputProjection } from './resource-input.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { AgentError, describeAgentError } from '../error.js';
+import { transformCoreModelStream } from '../extensions/model-stream.js';
+import { invokeCorePromptSubmission } from '../extensions/prompt-input.js';
+import { prepareModelConfiguration } from '../model/request-configuration.js';
+import { MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
+import { autoPermissionPrompt } from '../prompts/permissions.js';
+import { renderPromptSections } from '../prompts/prompt-sections.js';
+import { retainedSessionResourcesSnapshot } from '../prompts/resources.js';
+import { CompactionOperation } from '../runtime/compaction/operation.js';
+import { latestSmartContextTokens } from '../runtime/compaction/smart.js';
+import { currentLocalTimeContext } from '../runtime/context/environment.js';
+import { ContextGcRuntime } from '../runtime/context/gc-runtime.js';
+import { loadAgentInstructions, renderAgentInstructions } from '../runtime/context/instructions.js';
+import { normalizeMessagesForModel } from '../runtime/context/normalize.js';
+import { compactSummaryFromCheckpoint } from '../session/record-projection.js';
+import { SessionExecution } from './session-execution.js';
+function restoreSubagentOrigin(origin) {
+    return { ...origin.correlation, signal: origin.signal };
+}
+/** Composes the execution-owned workflow from Session capabilities. */
+export function createSessionExecutionFactory(ports) {
+    const { assertCanStart, extensions: extensionManager, baseTools: extensionBaseTools, hasCustomAdapters, modelState, host, store, description, settings, sessionWriterOwner, activeExecutionAdapters, sessionId, sessionRuntime, sessionSource, logicalWorkspace, instructionWorkspace, currentEnvironment, buildSessionPromptSections, sessionAdapter, refreshSessionAdapters, sessionInputs, withRecordProjection, appendExtensionMessage, startSubagentTurn } = ports;
+    const execution = (mode, input, internal = {}) => {
+        assertCanStart(sessionId);
+        sessionRuntime.assertCanExecute();
+        const { models: executionModels, defaultModelId: executionDefaultModelId, generation: executionModelGeneration } = modelState();
+        if (mode !== 'compact' &&
+            executionModels.get(input.modelId ?? executionDefaultModelId)?.conversationModel === false)
+            throw new AgentError('MAR_AGENT_MODEL_DISABLED', 'The selected model is not a conversation model.');
+        const executionId = randomUUID(), turnId = internal.turnId ?? randomUUID(), executionOwner = new SessionExecution(sessionId, executionId, turnId, mode, sessionSource.type, {
+            modelId: input.modelId ?? executionDefaultModelId,
+            mode: mode === 'compact' ? 'run' : mode,
+            models: executionModels,
+            generation: executionModelGeneration,
+            instruction: settings.systemInstruction
+        }, activeExecutionAdapters), controller = executionOwner.controller;
+        const compactCoordinator = executionOwner.compact;
+        const messageSources = new WeakMap();
+        let liveModelMessages = [];
+        const compactRequests = executionOwner.compactRequests;
+        const permissionPolicy = new ExecutionToolPermissions(mode === 'compact' ? 'full-access' : resolvePermissionMode(input.permissionMode), { sessionId, executionId }, host.requestToolApproval
+            ? {
+                request: (request, signal) => host.requestToolApproval(request, signal),
+                signal: controller.signal
+            }
+            : undefined);
+        const projectTools = (tools) => permissionPolicy.mode === 'auto' ? tools.map(projectPermissionTool) : tools;
+        const abortSource = () => executionOwner.cancel(internal.signal?.reason);
+        internal.signal?.addEventListener('abort', abortSource, { once: true });
+        if (internal.signal?.aborted)
+            abortSource();
+        let executionEnvironment = {
+            ...currentEnvironment,
+            ...currentLocalTimeContext()
+        };
+        const executionSystemInstruction = executionOwner.snapshot.instruction;
+        const executionContext = executionOwner.context;
+        sessionRuntime.bindExecutionContext(executionContext);
+        const manualCompactionId = mode === 'compact' ? randomUUID() : undefined;
+        sessionRuntime.registerExecution(executionOwner);
+        const inputs = sessionInputs();
+        const acceptParent = (message) => {
+            const origin = message.delivery?.origin === undefined
+                ? undefined
+                : restoreSubagentOrigin(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: extensionManager.session(sessionId)?.epoch ?? 0,
+                    signal,
+                    executionId,
+                    turnId
+                }));
+                return;
+            }
+            extensionManager.operations.enter({
+                sessionId,
+                sessionEpoch: extensionManager.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 acceptsSteer = false;
+        let exhaustedModelAttempt;
+        const eventPorts = {
+            hasRetainedLease: () => store.hasRetainedSessionLease(sessionId, sessionWriterOwner),
+            persist: async (full, persistent) => {
+                const stored = await store.append(sessionId, {
+                    type: full.type,
+                    payload: persistent,
+                    executionId,
+                    turnId
+                });
+                if (full.type === 'message.completed') {
+                    const message = liveModelMessages.findLast((item) => item.role === 'assistant' && item.content === full.text);
+                    if (message)
+                        messageSources.set(message, stored);
+                }
+            },
+            ...(internal.publishHostEvents === false
+                ? {}
+                : { publish: (full) => host.emit(full) })
+        };
+        const emit = (event, assertLive) => executionOwner.emit(event, eventPorts, assertLive);
+        const recordModelAttempt = (purpose) => (diagnostic) => {
+            if (purpose === 'EXECUTION' || purpose === 'COMPACTION') {
+                if ((diagnostic.state === 'STARTED' && diagnostic.attempt === 1) ||
+                    diagnostic.state === 'SUCCEEDED')
+                    exhaustedModelAttempt = undefined;
+                else if (diagnostic.state === 'FAILED' &&
+                    diagnostic.willRetry === false &&
+                    diagnostic.attempt > 1)
+                    exhaustedModelAttempt = {
+                        attempts: diagnostic.attempt,
+                        retries: diagnostic.attempt - 1
+                    };
+            }
+            const operation = executionOwner.orderEvent(async () => {
+                await store.append(sessionId, {
+                    type: 'model.attempt',
+                    payload: { purpose, ...diagnostic },
+                    executionId,
+                    turnId
+                });
+            });
+            return operation;
+        };
+        const createCompactionOperation = (compactionId, signal = controller.signal) => new CompactionOperation(signal, (progress) => {
+            const operation = executionOwner.orderEvent(async () => {
+                await store.append(sessionId, {
+                    type: 'compact.progress',
+                    payload: { compactionId, ...progress },
+                    executionId,
+                    turnId
+                });
+            });
+            return operation;
+        });
+        let finalAnswer = '';
+        let executionToolSources;
+        let releaseImageBytes;
+        const contextGc = new ContextGcRuntime();
+        let selectedAdapter;
+        const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
+        executionOwner.start({
+            scope: (run) => withToolPermissions(permissionPolicy, run),
+            prepareProgram: async () => {
+                await executionOwner.prepare({
+                    acquireLease: () => store.acquireSessionLease(sessionId, sessionWriterOwner),
+                    waitForInputs: () => (inputs.executing ? Promise.resolve() : inputs.idle()),
+                    bindCommittedInputs: () => {
+                        executionOwner.bindViews({
+                            appendedMessages: {
+                                append(recordId, message) {
+                                    executionOwner.appendCommittedMessage(recordId, message);
+                                }
+                            }
+                        });
+                    },
+                    refreshAdapters: () => refreshSessionAdapters(executionModelGeneration)
+                });
+                const { todo, contextRecords, generation: contextualWorldStateGeneration, world: initialContextualWorldState } = await sessionRuntime.restoreExecutionState(store, sessionWriterOwner);
+                const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
+                const restored = await restoreMessages(store, sessionId, contextRecords, {
+                    messageSources,
+                    includeImages: mode !== 'compact'
+                });
+                let modelLifecycle;
+                let applyCompactBoundary = () => { };
+                const modelContext = createExecutionModelContext({
+                    restored,
+                    initialContextualWorldState,
+                    store,
+                    sessionId,
+                    executionId,
+                    turnId,
+                    mode,
+                    contextRecords,
+                    contextualWorldStateGeneration,
+                    compactMayContainAgentInstructions,
+                    messageSources,
+                    updateWorldState: (state) => sessionRuntime.updateContextualWorldState(state),
+                    environment: () => executionEnvironment,
+                    instructionSnapshot: () => currentInstructionSnapshot,
+                    renderInstructions: (previous) => renderAgentInstructions(instructionEntries, previous),
+                    retainedResourceSnapshot: async () => retainedSessionResourcesSnapshot(await loadRetainedSessionResources()),
+                    mcpNavigation: () => mcpRegistry.navigation(),
+                    reportSidecarFailure: () => coreExtensions.diagnose({
+                        code: 'MAR_AGENT_COMPACT_SIDECAR_PERSIST_FAILED',
+                        sessionId
+                    }),
+                    resetGc: () => contextGc.reset(),
+                    restoreMcp: () => restoreMcpDiscovery(),
+                    resetContinuation: () => selected.resetContinuation?.(),
+                    resetSmartContext: () => {
+                        modelLifecycle.resetSmart();
+                    },
+                    replaceResources: (items) => resourceInput.replace(items),
+                    adoptGcResources: (state) => resourceInput.adoptGc(state),
+                    clearAppendedMessages: () => executionOwner.clearAppendedMessages(),
+                    appendedAfter: (boundary, ids) => executionOwner.appendedAfter(boundary, ids)
+                });
+                const messages = modelContext.messages;
+                const pendingInputs = restored.pendingInputs;
+                const waitInterrupt = createToolWaitInterrupt(() => pendingInputs.size > 0);
+                liveModelMessages = messages;
+                const restoredRecordIds = new Set(contextRecords.map((record) => record.recordId));
+                executionOwner.connectMessageProjection(messages, restoredRecordIds);
+                let smartInput;
+                let compactContext;
+                let startCompact;
+                const { startInitialInput, receiveSteer, appendSubagentUpdates, appendMailboxMessages } = createExecutionInput({
+                    host,
+                    store,
+                    sessionId,
+                    executionId,
+                    turnId,
+                    mode,
+                    source: sessionSource.type,
+                    controller,
+                    inputs,
+                    messages,
+                    pendingInputs,
+                    messageSources,
+                    modelContext,
+                    model: () => selectedModel,
+                    tokens: () => modelLifecycle.smartContextTokens,
+                    setSmartInput: (value) => {
+                        smartInput = value;
+                    },
+                    withRecordProjection,
+                    appendExtensionMessage,
+                    startCompact: () => startCompact,
+                    compactContext: () => compactContext
+                });
+                const hasRestoredUserImages = messages.some((message) => message.role === 'user' && Boolean(message.images?.length));
+                let modelInputImages;
+                const inputImageBytes = new Map();
+                const currentExecutionToolImages = [];
+                let currentExecutionUserIndex;
+                await emit({
+                    type: 'execution.started',
+                    mode,
+                    permissionMode: permissionPolicy.mode
+                });
+                if (restored.ignoredImages > 0)
+                    await store.append(sessionId, {
+                        type: 'context.warning',
+                        payload: {
+                            code: 'MAR_AGENT_INPUT_IMAGE_IGNORED',
+                            message: 'One or more corrupt historical input images were ignored.',
+                            ignoredImages: restored.ignoredImages
+                        },
+                        executionId,
+                        turnId
+                    });
+                selectedAdapter = sessionAdapter(input.modelId ?? executionDefaultModelId, executionModels);
+                const selectedModel = executionModels.get(input.modelId ?? executionDefaultModelId);
+                const restoredMessageCount = messages.length;
+                const resourceInput = new ResourceInputProjection(selectedModel.useResourceUrl === true, store, sessionId, messages, {
+                    records: contextRecords,
+                    persist: async (state) => {
+                        await withRecordProjection(() => store.append(sessionId, {
+                            type: 'resource.window',
+                            payload: state,
+                            executionId,
+                            turnId
+                        }));
+                    }
+                });
+                releaseImageBytes = () => resourceInput.releaseBytes();
+                const selected = executionOwner.openMainTurn(selectedAdapter, hasCustomAdapters && selectedAdapter.createTurnSession === undefined);
+                const initialUsage = latestModelUsage(contextRecords, selectedModel.id);
+                const initialSmartTokens = latestSmartContextTokens(contextRecords, selectedModel.id, selectedModel.contextWindowTokens);
+                const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
+                const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
+                if (mode !== 'compact' && subagents)
+                    await subagents.beginParentExecution({
+                        executionId,
+                        modelId: selectedModel.id,
+                        reasoningEffort,
+                        models: executionModels,
+                        emitTerminal: async (task) => emit({
+                            type: 'subagent.completed',
+                            agentId: task.agentId,
+                            description: task.description,
+                            status: task.status,
+                            ...(task.permissionStop === undefined
+                                ? {}
+                                : { permissionStop: task.permissionStop }),
+                            ...(task.modelId === undefined ? {} : { modelId: task.modelId }),
+                            ...(task.modelName === undefined ? {} : { modelName: task.modelName }),
+                            ...(task.reasoningEffort === undefined
+                                ? {}
+                                : { reasoningEffort: task.reasoningEffort }),
+                            ...(task.latestMessage === undefined ? {} : { latestMessage: task.latestMessage }),
+                            ...(task.latestActivity === undefined
+                                ? {}
+                                : { latestActivity: task.latestActivity }),
+                            ...(task.errorCode === undefined ? {} : { errorCode: task.errorCode }),
+                            ...(task.errorMessage === undefined ? {} : { errorMessage: task.errorMessage })
+                        }),
+                        startTurn: async (turn) => {
+                            return startSubagentTurn(turn.sessionId, {
+                                permissionMode: permissionPolicy.mode,
+                                prompt: turn.prompt,
+                                modelId: turn.modelId,
+                                reasoningEffort: turn.reasoningEffort,
+                                role: turn.role,
+                                initialMailbox: turn.initialMailbox,
+                                turnId: turn.turnId,
+                                ...(turn.origin === undefined
+                                    ? {}
+                                    : { origin: restoreSubagentOrigin(turn.origin) }),
+                                mcpExecutionScopeId: executionId,
+                                ...(turn.delivery ? { delivery: turn.delivery } : {})
+                            });
+                        }
+                    });
+                const catalogContext = {
+                    sessionId,
+                    executionId,
+                    modelId: selectedModel.id,
+                    ...(sessionSource.type === 'subagent'
+                        ? internal.mcpExecutionScopeId === undefined
+                            ? {}
+                            : { executionScopeId: internal.mcpExecutionScopeId }
+                        : { claimExecutionScope: true })
+                };
+                const { catalog: mcpCatalog, registry: mcpRegistry, extensions, supplemental: supplementalBindings, sources } = await initializeExecutionToolCatalog({
+                    host,
+                    context: catalogContext,
+                    models: executionModels,
+                    messages,
+                    supplemental: (names) => extensionBaseTools?.(sessionId, { executionId })?.filter((binding) => !names.has(binding.definition.name)) ?? []
+                });
+                executionToolSources = sources;
+                const sourceBindings = sources.bindings;
+                const selectedModelForTools = executionModels.get(input.modelId ?? executionDefaultModelId);
+                const coreExtensions = await extensionManager.prepare(sessionId, controller.signal, sourceBindings, sessionSource.type === 'user' && !internal.automaticInput);
+                executionOwner.bindViews({ toolSources: sources });
+                const operation = (run) => extensionManager.operations.run({
+                    sessionId,
+                    sessionEpoch: coreExtensions.epoch,
+                    executionId,
+                    turnId,
+                    actor: 'sdk',
+                    entry: 'native-api',
+                    signal: controller.signal
+                }, run);
+                if (mode !== 'compact') {
+                    // Missing entries prepend in reverse order; warm entries retain their FIFO position.
+                    for (const record of [...pendingInputs.values()].reverse()) {
+                        operation((call) => inputs.restoreSteer(record.recordId, record.payload.prompt, call));
+                    }
+                }
+                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
+                }));
+                modelLifecycle = new ExecutionModelLifecycle({
+                    modelId: selectedModel.id,
+                    contextWindowTokens: selectedModel.contextWindowTokens,
+                    signal: controller.signal,
+                    messages,
+                    turn: selected,
+                    runtime: sessionRuntime,
+                    resources: resourceInput,
+                    stream: streamModel,
+                    compactPending: () => compactCoordinator.pending,
+                    startCompact: () => {
+                        startCompact({ async: true });
+                    },
+                    updateBoundary: (value) => applyCompactBoundary(value),
+                    initialUsage,
+                    initialSmartTokens
+                });
+                const transformModelRequest = createExecutionModelRequest({
+                    sessionId,
+                    executionId,
+                    modelId: selectedModel.id,
+                    source: sessionSource.type,
+                    compact: mode === 'compact',
+                    autoPermission: permissionPolicy.mode === 'auto',
+                    turn: selected,
+                    hooks: coreExtensions.hooks,
+                    host,
+                    capture: captureTools,
+                    operation,
+                    usageFailed: () => coreExtensions.diagnose({ code: 'MAR_AGENT_MODEL_USAGE_FAILED', sessionId })
+                });
+                let instructionSkills;
+                const toolCatalog = new ExecutionToolCatalog({
+                    catalog: mcpCatalog,
+                    registry: mcpRegistry,
+                    messages,
+                    model: selectedModelForTools,
+                    child: sessionSource.type === 'subagent',
+                    mode,
+                    codeExecute: description.capabilities.includes('code.execute'),
+                    capture: captureTools,
+                    servers: () => coreExtensions.mcp.servers(),
+                    hasSkills: () => (instructionSkills?.size ?? 0) > 0
+                });
+                const updateMcpRegistry = () => toolCatalog.updateRegistry();
+                updateMcpRegistry();
+                rebindMcpToolSearchOutputs(messages, mcpRegistry);
+                const availableTools = toolCatalog.available();
+                const instructionContext = await loadAgentInstructions({
+                    home: description.homeDirectory,
+                    workspace: instructionWorkspace,
+                    availableTools: new Set(availableTools.map((tool) => tool.name)),
+                    hostSkills: extensions.skills ?? [],
+                    ...(settings.workspaceMapping === undefined
+                        ? {}
+                        : { workspaceDisplayPath: logicalWorkspace })
+                });
+                const instructionEntries = instructionContext?.entries ?? [];
+                const currentInstructionSnapshot = renderAgentInstructions(instructionEntries, false);
+                instructionSkills = instructionContext?.skills;
+                const baseTools = () => toolCatalog.base();
+                toolCatalog.refresh();
+                const restoreMcpDiscovery = () => toolCatalog.restore();
+                const loadRetainedSessionResources = async () => {
+                    await subagents?.prepareSessionResources(controller.signal);
+                    const hostResources = (await host.listSessionResources?.(sessionId)) ?? {
+                        processes: []
+                    };
+                    return {
+                        ...(hostResources.idleTtlMs === undefined
+                            ? {}
+                            : { idleTtlMs: hostResources.idleTtlMs }),
+                        processes: hostResources.processes,
+                        ...(hostResources.codeCells ? { codeCells: hostResources.codeCells } : {}),
+                        subagents: subagents?.listSessionResources() ?? []
+                    };
+                };
+                await modelContext.initializeWorldState();
+                const buildExecutionPromptSections = (availableTools = toolCatalog.tools, promptMode = mode) => buildSessionPromptSections(availableTools, promptMode, selectedModel, executionSystemInstruction, instructionContext?.skillCatalog);
+                const buildExecutionSystemPrompt = (availableTools = toolCatalog.tools, 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)
+                    }
+                });
+                if (mode !== 'compact')
+                    await modelContext.syncMcpWorldState();
+                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 AgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Compaction focus is invalid.');
+                    const outcome = await leaf(input, effective);
+                    commit(outcome);
+                    return outcome;
+                })));
+                const captureRoundToolScope = createExecutionToolScope({
+                    store,
+                    host,
+                    sessionId,
+                    executionId,
+                    turnId,
+                    mode,
+                    controller,
+                    sessionWriterOwner,
+                    selectedModel,
+                    permissionPolicy,
+                    todo,
+                    waitInterrupt,
+                    skills: instructionContext?.skills ?? new Map(),
+                    subagents,
+                    coreExtensions,
+                    operations: extensionManager.operations,
+                    scheduleTool: sessionRuntime.scheduleTool,
+                    sources,
+                    mcpRegistry,
+                    autoPermissionPrompt,
+                    currentExecutionToolImages,
+                    inputImageBytes,
+                    snapshotTools: () => projectTools(toolCatalog.tools),
+                    baseTools: () => projectTools(baseTools()),
+                    captureTools,
+                    promptComposition,
+                    smartInput: () => smartInput,
+                    modelInputImages: () => modelInputImages,
+                    startCompact: (input) => startCompact(input),
+                    preparedPrompt: () => preparedCompactPrompt,
+                    clearPreparedPrompt: () => {
+                        preparedCompactPrompt = undefined;
+                    },
+                    operation,
+                    emit
+                });
+                let preparedCompactPrompt;
+                sources.bind(captureRoundToolScope().toolScope);
+                let preparingRequestMessages;
+                let preparingRequestBaseLength = 0;
+                executionOwner.bindViews({
+                    requestMessages: {
+                        read: () => preparingRequestMessages !== undefined
+                            ? normalizeMessagesForModel([...preparingRequestMessages, ...messages.slice(preparingRequestBaseLength)], { supportsImages: selectedModel.inputCapabilities.includes('IMAGE') })
+                            : projectSessionRequestMessages(messages.map((message, index) => index === currentExecutionUserIndex && modelInputImages?.length
+                                ? { ...message, images: modelInputImages }
+                                : message), mode === 'compact' ? [] : modelContext.worldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), baseTools().some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto')
+                    }
+                });
+                if (mode !== 'compact') {
+                    const entered = await startInitialInput({
+                        input,
+                        internal,
+                        restoredImages: hasRestoredUserImages,
+                        operation,
+                        admit: (content, call, write) => invokeCorePromptSubmission(coreExtensions.hooks, content, call, write),
+                        enqueue: (content, call) => sessionRuntime.sessionBackend.enqueue({ kind: 'submit', input: { ...content, delivery: 'idle' } }, call, (request, effective, next) => next(request, effective)),
+                        project: (actual, metadata) => {
+                            modelInputImages = actual.images?.map((image) => ({ ...image }));
+                            messages.push({
+                                role: 'user',
+                                content: actual.modelText ?? actual.text,
+                                metadata,
+                                ...(modelInputImages?.length ? { images: modelInputImages } : {})
+                            });
+                            currentExecutionUserIndex = messages.length - 1;
+                        }
+                    });
+                    if (!entered)
+                        return { inputHandled: true };
+                    acceptsSteer = true;
+                    executionOwner.acceptSteer(createNativeSteer({
+                        executionId,
+                        inputs,
+                        signal: controller.signal,
+                        isOpen: () => acceptsSteer,
+                        operation,
+                        admit: (content, call, write) => invokeCorePromptSubmission(coreExtensions.hooks, content, call, write),
+                        receive: receiveSteer,
+                        notify: (entry) => emit({ type: 'input.received', entry }),
+                        wake: () => waitInterrupt.notify(),
+                        diagnose: () => coreExtensions.diagnose({
+                            code: 'MAR_AGENT_STEER_POST_COMMIT_FAILED',
+                            sessionId
+                        })
+                    }));
+                }
+                const modelConfiguration = prepareModelConfiguration(selectedModel, reasoningEffort, {
+                    baselineEffort: reasoningEffortBaseline(contextRecords, selectedModel.id),
+                    messages
+                });
+                let requestReasoningEffort = modelConfiguration.requestReasoningEffort;
+                if (mode !== 'compact')
+                    for (const update of modelConfiguration.updates) {
+                        messages.push(update);
+                        await store.append(sessionId, {
+                            type: 'model.context',
+                            payload: update,
+                            executionId,
+                            turnId
+                        });
+                    }
+                const runPreparedExecution = async (compactFocus = input.prompt, compactSignal = controller.signal) => {
+                    const initialSystemPrompt = mode === 'compact'
+                        ? buildExecutionSystemPrompt(toolCatalog.tools, 'run')
+                        : buildExecutionSystemPrompt();
+                    const generateCompactExtension = createExecutionCompactExtension({
+                        contextWindowTokens: selectedModel.contextWindowTokens,
+                        maxOutputTokens: selectedModel.maxOutputTokens,
+                        hasInterceptor: () => coreExtensions.hooks.hasInterceptors('compact.generate'),
+                        invoke: (context, signal) => operation((call) => coreExtensions.hooks.invoke('compact.generate', Object.freeze({ ...context, operationId: call.operationId }), Object.freeze({ ...call, signal }), async () => undefined)),
+                        ...(host.modelUsage === undefined
+                            ? {}
+                            : {
+                                reportUsage: (usage) => host.modelUsage({
+                                    ...usage,
+                                    sessionId,
+                                    executionId,
+                                    purpose: 'compact',
+                                    agentRole: sessionSource.type === 'subagent' ? 'subagent' : 'root'
+                                })
+                            })
+                    });
+                    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 contextCoordinator = new ExecutionContextCoordinator({
+                        initialBoundary: restoredMessageCount,
+                        messages,
+                        resources: resourceInput,
+                        execution: executionOwner,
+                        model: modelLifecycle,
+                        context: modelContext,
+                        compact: compactCoordinator,
+                        requests: compactRequests,
+                        signal: controller.signal,
+                        window: selectedModel.contextWindowTokens,
+                        gc: contextGc,
+                        gcBase: {
+                            store,
+                            sessionId,
+                            modelId: selectedModel.id,
+                            contextWindowTokens: selectedModel.contextWindowTokens,
+                            ...modelConfiguration.contextProjection,
+                            workspace: logicalWorkspace,
+                            platform: description.platform
+                        },
+                        child: sessionSource.type === 'subagent',
+                        start: (value) => startCompact(value),
+                        wait: (value) => compactContext(value),
+                        activeProcesses: async () => {
+                            const resources = await host.listSessionResources?.(sessionId).catch(() => undefined);
+                            return new Set((resources?.processes ?? [])
+                                .filter((process) => process.status === 'running')
+                                .map((process) => process.processId));
+                        }
+                    });
+                    applyCompactBoundary = (value) => contextCoordinator.setBoundary(value);
+                    const invalidateCompactUsage = () => {
+                        modelLifecycle.invalidate();
+                        requestReasoningEffort = prepareModelConfiguration(selectedModel, reasoningEffort, {
+                            checkpointAdopted: true
+                        }).requestReasoningEffort;
+                    };
+                    const compactLeaf = createExecutionCompaction({
+                        mode,
+                        sessionId,
+                        executionId,
+                        turnId,
+                        model: selectedModel,
+                        messages,
+                        pendingInputs,
+                        messageSources,
+                        modelContext,
+                        resourceInput,
+                        store,
+                        coordinator: compactCoordinator,
+                        userTokenLimit: compactUserTokenLimit,
+                        boundary: () => contextCoordinator.boundary,
+                        updateBoundary: (value) => {
+                            contextCoordinator.setBoundary(value);
+                        },
+                        snapshotTools: () => projectTools(toolCatalog.tools),
+                        usage: () => modelLifecycle.usage,
+                        effort: () => requestReasoningEffort ?? reasoningEffort,
+                        environment: () => executionEnvironment,
+                        compose: (tools) => operation((call) => coreExtensions.composeModelSystem(promptComposition(tools, 'run'), call)),
+                        generate: (snapshot, compactionId, signal) => generateExecutionCompaction({
+                            snapshot,
+                            createOperation: () => createCompactionOperation(compactionId, signal),
+                            withTurn: (run) => executionOwner.withCompactTurn(selectedAdapter, run),
+                            generateExtension: generateCompactExtension,
+                            transformRequest: (request) => transformModelRequest(request, undefined, selectedModel.id, 'compact'),
+                            stream: streamModel,
+                            observeUsage: (usage) => emit({ type: 'usage.updated', purpose: 'compact', ...publicModelUsage(usage) }),
+                            onAttemptDiagnostic: recordModelAttempt('COMPACTION')
+                        }),
+                        retainedResources: async () => retainedSessionResourcesSnapshot(await loadRetainedSessionResources()),
+                        withProjection: withRecordProjection,
+                        recordCommit: (recordId) => inputs.recordCompactCommit({ changed: true, recordId, executionId }),
+                        invalidateContext: (error) => executionOwner.invalidateContext(error),
+                        invalidateUsage: invalidateCompactUsage,
+                        emit
+                    });
+                    ({ start: startCompact, wait: compactContext } = createExecutionCompactionFlight({
+                        coordinator: compactCoordinator,
+                        executionId,
+                        manualId: manualCompactionId,
+                        mode,
+                        executionSignal: controller.signal,
+                        compactSignal,
+                        currentManual: () => Boolean(inputs.currentCompact()),
+                        markSmartRequested: () => {
+                            if (smartInput)
+                                smartInput.requested = true;
+                        },
+                        compact: compactLeaf,
+                        perform: performCompact,
+                        emit
+                    }));
+                    compactRequests.bind((input) => compactCoordinator.pending
+                        ? startCompact({
+                            ...(input.prompt === undefined ? {} : { focus: input.prompt }),
+                            async: input.async === true
+                        })
+                        : undefined);
+                    if (mode === 'compact') {
+                        startCompact({ focus: compactFocus });
+                        compactRequests.drain((input) => startCompact({
+                            ...(input.prompt === undefined ? {} : { focus: input.prompt }),
+                            async: input.async === true
+                        }));
+                        await compactCoordinator.checkpoint(true);
+                        compactRequests.seal();
+                        compactRequests.drain((input) => startCompact({
+                            ...(input.prompt === undefined ? {} : { focus: input.prompt }),
+                            async: input.async === true
+                        }));
+                        await compactCoordinator.checkpoint(true);
+                        return;
+                    }
+                    const prepareRound = createExecutionRoundPreparer({
+                        prepareInputs: (includeSubagentUpdates) => contextCoordinator.prepareInputs({
+                            includeSubagentUpdates,
+                            appendMailbox: appendMailboxMessages,
+                            appendSubagentUpdates: () => appendSubagentUpdates(subagents),
+                            refreshTools: () => {
+                                updateMcpRegistry();
+                                toolCatalog.refresh();
+                            },
+                            updateEnvironment: () => {
+                                executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
+                            }
+                        }),
+                        buildCandidate: (continuation) => prepareExecutionRoundRequest({
+                            messages,
+                            continuation,
+                            model: selectedModel,
+                            requestBase: {
+                                promptCacheKey: sessionId,
+                                reasoningEffort,
+                                ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),
+                                ...(modelInputImages?.length ? { images: modelInputImages } : {}),
+                                onAttemptDiagnostic: recordModelAttempt('EXECUTION')
+                            },
+                            residentTools: () => projectTools(mcpRegistry.projectDirect(baseTools())),
+                            autoPermission: permissionPolicy.mode === 'auto',
+                            signal: controller.signal,
+                            capture: captureRoundToolScope,
+                            bind: (scope) => sources.bind(scope),
+                            world: () => modelContext.worldState,
+                            commitWorld: (world) => modelContext.commitWorldState(world),
+                            preparing: (next, baseLength) => {
+                                preparingRequestMessages = next;
+                                preparingRequestBaseLength = baseLength;
+                            },
+                            transform: (candidate, bindings) => transformModelRequest(candidate, bindings)
+                        }),
+                        adoptLateInput: async () => {
+                            const lateCoreChange = inputs.hasBoundaryCompactPending && (await appendMailboxMessages());
+                            const lateBlocking = compactRequests.drain((input) => startCompact({
+                                ...(input.prompt === undefined ? {} : { focus: input.prompt }),
+                                async: input.async === true
+                            }));
+                            const lateAdopted = lateBlocking && (await compactCoordinator.checkpoint(true));
+                            return Boolean(lateCoreChange || lateAdopted);
+                        },
+                        prepareResources: async ({ candidateRequest, request, toolScope }) => {
+                            resourceInput.observe(candidateRequest.messages);
+                            const media = sessionSource.type === 'subagent'
+                                ? undefined
+                                : await resourceInput.gcCandidate(request, candidateRequest.images);
+                            if (media?.reason === 'HARD_LIMIT') {
+                                const committed = await contextCoordinator.gc({ request, toolScope }, modelLifecycle.usage, media);
+                                if (committed)
+                                    return { retry: true };
+                            }
+                            return {
+                                round: {
+                                    request: await resourceInput.prepare(request, candidateRequest.images, candidateRequest.messages),
+                                    toolScope
+                                }
+                            };
+                        }
+                    });
+                    const completed = await executionOwner.runMainLoop({
+                        mode,
+                        sourceType: sessionSource.type,
+                        permissionStop: () => permissionPolicy.stop,
+                        signal: controller.signal,
+                        model: selectedModel,
+                        messages,
+                        toolImages: currentExecutionToolImages,
+                        publish: emit,
+                        appendContext: (message) => withRecordProjection(async () => {
+                            const stored = await store.append(sessionId, {
+                                type: 'model.context',
+                                payload: message,
+                                executionId,
+                                turnId
+                            });
+                            messageSources.set(message, stored);
+                        }),
+                        prepareRound,
+                        runTools: executeRoundTools,
+                        startModel: (request) => modelLifecycle.start(request),
+                        recoverySignal: () => controller.signal,
+                        compactContext,
+                        afterModel: (closedPrefixLength, request) => modelLifecycle.afterModel(closedPrefixLength, request),
+                        observeContextTokens: (tokens) => modelLifecycle.observeTokens(tokens),
+                        observeUsage: (usage) => modelLifecycle.observeUsage(usage),
+                        checkpoint: (round, latestUsage) => contextCoordinator.checkpoint(round, latestUsage),
+                        mailbox: {
+                            hasPending: () => inputs.hasBoundaryPending && !inputs.executing,
+                            append: appendMailboxMessages,
+                            close: () => {
+                                acceptsMailbox = false;
+                                acceptsSteer = false;
+                            }
+                        }
+                    });
+                    compactRequests.seal();
+                    compactRequests.drain((input) => startCompact({
+                        ...(input.prompt === undefined ? {} : { focus: input.prompt }),
+                        async: input.async === true
+                    }));
+                    await compactCoordinator.checkpoint(true).catch(() => {
+                        controller.signal.throwIfAborted();
+                        executionOwner.assertContextValid();
+                    });
+                    finalAnswer = completed.finalAnswer;
+                };
+                return {
+                    run: runPreparedExecution,
+                    performManualCompact: (run) => performCompact({ focus: input.prompt }, async (effective, call) => {
+                        await run(effective.focus, call.signal);
+                        return { changed: true, executionId };
+                    }),
+                    finalAnswer: () => finalAnswer,
+                    permissionStop: () => permissionPolicy.stop
+                };
+            },
+            beforeFailure: async (error) => {
+                acceptsMailbox = false;
+                acceptsSteer = false;
+                executionOwner.stopSteer();
+                await sessionRuntime.joinRecordProjection();
+                await compactCoordinator.close(error).catch(() => undefined);
+                executionOwner.retireCompactRequests(new AgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));
+            },
+            diagnostic: (error) => modelAttemptFailureDiagnostic(describeAgentError(error, 'MAR_AGENT_EXECUTION_FAILED'), exhaustedModelAttempt),
+            emit,
+            endParent: () => subagents?.endParentExecution(executionId),
+            finalize: (failed) => executionOwner.finish({
+                failed,
+                reason: controller.signal.reason ?? new AgentError('MAR_AGENT_CANCELLED', 'Execution ended.'),
+                releaseImageBytes: () => releaseImageBytes?.(),
+                revokeBindings: () => {
+                    executionOwner.revokeViews(new AgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));
+                    acceptsMailbox = false;
+                },
+                closeToolSources: () => {
+                    executionToolSources?.close();
+                    executionOwner.detachToolSources();
+                },
+                detachAbort: () => internal.signal?.removeEventListener('abort', abortSource),
+                endParent: () => subagents?.endParentExecution(executionId),
+                deactivate: () => {
+                    sessionRuntime.unbindExecutionContext(executionContext);
+                    sessionRuntime.deactivateExecution(executionOwner);
+                    sessionRuntime.sessionBackend?.kick();
+                }
+            }),
+            settle: (status) => {
+                inputs.settleExecution(executionId, status);
+                sessionRuntime.unregisterExecution(executionOwner);
+            }
+        });
+        return executionOwner.handle((message, delivery) => {
+            if (!acceptsMailbox || controller.signal.aborted)
+                return false;
+            acceptParent({ text: message, ...(delivery ? { delivery } : {}) });
+            return true;
+        });
+    };
+    return execution;
+}
+function modelAttemptFailureDiagnostic(diagnostic, summary) {
+    if (summary === undefined)
+        return diagnostic;
+    const prefix = `Model request failed after ${summary.attempts} attempts (${summary.retries} retries). `;
+    const availableCharacters = Math.max(0, 1_000 - [...prefix].length);
+    return {
+        code: diagnostic.code,
+        message: `${prefix}${[...diagnostic.message].slice(0, availableCharacters).join('')}`
+    };
+}