@myagentroam/agent 0.9.141 → 0.9.142

package/dist/sdk/agent.js

@@ -1,2548 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { isDeepStrictEqual } from 'node:util';
-import { describeMarAgentError, MarAgentError } from '../error.js';
-import { CodeCellExecutionError } from '../tools/code-mode/cells.js';
-import { negotiateHost } from '../host/contracts.js';
-import { AnthropicMessagesAdapter, isAnthropicRecoverableStreamError } from '../model/anthropic-messages.js';
-import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from '../model/configuration.js';
-import { modelRetryMaxAttempts, isRetryableModelRequestError, waitForModelRetry } from '../model/http.js';
-import { OpenAiResponsesAdapter, isOpenAiResponsesRecoverableStreamError } from '../model/openai-responses.js';
-import { AsyncQueue } from '../runtime/async-queue.js';
-import { PlanOutputPrefix, splitPlanOutput } from '../runtime/plan-output.js';
-import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
-import { RolloutBudget, resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
-import { ContextGcRuntime } from '../runtime/context-gc-runtime.js';
-import { buildContextProjection, providerToolCallId, providerToolName } from '../runtime/context-projection.js';
-import { countModelTokens, countTextLines, truncateModelText } from '../runtime/token-budget.js';
-import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
-import { DeferredMcpRegistry } from '../tools/tool-search.js';
-import { assertMcpToolCatalog } from './mcp-catalog.js';
-import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, buildCompactionMessages, buildNativeCompactionMessages, buildCompactedHistory, compactedHistoryMessages, continuationMessage } from '../runtime/compact.js';
-import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
-import { buildEnvironmentContext } from '../prompts/core.js';
-import { modelOutputContinuationMessage } from '../prompts/output.js';
-import { retainedSessionResourcesSnapshot, retainedSessionResourcesUpdate } from '../prompts/resources.js';
-import { currentLocalTimeContext, environmentContextUpdate, restoreEnvironmentState } from '../runtime/environment-context.js';
-import { executionBudgetEnvironmentEntry } from '../prompts/execution-budget.js';
-import { childSubagentInstruction } from '../prompts/subagent.js';
-import { sessionTitlePrompt } from '../prompts/title.js';
-import { loadAgentInstructions, renderAgentInstructions } from '../runtime/instructions.js';
-import { normalizeMessagesForModel } from '../runtime/normalize.js';
-import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, JsonlSessionStore } from '../session/jsonl-store.js';
-import { TodoStore } from '../tools/todo.js';
-import { BUILTIN_TOOL_DEFINITIONS } from '../tools/registry.js';
-import { agentStartToolDefinitionWithModels } from '../tools/agent-start.js';
-import { executeRegisteredTool } from '../tools/runtime.js';
-import { createCodeToolDispatch } from '../tools/code-mode/dispatch.js';
-import { createSessionToolScheduler, scheduleToolCallBatch } from '../tools/scheduler.js';
-import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode.js';
-import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
-import { modelStreamEventObservedAt } from '../model/sse.js';
-import { SubagentSessionController } from '../subagent/session-controller.js';
-/** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
-async function recoverModelStream(error, retryState, signal) {
-    if (signal.aborted ||
-        !(isRetryableModelRequestError(error) ||
-            isOpenAiResponsesRecoverableStreamError(error) ||
-            isAnthropicRecoverableStreamError(error)) ||
-        retryState.attempts >= modelRetryMaxAttempts(retryState))
-        return false;
-    const delayMs = retryState.retryDelayMs;
-    delete retryState.retryDelayMs;
-    await waitForModelRetry(typeof error.details?.retryAfter === 'string' ? error.details.retryAfter : null, retryState.attempts - 1, signal, delayMs);
-    return true;
-}
-/** Validate models before Host negotiation and expose only built-in protocol adapters. */
-export async function createMarAgent(options) {
-    if (Object.hasOwn(options, 'adapterFactory'))
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Custom model adapters are not supported.');
-    return createMarAgentWithAdapter(options);
-}
-/** Package-internal seam for deterministic adapter tests; not a package export. */
-export async function createMarAgentWithAdapter(options) {
-    const rolloutBudgetOptions = resolveRolloutBudgetOptions(options.rolloutBudget);
-    const resolvedModels = resolveAgentModels(options.models);
-    let { models, defaultModelId } = resolvedModels;
-    let modelGeneration = 0;
-    const { credentialProviders } = resolvedModels;
-    const description = negotiateHost(await options.host.describe());
-    if (description.mode !== options.mode)
-        throw new MarAgentError('MAR_AGENT_HOST_INCOMPATIBLE', 'Host mode does not match Agent mode.');
-    const store = await JsonlSessionStore.open(description.homeDirectory);
-    const active = new Map();
-    const activeExecutionAdapters = new Set();
-    const executionResults = new Map();
-    const sessionRuntimes = new Map();
-    const sessionWriterOwner = {};
-    let disposed = false;
-    let reconfiguring = false;
-    const createAdapter = (modelId, configuredModels = models) => {
-        const configuration = configuredModels.get(modelId);
-        if (!configuration)
-            throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
-        return (options.adapterFactory?.(configuration) ??
-            (configuration.protocol === 'OPENAI_RESPONSES'
-                ? new OpenAiResponsesAdapter(configuration)
-                : new AnthropicMessagesAdapter(configuration)));
-    };
-    const activeSessionIds = () => new Set([...active.keys()].map((key) => key.slice(0, key.indexOf(':'))));
-    const activeAdaptersExcept = (sessionId) => {
-        const activeAdapters = new Set();
-        for (const [candidateSessionId, runtime] of sessionRuntimes)
-            if (candidateSessionId !== sessionId && activeSessionIds().has(candidateSessionId))
-                for (const adapter of runtime.adapters.values())
-                    activeAdapters.add(adapter);
-        return activeAdapters;
-    };
-    const openSession = async (sessionId, workspace) => {
-        const storedSession = await store.getSession(sessionId);
-        const storedWorkspace = storedSession.workspace;
-        const sessionSource = storedSession.source;
-        const logicalWorkspace = options.workspaceMapping?.logicalPath ?? workspace ?? storedWorkspace ?? '';
-        const instructionWorkspace = options.workspaceMapping?.physicalPath ?? workspace ?? storedWorkspace ?? '';
-        const currentEnvironment = {
-            platform: description.platform,
-            ...(description.architecture ? { architecture: description.architecture } : {}),
-            ...(description.shell ? { shell: description.shell } : {}),
-            ...(description.guaranteedCommands
-                ? { guaranteedCommands: description.guaranteedCommands }
-                : {}),
-            workspace: logicalWorkspace
-        };
-        if (!restoreEnvironmentState({ version: 1, state: currentEnvironment }))
-            throw new MarAgentError('MAR_AGENT_HOST_INCOMPATIBLE', 'Host environment facts are invalid or exceed the context limit.');
-        const environmentContext = buildEnvironmentContext(currentEnvironment);
-        let sessionRuntime = sessionRuntimes.get(sessionId);
-        if (sessionRuntime === undefined) {
-            sessionRuntime = {
-                sourceType: sessionSource.type,
-                scheduleTool: createSessionToolScheduler(),
-                adapterGeneration: modelGeneration,
-                adapters: new Map()
-            };
-            sessionRuntimes.set(sessionId, sessionRuntime);
-        }
-        if (sessionSource.type === 'user' && sessionRuntime.subagents === undefined) {
-            sessionRuntime.subagentsOpening ??= SubagentSessionController.open({
-                parentSessionId: sessionId,
-                rootSessionId: sessionId,
-                backend: createSubagentBackend(store, storedWorkspace)
-            });
-            try {
-                sessionRuntime.subagents = await sessionRuntime.subagentsOpening;
-            }
-            finally {
-                delete sessionRuntime.subagentsOpening;
-            }
-        }
-        const sessionAdapter = (modelId, configuredModels) => {
-            let selected = sessionRuntime.adapters.get(modelId);
-            if (selected === undefined) {
-                selected = createAdapter(modelId, configuredModels);
-                if (options.adapterFactory === undefined || selected.createTurnSession !== undefined)
-                    sessionRuntime.adapters.set(modelId, selected);
-            }
-            return selected;
-        };
-        const refreshSessionAdapters = async (generation) => {
-            if (sessionRuntime.adapterGeneration === generation)
-                return;
-            const retainedByActiveSessions = activeAdaptersExcept(sessionId);
-            await closeModelAdapters([...sessionRuntime.adapters.values()].filter((adapter) => !retainedByActiveSessions.has(adapter)));
-            sessionRuntime.adapters.clear();
-            sessionRuntime.adapterGeneration = generation;
-        };
-        const execution = (mode, input, internal = {}) => {
-            if (disposed)
-                throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
-            if (reconfiguring)
-                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models are being reconfigured for the next execution.');
-            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();
-            let executionEnvironment = {
-                ...currentEnvironment,
-                ...currentLocalTimeContext()
-            };
-            const executionModels = models;
-            const executionDefaultModelId = defaultModelId;
-            const executionModelGeneration = modelGeneration;
-            const manualCompactionId = mode === 'compact' ? randomUUID() : undefined;
-            active.set(`${sessionId}:${executionId}`, controller);
-            const mailbox = [...(internal.initialMailbox ?? [])];
-            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 full = {
-                    ...event,
-                    eventId: randomUUID(),
-                    sequence: ++sequence,
-                    timestamp: new Date().toISOString(),
-                    sessionId,
-                    executionId,
-                    turnId
-                };
-                const operation = emitTail.then(async () => {
-                    // Transport-only progress events never become recoverable history.
-                    const persistent = eventForPersistence(full);
-                    if (persistent !== undefined)
-                        await store.append(sessionId, {
-                            type: full.type,
-                            payload: persistent,
-                            executionId,
-                            turnId
-                        });
-                    queue.push(full);
-                    if (internal.publishHostEvents !== false)
-                        await options.host.emit(full);
-                });
-                emitTail = operation.catch(() => undefined);
-                return operation;
-            };
-            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 = emitTail.then(async () => {
-                    await store.append(sessionId, {
-                        type: 'model.attempt',
-                        payload: { purpose, ...diagnostic },
-                        executionId,
-                        turnId
-                    });
-                });
-                emitTail = operation.catch(() => undefined);
-                return operation;
-            };
-            const createCompactionOperation = (compactionId) => new CompactionOperation(controller.signal, (progress) => {
-                const operation = emitTail.then(async () => {
-                    await store.append(sessionId, {
-                        type: 'compact.progress',
-                        payload: { compactionId, ...progress },
-                        executionId,
-                        turnId
-                    });
-                });
-                emitTail = operation.catch(() => undefined);
-                return operation;
-            });
-            const result = (async () => {
-                let finalAnswer = '';
-                const planOutputPrefixes = new Map();
-                let manualCompaction;
-                const rolloutBudget = internal.sharedRolloutBudget ??
-                    (rolloutBudgetOptions ? new RolloutBudget(rolloutBudgetOptions) : undefined);
-                const ownsRolloutBudget = rolloutBudget !== undefined && internal.sharedRolloutBudget === undefined;
-                let releaseSession;
-                let selectedTurn;
-                const contextGc = new ContextGcRuntime();
-                let selectedAdapter;
-                let titleAdapter;
-                const executionScopedAdapters = new Set();
-                let titleTask;
-                let titleSettled = false;
-                const settleTitle = async () => {
-                    if (titleSettled)
-                        return;
-                    titleSettled = true;
-                    const generatedTitle = await titleTask;
-                    if (generatedTitle)
-                        await store
-                            .updateTitle(sessionId, generatedTitle, { executionId, turnId })
-                            .catch(() => undefined);
-                };
-                const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
-                try {
-                    releaseSession = await store.acquireSessionLease(sessionId, sessionWriterOwner);
-                    await refreshSessionAdapters(executionModelGeneration);
-                    const sessionState = await store.readExecutionState(sessionId);
-                    if (!store.hasRetainedSessionLease(sessionId, sessionWriterOwner))
-                        sessionRuntime.todo = TodoStore.restore(sessionState.todo);
-                    const todo = (sessionRuntime.todo ??= TodoStore.restore(sessionState.todo));
-                    const contextRecords = sessionState.contextRecords;
-                    const contextualWorldStateGeneration = latestContextualWorldStateGeneration(contextRecords);
-                    const restoredContextualWorldState = sessionRuntime.contextualWorldState;
-                    const persistedContextualWorldState = parsePersistedContextualWorldState(await store.readContextualWorldState(sessionId));
-                    let contextualWorldState;
-                    if (restoredContextualWorldState !== undefined &&
-                        restoredContextualWorldState.generation === contextualWorldStateGeneration)
-                        contextualWorldState = restoredContextualWorldState;
-                    else if (persistedContextualWorldState !== undefined &&
-                        persistedContextualWorldState.generation === contextualWorldStateGeneration) {
-                        contextualWorldState = persistedContextualWorldState;
-                        sessionRuntime.contextualWorldState = contextualWorldState;
-                    }
-                    else {
-                        contextualWorldState = {
-                            generation: contextualWorldStateGeneration,
-                            initialized: false,
-                            instructionSnapshot: undefined,
-                            resourceSnapshot: undefined,
-                            entries: []
-                        };
-                        sessionRuntime.contextualWorldState = contextualWorldState;
-                    }
-                    const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
-                    const compactMayContainRetainedResources = compactHistoryMayContainRetainedResources(contextRecords);
-                    const restored = await restoreMessages(store, sessionId, contextRecords, {
-                        includeImages: mode !== 'compact'
-                    });
-                    const messages = restored.messages;
-                    let recordedEnvironment = restored.environmentState;
-                    let projectedExecutionBudgetStage;
-                    const appendExecutionBudgetEnvironment = () => {
-                        const currentStage = rolloutBudget?.active ? rolloutBudget.stage : 'inactive';
-                        if (currentStage === projectedExecutionBudgetStage)
-                            return;
-                        const previousStage = projectedExecutionBudgetStage;
-                        projectedExecutionBudgetStage = currentStage;
-                        if ((previousStage === undefined &&
-                            (currentStage === 'normal' || currentStage === 'inactive')) ||
-                            (currentStage === 'inactive' && previousStage === 'normal'))
-                            return;
-                        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;
-                    };
-                    const recordEnvironment = async () => {
-                        const message = environmentContextUpdate(executionEnvironment, recordedEnvironment);
-                        if (!message)
-                            return;
-                        await store.append(sessionId, {
-                            type: 'context.environment',
-                            payload: { version: 1, state: executionEnvironment },
-                            executionId,
-                            turnId
-                        });
-                        messages.push(message);
-                        recordedEnvironment = executionEnvironment;
-                    };
-                    let compactionUserMessages = [
-                        ...restored.userMessages,
-                        ...(mode === 'compact' ? [] : [input.prompt])
-                    ];
-                    const hasRestoredUserImages = messages.some((message) => message.role === 'user' && Boolean(message.images?.length));
-                    const modelInputImages = mode === 'compact'
-                        ? undefined
-                        : input.images?.map(({ mimeType, dataBase64 }) => ({
-                            mimeType,
-                            dataBase64
-                        }));
-                    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();
-                        if (sessionState.automaticTitlePending) {
-                            const titleModel = [...executionModels.values()].find((model) => model.titleGeneration) ??
-                                executionModels.get(input.modelId ?? executionDefaultModelId);
-                            titleAdapter = createAdapter(titleModel.id, executionModels);
-                            activeExecutionAdapters.add(titleAdapter);
-                            titleTask = generateSessionTitle(titleAdapter, input.prompt, titleModel.defaultReasoningEffort, controller.signal, recordModelAttempt('TITLE')).catch(() => undefined);
-                        }
-                    }
-                    await emit({ type: 'execution.started', 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);
-                    if (options.adapterFactory !== undefined &&
-                        selectedAdapter.createTurnSession === undefined) {
-                        executionScopedAdapters.add(selectedAdapter);
-                        activeExecutionAdapters.add(selectedAdapter);
-                    }
-                    const selected = createModelTurnSession(selectedAdapter);
-                    selectedTurn = selected;
-                    let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
-                    const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
-                    const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
-                    const useEffortUpdates = usesResponsesConfigurationUpdates(selectedModel);
-                    const previousReasoningEffort = useEffortUpdates
-                        ? reasoningEffortBaseline(contextRecords, selectedModel.id)
-                        : undefined;
-                    let requestReasoningEffort = useEffortUpdates
-                        ? (previousReasoningEffort ?? reasoningEffort)
-                        : undefined;
-                    let effectiveReasoningEffort = useEffortUpdates
-                        ? previousReasoningEffort === undefined
-                            ? 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,
-                            modelId: selectedModel.id,
-                            reasoningEffort,
-                            models: executionModels,
-                            emitTerminal: async (task) => emit({
-                                type: 'subagent.completed',
-                                agentId: task.agentId,
-                                description: task.description,
-                                status: task.status,
-                                ...(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) => {
-                                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,
-                                    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,
-                        ...(sessionSource.type === 'subagent'
-                            ? internal.mcpExecutionScopeId === undefined
-                                ? {}
-                                : { executionScopeId: internal.mcpExecutionScopeId }
-                            : { claimExecutionScope: true })
-                    };
-                    const readMcpCatalog = async () => {
-                        if (options.host.listMcpToolCatalog) {
-                            const catalog = await options.host.listMcpToolCatalog(catalogContext);
-                            assertMcpToolCatalog(catalog);
-                            return catalog;
-                        }
-                        const definitions = (await options.host.listMcpTools?.(catalogContext)) ?? [];
-                        return {
-                            revision: createHash('sha256').update(JSON.stringify(definitions)).digest('hex'),
-                            servers: [{ id: 'legacy', name: 'External MCP' }],
-                            tools: definitions.map((definition) => ({
-                                definition,
-                                serverId: 'legacy',
-                                rawName: definition.name,
-                                sourceIdentity: `legacy:${executionId}`,
-                                definitionRevision: createHash('sha256')
-                                    .update(JSON.stringify(definition))
-                                    .digest('hex'),
-                                lifetime: 'execution',
-                                exposure: 'deferred'
-                            }))
-                        };
-                    };
-                    const mcpCatalog = await readMcpCatalog();
-                    const mcpRegistry = new DeferredMcpRegistry(discoveredMcpToolNames(messages));
-                    const mcpTools = mcpCatalog.tools.map((tool) => tool.definition);
-                    const extensions = (await options.host.listExecutionExtensions?.(catalogContext)) ?? {};
-                    if (extensions.tools?.some((tool) => tool.name.startsWith('mcp__')))
-                        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Host tools cannot use the MCP namespace.');
-                    const selectedModelForTools = executionModels.get(input.modelId ?? executionDefaultModelId);
-                    const builtinTools = BUILTIN_TOOL_DEFINITIONS.map((tool) => tool.name === 'agent_start'
-                        ? agentStartToolDefinitionWithModels([...executionModels.values()].map((configuration) => ({
-                            id: configuration.id,
-                            name: configuration.name,
-                            reasoningEfforts: configuration.reasoningEfforts
-                        })))
-                        : tool);
-                    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 toolEligible = (tool) => {
-                        toolCallers(tool);
-                        if (sessionSource.type === 'subagent' && tool.agentScope === 'ROOT_ONLY')
-                            return false;
-                        if (sessionSource.type === 'subagent' &&
-                            (tool.name.startsWith('agent_') || tool.name === 'question'))
-                            return false;
-                        if (tool.name === 'tool_search')
-                            return mcpRegistry.hasDeferred;
-                        return tool.name === 'code_exec' || tool.name === 'code_exec_wait'
-                            ? selectedModelForTools.codeMode && description.capabilities.includes('code.execute')
-                            : tool.name === 'question'
-                                ? mode === 'plan'
-                                : tool.name === 'web_search'
-                                    ? !selectedModelForTools.hostedWebSearch &&
-                                        description.capabilities.includes('web.search')
-                                    : tool.name === 'view_image'
-                                        ? selectedModelForTools.inputCapabilities.includes('IMAGE')
-                                        : tool.name !== 'web_fetch' || description.capabilities.includes('web.fetch');
-                    };
-                    mcpRegistry.update(mcpCatalog, (tool) => toolEligible(tool.definition));
-                    rebindMcpToolSearchOutputs(messages, mcpRegistry);
-                    const availableTools = combinedTools.filter(toolEligible);
-                    const instructionContext = await loadAgentInstructions({
-                        home: description.homeDirectory,
-                        workspace: instructionWorkspace,
-                        availableTools: new Set(availableTools.map((tool) => tool.name)),
-                        hostSkills: extensions.skills ?? [],
-                        ...(options.workspaceMapping === undefined
-                            ? {}
-                            : { workspaceDisplayPath: logicalWorkspace })
-                    });
-                    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) &&
-                        (tool.name !== 'skill' || (instructionContext?.skills.size ?? 0) > 0));
-                    let executionTools = mcpRegistry.project(baseTools());
-                    const restoreMcpDiscovery = () => {
-                        mcpRegistry.restore(discoveredMcpToolNames(messages));
-                        rebindMcpToolSearchOutputs(messages, mcpRegistry);
-                        executionTools = mcpRegistry.project(baseTools());
-                    };
-                    const loadRetainedSessionResources = async () => {
-                        const hostResources = (await options.host.listSessionResources?.(sessionId)) ?? {
-                            processes: []
-                        };
-                        return {
-                            ...(hostResources.idleTtlMs === undefined
-                                ? {}
-                                : { idleTtlMs: hostResources.idleTtlMs }),
-                            processes: hostResources.processes,
-                            ...(hostResources.codeCells ? { codeCells: hostResources.codeCells } : {}),
-                            subagents: subagents?.listSessionResources() ?? []
-                        };
-                    };
-                    let currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
-                    const previousContextualWorldState = contextualWorldState;
-                    contextualWorldState = updateContextualWorldState(contextualWorldState, agentInstructionInsertIndex, {
-                        instructionSnapshot: currentInstructionSnapshot,
-                        instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
-                            contextualWorldState.instructionSnapshot !== undefined),
-                        resourceSnapshot: currentResourceSnapshot,
-                        previousMayContainResources: (!contextualWorldState.initialized && compactMayContainRetainedResources) ||
-                            (options.host.listSessionResources !== undefined &&
-                                currentResourceSnapshot === undefined &&
-                                messages
-                                    .slice(contextualWorldState.entries.findLast((entry) => entry.kind === 'resources')
-                                    ?.index ?? 0)
-                                    .some((message) => message.role === 'tool_call' &&
-                                    ['exec', 'code_exec', 'code_mode', 'agent_start'].includes(message.name ?? '')))
-                    });
-                    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: [
-                            options.systemInstruction,
-                            instructionContext?.skillCatalog,
-                            sessionSource.type === 'subagent' ? childSubagentInstruction : undefined
-                        ]
-                            .filter(Boolean)
-                            .join('\n\n')
-                    });
-                    const syncMcpWorldState = async (index) => {
-                        const snapshot = mcpRegistry.navigation();
-                        if (contextualWorldState.mcpSnapshot === snapshot)
-                            return;
-                        contextualWorldState = {
-                            ...contextualWorldState,
-                            mcpSnapshot: snapshot,
-                            entries: [
-                                ...contextualWorldState.entries,
-                                {
-                                    index,
-                                    kind: 'mcp',
-                                    content: snapshot ?? '<mcp_catalog>No deferred MCP tools remain.</mcp_catalog>'
-                                }
-                            ]
-                        };
-                        sessionRuntime.contextualWorldState = contextualWorldState;
-                        await persistContextualWorldState(store, sessionId, contextualWorldState);
-                    };
-                    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
-                    });
-                    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) });
-                                        }
-                                        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;
-                                }
-                            }
-                        }
-                        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 }),
-                            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.');
-                    };
-                    let recoveringFromContextOverflow = false;
-                    let maxOutputContinuationUsed = false;
-                    let pendingOutputContinuation;
-                    const modelRetryState = { attempts: 0 };
-                    while (true) {
-                        await appendMailboxMessages();
-                        appendExecutionBudgetEnvironment();
-                        let stop;
-                        let sawTool = false;
-                        let latestUsage;
-                        let roundServerUsage;
-                        const pendingTools = [];
-                        let incompleteToolCall = false;
-                        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 toolsAllowed = mode !== 'compact' && (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
-                        const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
-                        const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
-                        const residentTools = mcpRegistry.projectDirect(baseTools());
-                        const requestTools = (() => {
-                            if (selectedModel.protocol !== 'OPENAI_RESPONSES' ||
-                                selectedModel.responsesEncoding === 'LITE')
-                                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)]));
-                        let sawModelSemanticEvent = false;
-                        let requestStartedAt;
-                        let firstModelResponseAt;
-                        let firstOutputDeltaAt;
-                        let lastOutputDeltaAt;
-                        let requestCompletedAt;
-                        let requestOutputTokens;
-                        const roundMessageCount = messages.length;
-                        const emitLatency = async () => {
-                            if (mode === 'compact' || firstModelResponseAt === undefined)
-                                return;
-                            await emit({
-                                type: 'model.performance',
-                                latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt))
-                            });
-                        };
-                        const emitFinalPerformance = async (completedAt) => {
-                            if (mode === 'compact' ||
-                                firstModelResponseAt === undefined ||
-                                firstOutputDeltaAt === undefined ||
-                                lastOutputDeltaAt === undefined ||
-                                lastOutputDeltaAt - firstOutputDeltaAt < 1)
-                                return;
-                            const outputDuration = completedAt - firstOutputDeltaAt;
-                            const outputTokens = requestOutputTokens;
-                            if (outputTokens === undefined ||
-                                outputDuration < 1 ||
-                                completedAt < lastOutputDeltaAt)
-                                return;
-                            await emit({
-                                type: 'model.performance',
-                                latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
-                                outputTokens,
-                                outputDurationMs: Math.round(outputDuration),
-                                tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
-                            });
-                        };
-                        const persistToolCalls = async (calls) => {
-                            for (const call of calls) {
-                                const message = {
-                                    role: 'tool_call',
-                                    callId: call.callId,
-                                    name: call.name,
-                                    arguments: call.arguments,
-                                    ...(call.inputMode ? { inputMode: call.inputMode } : {}),
-                                    content: ''
-                                };
-                                messages.push(message);
-                                await store.append(sessionId, {
-                                    type: 'model.context',
-                                    payload: message,
-                                    executionId,
-                                    turnId
-                                });
-                            }
-                        };
-                        try {
-                            if (manualCompactionId !== undefined && !manualCompactionStarted) {
-                                manualCompactionStarted = true;
-                                manualCompaction = createCompactionOperation(manualCompactionId);
-                                await emit({ type: 'context.compacting', compactionId: manualCompactionId });
-                            }
-                            const startModel = manualCompaction
-                                ? (request) => manualCompaction.start(selected, request)
-                                : (request) => selected.start(request, controller.signal);
-                            requestStartedAt = performance.now();
-                            for await (const event of startModel({
-                                retryState: modelRetryState,
-                                system: systemPrompt,
-                                messages: modelMessages.map((message) => projectCodeModeSearchResult(message, codeModeEnabled)),
-                                tools: requestTools,
-                                ...(mode === 'compact'
-                                    ? { toolChoice: 'none' }
-                                    : toolsAllowed
-                                        ? {}
-                                        : { allowTools: false }),
-                                promptCacheKey: sessionId,
-                                reasoningEffort,
-                                ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),
-                                ...(modelInputImages?.length ? { images: modelInputImages } : {}),
-                                onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
-                            })) {
-                                if (event.type === 'output.reset') {
-                                    firstOutputDeltaAt = undefined;
-                                    lastOutputDeltaAt = undefined;
-                                    requestOutputTokens = undefined;
-                                    continue;
-                                }
-                                const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event)
-                                    ? Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now())
-                                    : undefined;
-                                const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
-                                if (modelResponseAt !== undefined) {
-                                    if (event.type !== 'output.delta')
-                                        sawModelSemanticEvent = true;
-                                    firstModelResponseAt ??= modelResponseAt;
-                                    if (event.type === 'output.delta' ||
-                                        (event.type === 'text.delta' && event.delta.length > 0)) {
-                                        firstOutputDeltaAt ??= modelResponseAt;
-                                        lastOutputDeltaAt = modelResponseAt;
-                                    }
-                                }
-                                if (event.type === 'response.item') {
-                                    // Compaction keeps only its successful checkpoint, never intermediate native output.
-                                    if (mode === 'compact')
-                                        continue;
-                                    const message = {
-                                        role: 'provider',
-                                        content: '',
-                                        provider: event.provider,
-                                        providerModelId: selectedModel.id,
-                                        ...(event.provider === 'ANTHROPIC_MESSAGES'
-                                            ? { contextKind: 'private' }
-                                            : {}),
-                                        item: event.item
-                                    };
-                                    messages.push(message);
-                                    await store.append(sessionId, {
-                                        type: 'model.context',
-                                        payload: message,
-                                        executionId,
-                                        turnId
-                                    });
-                                }
-                                else if (event.type === 'text.delta') {
-                                    let delta = event.delta;
-                                    if (mode === 'plan' && sessionSource.type !== 'subagent') {
-                                        let prefix = planOutputPrefixes.get(event.itemId);
-                                        if (!prefix) {
-                                            prefix = new PlanOutputPrefix();
-                                            planOutputPrefixes.set(event.itemId, prefix);
-                                        }
-                                        delta = prefix.push(delta);
-                                    }
-                                    if (mode !== 'compact' && delta) {
-                                        await emit({
-                                            type: 'message.delta',
-                                            itemId: event.itemId,
-                                            phase: event.phase,
-                                            delta
-                                        });
-                                    }
-                                }
-                                else if (event.type === 'text.completed') {
-                                    const phase = event.phase ?? 'final_answer';
-                                    if (phase === 'final_answer')
-                                        finalAnswer = event.text;
-                                    planOutputPrefixes.delete(event.itemId);
-                                    if (mode !== 'compact') {
-                                        if (mode === 'plan' && sessionSource.type !== 'subagent') {
-                                            const parts = splitPlanOutput(event.text);
-                                            for (const [index, part] of parts.entries()) {
-                                                const itemId = index === 0 ? event.itemId : `${event.itemId}:plan-part:${index}`;
-                                                if (part.kind === 'plan')
-                                                    await emit({ type: 'plan.completed', itemId, text: part.text });
-                                                else {
-                                                    await emit({
-                                                        type: 'message.completed',
-                                                        itemId,
-                                                        phase,
-                                                        text: part.text,
-                                                        modelId: selectedModel.id,
-                                                        modelName: selectedModel.name
-                                                    });
-                                                }
-                                            }
-                                        }
-                                        else {
-                                            await emit({
-                                                type: 'message.completed',
-                                                itemId: event.itemId,
-                                                phase,
-                                                text: event.text,
-                                                modelId: selectedModel.id,
-                                                modelName: selectedModel.name
-                                            });
-                                        }
-                                    }
-                                    messages.push({ role: 'assistant', content: event.text });
-                                }
-                                else if (event.type === 'usage') {
-                                    latestUsage = event.usage;
-                                    const outputTokens = typeof event.usage.outputTokens === 'number' &&
-                                        Number.isSafeInteger(event.usage.outputTokens) &&
-                                        event.usage.outputTokens >= 0
-                                        ? event.usage.outputTokens
-                                        : undefined;
-                                    if (outputTokens !== undefined) {
-                                        requestOutputTokens = outputTokens;
-                                    }
-                                    const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
-                                    if (reportedContext !== undefined &&
-                                        Number.isSafeInteger(reportedContext) &&
-                                        reportedContext >= 0) {
-                                        lastServerContextTokens = reportedContext;
-                                        roundServerUsage = {
-                                            contextInputTokens: reportedContext,
-                                            outputTokens: typeof event.usage.outputTokens === 'number' &&
-                                                Number.isSafeInteger(event.usage.outputTokens) &&
-                                                event.usage.outputTokens >= 0
-                                                ? event.usage.outputTokens
-                                                : undefined
-                                        };
-                                    }
-                                    await emit({ type: 'usage.updated', ...publicModelUsage(event.usage) });
-                                }
-                                else if (event.type === 'reasoning.summary') {
-                                    if (mode !== 'compact')
-                                        await emit({ type: 'reasoning.summary', text: event.text });
-                                }
-                                else if (event.type === 'hosted_tool') {
-                                    if (mode !== 'compact')
-                                        await emit({
-                                            type: 'hosted_tool.updated',
-                                            itemId: event.itemId,
-                                            kind: event.kind,
-                                            status: event.status,
-                                            summary: event.summary
-                                        });
-                                }
-                                else if (event.type === 'citation') {
-                                    if (mode !== 'compact')
-                                        await emit({
-                                            type: 'citation.added',
-                                            id: event.citation.id,
-                                            url: event.citation.url,
-                                            ...(event.citation.title ? { title: event.citation.title } : {})
-                                        });
-                                }
-                                else if (event.type === 'client_tool.call') {
-                                    if (mode === 'compact')
-                                        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
-                                    sawTool = true;
-                                    pendingTools.push(event);
-                                }
-                                else if (event.type === 'completed') {
-                                    stop = event.reason;
-                                    requestCompletedAt = modelStreamEventObservedAt(event) ?? performance.now();
-                                }
-                                if (isFirstModelResponse)
-                                    await emitLatency();
-                            }
-                            if (mode !== 'compact' && firstModelResponseAt !== undefined) {
-                                const completedAt = requestCompletedAt ?? performance.now();
-                                await emitFinalPerformance(completedAt);
-                            }
-                            pendingOutputContinuation = undefined;
-                            incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
-                            if (!(stop === 'max_output' && incompleteToolCall)) {
-                                await persistToolCalls(pendingTools);
-                            }
-                            else
-                                pendingTools.splice(0, pendingTools.length);
-                            modelRetryState.attempts = 0;
-                        }
-                        catch (error) {
-                            planOutputPrefixes.clear();
-                            if (await recoverModelStream(error, modelRetryState, manualCompaction?.signal ?? controller.signal)) {
-                                finalAnswer = '';
-                                if (mode === 'compact')
-                                    messages.splice(roundMessageCount);
-                                if (pendingTools.some((call) => call.argumentError !== undefined))
-                                    pendingTools.splice(0, pendingTools.length);
-                                else if (pendingTools.length > 0)
-                                    await persistToolCalls(pendingTools);
-                                if (pendingTools.length === 0)
-                                    continue;
-                            }
-                            else if (mode === 'compact' &&
-                                !sawModelSemanticEvent &&
-                                isProviderContextOverflow(error) &&
-                                useManualCompactionFallback?.()) {
-                                modelRetryState.attempts = 0;
-                                finalAnswer = '';
-                                continue;
-                            }
-                            else if (mode !== 'compact' &&
-                                !sawModelSemanticEvent &&
-                                isProviderContextOverflow(error)) {
-                                if (!recoveringFromContextOverflow && (await compactContext())) {
-                                    modelRetryState.attempts = 0;
-                                    recoveringFromContextOverflow = true;
-                                    continue;
-                                }
-                                throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'The model rejected the compacted context as too large.', { cause: error });
-                            }
-                            else
-                                throw error;
-                        }
-                        recoveringFromContextOverflow = false;
-                        if (roundServerUsage !== undefined)
-                            lastServerUsage = {
-                                ...roundServerUsage,
-                                historyMessages: [...messages]
-                            };
-                        if (pendingTools.length === 0 && mailbox.length > 0) {
-                            await appendMailboxMessages();
-                            finalAnswer = '';
-                            continue;
-                        }
-                        const executeCall = async (call, signal = controller.signal, caller = 'direct', parentCallId) => {
-                            await emit({
-                                type: 'tool.started',
-                                toolName: call.name,
-                                callId: call.callId,
-                                ...(parentCallId === undefined ? {} : { parentCallId }),
-                                input: call.arguments
-                            });
-                            try {
-                                if (call.argumentError)
-                                    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', call.argumentError);
-                                if (!roundTools.some((tool) => tool.name === call.name && allowsToolCaller(tool, caller)))
-                                    throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable in this execution.');
-                                const stateSnapshot = call.name === 'code_exec' ? await store.readCodeModeState(sessionId) : [];
-                                const runTool = () => {
-                                    signal.throwIfAborted();
-                                    return executeRegisteredTool(call.name, call.arguments, call.callId, {
-                                        host: options.host,
-                                        todo,
-                                        ...(roundMcpExpectations.get(call.name)
-                                            ? { expectedMcpTool: roundMcpExpectations.get(call.name) }
-                                            : {}),
-                                        searchMcpTools: (arguments_, searchSignal) => mcpRegistry.expose(arguments_, {
-                                            signal: searchSignal,
-                                            base: baseTools(),
-                                            window: selectedModel.contextWindowTokens,
-                                            system: systemPrompt
-                                        }),
-                                        ...(subagents === undefined ? {} : { subagents }),
-                                        mode,
-                                        sessionId,
-                                        executionId,
-                                        signal,
-                                        codeMode: {
-                                            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
-                                            }),
-                                            invoke: createCodeToolDispatch({
-                                                context: {
-                                                    host: options.host,
-                                                    todo,
-                                                    ...(subagents ? { subagents: subagents.captureExecution() } : {}),
-                                                    mode,
-                                                    sessionId,
-                                                    executionId,
-                                                    emit,
-                                                    skills: instructionContext?.skills ?? new Map(),
-                                                    recentImages: currentExecutionImages(modelInputImages, currentExecutionToolImages)
-                                                },
-                                                tools: roundTools,
-                                                expectations: roundMcpExpectations,
-                                                parentCallId: call.callId,
-                                                schedule: sessionRuntime.scheduleTool,
-                                                emit,
-                                                projectData: structuredToolEventData
-                                            })
-                                        },
-                                        emit,
-                                        skills: instructionContext?.skills ?? new Map(),
-                                        ...(extensions.tools?.some((tool) => tool.name === call.name)
-                                            ? {
-                                                recentImages: currentExecutionImages(modelInputImages, currentExecutionToolImages)
-                                            }
-                                            : {})
-                                    });
-                                };
-                                const output = call.name === 'code_exec' || call.name === 'code_exec_wait'
-                                    ? await runTool()
-                                    : await sessionRuntime.scheduleTool(roundTools.find((tool) => tool.name === call.name), runTool);
-                                const modelOutput = boundedModelToolOutput(call.name, output.content, output.data);
-                                const eventSummary = output.content.slice(0, AGENT_EXECUTION_POLICY.toolEventSummaryCharacters);
-                                const structuredData = structuredToolEventData(call.name, output.data);
-                                const artifacts = structuredToolArtifacts(output.artifacts);
-                                await emit({
-                                    type: 'tool.completed',
-                                    toolName: call.name,
-                                    callId: call.callId,
-                                    ...(parentCallId === undefined ? {} : { parentCallId }),
-                                    summary: eventSummary,
-                                    truncated: output.truncated === true ||
-                                        modelOutput.truncated ||
-                                        eventSummary.length < output.content.length,
-                                    ...(artifacts === undefined ? {} : { artifacts }),
-                                    ...(structuredData === undefined ? {} : { data: structuredData })
-                                });
-                                return {
-                                    call,
-                                    output,
-                                    content: modelOutput.content,
-                                    ...(output.images?.length ? { images: output.images } : {}),
-                                    failed: false
-                                };
-                            }
-                            catch (error) {
-                                const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
-                                const partial = error instanceof CodeCellExecutionError ? error.result : undefined;
-                                await emit({
-                                    type: 'tool.failed',
-                                    toolName: call.name,
-                                    callId: call.callId,
-                                    ...(parentCallId === undefined ? {} : { parentCallId }),
-                                    code: diagnostic.code,
-                                    message: diagnostic.message
-                                });
-                                return {
-                                    call,
-                                    content: partial === undefined
-                                        ? JSON.stringify({
-                                            error: diagnostic.code,
-                                            message: diagnostic.message,
-                                            ...(error instanceof MarAgentError && error.retryable
-                                                ? { retryable: true }
-                                                : {})
-                                        })
-                                        : boundedModelToolOutput(call.name, partial.content, partial.data).content,
-                                    ...(partial?.images?.length ? { images: partial.images } : {}),
-                                    failed: true,
-                                    error
-                                };
-                            }
-                        };
-                        const toolResults = await scheduleToolCallBatch(pendingTools, roundTools, executeCall);
-                        for (const result of toolResults) {
-                            if ('images' in result && result.images?.length)
-                                currentExecutionToolImages.push(...result.images.map((image) => ({
-                                    mimeType: image.mimeType,
-                                    data: Buffer.from(image.dataBase64, 'base64')
-                                })));
-                            const toolSearchTools = result.call.name === 'tool_search' && !result.failed
-                                ? result.output.toolSearchTools
-                                : undefined;
-                            const message = {
-                                role: 'tool',
-                                callId: result.call.callId,
-                                content: result.content,
-                                ...(toolSearchTools === undefined ? {} : { toolSearchTools }),
-                                ...('images' in result && result.images?.length ? { images: result.images } : {})
-                            };
-                            messages.push(message);
-                            await store.append(sessionId, {
-                                type: 'model.context',
-                                payload: {
-                                    role: message.role,
-                                    callId: message.callId,
-                                    content: message.content,
-                                    ...(message.toolSearchTools === undefined
-                                        ? {}
-                                        : { toolSearchTools: message.toolSearchTools })
-                                },
-                                executionId,
-                                turnId
-                            });
-                        }
-                        if (sawTool) {
-                            modelRetryState.attempts = 0;
-                            if (sessionSource.type === 'subagent')
-                                finalAnswer = '';
-                        }
-                        rolloutBudget?.recordUsage(latestUsage);
-                        if (mode !== 'compact' && stop === 'max_output') {
-                            const needsContinuation = !sawTool || incompleteToolCall;
-                            if (needsContinuation) {
-                                if (maxOutputContinuationUsed ||
-                                    (rolloutBudget?.active && rolloutBudget.stage === 'exhausted'))
-                                    throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model output reached its limit before completing.');
-                                maxOutputContinuationUsed = true;
-                                pendingOutputContinuation = {
-                                    role: 'user',
-                                    content: modelOutputContinuationMessage
-                                };
-                                finalAnswer = '';
-                                continue;
-                            }
-                            maxOutputContinuationUsed = false;
-                        }
-                        else
-                            maxOutputContinuationUsed = false;
-                        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: systemPrompt,
-                                tools: roundTools,
-                                modelId: selectedModel.id,
-                                contextWindowTokens: selectedModel.contextWindowTokens,
-                                usage: latestUsage,
-                                modelProtocol: selectedModel.protocol,
-                                responsesConfigurationUpdates: usesResponsesConfigurationUpdates(selectedModel),
-                                workspace: logicalWorkspace,
-                                platform: description.platform,
-                                getActiveProcessIds: async () => {
-                                    const resources = await options.host
-                                        .listSessionResources?.(sessionId)
-                                        .catch(() => undefined);
-                                    return new Set((resources?.processes ?? [])
-                                        .filter((process) => process.status === 'running')
-                                        .map((process) => process.processId));
-                                }
-                            });
-                            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)
-                                });
-                                sessionRuntime.contextualWorldState = contextualWorldState;
-                                await persistContextualWorldState(store, sessionId, contextualWorldState);
-                            }
-                        }
-                        if (controller.signal.aborted) {
-                            const aborted = toolResults.find((result) => result.failed)?.error;
-                            throw (aborted ??
-                                new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
-                        }
-                        if (mailbox.length > 0) {
-                            await appendMailboxMessages();
-                            finalAnswer = '';
-                            continue;
-                        }
-                        if (stop === 'completed' && !sawTool) {
-                            acceptsMailbox = false;
-                            const compactSummary = mode === 'compact' ? finalAnswer.trim() : '';
-                            if (mode === 'compact' && !compactSummary)
-                                throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Compaction returned an empty handoff.');
-                            if (mode !== 'compact' && !finalAnswer.trim())
-                                throw new MarAgentError(sessionSource.type === 'subagent'
-                                    ? 'MAR_AGENT_SUBAGENT_FAILED'
-                                    : 'MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', sessionSource.type === 'subagent'
-                                    ? 'Subagent completed without a final summary.'
-                                    : 'Model completed without an answer or tool request.');
-                            if (manualCompaction) {
-                                manualCompaction.signal.throwIfAborted();
-                                await manualCompaction.dispose();
-                            }
-                            if (mode === 'compact')
-                                await store.compact(sessionId, {
-                                    summary: compactSummary,
-                                    replacementHistory: buildCompactedHistory(compactSummary, compactionUserMessages, compactUserTokenLimit),
-                                    modelId: selectedModel.id,
-                                    contextWindowTokens: selectedModel.contextWindowTokens,
-                                    ...(latestUsage === undefined ? {} : { usage: latestUsage }),
-                                    executionId,
-                                    turnId
-                                });
-                            if (mode === 'compact' && manualCompactionId !== undefined)
-                                await emit({ type: 'context.compacted', compactionId: manualCompactionId });
-                            await settleTitle();
-                            subagents?.endParentExecution(executionId);
-                            await emit({ type: 'execution.completed' });
-                            return {
-                                executionId,
-                                status: 'completed',
-                                finalAnswer: mode === 'compact' ? '' : finalAnswer
-                            };
-                        }
-                        if (!sawTool && stop !== 'pause')
-                            throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model did not complete or request a tool.');
-                    }
-                }
-                catch (error) {
-                    acceptsMailbox = false;
-                    await settleTitle();
-                    if (controller.signal.aborted) {
-                        subagents?.endParentExecution(executionId);
-                        await emit({ type: 'execution.cancelled' });
-                        return {
-                            executionId,
-                            status: 'cancelled',
-                            finalAnswer: mode === 'compact' ? '' : finalAnswer
-                        };
-                    }
-                    const diagnostic = modelAttemptFailureDiagnostic(describeMarAgentError(error, 'MAR_AGENT_EXECUTION_FAILED'), exhaustedModelAttempt);
-                    subagents?.endParentExecution(executionId);
-                    await emit({ type: 'execution.failed', ...diagnostic });
-                    return {
-                        executionId,
-                        status: 'failed',
-                        finalAnswer: mode === 'compact' ? '' : finalAnswer,
-                        errorCode: diagnostic.code,
-                        errorMessage: diagnostic.message
-                    };
-                }
-                finally {
-                    acceptsMailbox = false;
-                    if (ownsRolloutBudget)
-                        rolloutBudget.discard();
-                    await manualCompaction?.dispose();
-                    await selectedTurn?.close().catch(() => undefined);
-                    if (titleAdapter !== undefined && titleAdapter !== selectedAdapter)
-                        executionScopedAdapters.add(titleAdapter);
-                    try {
-                        await closeModelAdapters(executionScopedAdapters);
-                    }
-                    catch {
-                        // Execution cleanup is best effort.
-                    }
-                    finally {
-                        for (const adapter of executionScopedAdapters)
-                            activeExecutionAdapters.delete(adapter);
-                    }
-                    subagents?.endParentExecution(executionId);
-                    await releaseSession?.();
-                    active.delete(`${sessionId}:${executionId}`);
-                    queue.close();
-                }
-            })();
-            const executionKey = `${sessionId}:${executionId}`;
-            executionResults.set(executionKey, result);
-            void result.then(() => executionResults.delete(executionKey), () => executionResults.delete(executionKey));
-            return {
-                executionId,
-                turnId,
-                [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator](),
-                result: () => {
-                    queue.discardIfUnobserved();
-                    return result;
-                },
-                cancel: () => controller.abort(new MarAgentError('MAR_AGENT_CANCELLED', 'Execution was cancelled.')),
-                enqueueMessage: (message, delivery) => {
-                    if (!acceptsMailbox || controller.signal.aborted)
-                        return false;
-                    mailbox.push({ text: message, ...(delivery ? { delivery } : {}) });
-                    return true;
-                }
-            };
-        };
-        return {
-            id: sessionId,
-            run: (input) => execution('run', input),
-            plan: (input) => execution('plan', input),
-            compact: (input = {}) => execution('compact', {
-                prompt: input.prompt ?? DEFAULT_COMPACTION_FOCUS,
-                ...input
-            }),
-            cancel: async (executionId) => active.get(`${sessionId}:${executionId}`)?.abort(),
-            startSubagentTurn: (turn) => execution(turn.role === 'explore' ? 'plan' : 'run', {
-                prompt: turn.prompt,
-                modelId: turn.modelId,
-                reasoningEffort: turn.reasoningEffort
-            }, {
-                publishHostEvents: false,
-                inputSource: 'parent_agent',
-                initialMailbox: turn.initialMailbox,
-                turnId: turn.turnId,
-                mcpExecutionScopeId: turn.mcpExecutionScopeId,
-                ...(turn.delivery ? { delivery: turn.delivery } : {}),
-                ...(turn.sharedRolloutBudget === undefined
-                    ? {}
-                    : { sharedRolloutBudget: turn.sharedRolloutBudget })
-            })
-        };
-    };
-    return {
-        createSession: async (input) => openSession((await store.createSession(input)).id, input.workspace),
-        openSession: (id) => openSession(id),
-        listSessions: (input) => store.list(input),
-        clearSession: async (id) => {
-            const runtime = sessionRuntimes.get(id);
-            if ([...active.keys()].some((key) => key.startsWith(`${id}:`)))
-                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'A session cannot be cleared while an execution is active.');
-            await runtime?.subagents?.dispose();
-            await closeModelAdapters(runtime === undefined ? [] : [...runtime.adapters.values()]);
-            sessionRuntimes.delete(id);
-            await options.host.disposeSessionResources?.(id);
-            await store.clearSession(id);
-        },
-        reconfigureModels: async (input) => {
-            if (disposed)
-                throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
-            if (reconfiguring)
-                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models are already being reconfigured for the next execution.');
-            const next = resolveAgentModels(input.models, input.defaultModelId);
-            const activeSessions = activeSessionIds();
-            if ([...activeSessions].some((sessionId) => sessionRuntimes.get(sessionId)?.sourceType !== 'subagent'))
-                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models cannot be reconfigured while a main execution is active.');
-            const activeAdapters = new Set(activeExecutionAdapters);
-            for (const [sessionId, runtime] of sessionRuntimes)
-                if (activeSessions.has(sessionId))
-                    for (const adapter of runtime.adapters.values())
-                        activeAdapters.add(adapter);
-            const inactiveRuntimes = [...sessionRuntimes].flatMap(([sessionId, runtime]) => activeSessions.has(sessionId) ? [] : [runtime]);
-            reconfiguring = true;
-            try {
-                const reconfigurationCommits = new Map();
-                for (const runtime of inactiveRuntimes)
-                    for (const [modelId, adapter] of runtime.adapters) {
-                        if (activeAdapters.has(adapter))
-                            continue;
-                        const configuration = next.models.get(modelId);
-                        const commit = configuration === undefined ? undefined : adapter.prepareReconfigure?.(configuration);
-                        if (commit !== undefined)
-                            reconfigurationCommits.set(adapter, commit);
-                    }
-                const retainedAdapters = new Set(reconfigurationCommits.keys());
-                const adapters = [
-                    ...new Set(inactiveRuntimes.flatMap((runtime) => [...runtime.adapters.values()]))
-                ].filter((adapter) => !activeAdapters.has(adapter) && !retainedAdapters.has(adapter));
-                for (const runtime of inactiveRuntimes) {
-                    for (const [modelId, adapter] of runtime.adapters)
-                        if (!retainedAdapters.has(adapter))
-                            runtime.adapters.delete(modelId);
-                }
-                await closeModelAdapters(adapters);
-                if (disposed)
-                    throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
-                for (const commit of reconfigurationCommits.values())
-                    commit();
-                models = next.models;
-                defaultModelId = next.defaultModelId;
-                modelGeneration++;
-                for (const provider of next.credentialProviders)
-                    credentialProviders.add(provider);
-                for (const runtime of inactiveRuntimes) {
-                    runtime.adapterGeneration = modelGeneration;
-                }
-                const liveProviders = new Set(next.credentialProviders);
-                for (const adapter of activeExecutionAdapters)
-                    addModelCredentialProviders(liveProviders, adapter.configuration);
-                for (const runtime of sessionRuntimes.values())
-                    for (const adapter of runtime.adapters.values())
-                        addModelCredentialProviders(liveProviders, adapter.configuration);
-                const obsoleteProviders = [...credentialProviders].filter((provider) => !liveProviders.has(provider));
-                const providerCloseResults = await Promise.allSettled(obsoleteProviders.map((provider) => provider.close()));
-                for (const [index, result] of providerCloseResults.entries())
-                    if (result.status === 'fulfilled')
-                        credentialProviders.delete(obsoleteProviders[index]);
-            }
-            finally {
-                reconfiguring = false;
-            }
-        },
-        deleteSession: async (id) => {
-            const sessionIds = await store.sessionTree(id);
-            const sessionIdSet = new Set(sessionIds);
-            const executionKeys = [...active.keys()].filter((key) => sessionIdSet.has(key.slice(0, key.indexOf(':'))));
-            for (const key of executionKeys)
-                active.get(key)?.abort();
-            const runtimes = sessionIds.flatMap((sessionId) => {
-                const runtime = sessionRuntimes.get(sessionId);
-                sessionRuntimes.delete(sessionId);
-                return runtime === undefined ? [] : [runtime];
-            });
-            await Promise.all(runtimes.map((runtime) => runtime.subagents?.dispose()));
-            await Promise.allSettled(executionKeys.flatMap((key) => {
-                const result = executionResults.get(key);
-                return result === undefined ? [] : [result];
-            }));
-            await closeModelAdapters(runtimes.flatMap((runtime) => [...runtime.adapters.values()]));
-            await Promise.all(sessionIds.map((sessionId) => options.host.disposeSessionResources?.(sessionId)));
-            await store.delete(id);
-        },
-        dispose: async () => {
-            if (disposed)
-                return;
-            disposed = true;
-            for (const controller of active.values())
-                controller.abort();
-            await Promise.all([...sessionRuntimes.values()].map((runtime) => runtime.subagents?.dispose().catch(() => undefined)));
-            await Promise.allSettled([...executionResults.values()]);
-            await closeModelAdapters([...sessionRuntimes.values()].flatMap((runtime) => [...runtime.adapters.values()]));
-            let disposalError;
-            const providerResults = await Promise.allSettled([...credentialProviders].map((provider) => provider.close()));
-            disposalError = providerResults.find((result) => result.status === 'rejected')?.reason;
-            try {
-                await options.host.dispose();
-            }
-            catch (error) {
-                disposalError ??= error;
-            }
-            try {
-                await store.close();
-            }
-            catch (error) {
-                disposalError ??= error;
-            }
-            if (disposalError !== undefined)
-                throw disposalError;
-        }
-    };
-}
-function createSubagentBackend(store, workspace) {
-    return {
-        createSession: async (input) => {
-            const session = await store.createSession({
-                workspace,
-                title: input.title,
-                source: input.source
-            });
-            return { id: session.id };
-        },
-        deleteSession: async (sessionId) => {
-            await store.delete(sessionId);
-        },
-        listChildren: async (parentSessionId) => {
-            const sessions = await store.listSubagentChildren(parentSessionId);
-            return Promise.all(sessions.map(async (session) => ({
-                id: session.id,
-                createdAt: session.createdAt,
-                lastActivityAt: session.lastActivityAt,
-                source: session.source,
-                records: await store.read(session.id)
-            })));
-        },
-        loadChild: async (parentSessionId, childSessionId) => {
-            let session;
-            try {
-                session = await store.getSession(childSessionId);
-            }
-            catch (error) {
-                if (error instanceof MarAgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND')
-                    return undefined;
-                throw error;
-            }
-            if (session.source.type !== 'subagent' || session.source.parentSessionId !== parentSessionId)
-                return undefined;
-            return {
-                id: session.id,
-                createdAt: session.createdAt,
-                lastActivityAt: session.lastActivityAt,
-                source: session.source,
-                records: await store.read(session.id)
-            };
-        }
-    };
-}
-function resolveAgentModels(configurations, requestedDefaultModelId) {
-    const configuredModels = configurations.map((model) => ({
-        ...model,
-        defaultReasoningEffort: resolveModelDefaultReasoningEffort(model)
-    }));
-    const credentialProviders = new Set();
-    for (const model of configuredModels) {
-        if ((model.apiKey === undefined) === (model.credentialProvider === undefined))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Exactly one model credential source is required.');
-        if (model.responsesEncoding !== undefined &&
-            (model.protocol !== 'OPENAI_RESPONSES' ||
-                !['STANDARD', 'LITE'].includes(model.responsesEncoding)))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses encoding is invalid.');
-        if (model.fastMode === true && model.protocol !== 'OPENAI_RESPONSES')
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Fast mode requires Responses.');
-        if (model.serviceTier !== undefined &&
-            (model.protocol !== 'OPENAI_RESPONSES' ||
-                !['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'].includes(model.serviceTier)))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses service tier is invalid.');
-        if (model.credentialProvider !== undefined)
-            credentialProviders.add(model.credentialProvider);
-    }
-    const models = new Map(configuredModels.filter((model) => model.enabled).map((model) => [model.id, model]));
-    if (models.size === 0)
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'At least one enabled model is required.');
-    const defaultModelId = requestedDefaultModelId ?? models.keys().next().value;
-    if (!models.has(defaultModelId))
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Default model is unavailable.');
-    return { models, defaultModelId, credentialProviders };
-}
-function createModelTurnSession(adapter) {
-    const turn = adapter.createTurnSession?.() ?? {
-        start: (request, signal) => adapter.start(request, signal),
-        close: async () => undefined
-    };
-    return {
-        async *start(request, signal) {
-            const before = request.retryState?.attempts;
-            try {
-                yield* turn.start(request, signal);
-            }
-            finally {
-                // Custom adapters may not participate in the shared attempt accounting.
-                if (request.retryState && request.retryState.attempts === before)
-                    request.retryState.attempts++;
-            }
-        },
-        resetContinuation: () => turn.resetContinuation?.(),
-        close: () => turn.close()
-    };
-}
-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('')}`
-    };
-}
-async function closeModelAdapters(adapters) {
-    const results = await Promise.allSettled([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
-    const failure = results.find((result) => result.status === 'rejected');
-    if (failure !== undefined)
-        throw failure.reason;
-}
-function addModelCredentialProviders(target, configuration) {
-    if (configuration.credentialProvider !== undefined)
-        target.add(configuration.credentialProvider);
-}
-function truncateUtf8(value, maximumBytes) {
-    const bytes = Buffer.from(value);
-    if (bytes.length <= maximumBytes)
-        return value;
-    let end = maximumBytes;
-    while (end > 0 && (bytes[end] & 0xc0) === 0x80)
-        end--;
-    return bytes.subarray(0, end).toString('utf8');
-}
-function publicModelUsage(usage) {
-    const { rolloutBudgetUnits, ...publicUsage } = usage;
-    void rolloutBudgetUnits;
-    return publicUsage;
-}
-async function generateSessionTitle(adapter, prompt, reasoningEffort, signal, onAttemptDiagnostic) {
-    let titleInput = '';
-    let characters = 0;
-    for (const character of prompt) {
-        if (characters++ >= 1000)
-            break;
-        titleInput += character;
-    }
-    let output = '';
-    let completed = false;
-    const turn = createModelTurnSession(adapter);
-    try {
-        for await (const event of turn.start({
-            retryState: { attempts: 0, maxAttempts: 1 },
-            system: sessionTitlePrompt,
-            messages: [{ role: 'user', content: titleInput }],
-            tools: [],
-            reasoningEffort,
-            onAttemptDiagnostic
-        }, signal)) {
-            if (event.type === 'text.completed')
-                output = event.text;
-            else if (event.type === 'completed')
-                completed = event.reason === 'completed';
-        }
-    }
-    finally {
-        await turn.close();
-    }
-    if (!completed)
-        return undefined;
-    const line = output
-        .replace(/<think>[\s\S]*?<\/think>\s*/giu, '')
-        .split(/\r?\n/u)
-        .map((value) => value.trim())
-        .find(Boolean);
-    if (!line)
-        return undefined;
-    return [...line].slice(0, 50).join('');
-}
-async function restoreMessages(store, sessionId, records, options) {
-    const messages = [];
-    const modelProjection = new Map((options.projection ??
-        buildContextProjection(records, (await store.getSession(sessionId)).workspace)).entries.map((entry) => [entry.record.recordId, entry.message]));
-    let userMessages = [];
-    let ignoredImages = 0;
-    let currentTurnUserIndex;
-    let environmentState;
-    for (const record of records) {
-        const payload = record.payload;
-        const compactSummary = compactSummaryFromCheckpoint(record);
-        if (record.type === 'turn.user' && typeof payload.prompt === 'string') {
-            userMessages.push(payload.prompt);
-            let images = [];
-            if (options.includeImages)
-                try {
-                    images = await store.readInputImages(sessionId, payload.images);
-                }
-                catch (error) {
-                    if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_SESSION_CORRUPT')
-                        throw error;
-                    ignoredImages += Array.isArray(payload.images) ? payload.images.length : 1;
-                }
-            if (record.turnId === options.currentTurnId && currentTurnUserIndex === undefined)
-                currentTurnUserIndex = messages.length;
-            messages.push({
-                role: 'user',
-                content: payload.prompt,
-                ...(images.length ? { images } : {})
-            });
-        }
-        else if ((record.type === 'message.completed' || record.type === 'plan.completed') &&
-            typeof payload.text === 'string')
-            messages.push({ role: 'assistant', content: payload.text });
-        else if (compactSummary !== undefined) {
-            environmentState = restoreEnvironmentState({ version: 1, state: payload.environment });
-            if (environmentState)
-                messages.push(environmentContextUpdate(environmentState));
-            const history = replacementHistoryFromCheckpoint(record);
-            userMessages =
-                history
-                    ?.filter((message) => message.kind === 'user_input')
-                    .map((message) => message.content) ?? [];
-            messages.push(...(history
-                ? compactedHistoryMessages(history)
-                : [{ role: 'user', content: continuationMessage(compactSummary) }]));
-        }
-        else if (record.type === 'context.environment') {
-            const current = restoreEnvironmentState(payload);
-            if (current) {
-                const message = environmentContextUpdate(current, environmentState);
-                if (message)
-                    messages.push(message);
-                environmentState = current;
-            }
-        }
-        else if (record.type === 'model.context') {
-            const message = modelProjection.get(record.recordId);
-            if (message)
-                messages.push(message);
-        }
-    }
-    const completedToolCalls = new Set(messages.filter((message) => message.role === 'tool').map((message) => message.callId));
-    return {
-        environmentState,
-        userMessages,
-        messages: messages.filter((message) => {
-            if (message.role === 'tool_call')
-                return completedToolCalls.has(message.callId);
-            if (message.role !== 'provider' || message.provider !== 'OPENAI_RESPONSES')
-                return true;
-            const item = message.item;
-            if (item.type !== 'function_call' && item.type !== 'custom_tool_call')
-                return true;
-            return typeof item.call_id !== 'string' || completedToolCalls.has(item.call_id);
-        }),
-        ignoredImages,
-        currentTurnUserIndex
-    };
-}
-function currentExecutionImages(modelInputImages, toolImages) {
-    return [
-        ...(modelInputImages ?? []).map((image) => ({
-            mimeType: image.mimeType,
-            data: Buffer.from(image.dataBase64, 'base64')
-        })),
-        ...toolImages
-    ]
-        .slice(-5)
-        .map((image) => ({ mimeType: image.mimeType, data: Buffer.from(image.data) }));
-}
-function latestModelUsage(records, selectedModelId) {
-    let usage;
-    const toolCallIds = new Set();
-    // readContext starts at compact.completed, whose execution header is before the boundary.
-    let activeModelId = selectedModelId;
-    for (const record of records) {
-        const payload = record.payload;
-        if (compactSummaryFromCheckpoint(record) !== undefined) {
-            usage = undefined;
-            toolCallIds.clear();
-            activeModelId = modelIdFromPayload(payload);
-            continue;
-        }
-        if (record.type === 'execution.header') {
-            activeModelId = modelIdFromPayload(payload);
-            usage = undefined;
-            toolCallIds.clear();
-            continue;
-        }
-        if (record.type === 'model.context' && payload.role === 'tool_call') {
-            if (typeof payload.callId === 'string' && payload.callId.length > 0)
-                toolCallIds.add(payload.callId);
-            else
-                usage = undefined;
-        }
-        if (usage !== undefined) {
-            if (record.type === 'model.context') {
-                const role = payload.role;
-                if (role === 'tool') {
-                    if (typeof payload.callId !== 'string' || !toolCallIds.has(payload.callId))
-                        usage = undefined;
-                    else
-                        usage = {
-                            ...usage,
-                            appendedMessages: [
-                                ...(usage.appendedMessages ?? []),
-                                payload
-                            ]
-                        };
-                }
-                else if (role !== 'tool_call' && role !== 'assistant' && role !== 'provider')
-                    usage = undefined;
-            }
-            else if (invalidatesUsageCalibration(record.type, payload.type))
-                usage = undefined;
-        }
-        if (payload.type === 'usage.updated' && activeModelId === selectedModelId) {
-            const value = payload.contextInputTokens ?? payload.inputTokens;
-            if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
-                usage = {
-                    contextInputTokens: value,
-                    outputTokens: typeof payload.outputTokens === 'number' &&
-                        Number.isSafeInteger(payload.outputTokens) &&
-                        payload.outputTokens >= 0
-                        ? payload.outputTokens
-                        : undefined
-                };
-        }
-    }
-    return usage;
-}
-function reasoningEffortBaseline(records, modelId) {
-    let baseline;
-    for (let index = records.length - 1; index >= 0; index--) {
-        const record = records[index];
-        if (compactSummaryFromCheckpoint(record) !== undefined)
-            break;
-        if (record.type !== 'execution.header')
-            continue;
-        const payload = record.payload;
-        if (payload.modelId !== modelId)
-            break;
-        const effort = marAgentReasoningEffortSchema.safeParse(payload.reasoningEffort);
-        if (effort.success)
-            baseline = effort.data;
-    }
-    return baseline;
-}
-function lastConfigurationEffort(messages, modelId) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message.role !== 'provider' ||
-            message.provider !== 'OPENAI_RESPONSES' ||
-            message.providerModelId !== modelId ||
-            message.item?.type !== 'configuration_update')
-            continue;
-        const reasoning = message.item.reasoning;
-        const effort = marAgentReasoningEffortSchema.safeParse(reasoning?.effort);
-        if (effort.success)
-            return effort.data;
-    }
-    return undefined;
-}
-function shouldUseNativeCompaction(input) {
-    if (input.estimatedRequestTokens <= input.contextWindowTokens)
-        return true;
-    if (input.latestUsage === undefined || input.latestUsage.outputTokens === undefined)
-        return false;
-    const historyDelta = appendOnlyUsageDelta(input.latestUsage, input.historyMessages);
-    if (historyDelta === undefined)
-        return false;
-    const appendedTokens = countModelTokens(stableJson([...historyDelta, ...input.appendedMessages]));
-    return (input.latestUsage.contextInputTokens + input.latestUsage.outputTokens + appendedTokens <=
-        input.contextWindowTokens);
-}
-function appendOnlyUsageDelta(usage, historyMessages) {
-    if (usage.historyMessages === undefined)
-        return usage.appendedMessages ?? [];
-    if (historyMessages.length < usage.historyMessages.length)
-        return undefined;
-    for (let index = 0; index < usage.historyMessages.length; index++)
-        if (!isDeepStrictEqual(usage.historyMessages[index], historyMessages[index]))
-            return undefined;
-    const appended = historyMessages.slice(usage.historyMessages.length);
-    const toolCallIds = new Set(usage.historyMessages
-        .filter((message) => message.role === 'tool_call')
-        .map((message) => message.callId));
-    return appended.every((message) => (message.role === 'tool' && toolCallIds.has(message.callId)) ||
-        (message.role === 'user' && message.contextKind === 'environment'))
-        ? appended
-        : undefined;
-}
-function invalidatesUsageCalibration(recordType, payloadType) {
-    if (recordType === 'turn.user' ||
-        recordType === 'context.environment' ||
-        recordType === 'context.gc.completed')
-        return true;
-    return payloadType === 'message.completed';
-}
-const PROVIDER_CONTEXT_OVERFLOW_CODES = new Set([
-    'mar_agent_context_limit',
-    'context_length_exceeded',
-    'context_overflow',
-    'context_window_exceeded',
-    'prompt_too_long',
-    'request_too_large',
-    'string_above_max_length'
-]);
-const PROVIDER_CONTEXT_OVERFLOW_PATTERNS = [
-    /prompt is too long/iu,
-    /request_too_large/iu,
-    /input is too long for requested model/iu,
-    /exceeds (?:the )?(?:model'?s )?(?:maximum )?context (?:length|window)/iu,
-    /input token count.*exceeds the maximum/iu,
-    /tokens in request more than max tokens allowed/iu,
-    /maximum prompt length is \d+/iu,
-    /reduce the length of the messages/iu,
-    /maximum context length is \d+ tokens/iu,
-    /exceeds (?:the )?maximum allowed input length/iu,
-    /greater than the context length/iu,
-    /context window exceeds limit/iu,
-    /exceeded model token limit/iu,
-    /context[_ ]length[_ ]exceeded/iu,
-    /request entity too large/iu,
-    /input length.*exceeds.*context length/iu,
-    /prompt too long; exceeded (?:max )?context length/iu,
-    /model_context_window_exceeded/iu,
-    /too many tokens/iu,
-    /token limit exceeded/iu
-];
-const PROVIDER_CONTEXT_OVERFLOW_EXCLUSIONS = [
-    /^(?:[^:]+: )?(?:throttling error|service unavailable):/iu,
-    /rate limit/iu,
-    /too many requests/iu
-];
-function isProviderContextOverflow(error) {
-    if (!(error instanceof MarAgentError))
-        return false;
-    const code = error.code.trim().toLowerCase();
-    if (PROVIDER_CONTEXT_OVERFLOW_CODES.has(code))
-        return true;
-    if (error.details?.status === 413)
-        return true;
-    const message = error.message;
-    // K3-compatible gateways report context overflow as HTTP 401 instead of a
-    // standard provider error code. Keep this exception scoped to that exact shape.
-    if (error.details?.status === 401 && /supports only [\d,.]+[km]? context/iu.test(message))
-        return true;
-    if (code !== 'invalid_request_error' && code !== 'mar_agent_model_protocol_error')
-        return false;
-    return (!PROVIDER_CONTEXT_OVERFLOW_EXCLUSIONS.some((pattern) => pattern.test(message)) &&
-        PROVIDER_CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(message)));
-}
-function modelIdFromPayload(payload, key = 'modelId') {
-    const value = payload[key];
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function insertContextualWorldState(messages, entries) {
-    const result = [...messages];
-    let offset = 0;
-    for (const entry of entries) {
-        const insertionIndex = Math.max(0, Math.min(entry.index + offset, result.length));
-        result.splice(insertionIndex, 0, { role: 'user', content: entry.content });
-        offset++;
-    }
-    return result;
-}
-function latestContextualWorldStateGeneration(records) {
-    let generation;
-    for (const record of records)
-        if (record.type === 'context.gc.completed' ||
-            compactSummaryFromCheckpoint(record) !== undefined)
-            generation = record.recordId;
-    return generation;
-}
-const MAX_CONTEXTUAL_WORLD_STATE_ENTRIES = 1_024;
-const MAX_CONTEXTUAL_WORLD_STATE_CONTENT_BYTES = 8 * 1024 * 1024;
-function parsePersistedContextualWorldState(payload) {
-    if (payload === null || typeof payload !== 'object' || Array.isArray(payload))
-        return undefined;
-    const record = payload;
-    if (record.version !== 1)
-        return undefined;
-    const generation = record.generation === null
-        ? undefined
-        : typeof record.generation === 'string' && record.generation.length <= 128
-            ? record.generation
-            : null;
-    if (generation === null)
-        return undefined;
-    const instructionSnapshot = nullableWorldStateString(record.instructionSnapshot);
-    const resourceSnapshot = nullableWorldStateString(record.resourceSnapshot);
-    if (instructionSnapshot === null || resourceSnapshot === null || !Array.isArray(record.entries))
-        return undefined;
-    if (record.entries.length > MAX_CONTEXTUAL_WORLD_STATE_ENTRIES)
-        return undefined;
-    const entries = [];
-    let contentBytes = 0;
-    for (const value of record.entries) {
-        if (value === null || typeof value !== 'object' || Array.isArray(value))
-            return undefined;
-        const entry = value;
-        if (!Number.isSafeInteger(entry.index) ||
-            entry.index < 0 ||
-            (entry.kind !== 'instructions' && entry.kind !== 'resources' && entry.kind !== 'mcp') ||
-            typeof entry.content !== 'string' ||
-            entry.content.length === 0)
-            return undefined;
-        contentBytes += Buffer.byteLength(entry.content);
-        if (contentBytes > MAX_CONTEXTUAL_WORLD_STATE_CONTENT_BYTES)
-            return undefined;
-        entries.push({
-            index: entry.index,
-            kind: entry.kind,
-            content: entry.content
-        });
-    }
-    return {
-        generation,
-        initialized: true,
-        instructionSnapshot,
-        resourceSnapshot,
-        mcpSnapshot: typeof record.mcpSnapshot === 'string' ? record.mcpSnapshot : undefined,
-        entries
-    };
-}
-function nullableWorldStateString(value) {
-    if (value === null)
-        return undefined;
-    return typeof value === 'string' &&
-        Buffer.byteLength(value) <= MAX_CONTEXTUAL_WORLD_STATE_CONTENT_BYTES
-        ? value
-        : null;
-}
-async function persistContextualWorldState(store, sessionId, state) {
-    await store.writeContextualWorldState(sessionId, {
-        version: 1,
-        generation: state.generation ?? null,
-        instructionSnapshot: state.instructionSnapshot ?? null,
-        resourceSnapshot: state.resourceSnapshot ?? null,
-        mcpSnapshot: state.mcpSnapshot ?? null,
-        entries: state.entries
-    });
-}
-function compactHistoryMayContainRetainedResources(records) {
-    return records.some((record) => compactSummaryFromCheckpoint(record)?.includes('# Retained Session resources'));
-}
-function updateContextualWorldState(state, index, current) {
-    const entries = [...state.entries];
-    if (!state.initialized || state.instructionSnapshot !== current.instructionSnapshot) {
-        if (current.instructionContent !== undefined)
-            entries.push({ index, kind: 'instructions', content: current.instructionContent });
-    }
-    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, current.previousMayContainResources);
-    if (resourceContent !== undefined)
-        entries.push({ index, kind: 'resources', content: resourceContent });
-    return {
-        generation: state.generation,
-        mcpSnapshot: state.mcpSnapshot,
-        initialized: true,
-        instructionSnapshot: current.instructionSnapshot,
-        resourceSnapshot: current.resourceSnapshot,
-        entries
-    };
-}
-function resetContextualWorldState(generation, index, current) {
-    const entries = [];
-    if (current.instructionContent !== undefined)
-        entries.push({ index, kind: 'instructions', content: current.instructionContent });
-    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, undefined, current.previousMayContainResources);
-    if (resourceContent !== undefined)
-        entries.push({ index, kind: 'resources', content: resourceContent });
-    return {
-        generation,
-        initialized: true,
-        instructionSnapshot: current.instructionSnapshot,
-        resourceSnapshot: current.resourceSnapshot,
-        entries
-    };
-}
-function contextualInstructionInsertIndex(messages) {
-    let index = messages.findLastIndex((message) => message.role === 'user' && message.contextKind !== 'environment');
-    if (index < 0)
-        return 0;
-    if (index > 0 && messages[index - 1]?.contextKind === 'environment')
-        index--;
-    return index;
-}
-function estimatedRequestTokens(system, messages, tools, images) {
-    const transientImageCount = messages.reduce((total, message) => total + (message.images?.length ?? 0), images?.length ?? 0);
-    const textMessages = messages.map((message) => {
-        const textMessage = { ...message };
-        delete textMessage.images;
-        return textMessage;
-    });
-    return (countModelTokens(`${system}${stableJson(textMessages)}${stableJson(tools)}`) +
-        transientImageCount * AGENT_EXECUTION_POLICY.estimatedTokensPerImage);
-}
-function boundedModelToolOutput(toolName, value, data) {
-    const execDiagnostics = (toolName === 'exec' || toolName === 'exec_wait') &&
-        isRecord(data) &&
-        typeof data.stdout === 'string' &&
-        typeof data.stderr === 'string'
-        ? {
-            originalTokenCount: countModelTokens(data.stdout) + countModelTokens(data.stderr),
-            totalLines: countTextLines(data.stdout) + countTextLines(data.stderr)
-        }
-        : undefined;
-    const result = truncateModelText(value, AGENT_EXECUTION_POLICY.modelToolOutputTokens, 'tool output', execDiagnostics);
-    return { content: result.content, truncated: result.truncated };
-}
-function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(stableJson).join(',')}]`;
-    if (value !== null && typeof value === 'object')
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
-            .join(',')}}`;
-    return JSON.stringify(value) ?? 'undefined';
-}
-function discoveredMcpToolNames(messages) {
-    const calls = toolSearchCallIds(messages);
-    const names = new Set();
-    for (const message of messages)
-        for (const tool of calls.has(message.callId ?? '') ? (message.toolSearchTools ?? []) : [])
-            if (tool.name.startsWith('mcp__'))
-                names.add(tool.name);
-    return [...names];
-}
-function rebindMcpToolSearchOutputs(messages, registry) {
-    const calls = toolSearchCallIds(messages);
-    for (const message of messages) {
-        if (!message.toolSearchTools)
-            continue;
-        if (!calls.has(message.callId ?? '')) {
-            delete message.toolSearchTools;
-            continue;
-        }
-        const definitions = registry.restoredDefinitions(message.toolSearchTools.map((tool) => tool.name));
-        message.toolSearchTools = definitions;
-    }
-}
-function toolSearchCallIds(messages) {
-    return new Set(messages
-        .filter((message) => (message.role === 'tool_call' &&
-        message.name === 'tool_search' &&
-        typeof message.callId === 'string') ||
-        (message.role === 'provider' &&
-            providerToolName(message) === 'tool_search' &&
-            providerToolCallId(message) !== undefined))
-        .map((message) => message.role === 'provider' ? providerToolCallId(message) : message.callId));
-}
-/** Project only known, validated tool result shapes into public structured events. */
-function structuredToolEventData(toolName, value) {
-    if (!isRecord(value))
-        return undefined;
-    if ((toolName === 'code_exec' || toolName === 'code_exec_wait') &&
-        typeof value.cellId === 'string' &&
-        ['running', 'completed', 'failed', 'cancelled'].includes(String(value.status)))
-        return {
-            cellId: value.cellId,
-            status: value.status,
-            cached: value.cached === true
-        };
-    if ((toolName === 'agent_start' ||
-        toolName === 'agent_wait' ||
-        toolName === 'agent_message' ||
-        toolName === 'agent_cancel') &&
-        isSubagentTaskSnapshot(value))
-        return value;
-    if (toolName === 'read' &&
-        value.mode === 'batch' &&
-        Array.isArray(value.results) &&
-        typeof value.truncated === 'boolean' &&
-        value.results.every((result) => isRecord(result) &&
-            typeof result.path === 'string' &&
-            (result.startLine === undefined || isNonnegativeInteger(result.startLine)) &&
-            (result.endLine === undefined || isNonnegativeInteger(result.endLine)) &&
-            (result.error === undefined ||
-                (isRecord(result.error) &&
-                    typeof result.error.code === 'string' &&
-                    typeof result.error.message === 'string')))) {
-        const result = value;
-        return {
-            mode: 'batch',
-            truncated: result.truncated,
-            results: result.results.map((item) => ({
-                path: item.path,
-                ...('startLine' in item && item.startLine !== undefined
-                    ? { startLine: item.startLine }
-                    : {}),
-                ...('endLine' in item && item.endLine !== undefined ? { endLine: item.endLine } : {}),
-                ...('error' in item ? { error: { ...item.error } } : {})
-            }))
-        };
-    }
-    if (toolName === 'view_image' &&
-        typeof value.path === 'string' &&
-        (value.mimeType === 'image/png' ||
-            value.mimeType === 'image/jpeg' ||
-            value.mimeType === 'image/webp') &&
-        isNonnegativeInteger(value.bytes) &&
-        typeof value.sha256 === 'string' &&
-        /^[a-f0-9]{64}$/u.test(value.sha256))
-        return value;
-    if ((toolName === 'exec' || toolName === 'exec_wait') &&
-        (value.status === 'running' || value.status === 'completed' || value.status === 'cancelled') &&
-        typeof value.stdout === 'string' &&
-        typeof value.stderr === 'string' &&
-        typeof value.truncated === 'boolean' &&
-        (value.processId === undefined || typeof value.processId === 'string') &&
-        (value.exitCode === undefined ||
-            value.exitCode === null ||
-            (typeof value.exitCode === 'number' && Number.isInteger(value.exitCode))) &&
-        isNonnegativeInteger(value.stdoutBytes) &&
-        isNonnegativeInteger(value.stderrBytes) &&
-        isNonnegativeInteger(value.stdoutDroppedBytes) &&
-        isNonnegativeInteger(value.stderrDroppedBytes))
-        return value;
-    if (toolName === 'apply_patch' &&
-        Array.isArray(value.files) &&
-        value.files.every((file) => isRecord(file) &&
-            typeof file.path === 'string' &&
-            file.path.length > 0 &&
-            (file.targetPath === undefined || typeof file.targetPath === 'string') &&
-            (file.operation === 'added' ||
-                file.operation === 'modified' ||
-                file.operation === 'deleted' ||
-                file.operation === 'moved') &&
-            isNonnegativeInteger(file.addedLines) &&
-            isNonnegativeInteger(file.deletedLines)) &&
-        isRecord(value.totals) &&
-        isNonnegativeInteger(value.totals.files) &&
-        isNonnegativeInteger(value.totals.addedLines) &&
-        isNonnegativeInteger(value.totals.deletedLines))
-        return value;
-    return undefined;
-}
-function structuredToolArtifacts(value) {
-    if (value === undefined)
-        return undefined;
-    if (value.length !== 1 ||
-        value.some((artifact) => artifact.kind !== 'image' ||
-            artifact.mimeType !== 'image/png' ||
-            typeof artifact.name !== 'string' ||
-            artifact.name.length === 0 ||
-            typeof artifact.fileName !== 'string' ||
-            !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}\.png$/u.test(artifact.fileName) ||
-            !isNonnegativeInteger(artifact.byteSize) ||
-            typeof artifact.sha256 !== 'string' ||
-            !/^[a-f0-9]{64}$/u.test(artifact.sha256)))
-        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_INVALID', 'Tool image artifact is invalid.');
-    return value.map((artifact) => ({ ...artifact }));
-}
-/** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
-function eventForPersistence(event) {
-    if (event.type === 'message.delta' ||
-        event.type === 'context.compacting' ||
-        event.type === 'model.performance' ||
-        event.type === 'message.performance')
-        return undefined;
-    if (event.type !== 'tool.completed' || event.toolName !== 'exec' || !event.data)
-        return event;
-    const metadata = Object.fromEntries(Object.entries(event.data).filter(([key]) => key !== 'stdout' && key !== 'stderr'));
-    return { ...event, data: metadata };
-}
-function isModelResponseEvent(event) {
-    if (event.type === 'text.delta')
-        return event.delta.length > 0;
-    if (event.type === 'text.completed' || event.type === 'reasoning.summary')
-        return event.text.length > 0;
-    return (event.type === 'response.item' ||
-        event.type === 'output.delta' ||
-        event.type === 'client_tool.call' ||
-        event.type === 'hosted_tool' ||
-        event.type === 'citation');
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function isSubagentTaskSnapshot(value) {
-    return (typeof value.agentId === 'string' &&
-        value.agentId.length > 0 &&
-        value.agentId.length <= 128 &&
-        typeof value.description === 'string' &&
-        value.description.length > 0 &&
-        value.description.length <= TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters &&
-        (value.status === 'queued' ||
-            value.status === 'running' ||
-            value.status === 'completed' ||
-            value.status === 'failed' ||
-            value.status === 'cancelled' ||
-            value.status === 'interrupted') &&
-        (value.modelId === undefined || typeof value.modelId === 'string') &&
-        (value.modelName === undefined || typeof value.modelName === 'string') &&
-        (value.reasoningEffort === undefined ||
-            (typeof value.reasoningEffort === 'string' &&
-                ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(value.reasoningEffort))) &&
-        (value.waitOutcome === undefined ||
-            value.waitOutcome === 'snapshot' ||
-            value.waitOutcome === 'message' ||
-            value.waitOutcome === 'completion' ||
-            value.waitOutcome === 'timeout') &&
-        (value.latestMessage === undefined ||
-            (isRecord(value.latestMessage) &&
-                typeof value.latestMessage.itemId === 'string' &&
-                typeof value.latestMessage.turnId === 'string' &&
-                (value.latestMessage.phase === 'commentary' ||
-                    value.latestMessage.phase === 'final_answer') &&
-                typeof value.latestMessage.text === 'string' &&
-                typeof value.latestMessage.timestamp === 'string' &&
-                typeof value.latestMessage.truncated === 'boolean')) &&
-        (value.summary === undefined || typeof value.summary === 'string') &&
-        (value.changedFiles === undefined ||
-            (Array.isArray(value.changedFiles) &&
-                value.changedFiles.every((path) => typeof path === 'string'))) &&
-        (value.verification === undefined ||
-            (Array.isArray(value.verification) &&
-                value.verification.every((item) => typeof item === 'string'))) &&
-        (value.evidence === undefined ||
-            (Array.isArray(value.evidence) &&
-                value.evidence.every((item) => isRecord(item) &&
-                    typeof item.path === 'string' &&
-                    (item.startLine === undefined ||
-                        (typeof item.startLine === 'number' &&
-                            Number.isInteger(item.startLine) &&
-                            item.startLine >= 1)) &&
-                    (item.endLine === undefined ||
-                        (typeof item.endLine === 'number' &&
-                            Number.isInteger(item.endLine) &&
-                            item.endLine >= 1))))) &&
-        (value.errorCode === undefined || typeof value.errorCode === 'string'));
-}
-function isNonnegativeInteger(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
-}