@myagentroam/node 0.11.39 → 0.11.40

package/dist/session/session-lifecycle-service.js

@@ -6,6 +6,8 @@ import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 import { ScheduledSessionStore } from '../service/scheduled-session-store.js';
 import { normalizeSessionPrompt } from '../runner/personal-instructions.js';
 import { resolveWorkspaceExecutionDirectory } from '../workspace/path-access.js';
+import { checkSessionAdmission } from './operation-admission.js';
+const AGENT_GOAL_START = Symbol('agent-goal-start');
 export class SessionLifecycleService {
     options;
     starts = new Map();
@@ -24,6 +26,10 @@ export class SessionLifecycleService {
     clear() {
         this.starts.clear();
     }
+    /** Use the normal Session bootstrap while its Goal owner submits the first message. */
+    startAgentWithGoal(input, submit) {
+        return this.start({ ...input, [AGENT_GOAL_START]: submit });
+    }
     async updateMetadata(input) {
         if (input.parentSessionId !== undefined ||
             (input.clearParent !== undefined &&
@@ -47,27 +53,8 @@ export class SessionLifecycleService {
             (await this.options.projection.createMetadataProjection(input.sessionId));
         if (current === undefined)
             throw new Error('SESSION_NOT_FOUND');
-        if (input.clearParent === true) {
-            if (current.externalSessionId === null)
-                throw new Error('SESSION_ACTIVATION_REQUIRED');
-            const metadata = this.options
-                .database()
-                .getNativeSessionMetadata(current.runner, current.externalSessionId, current.workspaceId);
-            const parentSessionId = metadata === undefined ? current.parentSessionId : metadata.parentSessionId;
-            if (parentSessionId == null) {
-                const next = current.parentSessionId == null
-                    ? current
-                    : this.options.runtime.clearSessionParent(current.id);
-                return { session: this.options.present(next) };
-            }
-            this.options
-                .database()
-                .clearSessionParent(current.runner, current.externalSessionId, current.workspaceId);
-            const next = this.options.runtime.clearSessionParent(current.id);
-            this.options.parentCleared?.(next);
-            this.options.emitSession(next);
-            return { session: this.options.present(next) };
-        }
+        if (input.clearParent === true)
+            throw new Error('SESSION_PARENT_IMMUTABLE');
         if (sessionPrompt !== undefined && current.externalSessionId === null)
             throw new Error('SESSION_ACTIVATION_REQUIRED');
         if (input.pinned === false) {
@@ -142,6 +129,7 @@ export class SessionLifecycleService {
         if (workspace === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
         const cwd = await resolveWorkspaceExecutionDirectory(workspace.path, input.cwd);
+        checkSessionAdmission(input);
         if (database.getWorkspace(workspace.id)?.path !== workspace.path)
             throw new Error('WORKSPACE_NOT_FOUND');
         let parentSessionId;
@@ -157,6 +145,26 @@ export class SessionLifecycleService {
             if (liveParent?.externalSessionId === null)
                 throw new Error('SESSION_ACTIVATION_REQUIRED');
             parentSessionId = liveParent?.externalSessionId ?? parent.id;
+            this.options.runtime.assertSessionHistoryMutable(parent.id);
+            if (parentSessionId !== parent.id)
+                this.options.runtime.assertSessionHistoryMutable(parentSessionId);
+            const visited = new Set();
+            let ancestorId = parentSessionId;
+            let depth = 0;
+            while (ancestorId !== null) {
+                if (visited.has(ancestorId))
+                    throw new Error('SESSION_RELATION_INVALID');
+                visited.add(ancestorId);
+                const live = this.options.runtime.getAgentSession(ancestorId);
+                const stored = database.getSessionRecord(ancestorId);
+                const ancestorWorkspace = live?.workspaceId ?? stored?.workspaceId;
+                if (ancestorWorkspace !== workspace.id)
+                    throw new Error('SESSION_RELATION_INVALID');
+                depth += 1;
+                if (depth >= 3)
+                    throw new Error('SESSION_DEPTH_EXCEEDED');
+                ancestorId = live?.parentSessionId ?? stored?.metadata.parentSessionId ?? null;
+            }
         }
         const environment = parseSecretEnvironment(input.secretEnvironment);
         const saved = database.getRunnerDefaults().find((value) => value.runner === runner.name);
@@ -173,6 +181,8 @@ export class SessionLifecycleService {
         };
         if (runner.name === 'mar-agent' && !['auto', 'full-access'].includes(configuration.access))
             throw new Error('SESSION_INVALID');
+        if (parentSessionId !== undefined)
+            runner.assertChildModel(configuration.model);
         const session = this.options.runtime.createAgentSession({
             ...(parentSessionId === undefined ? {} : { parentSessionId }),
             workspaceId: input.workspaceId,
@@ -211,6 +221,8 @@ export class SessionLifecycleService {
             input.access !== undefined &&
             !['auto', 'full-access'].includes(input.access))
             throw new Error('SESSION_INVALID');
+        if (current.parentSessionId != null && typeof input.model === 'string')
+            this.options.runners.require(current.runner).assertChildModel(input.model);
         const session = this.options.runtime.updateAgentSessionConfiguration({
             sessionId: current.id,
             ...(typeof input.model === 'string' ? { model: input.model } : {}),
@@ -230,6 +242,7 @@ export class SessionLifecycleService {
         return { session: this.options.present(session) };
     }
     async start(input) {
+        checkSessionAdmission(input);
         const attachments = parseMessageAttachments(input.attachments);
         if (typeof input.clientMessageId !== 'string' ||
             input.clientMessageId.length === 0 ||
@@ -292,27 +305,40 @@ export class SessionLifecycleService {
             const messageSessionId = interceptedId ?? bootstrapId;
             if (interceptedId !== undefined)
                 this.options.identity.promote(bootstrapId, interceptedId);
-            const message = (await this.options.execute('session.message', {
-                sessionId: messageSessionId,
-                clientMessageId: input.clientMessageId,
-                content: input.content,
-                ...(input.__marctlOrigin === undefined ? {} : { __marctlOrigin: input.__marctlOrigin }),
-                ...(input.__suppressNotifications === true ? { __suppressNotifications: true } : {}),
-                ...(input.__requestUserId === undefined ? {} : { __requestUserId: input.__requestUserId }),
-                ...(input.__usageGrant === undefined ? {} : { __usageGrant: input.__usageGrant }),
-                ...(input.secretEnvironment === undefined
-                    ? {}
-                    : { secretEnvironment: input.secretEnvironment }),
-                ...(input.personalInstructions === undefined
-                    ? {}
-                    : { personalInstructions: input.personalInstructions }),
-                [RUNNER_EXECUTION_CONTEXT]: this.options.runners
-                    .require(created.session.runner)
-                    .prepareExecutionContext(input),
-                ...(input.computerUse === undefined ? {} : { computerUse: input.computerUse }),
-                ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds }),
-                ...(input.attachments === undefined ? {} : { attachments: input.attachments })
-            }));
+            const executionContext = this.options.runners
+                .require(created.session.runner)
+                .prepareExecutionContext(input);
+            const goalStart = input[AGENT_GOAL_START];
+            const goalSession = goalStart === undefined
+                ? undefined
+                : this.options.runtime.getAgentSession(messageSessionId);
+            if (goalStart !== undefined && goalSession === undefined)
+                throw new Error('SESSION_START_FAILED');
+            const message = (goalStart === undefined
+                ? await this.options.execute('session.message', {
+                    sessionId: messageSessionId,
+                    clientMessageId: input.clientMessageId,
+                    content: input.content,
+                    ...(input.__marctlOrigin === undefined
+                        ? {}
+                        : { __marctlOrigin: input.__marctlOrigin }),
+                    ...(input.__suppressNotifications === true ? { __suppressNotifications: true } : {}),
+                    ...(input.__requestUserId === undefined
+                        ? {}
+                        : { __requestUserId: input.__requestUserId }),
+                    ...(input.__usageGrant === undefined ? {} : { __usageGrant: input.__usageGrant }),
+                    ...(input.secretEnvironment === undefined
+                        ? {}
+                        : { secretEnvironment: input.secretEnvironment }),
+                    ...(input.personalInstructions === undefined
+                        ? {}
+                        : { personalInstructions: input.personalInstructions }),
+                    [RUNNER_EXECUTION_CONTEXT]: executionContext,
+                    ...(input.computerUse === undefined ? {} : { computerUse: input.computerUse }),
+                    ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds }),
+                    ...(input.attachments === undefined ? {} : { attachments: input.attachments })
+                })
+                : await goalStart(goalSession, executionContext));
             const nativeSessionId = await identity;
             const session = this.options.runtime.getAgentSession(nativeSessionId);
             const run = this.options.runtime.getRun(message.run.id);

package/dist/session/session-message-service.js

@@ -5,6 +5,7 @@ import { sessionTitleFromFirstMessage } from './input-validation.js';
 import { isImageAttachment, isRunnerImageAttachment, parseComposerAttachmentIds, parseMessageAttachments, withNonImageAttachmentPrompt } from './attachments.js';
 import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 import { personalInstructionsForRunner } from '../runner/personal-instructions.js';
+import { checkSessionAdmission } from './operation-admission.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { publicGoalStartText } from '../service/goal-runtime.js';
 import { serializeComposerTag, composerVisibleText, steerComposerMessage } from '@myagentroam/protocol';
@@ -45,12 +46,17 @@ export class SessionMessageService {
             __suppressNotifications: input.suppressNotifications === true ||
                 (input.kind === 'continue' &&
                     this.options.runtime.activeSessionRun(input.sessionId)?.suppressNotifications === true),
-            clientMessageId: `goal:${randomUUID()}`,
+            clientMessageId: input.clientMessageId ?? `goal:${randomUUID()}`,
             content: input.kind === 'start'
-                ? publicGoalStartText(input.objective ?? '')
+                ? [publicGoalStartText(input.objective ?? ''), input.messageContent]
+                    .filter(Boolean)
+                    .join('\n')
                 : serializeComposerTag('mar_goal_continue', {}),
-            __runnerContent: input.content,
+            __runnerContent: [input.content, input.messageContent].filter(Boolean).join('\n\n'),
             __goalRef: input.goal,
+            ...(input.messageOrigin === undefined ? {} : { __marctlOrigin: input.messageOrigin }),
+            ...(input.attachments === undefined ? {} : { attachments: input.attachments }),
+            ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds }),
             ...(input.initiatedByUserId === undefined
                 ? {}
                 : { __requestUserId: input.initiatedByUserId }),
@@ -84,6 +90,7 @@ export class SessionMessageService {
         return task.finally(() => this.preparations.delete(task));
     }
     async prepareMessage(input) {
+        checkSessionAdmission(input);
         if (typeof input.sessionId !== 'string' ||
             typeof input.clientMessageId !== 'string' ||
             input.clientMessageId.length === 0 ||
@@ -107,6 +114,7 @@ export class SessionMessageService {
         if (inlineAttachments.length > 0 && attachmentIds.length > 0)
             throw new Error('MESSAGE_ATTACHMENTS_INVALID');
         const accepted = await this.options.resolve(input.sessionId);
+        checkSessionAdmission(input);
         const session = accepted.session;
         if (input.workspaceId !== undefined && session.workspaceId !== input.workspaceId)
             throw new Error('SESSION_NOT_FOUND');
@@ -135,20 +143,22 @@ export class SessionMessageService {
                 idempotent: true,
                 auditReceipt: auditReceipt(session, existing.kind === 'queue' ? 'QUEUE' : 'SEND', existing.kind === 'queue' ? existing.item.id : existing.run.id, existing.kind === 'queue' ? existing.item.id : undefined)
             };
+        if (session.parentSessionId != null)
+            this.options.runners.require(session.runner).assertChildModel(session.model);
         const executionContext = input[RUNNER_EXECUTION_CONTEXT] ??
             this.options.runners.require(session.runner).prepareExecutionContext(input);
-        const sourceContent = withSessionMessageOrigin(content, input.__marctlOrigin);
+        const sourceContent = withSessionMessageOrigin(content, input.__marctlOrigin, session.parentSessionId);
         const goalMessage = internalGoal || internalSchedule || internalRestore
             ? undefined
             : this.options.goalMessage(session, content, requestedIntent);
         const executionContent = goalMessage?.runnerContent ?? internalRunnerContent;
         const runnerContent = executionContent === content
             ? sourceContent
-            : withSessionMessageOrigin(executionContent, input.__marctlOrigin);
+            : withSessionMessageOrigin(executionContent, input.__marctlOrigin, session.parentSessionId);
         const publicContent = goalMessage?.activated === true
             ? withSessionMessageOrigin([publicGoalStartText(composerVisibleText(content)), composerResourceInputTags(content)]
                 .filter(Boolean)
-                .join('\n'), input.__marctlOrigin)
+                .join('\n'), input.__marctlOrigin, session.parentSessionId)
             : sourceContent;
         const intent = goalMessage?.activated === true ? 'REPLACE_CURRENT' : requestedIntent;
         const releasePreparation = this.options.attachments.protectSession(session.id);

package/dist/supervisor.js

@@ -6,6 +6,9 @@ import { nodeLog, platformCliInvocation } from './operational.js';
 import { nodeUpgradeRequestPath } from './service/node-upgrade-coordinator.js';
 import { safeErrorCode } from './util/safe-error.js';
 import { NODE_OWNER_CONFLICT_EXIT_CODE } from './node-process-lock.js';
+import { runSupervisedNodeChild } from './service/supervised-node-child.js';
+import { NodeUpgradeReporter } from './service/node-upgrade-reporter.js';
+import { terminateProcessTree } from './process-tree.js';
 const UPGRADE_EXIT_CODE = 75;
 const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
 export async function superviseNode(configPath, bootstrapEntrypoint) {
@@ -13,26 +16,92 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
     const dataDirectory = dirname(nodeDatabasePath(config, configPath));
     const activePath = resolve(dataDirectory, 'node-active-entrypoint');
     let entrypoint = await readActiveEntrypoint(activePath, bootstrapEntrypoint);
+    let reporter;
+    let awaitingOnline;
     for (;;) {
-        const childResult = await runProcess(process.execPath, [entrypoint, 'run', '--config', configPath], true, { ...process.env, MAR_NODE_SUPERVISED: '1' });
+        const requestPath = nodeUpgradeRequestPath(nodeDatabasePath(config, configPath));
+        let reportingIdentity;
+        const childResult = await runSupervisedNodeChild(entrypoint, configPath, async (handoff) => {
+            const currentConfig = await loadNodeConfig(configPath);
+            if (currentConfig.nodeId === undefined ||
+                !STABLE_VERSION.test(handoff.targetVersion) ||
+                !/^[0-9a-f-]{36}$/u.test(handoff.attemptId) ||
+                !/^[A-Za-z0-9_-]{43}$/u.test(handoff.credential))
+                return false;
+            const request = JSON.parse(await readFile(requestPath, 'utf8'));
+            const matches = request['schemaVersion'] === 1 &&
+                request['attemptId'] === handoff.attemptId &&
+                request['targetVersion'] === handoff.targetVersion;
+            if (matches)
+                reportingIdentity = { serverUrl: currentConfig.serverUrl, nodeId: currentConfig.nodeId };
+            return matches;
+        }, (handoff) => {
+            if (reportingIdentity === undefined)
+                throw new Error('NODE_UPGRADE_HANDOFF_UNAVAILABLE');
+            const next = new NodeUpgradeReporter(reportingIdentity.serverUrl, reportingIdentity.nodeId, handoff.credential);
+            reporter?.stop();
+            reporter = next;
+            next.update({ attemptId: handoff.attemptId, step: 'CLOSING_NODE' });
+        }, awaitingOnline);
         if (childResult.signalled) {
+            reporter?.stop();
             process.exitCode = childResult.code ?? 1;
             return;
         }
+        if (childResult.reclaimFailed) {
+            if (childResult.handoff !== undefined)
+                await reporter?.finish({
+                    attemptId: childResult.handoff.attemptId,
+                    step: 'CLOSING_NODE',
+                    result: 'FAILED',
+                    failure: {
+                        code: 'NODE_UPGRADE_RECLAIM_FAILED',
+                        message: 'The old Node process could not be stopped.',
+                        step: 'CLOSING_NODE',
+                        kind: 'INSTALL'
+                    }
+                });
+            process.exitCode = 1;
+            return;
+        }
+        if (childResult.forced)
+            nodeLog('node.supervisor.upgrade-old-node-reclaimed', {
+                code: 'NODE_UPGRADE_EXIT_TIMEOUT_RECLAIMED'
+            });
         const code = childResult.code;
-        if (code === NODE_OWNER_CONFLICT_EXIT_CODE) {
+        if (childResult.handoff === undefined &&
+            awaitingOnline !== undefined &&
+            reporter !== undefined) {
+            await reporter.finish({
+                attemptId: awaitingOnline,
+                step: 'WAITING_FOR_ONLINE',
+                result: 'FAILED',
+                operationEnded: true,
+                failure: {
+                    code: 'NODE_UPGRADE_START_FAILED',
+                    message: 'The upgraded Node process exited before reporting online.',
+                    step: 'WAITING_FOR_ONLINE',
+                    kind: 'START'
+                }
+            });
+            reporter = undefined;
+        }
+        if (code === NODE_OWNER_CONFLICT_EXIT_CODE && childResult.handoff === undefined) {
             process.exitCode = code;
             return;
         }
-        if (code !== UPGRADE_EXIT_CODE) {
+        if (code !== UPGRADE_EXIT_CODE && childResult.handoff === undefined) {
             if (code === 0)
                 return;
             nodeLog('node.supervisor.child-exited', { code });
             await delay(1_000);
             continue;
         }
-        const requestPath = nodeUpgradeRequestPath(nodeDatabasePath(config, configPath));
         let stopping = false;
+        let switched = false;
+        let installReclaimFailed = false;
+        let failureStage = 'VALIDATE_REQUEST';
+        let failureExitCode;
         try {
             const request = JSON.parse(await readFile(requestPath, 'utf8'));
             const targetVersion = request['targetVersion'];
@@ -41,6 +110,10 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
                 !STABLE_VERSION.test(targetVersion))
                 throw new Error('NODE_UPGRADE_REQUEST_INVALID');
             const prefix = resolve(dataDirectory, 'node-versions', targetVersion);
+            const installDeadline = Date.now() + 15 * 60_000;
+            if (childResult.handoff !== undefined)
+                reporter?.update({ attemptId: childResult.handoff.attemptId, step: 'INSTALLING' });
+            failureStage = 'PREPARE_INSTALL_DIRECTORY';
             await rm(prefix, { recursive: true, force: true });
             await mkdir(prefix, { recursive: true, mode: 0o700 });
             const invocation = platformCliInvocation('npm', [
@@ -52,62 +125,166 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
                 '--no-fund',
                 `@myagentroam/node@${targetVersion}`
             ]);
-            const installResult = await runProcess(invocation.command, invocation.args, false);
+            failureStage = 'NPM_INSTALL';
+            const installResult = await runProcess(invocation.command, invocation.args, false, installDeadline);
+            failureExitCode = installResult.code;
+            if (installResult.reclaimFailed) {
+                installReclaimFailed = true;
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_RECLAIM_FAILED');
+            }
             if (installResult.signalled) {
                 stopping = true;
                 throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
             }
+            if (installResult.timedOut)
+                throw new Error('NODE_UPGRADE_INSTALL_TIMEOUT');
             if (installResult.code !== 0)
                 throw new Error('NODE_UPGRADE_INSTALL_FAILED');
             const rebuild = platformCliInvocation('npm', ['rebuild', '--prefix', prefix, 'node-pty']);
-            const rebuildResult = await runProcess(rebuild.command, rebuild.args, false);
+            failureStage = 'NATIVE_REBUILD';
+            failureExitCode = undefined;
+            const rebuildResult = await runProcess(rebuild.command, rebuild.args, false, installDeadline);
+            failureExitCode = rebuildResult.code;
+            if (rebuildResult.reclaimFailed) {
+                installReclaimFailed = true;
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_RECLAIM_FAILED');
+            }
             if (rebuildResult.signalled) {
                 stopping = true;
                 throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
             }
+            if (rebuildResult.timedOut)
+                throw new Error('NODE_UPGRADE_INSTALL_TIMEOUT');
             if (rebuildResult.code !== 0)
                 throw new Error('NODE_UPGRADE_NATIVE_REBUILD_FAILED');
+            failureStage = 'BROWSER_INSTALL';
+            failureExitCode = undefined;
             const browserInstall = await runProcess(process.execPath, [
                 resolve(prefix, 'node_modules', '@myagentroam', 'node', 'scripts', 'install-web-browser.mjs')
-            ], true);
+            ], true, installDeadline);
+            failureExitCode = browserInstall.code;
+            if (browserInstall.reclaimFailed) {
+                installReclaimFailed = true;
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_RECLAIM_FAILED');
+            }
             if (browserInstall.signalled) {
                 stopping = true;
                 throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
             }
+            if (browserInstall.timedOut)
+                throw new Error('NODE_UPGRADE_INSTALL_TIMEOUT');
             if (browserInstall.code !== 0)
                 throw new Error('NODE_UPGRADE_BROWSER_INSTALL_FAILED');
+            failureStage = 'ENTRYPOINT_SWITCH';
+            failureExitCode = undefined;
             const nextEntrypoint = resolve(prefix, 'node_modules', '@myagentroam', 'node', 'dist', 'main.js');
             await access(nextEntrypoint);
             await writeAtomic(activePath, `${nextEntrypoint}\n`);
+            entrypoint = nextEntrypoint;
+            switched = true;
+            if (childResult.handoff !== undefined) {
+                awaitingOnline = childResult.handoff.attemptId;
+                reporter?.update({
+                    attemptId: childResult.handoff.attemptId,
+                    step: 'WAITING_FOR_ONLINE',
+                    result: 'INSTALLED'
+                });
+            }
             await writeResult(dataDirectory, {
                 state: 'SUCCEEDED',
                 targetVersion,
                 updatedAt: Date.now()
             });
-            await rm(requestPath, { force: true });
-            entrypoint = nextEntrypoint;
         }
         catch (error) {
-            await writeResult(dataDirectory, {
-                state: 'FAILED',
-                errorCode: safeErrorCode(error, 'NODE_UPGRADE_INSTALL_FAILED'),
-                updatedAt: Date.now()
-            });
+            if (switched) {
+                nodeLog('node.supervisor.upgrade-result-write-failed', {
+                    code: 'NODE_UPGRADE_RESULT_WRITE_FAILED'
+                });
+            }
+            else {
+                if (childResult.handoff !== undefined)
+                    await reporter?.finish({
+                        attemptId: childResult.handoff.attemptId,
+                        step: 'INSTALLING',
+                        result: 'FAILED',
+                        ...(installReclaimFailed ? {} : { operationEnded: true }),
+                        failure: {
+                            code: safeErrorCode(error, 'NODE_UPGRADE_INSTALL_FAILED'),
+                            message: 'The Node upgrade could not be installed.',
+                            step: 'INSTALLING',
+                            kind: 'INSTALL',
+                            details: `Stage: ${failureStage}${failureExitCode == null ? '' : `; exit code: ${failureExitCode}`}`
+                        }
+                    });
+                reporter = undefined;
+                try {
+                    await writeResult(dataDirectory, {
+                        state: 'FAILED',
+                        errorCode: safeErrorCode(error, 'NODE_UPGRADE_INSTALL_FAILED'),
+                        updatedAt: Date.now()
+                    });
+                }
+                catch {
+                    nodeLog('node.supervisor.upgrade-result-write-failed', {
+                        code: 'NODE_UPGRADE_RESULT_WRITE_FAILED'
+                    });
+                }
+            }
+        }
+        try {
             await rm(requestPath, { force: true });
         }
+        catch {
+            nodeLog('node.supervisor.upgrade-request-cleanup-failed', {
+                code: 'NODE_UPGRADE_REQUEST_CLEANUP_FAILED'
+            });
+        }
         if (stopping)
             return;
     }
 }
-async function runProcess(command, args, inherit, env = process.env) {
+async function runProcess(command, args, inherit, deadlineAt) {
     return new Promise((resolveProcess) => {
         const child = spawn(command, args, {
             windowsHide: true,
             stdio: inherit ? 'inherit' : 'ignore',
-            env
+            env: process.env,
+            detached: process.platform !== 'win32'
         });
         let settled = false;
         let signalled = false;
+        let timedOut = false;
+        let reclaimed = false;
+        let exited;
+        let reapDeadline;
+        const deadline = setTimeout(() => {
+            timedOut = true;
+            reapDeadline = setTimeout(() => finish(null, true), 10_000);
+            void terminateProcessTree(child)
+                .then(() => {
+                reclaimed = true;
+                if (exited !== undefined)
+                    finish(exited.code);
+            })
+                .catch(() => finish(null, true));
+            if (process.platform !== 'win32' && child.pid !== undefined) {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
+                }
+                catch {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        /* Wait for exit or timeout. */
+                    }
+                }
+            }
+        }, Math.max(0, deadlineAt - Date.now()));
         const forward = (signal) => {
             if (signalled)
                 return;
@@ -116,18 +293,30 @@ async function runProcess(command, args, inherit, env = process.env) {
         };
         const onSigint = () => forward('SIGINT');
         const onSigterm = () => forward('SIGTERM');
-        const finish = (code) => {
+        const finish = (code, reclaimFailed = false) => {
             if (settled)
                 return;
             settled = true;
+            clearTimeout(deadline);
+            if (reapDeadline !== undefined)
+                clearTimeout(reapDeadline);
             process.off('SIGINT', onSigint);
             process.off('SIGTERM', onSigterm);
-            resolveProcess({ code, signalled });
+            if (reclaimFailed)
+                child.unref();
+            resolveProcess({ code, signalled, timedOut, reclaimFailed });
         };
         process.on('SIGINT', onSigint);
         process.on('SIGTERM', onSigterm);
-        child.once('error', () => finish(null));
-        child.once('close', finish);
+        child.on('error', () => {
+            if (child.pid === undefined)
+                finish(null);
+        });
+        child.once('exit', (code) => {
+            exited = { code };
+            if (!timedOut || reclaimed)
+                finish(code);
+        });
     });
 }
 async function readActiveEntrypoint(path, fallback) {

package/dist/terminal.js

@@ -32,6 +32,7 @@ export class TerminalManager {
     pipeFactory;
     terminate;
     terminals = new Map();
+    closing = new Map();
     attachments = new Map();
     frameListeners = new Set();
     summaryListeners = new Set();
@@ -309,37 +310,56 @@ export class TerminalManager {
         }
         await this.close(terminal.id);
     }
-    async close(terminalId) {
+    close(terminalId) {
         const terminal = this.requireTerminal(terminalId);
+        const pending = this.closing.get(terminalId);
+        if (pending !== undefined)
+            return pending;
         if (terminal.state !== 'RUNNING')
-            return this.summary(terminal);
+            return Promise.resolve(this.summary(terminal));
         terminal.state = 'CLOSED';
         terminal.updatedAt = this.now();
-        this.detachAll(terminal);
-        const summary = this.notifySummary(terminal);
-        try {
-            if (terminal.pty !== undefined) {
-                // Native PTY hangup reaches POSIX foreground jobs in a separate process group
-                // and releases the native console on Windows; shell-group TERM cannot do this.
-                try {
-                    terminal.pty.kill();
-                }
-                catch {
-                    await this.terminate(terminal.pty, this.platform);
+        let resolveClosing;
+        let rejectClosing;
+        const closing = new Promise((resolve, reject) => {
+            resolveClosing = resolve;
+            rejectClosing = reject;
+        });
+        this.closing.set(terminalId, closing);
+        void (async () => {
+            this.detachAll(terminal);
+            const summary = this.notifySummary(terminal);
+            try {
+                if (terminal.pty !== undefined) {
+                    // Native PTY hangup reaches POSIX foreground jobs in a separate process group
+                    // and releases the native console on Windows; shell-group TERM cannot do this.
+                    try {
+                        terminal.pty.kill();
+                    }
+                    catch {
+                        await this.terminate(terminal.pty, this.platform);
+                    }
                 }
+                if (terminal.pipe !== undefined)
+                    await this.terminate(terminal.pipe, this.platform);
             }
-            if (terminal.pipe !== undefined)
-                await this.terminate(terminal.pipe, this.platform);
-        }
-        finally {
-            this.emit({ type: 'exit', terminalId: terminal.id, exitCode: terminal.exitCode });
-        }
-        return summary;
+            finally {
+                this.emit({ type: 'exit', terminalId: terminal.id, exitCode: terminal.exitCode });
+            }
+            return summary;
+        })().then((summary) => {
+            this.closing.delete(terminalId);
+            resolveClosing(summary);
+        }, (error) => {
+            this.closing.delete(terminalId);
+            rejectClosing(error);
+        });
+        return closing;
     }
     /** Ends current terminals without disposing the manager's idle collection. */
     async closeAll() {
         await Promise.all([...this.terminals.values()]
-            .filter((terminal) => terminal.state === 'RUNNING')
+            .filter((terminal) => terminal.state === 'RUNNING' || this.closing.has(terminal.id))
             .map((terminal) => this.close(terminal.id)));
     }
     async shutdown() {