@myagentroam/node 0.10.61 → 0.10.62

package/dist/runner/mar-agent/managed-run-controller.js

@@ -1,18 +1,13 @@
 import { NODE_MCP } from '../../mcp/naming.js';
 import { computerUseHostSkill } from './computer-use-skill.js';
 import { marctlExecutionEnvironment, marctlHostSkill } from './marctl-skill.js';
-import { compactRuntimeConfigurations, marAgentCompactExtensionSource, updateMarAgentCompactState } from './compact-extensions.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
-import { access, constants } from 'node:fs/promises';
-import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { nodeLog } from '../../operational.js';
-import { BUNDLED_RIPGREP_VERSION, bundledRipgrepPath, prependBundledRipgrepToPath } from '../../ripgrep-binary.js';
-import { LocalAgentHost, createMarAgent, generateSessionTitle } from '@myagentroam/agent';
-import { marAgentReasoningEffortSchema, resolveMarAgentDefaultReasoningEffort, marAgentRuntimeModelConfigurationSchema, marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
+import { createMarAgent, generateSessionTitle } from '@myagentroam/agent';
+import { marAgentReasoningEffortSchema, resolveMarAgentDefaultReasoningEffort, marAgentRuntimeModelConfigurationSchema } from '@myagentroam/protocol';
 import { boundedConversationItemId } from '../codex/conversation-parser.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
-import { canonicalJson } from '../../util/canonical-json.js';
 import { MarAgentMcpClientCache } from './mcp-client-pool.js';
 import { MarAgentConversationNormalizer, normalizeMarAgentUsage } from './conversation-normalizer.js';
 import { parseRunnerImageAttachments } from '../../util/node-operation-parsers.js';
@@ -21,29 +16,18 @@ import { MarAgentRuntimeModelFactory, sdkModelConfigurations, closeImageCredenti
 import { createImageGenerationExtensions } from './image-generation-extensions.js';
 import { createWebToolsExtensions } from './web-tools-extensions.js';
 import { combineExecutionExtensions } from './execution-extensions.js';
-const HOST_CONFIGURATION_CATEGORIES = [
-    'cwd',
-    'mcpServers',
-    'environment',
-    'guaranteedCommands'
-];
+import { MarAgentSessionRuntimeRegistry } from './session-runtime-registry.js';
+import { isExecutionScopedMcp } from './session-runtime.js';
 export class MarAgentManagedRunController {
     runner;
     host;
     #mcpClients = new MarAgentMcpClientCache();
     #executions = new Map();
     #steerTargets = new Map();
-    #sessionRuntimes = new Map();
-    #runtimeAcquisitions = new Map();
-    #runtimeCreations = new Map();
-    #sessionReleases = new Map();
+    #runtimes;
     #questions = new Map();
     #approvals = new Map();
     #normalizers = new Map();
-    #resourceIdleTtlMs;
-    #retainEnvironment;
-    #createAgent;
-    #modelFactory;
     #computerUse;
     #generateTitle;
     #disposePromise;
@@ -51,16 +35,30 @@ export class MarAgentManagedRunController {
     constructor(runner, host, options = {}) {
         this.runner = runner;
         this.host = host;
-        this.#resourceIdleTtlMs = options.resourceIdleTtlMs ?? 10 * 60_000;
-        this.#retainEnvironment = options.retainEnvironment;
-        this.#createAgent = options.createAgent ?? createMarAgent;
-        this.#modelFactory =
-            options.modelFactory ??
+        this.#runtimes = new MarAgentSessionRuntimeRegistry({
+            mcpClients: this.#mcpClients,
+            resourceIdleTtlMs: options.resourceIdleTtlMs ?? 10 * 60_000,
+            ...(options.retainEnvironment === undefined
+                ? {}
+                : { retainEnvironment: options.retainEnvironment }),
+            createAgent: options.createAgent ?? createMarAgent,
+            modelFactory: options.modelFactory ??
                 new MarAgentRuntimeModelFactory({
                     resolve: async () => {
                         throw new Error('MAR_AGENT_RUNTIME_CREDENTIALS_UNSUPPORTED');
                     }
-                });
+                }),
+            customTitle: (sessionId) => this.host.customTitle?.(sessionId) ?? undefined,
+            modelUsage: (runId, usage) => this.host.emit(runId, 'run.usage', normalizeMarAgentUsage(usage)),
+            question: (runId, request, signal) => this.requestQuestion(runId, request, signal),
+            ...(this.host.createApproval && this.host.publishApproval
+                ? {
+                    approval: (runId, request, signal) => this.requestApproval(runId, request, signal)
+                }
+                : {})
+        }, (sessionId, nativeId) => this.host.promote(sessionId, nativeId), async (sessionId) => {
+            await this.#computerUse?.releaseSession(sessionId);
+        });
         this.#computerUse = options.computerUse;
         this.#generateTitle = options.generateTitle ?? generateSessionTitle;
     }
@@ -68,50 +66,25 @@ export class MarAgentManagedRunController {
         if (this.#disposePromise !== undefined)
             return this.#disposePromise;
         this.#disposed = true;
-        this.#disposePromise = (async () => {
-            for (const execution of this.#executions.values()) {
-                execution.cancelTitle();
-                execution.cancel();
-            }
-            await Promise.allSettled([...new Set(this.#runtimeAcquisitions.values())]);
+        this.#disposePromise = Promise.resolve().then(async () => {
             for (const execution of this.#executions.values()) {
                 execution.cancelTitle();
                 execution.cancel();
             }
-            await Promise.all([...new Set(this.#sessionRuntimes.values())].map((runtime) => this.#releaseRuntime(runtime, 'controller_disposed')));
-            await this.#mcpClients.close();
-            await this.#computerUse?.dispose();
-        })();
+            const results = await Promise.allSettled([
+                this.#runtimes.dispose(),
+                ...[...this.#executions.values()].map((execution) => execution.settled)
+            ]);
+            results.push(...(await Promise.allSettled([this.#mcpClients.close()])));
+            results.push(...(await Promise.allSettled([this.#computerUse?.dispose()])));
+            const failure = results.find((result) => result.status === 'rejected');
+            if (failure?.status === 'rejected')
+                throw failure.reason;
+        });
         return this.#disposePromise;
     }
     releaseSession(sessionId) {
-        const existing = this.#sessionReleases.get(sessionId);
-        if (existing !== undefined)
-            return existing;
-        const release = (async () => {
-            await this.#runtimeAcquisitions.get(sessionId)?.catch(() => undefined);
-            const runtime = this.#sessionRuntimes.get(sessionId);
-            if (runtime === undefined) {
-                await this.#computerUse?.releaseSession(sessionId);
-                return;
-            }
-            if (runtime.activeRunId !== undefined) {
-                const execution = this.#executions.get(runtime.activeRunId);
-                execution?.cancelTitle();
-                execution?.cancel();
-            }
-            await this.#releaseRuntime(runtime, 'session_released');
-            await Promise.all([
-                this.#computerUse?.releaseSession(sessionId),
-                this.#computerUse?.releaseSession(runtime.session.id)
-            ]);
-        })();
-        const tracked = release.finally(() => {
-            if (this.#sessionReleases.get(sessionId) === tracked)
-                this.#sessionReleases.delete(sessionId);
-        });
-        this.#sessionReleases.set(sessionId, tracked);
-        return tracked;
+        return this.#runtimes.releaseSession(sessionId);
     }
     async executeCommand(session, command, input, context) {
         if (command.id === 'plan') {
@@ -260,28 +233,24 @@ export class MarAgentManagedRunController {
         const titleController = new AbortController();
         let cancelExecution;
         // Own cancellation before any asynchronous preparation, not only after SDK admission.
-        this.#executions.set(input.runId, {
+        let resolveSettled;
+        const settled = new Promise((resolve) => {
+            resolveSettled = resolve;
+        });
+        const execution = {
             cancel: () => {
                 if (controller.signal.aborted)
                     return;
                 controller.abort();
                 cancelExecution?.();
             },
-            cancelTitle: () => titleController.abort()
-        });
-        this.host.active.add(input.runId);
-        this.host.adopt({
-            runId: input.runId,
-            sessionId: input.sessionId,
-            runner: 'mar-agent',
-            cwd: input.cwd,
-            ...(input.externalSessionId ? { externalSessionId: input.externalSessionId } : {}),
-            ...(input.initiatedByUserId === undefined
-                ? {}
-                : { initiatedByUserId: input.initiatedByUserId })
-        });
-        this.host.emit(input.runId, 'run.started', {}, 'STARTING');
+            cancelTitle: () => titleController.abort(),
+            settled
+        };
+        this.#executions.set(input.runId, execution);
         let runtime;
+        let use;
+        let terminalPublished = false;
         let executionMcpLease;
         let executionMcpBinding;
         let computerUseBinding;
@@ -289,42 +258,35 @@ export class MarAgentManagedRunController {
         let titleTask;
         let cancelledDuringPreparation = false;
         try {
+            this.host.active.add(input.runId);
+            this.host.adopt({
+                runId: input.runId,
+                sessionId: input.sessionId,
+                runner: 'mar-agent',
+                cwd: input.cwd,
+                ...(input.externalSessionId ? { externalSessionId: input.externalSessionId } : {}),
+                ...(input.initiatedByUserId === undefined
+                    ? {}
+                    : { initiatedByUserId: input.initiatedByUserId })
+            });
+            this.host.emit(input.runId, 'run.started', {}, 'STARTING');
+            if (this.#disposed)
+                throw new Error('MAR_AGENT_RUN_CONTROLLER_DISPOSED');
             controller.signal.throwIfAborted();
-            const sessionKey = input.externalSessionId ?? input.sessionId;
-            // Reserve both identities while opening so a concurrent release can await the same runtime.
-            const acquisitionKeys = [...new Set([sessionKey, input.sessionId])];
-            if (acquisitionKeys.some((key) => this.#runtimeAcquisitions.get(key) !== undefined))
-                throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
-            const acquisition = this.#acquireRuntime(input);
-            for (const key of acquisitionKeys)
-                this.#runtimeAcquisitions.set(key, acquisition);
-            let acquired = false;
-            try {
-                runtime = await acquisition;
-                acquired = true;
-                executionModels = runtime.models;
-            }
-            finally {
-                for (const key of acquisitionKeys)
-                    if (this.#runtimeAcquisitions.get(key) === acquisition)
-                        this.#runtimeAcquisitions.delete(key);
-                // A failed acquisition may have retained an idle Runtime before setup failed.
-                if (!acquired)
-                    this.#restoreRuntimeRelease(this.#sessionRuntimes.get(sessionKey));
-            }
-            controller.signal.throwIfAborted();
-            if (this.#disposed ||
-                this.#sessionReleases.has(sessionKey) ||
-                this.#sessionReleases.has(input.sessionId) ||
-                this.#sessionReleases.has(runtime.session.id)) {
-                await this.#releaseRuntime(runtime, 'admission_released');
-                throw new Error('MAR_AGENT_SESSION_RUNTIME_RELEASED');
-            }
-            if (runtime.activeRunId !== undefined)
-                throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
-            runtime.activeRunId = input.runId;
+            use = await this.#runtimes.acquire(input, {
+                runId: input.runId,
+                signal: controller.signal,
+                cancel: () => {
+                    titleController.abort();
+                    execution.cancel();
+                },
+                settled
+            });
+            runtime = use.runtime;
+            executionModels = runtime.models;
+            use.assertUsable();
             await runtime.mcpLease.pool.refreshForExecution();
-            controller.signal.throwIfAborted();
+            use.assertUsable();
             const marctlSkill = marctlHostSkill(input.secretEnvironment);
             const executionMcpServers = input.mcpServers
                 .filter(isExecutionScopedMcp)
@@ -337,23 +299,14 @@ export class MarAgentManagedRunController {
                 enabled: input.computerUseEnabled === true,
                 modelSupportsImages: input.model.inputCapabilities.includes('IMAGE')
             });
-            controller.signal.throwIfAborted();
-            if (this.#disposed ||
-                this.#sessionReleases.has(sessionKey) ||
-                this.#sessionReleases.has(input.sessionId) ||
-                this.#sessionReleases.has(runtime.session.id)) {
-                await computerUseBinding?.close().catch(() => undefined);
-                computerUseBinding = undefined;
-                await this.#computerUse?.releaseSession(runtime.session.id);
-                throw new Error('MAR_AGENT_SESSION_RUNTIME_RELEASED');
-            }
+            use.assertUsable();
             if (executionMcpServers.length > 0) {
                 executionMcpLease = await this.#mcpClients.acquire(executionMcpServers, input.cwd, {
                     reusable: false,
                     authorizationScope: runtime.session.id
                 });
             }
-            controller.signal.throwIfAborted();
+            use.assertUsable();
             const userTools = executionMcpLease?.pool.definitions() ?? [];
             const nodeTools = computerUseBinding?.tools ?? [];
             if (userTools.some((tool) => tool.name.startsWith('mcp__mar_computer__')))
@@ -441,7 +394,7 @@ export class MarAgentManagedRunController {
             const metadata = input.mode === 'compact' || !runtime.automaticTitleEnabled
                 ? undefined
                 : await runtime.agent.getSession(session.id).catch(() => undefined);
-            controller.signal.throwIfAborted();
+            use.assertUsable();
             const handle = input.mode === 'plan'
                 ? session.plan({
                     ...runInput
@@ -498,7 +451,6 @@ export class MarAgentManagedRunController {
                             });
                         return undefined;
                     });
-                    runtime.automaticTitleTask = { cancel: () => titleController.abort(), result: titleTask };
                 }
                 this.project(input.runId, event);
             }
@@ -528,7 +480,8 @@ export class MarAgentManagedRunController {
                     : result.status === 'cancelled'
                         ? 'CANCELLED'
                         : 'FAILED';
-            this.#prepareRuntimeForTerminal(input.runId, runtime);
+            use?.terminal();
+            terminalPublished = true;
             this.host.emit(input.runId, status === 'SUCCEEDED'
                 ? 'run.completed'
                 : status === 'CANCELLED'
@@ -551,13 +504,18 @@ export class MarAgentManagedRunController {
             }, status);
         }
         catch (error) {
-            if (controller.signal.aborted && cancelExecution === undefined) {
+            if (terminalPublished) {
+                nodeLog('runner.mar-agent.run.cleanup_failed', {
+                    runId: input.runId,
+                    code: 'MAR_AGENT_RUN_CLEANUP_FAILED'
+                });
+            }
+            else if (controller.signal.aborted && cancelExecution === undefined) {
                 // Keep the Run owned until preparation and its resources actually settle.
                 cancelledDuringPreparation = true;
             }
             else {
-                if (runtime !== undefined)
-                    this.#prepareRuntimeForTerminal(input.runId, runtime);
+                use?.terminal();
                 const projected = runnerErrorProjection(error, 'MAR_AGENT_RUN_FAILED');
                 this.host.emitItem(input.runId, {
                     itemId: boundedConversationItemId('mar-agent-error', input.runId),
@@ -574,296 +532,55 @@ export class MarAgentManagedRunController {
         }
         finally {
             titleController.abort();
-            await titleTask;
-            if (runtime !== undefined && runtime.automaticTitleTask?.result === titleTask)
-                delete runtime.automaticTitleTask;
-            this.clearInteractions(input.runId);
-            this.#normalizers.delete(input.runId);
-            await closeImageCredentialProviders(executionModels);
-            await computerUseBinding?.close().catch(() => undefined);
-            runtime?.host.unbindExecutionMcp(executionMcpBinding);
-            await executionMcpLease?.release().catch(() => undefined);
-            if (runtime !== undefined)
-                await this.#finishRuntimeExecution(input.runId, runtime).catch(() => undefined);
-            this.host.active.delete(input.runId);
-            this.#executions.delete(input.runId);
-            this.#steerTargets.delete(input.runId);
-            if (cancelledDuringPreparation)
-                this.host.emit(input.runId, 'run.cancelled', { status: 'CANCELLED' }, 'CANCELLED');
-        }
-    }
-    #prepareRuntimeForTerminal(runId, runtime) {
-        if (runtime.activeRunId !== runId)
-            return;
-        delete runtime.activeRunId;
-        this.#scheduleRuntimeRelease(runtime);
-    }
-    async #finishRuntimeExecution(runId, runtime) {
-        if (runtime.activeRunId === runId)
-            this.#prepareRuntimeForTerminal(runId, runtime);
-        else
-            this.#restoreRuntimeRelease(runtime);
-    }
-    async #acquireRuntime(input) {
-        if (this.#disposed)
-            throw new Error('MAR_AGENT_RUN_CONTROLLER_DISPOSED');
-        const sessionKey = input.externalSessionId ?? input.sessionId;
-        const retained = this.#retainRuntime(sessionKey);
-        try {
-            const hostConfiguration = await resolveMarAgentHostRuntimeConfiguration(input.secretEnvironment);
-            if (this.#disposed)
-                throw new Error('MAR_AGENT_RUN_CONTROLLER_DISPOSED');
-            const fingerprint = sessionHostFingerprint(input, hostConfiguration);
-            const modelFingerprint = sessionModelFingerprint(input);
-            const creationKeys = [...new Set([sessionKey, input.sessionId])];
-            const pending = creationKeys
-                .map((key) => this.#runtimeCreations.get(key))
-                .find((creation) => creation !== undefined);
-            if (pending !== undefined) {
-                await pending;
-                return this.#acquireRuntime(input);
-            }
-            const existing = this.#sessionRuntimes.get(sessionKey);
-            if (existing !== undefined) {
-                if (existing.activeRunId !== undefined)
-                    throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
-                if (!existing.released &&
-                    existing.release === undefined &&
-                    existing.fingerprint.value === fingerprint.value) {
-                    const configurations = compactRuntimeConfigurations(input.models, input.compact);
-                    if (existing.modelFingerprint !== modelFingerprint ||
-                        configurations.some((model) => model.credential?.type === 'RUNTIME_TICKET' ||
-                            model.imageGeneration?.credential?.type === 'RUNTIME_TICKET')) {
-                        const models = this.#modelFactory.create(configurations, {
-                            ...(input.runtimeScopeId === undefined
-                                ? {}
-                                : { runtimeScopeId: input.runtimeScopeId }),
-                            executionId: input.runId
-                        });
-                        try {
-                            await existing.agent.reconfigureModels({
-                                models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
-                                defaultModelId: input.model.id
-                            });
-                            existing.models = models;
-                            existing.modelFingerprint = modelFingerprint;
-                        }
-                        catch (error) {
-                            await closeModelCredentialProviders(models);
-                            throw error;
-                        }
+            const cleanup = [
+                async () => {
+                    await titleTask;
+                },
+                async () => {
+                    this.clearInteractions(input.runId);
+                },
+                async () => {
+                    await closeImageCredentialProviders(executionModels);
+                },
+                async () => {
+                    await computerUseBinding?.close();
+                },
+                async () => {
+                    runtime?.host.unbindExecutionMcp(executionMcpBinding);
+                },
+                async () => {
+                    await executionMcpLease?.release();
+                }
+            ];
+            try {
+                for (const close of cleanup) {
+                    try {
+                        await close();
                     }
-                    const personalInstructions = input.personalInstructions ??
-                        (input.mode === 'compact' ? existing.personalInstructions : '');
-                    if (existing.personalInstructions !== personalInstructions) {
-                        existing.agent.setSystemInstruction(personalInstructions || undefined);
-                        existing.personalInstructions = personalInstructions;
+                    catch {
+                        nodeLog('runner.mar-agent.run.cleanup_failed', {
+                            runId: input.runId,
+                            code: 'MAR_AGENT_RUN_CLEANUP_FAILED'
+                        });
                     }
-                    updateMarAgentCompactState(existing.compactState, input.compact, existing.models, input.models.map((model) => model.id));
-                    this.#retainRuntime(sessionKey);
-                    nodeLog('runner.mar-agent.runtime.reused', {
-                        runtimeId: existing.runtimeId,
-                        sessionId: existing.session.id,
-                        runId: input.runId
-                    });
-                    return existing;
                 }
-                await this.#releaseRuntime(existing, 'host_configuration_changed', HOST_CONFIGURATION_CATEGORIES.filter((category) => existing.fingerprint.categories[category] !== fingerprint.categories[category]));
-            }
-            const creation = this.#createRuntime(input, sessionKey, fingerprint, hostConfiguration);
-            for (const key of creationKeys)
-                this.#runtimeCreations.set(key, creation);
-            try {
-                return await creation;
             }
             finally {
-                for (const key of creationKeys)
-                    if (this.#runtimeCreations.get(key) === creation)
-                        this.#runtimeCreations.delete(key);
+                use?.terminal();
+                this.#normalizers.delete(input.runId);
+                this.host.active.delete(input.runId);
+                this.#executions.delete(input.runId);
+                this.#steerTargets.delete(input.runId);
+                resolveSettled();
             }
-        }
-        catch (error) {
-            this.#restoreRuntimeRelease(retained);
-            throw error;
-        }
-    }
-    async #createRuntime(input, sessionKey, fingerprint, hostConfiguration) {
-        const sharedMcpServers = input.mcpServers.filter((server) => !isExecutionScopedMcp(server));
-        const mcpLease = await this.#mcpClients.acquire(sharedMcpServers, input.cwd, {
-            // Native Session IDs are assigned after the first lease; do not let that promotion
-            // change a confirmed actor's discovery identity when its warm runtime is recreated.
-            authorizationScope: input.secretEnvironment?.['MAR_USERNAME'] ? input.cwd : sessionKey
-        });
-        let agent;
-        let runtime;
-        let models = [];
-        let releaseEnvironment;
-        try {
-            releaseEnvironment = this.#retainEnvironment?.(input.secretEnvironment ?? {});
-            const mcp = mcpLease.pool;
-            const localHost = new LocalAgentHost({
-                modelUsage: (usage) => {
-                    const runId = runtime?.activeRunId;
-                    if (runId !== undefined)
-                        this.host.emit(runId, 'run.usage', normalizeMarAgentUsage(usage));
-                },
-                mode: 'node',
-                homeDirectory: homedir(),
-                workspace: input.cwd,
-                environment: hostConfiguration.environment,
-                guaranteedCommands: hostConfiguration.guaranteedCommands,
-                question: async (request, signal) => {
-                    const runId = runtime?.activeRunId;
-                    return runId === undefined ? {} : this.requestQuestion(runId, request, signal);
-                },
-                approval: this.host.createApproval && this.host.publishApproval
-                    ? (request, signal) => {
-                        const runId = runtime?.activeRunId;
-                        if (runId === undefined)
-                            return Promise.resolve('REJECTED');
-                        return this.requestApproval(runId, request, signal);
-                    }
-                    : undefined,
-                mcpCatalog: () => mcp.catalog(),
-                callMcp: async (call, signal, context) => mcp.call(call.name, call.arguments, signal, context?.expectedTool),
-                resourceIdleTtlMs: this.#resourceIdleTtlMs
-            });
-            models = this.#modelFactory.create(compactRuntimeConfigurations(input.models, input.compact), {
-                ...(input.runtimeScopeId === undefined ? {} : { runtimeScopeId: input.runtimeScopeId }),
-                executionId: input.runId
-            });
-            const compactState = { revision: 0 };
-            updateMarAgentCompactState(compactState, input.compact, models, input.models.map((model) => model.id));
-            agent = await this.#createAgent({
-                mode: 'node',
-                host: localHost,
-                models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
-                defaultModelId: input.model.id,
-                runtimeExtensions: marAgentCompactExtensionSource(compactState),
-                ...(input.personalInstructions ? { systemInstruction: input.personalInstructions } : {})
-            });
-            const customTitle = this.host.customTitle?.(input.sessionId) ?? undefined;
-            const session = input.externalSessionId
-                ? await agent.openSession(input.externalSessionId)
-                : await agent.createSession({
-                    workspace: input.cwd,
-                    ...(customTitle === undefined ? {} : { title: customTitle })
-                });
-            runtime = {
-                runtimeId: randomUUID(),
-                fingerprint,
-                agent,
-                session,
-                host: localHost,
-                normalizer: new MarAgentConversationNormalizer(),
-                mcpLease,
-                releaseEnvironment,
-                automaticTitleEnabled: input.externalSessionId === undefined,
-                models,
-                compactState,
-                modelFingerprint: sessionModelFingerprint(input),
-                personalInstructions: input.personalInstructions ?? '',
-                released: false
-            };
-            this.#sessionRuntimes.set(sessionKey, runtime);
-            this.#sessionRuntimes.set(session.id, runtime);
-            nodeLog('runner.mar-agent.runtime.created', {
-                runtimeId: runtime.runtimeId,
-                sessionId: session.id,
-                runId: input.runId
-            });
-            if (!input.externalSessionId)
-                this.host.promote(input.sessionId, session.id);
-            return runtime;
-        }
-        catch (error) {
-            await agent?.dispose().catch(() => undefined);
-            await closeModelCredentialProviders(models);
-            await mcpLease.release().catch(() => undefined);
-            releaseEnvironment?.();
-            throw error;
+            if (cancelledDuringPreparation)
+                this.host.emit(input.runId, 'run.cancelled', { status: 'CANCELLED' }, 'CANCELLED');
         }
     }
     #resolveMcpServers(installations, environment, executionServers = []) {
         const servers = this.runner.mcpConfiguration(installations, environment, executionServers);
         return servers;
     }
-    #runtimeInUse(runtime) {
-        return (runtime.activeRunId !== undefined ||
-            [...this.#runtimeAcquisitions.keys()].some((key) => this.#sessionRuntimes.get(key) === runtime));
-    }
-    #scheduleRuntimeRelease(runtime) {
-        // Old finalizers must neither reclaim a continuation nor extend its idle lease.
-        if (runtime.released ||
-            runtime.release !== undefined ||
-            runtime.idleTimer !== undefined ||
-            this.#runtimeInUse(runtime))
-            return;
-        const timer = setTimeout(() => {
-            if (runtime.idleTimer !== timer)
-                return;
-            delete runtime.idleTimer;
-            if (!this.#runtimeInUse(runtime))
-                void this.#releaseRuntime(runtime, 'idle_expired');
-        }, this.#resourceIdleTtlMs);
-        runtime.idleTimer = timer;
-        timer.unref();
-    }
-    #retainRuntime(sessionKey) {
-        const runtime = this.#sessionRuntimes.get(sessionKey);
-        if (runtime?.idleTimer !== undefined) {
-            clearTimeout(runtime.idleTimer);
-            delete runtime.idleTimer;
-        }
-        return runtime;
-    }
-    #restoreRuntimeRelease(runtime) {
-        if (runtime === undefined ||
-            runtime.released ||
-            runtime.release !== undefined ||
-            runtime.activeRunId !== undefined ||
-            ![...this.#sessionRuntimes.values()].includes(runtime))
-            return;
-        this.#scheduleRuntimeRelease(runtime);
-    }
-    #releaseRuntime(runtime, reason, changedCategories = []) {
-        if (runtime.release !== undefined)
-            return runtime.release;
-        runtime.release = (async () => {
-            runtime.released = true;
-            nodeLog('runner.mar-agent.runtime.releasing', {
-                runtimeId: runtime.runtimeId,
-                sessionId: runtime.session.id,
-                reason,
-                ...(changedCategories.length === 0 ? {} : { changedCategories }),
-                ...(runtime.activeRunId === undefined ? {} : { runId: runtime.activeRunId })
-            });
-            if (runtime.idleTimer !== undefined) {
-                clearTimeout(runtime.idleTimer);
-                delete runtime.idleTimer;
-            }
-            try {
-                if (runtime.automaticTitleTask !== undefined) {
-                    runtime.automaticTitleTask.cancel();
-                    await runtime.automaticTitleTask.result;
-                }
-                try {
-                    await this.#computerUse?.releaseSession(runtime.session.id);
-                }
-                finally {
-                    await runtime.agent.dispose();
-                }
-            }
-            finally {
-                await runtime.mcpLease.release().catch(() => undefined);
-                runtime.releaseEnvironment?.();
-                for (const [sessionId, candidate] of this.#sessionRuntimes)
-                    if (candidate === runtime)
-                        this.#sessionRuntimes.delete(sessionId);
-            }
-        })();
-        return runtime.release;
-    }
     requestQuestion(runId, request, signal = new AbortController().signal) {
         const questions = normalizeQuestions(request.questions);
         if (questions.length === 0)
@@ -980,7 +697,7 @@ export class MarAgentManagedRunController {
                 itemId: boundedConversationItemId('mar-agent-message', event.itemId)
             });
         else {
-            let normalizer = this.#normalizers.get(runId) ?? this.#sessionRuntimes.get(event.sessionId)?.normalizer;
+            let normalizer = this.#normalizers.get(runId) ?? this.#runtimes.findRuntime(event.sessionId)?.normalizer;
             if (normalizer === undefined) {
                 normalizer = new MarAgentConversationNormalizer();
                 this.#normalizers.set(runId, normalizer);
@@ -1008,77 +725,6 @@ function contextUsageChanged(event) {
             event.purpose !== 'compact' &&
             (event.contextInputTokens !== undefined || event.inputTokens !== undefined)));
 }
-function isExecutionScopedMcp(server) {
-    return (server.lifecycle === 'EXECUTION' ||
-        (server.transport === 'STDIO' && server.environment?.['MAR_CTL_USER_TOKEN'] !== undefined));
-}
-function sessionHostFingerprint(input, hostConfiguration) {
-    const configuration = {
-        cwd: input.cwd,
-        mcpServers: input.mcpServers.filter((server) => !isExecutionScopedMcp(server)),
-        environment: Object.entries(hostConfiguration.environment)
-            .filter((entry) => entry[1] !== undefined)
-            .sort(([left], [right]) => left.localeCompare(right)),
-        guaranteedCommands: Object.entries(hostConfiguration.guaranteedCommands).sort(([left], [right]) => left.localeCompare(right))
-    };
-    const digest = (value) => createHash('sha256').update(canonicalJson(value)).digest('hex');
-    return {
-        value: digest(configuration),
-        // Only fixed category names leave this comparison; never log these value fingerprints.
-        categories: {
-            cwd: digest(configuration.cwd),
-            mcpServers: digest(configuration.mcpServers),
-            environment: digest(configuration.environment),
-            guaranteedCommands: digest(configuration.guaranteedCommands)
-        }
-    };
-}
-function sessionModelFingerprint(input) {
-    const compact = marAgentRuntimeCompactConfigurationSchema.safeParse(input.compact);
-    return createHash('sha256')
-        .update(JSON.stringify({
-        defaultModelId: input.model.id,
-        compact: compact.success
-            ? {
-                model: runtimeModelFingerprint(compact.data.model),
-                effort: compact.data.reasoningEffort
-            }
-            : null,
-        models: input.models.map(runtimeModelFingerprint)
-    }))
-        .digest('hex');
-}
-async function resolveMarAgentHostRuntimeConfiguration(secretEnvironment = {}) {
-    const environment = nodeExecutionEnvironment({
-        ...secretEnvironment,
-        MAR_CTL_CONTEXT_REQUIRED: '1'
-    });
-    // CLI credentials are bound to each execution, never retained as Host configuration.
-    delete environment['MAR_CTL_USER_TOKEN'];
-    for (const key of [
-        'MAR_CTL_NODE_ID',
-        'MAR_CTL_WORKSPACE_ID',
-        'MAR_CTL_SESSION_ID',
-        'MAR_CTL_RUN_ID',
-        'MAR_CTL_RUNNER'
-    ])
-        delete environment[key];
-    const ripgrep = await availableBundledRipgrep();
-    return {
-        environment: ripgrep === undefined ? environment : prependBundledRipgrepToPath(environment, ripgrep),
-        guaranteedCommands: ripgrep === undefined ? {} : { rg: BUNDLED_RIPGREP_VERSION }
-    };
-}
-async function availableBundledRipgrep() {
-    try {
-        const executable = bundledRipgrepPath();
-        await access(executable, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
-        return executable;
-    }
-    catch {
-        return undefined;
-    }
-}
 function normalizeQuestions(raw) {
     return raw.flatMap((value) => {
         if (value === null || typeof value !== 'object' || Array.isArray(value))
@@ -1132,44 +778,3 @@ export function resolveRunModels(marAgentModel, marAgentModels) {
         return true;
     });
 }
-function runtimeModelFingerprint(model) {
-    const { apiKey, credential, imageGeneration, ...configuration } = model;
-    return {
-        ...configuration,
-        ...(imageGeneration === undefined
-            ? {}
-            : {
-                imageGeneration: {
-                    ...imageGeneration,
-                    credential: runtimeCredentialFingerprint(imageGeneration.credential)
-                }
-            }),
-        ...(apiKey === undefined
-            ? {}
-            : { apiKeyHash: createHash('sha256').update(apiKey).digest('hex') }),
-        credential: runtimeCredentialFingerprint(credential)
-    };
-}
-function runtimeCredentialFingerprint(credential) {
-    return credential?.type === 'INLINE_API_KEY'
-        ? {
-            type: credential.type,
-            valueHash: createHash('sha256').update(credential.value).digest('hex')
-        }
-        : credential === undefined
-            ? undefined
-            : {
-                type: credential.type,
-                credentialId: credential.credentialId
-            };
-}
-async function closeModelCredentialProviders(models) {
-    await Promise.allSettled([
-        ...new Set(models.flatMap((model) => [
-            ...(model.credentialProvider === undefined ? [] : [model.credentialProvider]),
-            ...(model.imageGeneration?.credentialProvider === undefined
-                ? []
-                : [model.imageGeneration.credentialProvider])
-        ]))
-    ].map((provider) => provider.close()));
-}