pi-agent-browser-native 0.6.10 → 0.6.11

package/dist/extensions/agent-browser/index.js

@@ -5,7 +5,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle } from "./lib/batch-lifecycle.js";
 import { PROJECT_RULE_PROMPT, buildBrowserDefaultProfileGuideline, buildBrowserExecutablePathGuideline, buildToolPromptGuidelines, } from "./lib/playbook.js";
 import { SessionPageState } from "./lib/session-page-state.js";
-import { buildExecutionPlan, canUseHeadlessCompatibilityUserAgent, createEphemeralSessionSeed, createFreshSessionName, createImplicitSessionName, extractUpstreamCommandTokens, getImplicitSessionCloseTimeoutMs, getImplicitSessionIdleTimeoutMs, isRestorableManagedSessionName, restoreManagedSessionStateFromBranch, validateToolArgs, redactSensitiveText, isPlainTextInspectionArgs, } from "./lib/runtime.js";
+import { buildExecutionPlan, canUseHeadlessCompatibilityUserAgent, createEphemeralSessionSeed, createFreshSessionName, createImplicitSessionName, extractUpstreamCommandTokens, getImplicitSessionCloseTimeoutMs, getImplicitSessionIdleTimeoutMs, isRestorableManagedSessionName, restoreManagedSessionStateFromBranch, validateToolArgs, redactSensitiveText, redactSensitiveValue, isPlainTextInspectionArgs, } from "./lib/runtime.js";
 import { deleteIdentityKeysInNamespace, extractExplicitNamespace, extractExplicitSessionName, getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, isUpstreamEnvFlagEnabled, resolveAgentBrowserNamespace } from "./lib/argv-grammar.js";
 import { parseArgvDescriptor } from "./lib/argv-descriptor.js";
 import { needsManagedSession } from "./lib/command-policy.js";
@@ -13,6 +13,7 @@ import { ManagedSessionRestoreState } from "./lib/managed-session-restore.js";
 import { isRecord } from "./lib/parsing.js";
 import { runAgentBrowserProcess } from "./lib/process.js";
 import { getAgentBrowserProcessEnvironment, withIsolatedAgentBrowserEnvironment } from "./lib/process-environment.js";
+import { withNativeSessionDefaults } from "./lib/orchestration/native-session-defaults.js";
 import { MINIMUM_AGENT_BROWSER_VERSION, SUPPORTED_AGENT_BROWSER_VERSION_LABEL, TARGET_AGENT_BROWSER_VERSION, getAgentBrowserVersionValidationError, parseAgentBrowserVersionOutput, } from "./lib/upstream-version.js";
 import { buildPromptPolicy, getLatestUserPrompt, shouldAppendBrowserSystemPrompt } from "./lib/prompt-policy.js";
 import { isCloseAllCommand, isCloseCommand } from "./lib/command-taxonomy.js";
@@ -26,13 +27,14 @@ import { findElectronLaunchRecordForSession, getActiveElectronRecords } from "./
 import { parseBatchCommandArgument, parseUserBatchStdin } from "./lib/orchestration/batch-stdin.js";
 import { ELECTRON_POST_COMMAND_STATUS_SETTLE_MS, ELECTRON_PROFILE_ISOLATION_DETAILS, cleanupActiveElectronHostLaunches, handleElectronHostInput, restoreElectronLaunchRecordsFromBranch, } from "./lib/orchestration/electron-host/index.js";
 import { buildValidationFailureResult, resolveAgentBrowserInput } from "./lib/orchestration/input-plan.js";
-import { applyAgentBrowserOutputPath, normalizeRequestedOutputPath } from "./lib/orchestration/output-file.js";
+import { applyAgentBrowserOutputPath, canWriteAgentBrowserOutput, normalizeRequestedOutputPath } from "./lib/orchestration/output-file.js";
 import { appendScriptSessionLease, buildScriptBrowserEnvelope, buildScriptToolResult, getScriptSessionLeasesFromBranch } from "./lib/orchestration/script-mode.js";
 import { formatSessionArtifactRetentionSummary, getSessionArtifactManifestEntryKey, isPendingRecordingCommand, isSessionArtifactManifest, mergeSessionArtifactManifest, retirePendingRecordingManifestEntries } from "./lib/results/artifact-manifest.js";
 import { appendUniqueAgentBrowserNextActions, applyNamespaceToNextActions, applySessionToNextActions, buildNextToolAction } from "./lib/results/next-actions.js";
 import { canRegisterWebSearchTool, loadAgentBrowserConfigSync } from "./lib/config.js";
 import { appendRecordingReservationTransition, applyRecordingArtifactsToReservations, restoreRecordingReservationStateFromBranch, retireRecordingReservation, } from "./lib/recording-reservations.js";
 import { createAgentBrowserWebSearchTool } from "./lib/web-search.js";
+import { scopeReadConfirmationArgs } from "./lib/read-confirmation.js";
 import { isDirectAgentBrowserBashAllowed, isHarmlessAgentBrowserInspectionCommand, looksLikeDirectAgentBrowserBash, } from "./lib/bash-guard.js";
 import { AgentBrowserResultComponent, buildAgentBrowserToolResultPatch, formatAgentBrowserRenderCall, formatAgentBrowserRenderResult, } from "./lib/pi-tool-rendering.js";
 function isBashToolCallEvent(event) {
@@ -157,26 +159,6 @@ function getResultFileArtifacts(result) {
     const details = isRecord(result.details) ? result.details : undefined;
     return Array.isArray(details?.artifacts) ? details.artifacts.filter(isResultFileArtifact) : [];
 }
-function reportsNoRecordingInProgress(value) {
-    try {
-        return /no recording in progress/i.test(JSON.stringify(value));
-    }
-    catch {
-        return false;
-    }
-}
-function batchStepReportsNoRecordingInProgress(step) {
-    if (!isRecord(step) || step.success !== false)
-        return false;
-    const command = Array.isArray(step.command) && step.command.every((token) => typeof token === "string") ? extractUpstreamCommandTokens(step.command) : [];
-    return command[0] === "record" && command[1] === "stop" && reportsNoRecordingInProgress(step);
-}
-function resultReportsNoRecordingInProgress(result) {
-    if (result.isError !== true)
-        return false;
-    const details = isRecord(result.details) ? result.details : undefined;
-    return details?.command === "record" && details.subcommand === "stop" && reportsNoRecordingInProgress(result.content);
-}
 function restoreArtifactManifestFromBranch(branch) {
     let restoredManifest;
     for (const entry of branch) {
@@ -801,7 +783,7 @@ function shouldIncludeProjectConfig(ctx, argv = process.argv) {
         return false;
     return ctx?.isProjectTrusted?.() ?? true;
 }
-export default function agentBrowserExtension(pi) {
+export default function agentBrowserExtension(pi, { beforeExecute } = {}) {
     const ephemeralSessionSeed = createEphemeralSessionSeed();
     const agentBrowserConfig = loadAgentBrowserConfigSync({
         cwd: process.cwd(),
@@ -913,6 +895,8 @@ export default function agentBrowserExtension(pi) {
         if (result.isError !== true)
             return result;
         const details = isRecord(result.details) ? result.details : {};
+        if (details.recordingRecovery)
+            return result;
         const cleanupOnly = details.managedSessionCleanupOnlyReason === "restore-disabled-daemon-without-provenance";
         const nextActions = (Array.isArray(details.nextActions) ? details.nextActions : [])
             .filter((action) => !cleanupOnly || action.id !== "stop-pending-recording");
@@ -973,12 +957,6 @@ export default function agentBrowserExtension(pi) {
             const command = Array.isArray(step.command) && step.command.every((token) => typeof token === "string") ? step.command : undefined;
             const commandTokens = command ? extractUpstreamCommandTokens(command) : [];
             const commandName = commandTokens[0];
-            if (resultSessionName && batchStepReportsNoRecordingInProgress(step)) {
-                const sessionKey = getAgentBrowserSessionIdentityKey(resultSessionName, resultNamespace);
-                retireRecordingSession(resultSessionName, resultNamespace, false);
-                handledClosedSessionKeys.add(sessionKey);
-                continue;
-            }
             if (step.success === true && commandName && isCloseCommand(commandName) && resultSessionName) {
                 const sessionKey = getAgentBrowserSessionIdentityKey(resultSessionName, resultNamespace);
                 retireRecordingSession(resultSessionName, resultNamespace, false);
@@ -1148,7 +1126,7 @@ export default function agentBrowserExtension(pi) {
         }
         for (const [key, reservation] of activeRecordingReservations) {
             const restored = restoredRecordingState.active.get(key);
-            if (restored?.absolutePath !== reservation.absolutePath || restored.cwd !== reservation.cwd)
+            if (restored?.absolutePath !== reservation.absolutePath || restored.cwd !== reservation.cwd || restored.recordingId !== reservation.recordingId || restored.startedAtMs !== reservation.startedAtMs)
                 recordingReservationsDirty = true;
             restoredRecordingState.active.set(key, reservation);
         }
@@ -1380,445 +1358,453 @@ export default function agentBrowserExtension(pi) {
             component.setState(formatAgentBrowserRenderResult(result, options, theme, context.isError), options.expanded, theme);
             return component;
         },
-        async execute(toolCallId, params, signal, onUpdate, ctx) {
+        async execute(toolCallId, params, signal, onUpdate, ctx, nativeToolCallId = toolCallId) {
             const promptPolicy = buildPromptPolicy(getLatestUserPrompt(ctx.sessionManager.getBranch()));
             const outputPath = isRecord(params) && typeof params.outputPath === "string" ? params.outputPath : undefined;
             const resolvedInput = resolveAgentBrowserInput({
                 getBatchPreflightValidationError: (args, stdin) => getArtifactPreflightValidationError({ args, cwd: ctx.cwd, outputPath, stdin }),
-                managedSessionActive,
                 params,
             });
             if (resolvedInput.status === "invalid") {
                 return buildValidationFailureResult(resolvedInput);
             }
-            const applyUnserializedOutputPath = async (result, preserveTextContent = false) => {
-                if (!outputPath || result.isError === true || (isRecord(result.details) && result.details.resultCategory === "failure"))
-                    return warnRecordingPersistence(result);
-                return artifactExecutionQueue.run(async () => {
-                    flushRecordingReservations();
-                    const reservationError = getArtifactPreflightValidationError({
-                        activeRecordingReservations: activeRecordingReservations.values(),
-                        args: [],
-                        cwd: ctx.cwd,
-                        outputPath,
-                    });
-                    if (reservationError) {
-                        return warnRecordingPersistence(buildValidationFailureResult({ attemptedKind: resolvedInput.kind, kind: "invalid", redactedArgs: resolvedInput.redactedArgs, status: "invalid", toolArgs: resolvedInput.toolArgs, toolStdin: resolvedInput.toolStdin, validationError: reservationError }));
-                    }
-                    return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, preserveTextContent, result: warnRecordingPersistence(result) });
-                });
-            };
-            const versionCheckCommand = extractUpstreamCommandTokens(resolvedInput.toolArgs)[0];
-            const electronHostOnlyAction = resolvedInput.kind === "electron" && ["cleanup", "list", "status"].includes(resolvedInput.compiledElectron.action);
-            const browserBackedVersionCheck = needsManagedSession(parseArgvDescriptor(resolvedInput.toolArgs));
-            if (resolvedInput.kind !== "script" && !electronHostOnlyAction && browserBackedVersionCheck && !isPlainTextInspectionArgs(resolvedInput.toolArgs) && !isCloseCommand(versionCheckCommand) && signal?.aborted !== true) {
-                const versionFailure = await validateUpstreamVersion(ctx.cwd, signal);
-                if (versionFailure)
-                    return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, result: versionFailure });
-            }
-            if (resolvedInput.kind === "script") {
-                if (!ctx.sessionManager.getSessionFile()) {
-                    return buildValidationFailureResult({
-                        attemptedKind: "script",
-                        kind: "invalid",
-                        redactedArgs: [],
-                        status: "invalid",
-                        toolArgs: [],
-                        validationError: "script requires a persisted Pi session so its isolated browser-session cleanup lease survives restart; relaunch Pi without --no-session.",
-                    });
+            if (resolvedInput.kind !== "script")
+                await beforeExecute?.(nativeToolCallId, { ...ctx, signal });
+            return withNativeSessionDefaults(resolvedInput, ctx.cwd, signal, async (resolvedInput) => {
+                const readConfirmation = sessionPageState.findReadConfirmation(resolvedInput.toolArgs, resolveAgentBrowserNamespace(resolvedInput.toolArgs, getAgentBrowserProcessEnvironment().AGENT_BROWSER_NAMESPACE));
+                if (readConfirmation)
+                    resolvedInput = { ...resolvedInput, toolArgs: scopeReadConfirmationArgs(resolvedInput.toolArgs, readConfirmation) };
+                if (resolvedInput.kind === "qa" && resolvedInput.compiledQaPreset.checks.attached && !managedSessionActive && !extractExplicitSessionName(resolvedInput.toolArgs)) {
+                    return buildValidationFailureResult({ ...resolvedInput, attemptedKind: "qa", kind: "invalid", status: "invalid", validationError: "qa.attached requires an active attached session. Run electron.launch or connect to an Electron debug port first, or configure a native shared session." });
                 }
-                const sessionName = createAgentBrowserScriptSessionName();
-                const innerResults = [];
-                const scriptTimeoutMs = params.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS;
-                const deadline = Date.now() + scriptTimeoutMs;
-                let leased = false;
-                let cleanupError;
-                let run = {
-                    callCount: 0,
-                    emitCount: 0,
-                    error: "Script sandbox execution failed.",
-                    failureCategory: "upstream-error",
-                    ok: false,
-                    rejectedCallCount: 0,
-                    steps: [],
+                const applyUnserializedOutputPath = async (result, preserveTextContent = false) => {
+                    if (!outputPath || !canWriteAgentBrowserOutput(result))
+                        return warnRecordingPersistence(result);
+                    return artifactExecutionQueue.run(async () => {
+                        flushRecordingReservations();
+                        const reservationError = getArtifactPreflightValidationError({
+                            activeRecordingReservations: activeRecordingReservations.values(),
+                            args: [],
+                            cwd: ctx.cwd,
+                            outputPath,
+                        });
+                        if (reservationError) {
+                            return warnRecordingPersistence(buildValidationFailureResult({ attemptedKind: resolvedInput.kind, kind: "invalid", redactedArgs: resolvedInput.redactedArgs, status: "invalid", toolArgs: resolvedInput.toolArgs, toolStdin: resolvedInput.toolStdin, validationError: reservationError }));
+                        }
+                        return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, preserveTextContent, result: warnRecordingPersistence(result) });
+                    });
                 };
-                const scriptController = new AbortController();
-                const abortScript = () => scriptController.abort();
-                signal?.addEventListener("abort", abortScript, { once: true });
-                if (signal?.aborted)
-                    scriptController.abort();
-                activeScriptControllers.add(scriptController);
-                let finishScriptExecution;
-                const scriptExecution = new Promise((resolve) => {
-                    finishScriptExecution = resolve;
-                });
-                activeScriptExecutions.add(scriptExecution);
-                try {
-                    // Keep preflight inside shutdown tracking so quit cannot race into starting the sandbox afterward.
-                    const versionFailure = await withIsolatedAgentBrowserEnvironment(() => validateUpstreamVersion(ctx.cwd, scriptController.signal));
+                const versionCheckCommand = extractUpstreamCommandTokens(resolvedInput.toolArgs)[0];
+                const electronHostOnlyAction = resolvedInput.kind === "electron" && ["cleanup", "list", "status"].includes(resolvedInput.compiledElectron.action);
+                const browserBackedVersionCheck = readConfirmation?.capabilities?.readRequiresConfirmation !== true && needsManagedSession(parseArgvDescriptor(resolvedInput.toolArgs), resolvedInput.toolStdin);
+                if (resolvedInput.kind !== "script" && !electronHostOnlyAction && browserBackedVersionCheck && !isPlainTextInspectionArgs(resolvedInput.toolArgs) && !isCloseCommand(versionCheckCommand) && signal?.aborted !== true) {
+                    const versionFailure = await validateUpstreamVersion(ctx.cwd, signal);
                     if (versionFailure)
                         return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, result: versionFailure });
-                    const pendingRun = runAgentBrowserScript({
-                        beforeFirstCall() {
-                            appendScriptSessionLease(pi, sessionName, "active");
-                            trackOwnedManagedSession(ownedManagedSessions, sessionName, ctx.cwd, { namespace: AGENT_BROWSER_SCRIPT_NAMESPACE });
-                            managedSessionRestoreState.disable(sessionName, AGENT_BROWSER_SCRIPT_NAMESPACE);
-                            leased = true;
-                        },
-                        code: resolvedInput.compiledScript.code,
-                        dispatch: async (innerParams, innerSignal) => {
-                            const remainingMs = Math.max(1, deadline - Date.now());
-                            const innerTimeoutMs = Math.min(innerParams.timeoutMs ?? remainingMs, remainingMs);
-                            const innerResult = await withIsolatedAgentBrowserEnvironment(() => agentBrowserTool.execute(`${toolCallId}:script:${innerResults.length + 1}`, {
-                                args: ["--namespace", AGENT_BROWSER_SCRIPT_NAMESPACE, "--session", sessionName, ...innerParams.args],
-                                stdin: innerParams.stdin,
-                                timeoutMs: innerTimeoutMs,
-                            }, innerSignal, undefined, ctx));
-                            innerResults.push(innerResult);
-                            return await buildScriptBrowserEnvelope(innerResult, innerParams.args, sessionName);
-                        },
-                        signal: scriptController.signal,
-                        timeoutMs: scriptTimeoutMs,
-                    });
-                    run = await pendingRun;
                 }
-                catch { }
-                finally {
-                    activeScriptControllers.delete(scriptController);
-                    signal?.removeEventListener("abort", abortScript);
-                    if (leased) {
-                        try {
-                            cleanupError = await artifactExecutionQueue.run(() => managedSessionExecutionQueue.run(() => {
-                                flushRecordingReservations();
-                                return closeScriptSessionLeaseWithinQueue(sessionName, ctx.cwd);
-                            }));
-                        }
-                        catch {
-                            cleanupError = "The isolated script session cleanup operation failed.";
-                            try {
-                                appendScriptSessionLease(pi, sessionName, "failed");
-                            }
-                            catch { }
-                        }
+                if (resolvedInput.kind === "script") {
+                    if (!ctx.sessionManager.getSessionFile()) {
+                        return buildValidationFailureResult({
+                            attemptedKind: "script",
+                            kind: "invalid",
+                            redactedArgs: [],
+                            status: "invalid",
+                            toolArgs: [],
+                            validationError: "script requires a persisted Pi session so its isolated browser-session cleanup lease survives restart; relaunch Pi without --no-session.",
+                        });
                     }
-                    activeScriptExecutions.delete(scriptExecution);
-                    finishScriptExecution();
-                }
-                let scriptResult = buildScriptToolResult({ cleanupError, innerResults, run, sessionName: leased ? sessionName : undefined });
-                if (artifactManifest) {
-                    scriptResult = {
-                        ...scriptResult,
-                        details: {
-                            ...(isRecord(scriptResult.details) ? scriptResult.details : {}),
-                            artifactManifest,
-                            artifactRetentionSummary: formatSessionArtifactRetentionSummary(artifactManifest),
-                        },
+                    const sessionName = createAgentBrowserScriptSessionName();
+                    const innerResults = [];
+                    const scriptTimeoutMs = params.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS;
+                    const deadline = Date.now() + scriptTimeoutMs;
+                    let leased = false;
+                    let cleanupError;
+                    let run = {
+                        callCount: 0,
+                        emitCount: 0,
+                        error: "Script sandbox execution failed.",
+                        failureCategory: "upstream-error",
+                        ok: false,
+                        rejectedCallCount: 0,
+                        steps: [],
                     };
-                }
-                return applyUnserializedOutputPath(scriptResult);
-            }
-            const { toolArgs } = resolvedInput;
-            const compiledElectron = resolvedInput.kind === "electron" ? resolvedInput.compiledElectron : undefined;
-            const redactedCompiledElectron = resolvedInput.kind === "electron" ? resolvedInput.redactedCompiledElectron : undefined;
-            const runElectronHostInput = async () => {
-                const electronHostLaunchRecords = getElectronHostLaunchRecordsForInput({
-                    branchRecords: electronLaunchRecords,
-                    compiledElectron,
-                    ownedRecords: ownedElectronLaunchRecords,
-                });
-                let electronHostResult = await handleElectronHostInput({
-                    attachedSessionKeys,
-                    compiledElectron,
-                    cwd: ctx.cwd,
-                    electronChildProcesses,
-                    electronLaunchRecords: electronHostLaunchRecords,
-                    implicitSessionCloseTimeoutMs,
-                    managedSessionActive,
-                    managedSessionName,
-                    managedSessionNamespace,
-                    managedSessionRestoreState,
-                    ownedManagedSessions,
-                    redactedCompiledElectron,
-                    sessionPageState,
-                    signal,
-                });
-                if (electronHostResult && compiledElectron?.action === "cleanup") {
-                    branchStateGeneration += 1;
-                    const cleanupRecords = isRecord(electronHostResult.details)
-                        && isRecord(electronHostResult.details.electron)
-                        && isRecord(electronHostResult.details.electron.cleanup)
-                        && Array.isArray(electronHostResult.details.electron.cleanup.results)
-                        ? electronHostResult.details.electron.cleanup.results
-                        : [];
-                    const cleanedLaunchIds = new Set();
-                    for (const cleanupResult of cleanupRecords) {
-                        if (isRecord(cleanupResult) && isElectronLaunchRecord(cleanupResult.record)) {
-                            cleanedLaunchIds.add(cleanupResult.record.launchId);
-                        }
+                    const scriptController = new AbortController();
+                    const abortScript = () => scriptController.abort();
+                    signal?.addEventListener("abort", abortScript, { once: true });
+                    if (signal?.aborted)
+                        scriptController.abort();
+                    activeScriptControllers.add(scriptController);
+                    let finishScriptExecution;
+                    const scriptExecution = new Promise((resolve) => {
+                        finishScriptExecution = resolve;
+                    });
+                    activeScriptExecutions.add(scriptExecution);
+                    try {
+                        // Keep preflight inside shutdown tracking so quit cannot race into starting the sandbox afterward.
+                        const versionFailure = await withIsolatedAgentBrowserEnvironment(() => validateUpstreamVersion(ctx.cwd, scriptController.signal));
+                        if (versionFailure)
+                            return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, result: versionFailure });
+                        const pendingRun = runAgentBrowserScript({
+                            beforeFirstCall() {
+                                appendScriptSessionLease(pi, sessionName, "active");
+                                trackOwnedManagedSession(ownedManagedSessions, sessionName, ctx.cwd, { namespace: AGENT_BROWSER_SCRIPT_NAMESPACE });
+                                managedSessionRestoreState.disable(sessionName, AGENT_BROWSER_SCRIPT_NAMESPACE);
+                                // This fresh, unselectable lease owns any daemon its first read starts.
+                                managedSessionRestoreState.recordDaemonRestoreKey(sessionName, AGENT_BROWSER_SCRIPT_NAMESPACE, null);
+                                leased = true;
+                            },
+                            code: resolvedInput.compiledScript.code,
+                            dispatch: async (innerParams, innerSignal) => {
+                                const remainingMs = Math.max(1, deadline - Date.now());
+                                const innerTimeoutMs = Math.min(innerParams.timeoutMs ?? remainingMs, remainingMs);
+                                const innerResult = await withIsolatedAgentBrowserEnvironment(() => agentBrowserTool.execute(`${toolCallId}:script:${innerResults.length + 1}`, {
+                                    args: ["--namespace", AGENT_BROWSER_SCRIPT_NAMESPACE, "--session", sessionName, ...innerParams.args],
+                                    stdin: innerParams.stdin,
+                                    timeoutMs: innerTimeoutMs,
+                                }, innerSignal, undefined, ctx, nativeToolCallId));
+                                innerResults.push(innerResult);
+                                return await buildScriptBrowserEnvelope(innerResult, innerParams.args, sessionName);
+                            },
+                            signal: scriptController.signal,
+                            timeoutMs: scriptTimeoutMs,
+                        });
+                        run = await pendingRun;
                     }
-                    replaceWithActiveElectronLaunchRecords(ownedElectronLaunchRecords, electronHostLaunchRecords, branchOwnedElectronLaunchIds, cleanedLaunchIds);
-                    mergeElectronCleanupRecords(electronLaunchRecords, cleanupRecords);
-                    const cleanupNamespace = isRecord(electronHostResult.details) && typeof electronHostResult.details.namespace === "string"
-                        ? electronHostResult.details.namespace
-                        : undefined;
-                    const closedSessionIdentities = getCleanupResultsClosedManagedSessionIdentities(cleanupRecords, cleanupNamespace);
-                    syncElectronCleanupManagedSessions(ownedManagedSessions, cleanupRecords, cleanupNamespace);
-                    for (const identity of closedSessionIdentities) {
-                        retireRecordingSession(identity.sessionName, identity.namespace);
-                        const closedSessionKey = getSessionContextKey(identity.sessionName, identity.namespace) ?? identity.sessionName;
-                        clearSessionScopedBrowserState(closedSessionKey);
-                        if (closedSessionKey === (getSessionContextKey(managedSessionName, managedSessionNamespace) ?? managedSessionName)) {
-                            managedSessionActive = false;
-                            managedSessionCompatibilityWorkaround = undefined;
-                            managedSessionHeadedAutosaveDisabled = false;
-                            managedSessionHeadedAutosaveInterval = undefined;
-                            managedSessionNamespace = undefined;
-                            freshSessionOrdinal += 1;
-                            managedSessionName = createFreshSessionName(managedSessionBaseName, ephemeralSessionSeed, freshSessionOrdinal);
+                    catch { }
+                    finally {
+                        activeScriptControllers.delete(scriptController);
+                        signal?.removeEventListener("abort", abortScript);
+                        if (leased) {
+                            try {
+                                cleanupError = await artifactExecutionQueue.run(() => managedSessionExecutionQueue.run(() => {
+                                    flushRecordingReservations();
+                                    return closeScriptSessionLeaseWithinQueue(sessionName, ctx.cwd);
+                                }));
+                            }
+                            catch {
+                                cleanupError = "The isolated script session cleanup operation failed.";
+                                try {
+                                    appendScriptSessionLease(pi, sessionName, "failed");
+                                }
+                                catch { }
+                            }
                         }
+                        activeScriptExecutions.delete(scriptExecution);
+                        finishScriptExecution();
                     }
+                    let scriptResult = buildScriptToolResult({ cleanupError, innerResults, run, sessionName: leased ? sessionName : undefined });
                     if (artifactManifest) {
-                        electronHostResult = {
-                            ...electronHostResult,
+                        scriptResult = {
+                            ...scriptResult,
                             details: {
-                                ...(isRecord(electronHostResult.details) ? electronHostResult.details : {}),
-                                artifactManifest,
+                                ...(isRecord(scriptResult.details) ? scriptResult.details : {}),
+                                artifactManifest: redactSensitiveValue(artifactManifest),
                                 artifactRetentionSummary: formatSessionArtifactRetentionSummary(artifactManifest),
                             },
                         };
                     }
+                    return applyUnserializedOutputPath(scriptResult);
                 }
-                return electronHostResult;
-            };
-            const runSerializedElectronHostInput = () => shouldSerializeElectronHostInput(compiledElectron)
-                ? managedSessionExecutionQueue.run(runElectronHostInput)
-                : runElectronHostInput();
-            const electronHostResult = compiledElectron?.action === "cleanup"
-                ? await artifactExecutionQueue.run(async () => {
-                    flushRecordingReservations();
-                    const reservationError = outputPath ? getArtifactPreflightValidationError({
-                        activeRecordingReservations: activeRecordingReservations.values(),
-                        args: [],
+                const { toolArgs } = resolvedInput;
+                const compiledElectron = resolvedInput.kind === "electron" ? resolvedInput.compiledElectron : undefined;
+                const redactedCompiledElectron = resolvedInput.kind === "electron" ? resolvedInput.redactedCompiledElectron : undefined;
+                const runElectronHostInput = async () => {
+                    const electronHostLaunchRecords = getElectronHostLaunchRecordsForInput({
+                        branchRecords: electronLaunchRecords,
+                        compiledElectron,
+                        ownedRecords: ownedElectronLaunchRecords,
+                    });
+                    let electronHostResult = await handleElectronHostInput({
+                        attachedSessionKeys,
+                        compiledElectron,
                         cwd: ctx.cwd,
-                        outputPath,
-                    }) : undefined;
-                    if (reservationError) {
-                        return warnRecordingPersistence(buildValidationFailureResult({ attemptedKind: resolvedInput.kind, kind: "invalid", redactedArgs: resolvedInput.redactedArgs, status: "invalid", toolArgs: resolvedInput.toolArgs, toolStdin: resolvedInput.toolStdin, validationError: reservationError }));
+                        electronChildProcesses,
+                        electronLaunchRecords: electronHostLaunchRecords,
+                        implicitSessionCloseTimeoutMs,
+                        managedSessionActive,
+                        managedSessionName,
+                        managedSessionNamespace,
+                        managedSessionRestoreState,
+                        ownedManagedSessions,
+                        redactedCompiledElectron,
+                        sessionPageState,
+                        signal,
+                    });
+                    if (electronHostResult && compiledElectron?.action === "cleanup") {
+                        branchStateGeneration += 1;
+                        const cleanupRecords = isRecord(electronHostResult.details)
+                            && isRecord(electronHostResult.details.electron)
+                            && isRecord(electronHostResult.details.electron.cleanup)
+                            && Array.isArray(electronHostResult.details.electron.cleanup.results)
+                            ? electronHostResult.details.electron.cleanup.results
+                            : [];
+                        const cleanedLaunchIds = new Set();
+                        for (const cleanupResult of cleanupRecords) {
+                            if (isRecord(cleanupResult) && isElectronLaunchRecord(cleanupResult.record)) {
+                                cleanedLaunchIds.add(cleanupResult.record.launchId);
+                            }
+                        }
+                        replaceWithActiveElectronLaunchRecords(ownedElectronLaunchRecords, electronHostLaunchRecords, branchOwnedElectronLaunchIds, cleanedLaunchIds);
+                        mergeElectronCleanupRecords(electronLaunchRecords, cleanupRecords);
+                        const cleanupNamespace = isRecord(electronHostResult.details) && typeof electronHostResult.details.namespace === "string"
+                            ? electronHostResult.details.namespace
+                            : undefined;
+                        const closedSessionIdentities = getCleanupResultsClosedManagedSessionIdentities(cleanupRecords, cleanupNamespace);
+                        syncElectronCleanupManagedSessions(ownedManagedSessions, cleanupRecords, cleanupNamespace);
+                        for (const identity of closedSessionIdentities) {
+                            retireRecordingSession(identity.sessionName, identity.namespace);
+                            const closedSessionKey = getSessionContextKey(identity.sessionName, identity.namespace) ?? identity.sessionName;
+                            clearSessionScopedBrowserState(closedSessionKey);
+                            if (closedSessionKey === (getSessionContextKey(managedSessionName, managedSessionNamespace) ?? managedSessionName)) {
+                                managedSessionActive = false;
+                                managedSessionCompatibilityWorkaround = undefined;
+                                managedSessionHeadedAutosaveDisabled = false;
+                                managedSessionHeadedAutosaveInterval = undefined;
+                                managedSessionNamespace = undefined;
+                                freshSessionOrdinal += 1;
+                                managedSessionName = createFreshSessionName(managedSessionBaseName, ephemeralSessionSeed, freshSessionOrdinal);
+                            }
+                        }
+                        if (artifactManifest) {
+                            electronHostResult = {
+                                ...electronHostResult,
+                                details: {
+                                    ...(isRecord(electronHostResult.details) ? electronHostResult.details : {}),
+                                    artifactManifest: redactSensitiveValue(artifactManifest),
+                                    artifactRetentionSummary: formatSessionArtifactRetentionSummary(artifactManifest),
+                                },
+                            };
+                        }
                     }
-                    const result = await runSerializedElectronHostInput();
-                    return result ? applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, result: warnRecordingPersistence(result) }) : result;
-                })
-                : await runSerializedElectronHostInput();
-            if (electronHostResult) {
-                return compiledElectron?.action === "cleanup" ? electronHostResult : applyUnserializedOutputPath(electronHostResult);
-            }
-            const explicitSessionName = extractExplicitSessionName(toolArgs);
-            const callerOwnedSessionNamespace = explicitSessionName
-                ? resolveAgentBrowserNamespace(toolArgs, getAgentBrowserProcessEnvironment().AGENT_BROWSER_NAMESPACE)
-                : undefined;
-            const serializeBrowserCommand = shouldSerializeBrowserCommand({
-                namespace: callerOwnedSessionNamespace,
-                explicitSessionName,
-                managedSessionName,
-                ownedElectronLaunchRecords,
-                ownedManagedSessions,
-            });
-            const callerOwnedSessionQueueKey = !serializeBrowserCommand && explicitSessionName
-                ? getSessionContextKey(explicitSessionName, callerOwnedSessionNamespace) ?? explicitSessionName
-                : undefined;
-            const runBrowserCommand = async () => {
-                flushRecordingReservations();
-                const branchRestoreGenerationAtStart = branchRestoreGeneration;
-                const generationAtStart = branchStateGeneration;
-                const sessionPageStateUpdate = sessionPageState.beginUpdate();
-                const browserRunState = {
-                    artifactManifest,
-                    attachedSessionKeys,
-                    closedManagedSessionNames: new Set(),
-                    electronChildProcesses,
-                    electronLaunchRecords,
-                    ephemeralSessionSeed,
-                    freshSessionOrdinal,
-                    managedSessionActive,
-                    managedSessionBaseName,
-                    managedSessionCompatibilityWorkaround,
-                    managedSessionHeadedAutosaveDisabled,
-                    managedSessionHeadedAutosaveInterval,
-                    managedSessionCwd,
+                    return electronHostResult;
+                };
+                const runSerializedElectronHostInput = () => shouldSerializeElectronHostInput(compiledElectron)
+                    ? managedSessionExecutionQueue.run(runElectronHostInput)
+                    : runElectronHostInput();
+                const electronHostResult = compiledElectron?.action === "cleanup"
+                    ? await artifactExecutionQueue.run(async () => {
+                        flushRecordingReservations();
+                        const reservationError = outputPath ? getArtifactPreflightValidationError({
+                            activeRecordingReservations: activeRecordingReservations.values(),
+                            args: [],
+                            cwd: ctx.cwd,
+                            outputPath,
+                        }) : undefined;
+                        if (reservationError) {
+                            return warnRecordingPersistence(buildValidationFailureResult({ attemptedKind: resolvedInput.kind, kind: "invalid", redactedArgs: resolvedInput.redactedArgs, status: "invalid", toolArgs: resolvedInput.toolArgs, toolStdin: resolvedInput.toolStdin, validationError: reservationError }));
+                        }
+                        const result = await runSerializedElectronHostInput();
+                        return result ? applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, result: warnRecordingPersistence(result) }) : result;
+                    })
+                    : await runSerializedElectronHostInput();
+                if (electronHostResult) {
+                    return compiledElectron?.action === "cleanup" ? electronHostResult : applyUnserializedOutputPath(electronHostResult);
+                }
+                const explicitSessionName = extractExplicitSessionName(toolArgs);
+                const callerOwnedSessionNamespace = explicitSessionName
+                    ? resolveAgentBrowserNamespace(toolArgs, getAgentBrowserProcessEnvironment().AGENT_BROWSER_NAMESPACE)
+                    : undefined;
+                const serializeBrowserCommand = shouldSerializeBrowserCommand({
+                    namespace: callerOwnedSessionNamespace,
+                    explicitSessionName,
                     managedSessionName,
-                    managedSessionNamespace,
-                    managedSessionRestoreState,
-                    networkRoutesBySession,
+                    ownedElectronLaunchRecords,
                     ownedManagedSessions,
-                    sessionPageState,
-                    traceOwners,
-                };
-                const selectedPlan = buildExecutionPlan(toolArgs, {
-                    freshSessionName: createFreshSessionName(browserRunState.managedSessionBaseName, browserRunState.ephemeralSessionSeed, browserRunState.freshSessionOrdinal + 1),
-                    managedSessionActive: browserRunState.managedSessionActive,
-                    managedSessionCompatibilityWorkaround: browserRunState.managedSessionCompatibilityWorkaround,
-                    managedSessionName: browserRunState.managedSessionName,
-                    managedSessionNamespace: browserRunState.managedSessionNamespace,
-                    sessionMode: compiledElectron?.action === "launch" ? "fresh" : params.sessionMode ?? "auto",
-                });
-                const initialArtifactManifest = browserRunState.artifactManifest;
-                const initialNetworkRoutesBySession = browserRunState.networkRoutesBySession;
-                const attachedSessionRequested = isAttachedBrowserInvocation(toolArgs)
-                    || (resolvedInput.kind === "electron" && resolvedInput.compiledElectron.action === "launch");
-                const allocatesFreshManagedSession = explicitSessionName === undefined
-                    && (params.sessionMode === "fresh" || (resolvedInput.kind === "electron" && resolvedInput.compiledElectron.action === "launch"));
-                const reusableSessionKey = allocatesFreshManagedSession
-                    ? undefined
-                    : getSessionContextKey(selectedPlan.sessionName, selectedPlan.namespace)
-                        ?? getSessionContextKey(browserRunState.managedSessionName, browserRunState.managedSessionNamespace);
-                const attachedSessionKnown = reusableSessionKey !== undefined && attachedSessionKeys.has(reusableSessionKey);
-                let result = await runAgentBrowserTool({
-                    ctx,
-                    cwd: ctx.cwd,
-                    electronPostCommandStatusSettleMs: ELECTRON_POST_COMMAND_STATUS_SETTLE_MS,
-                    electronProfileIsolationDetails: ELECTRON_PROFILE_ISOLATION_DETAILS,
-                    implicitSessionCloseTimeoutMs,
-                    implicitSessionIdleTimeoutMs,
-                    input: resolvedInput,
-                    onUpdate,
-                    params,
-                    establishAttachedBrowserSession: attachedSessionRequested && !attachedSessionKnown,
-                    preserveAttachedBrowserSession: attachedSessionRequested || attachedSessionKnown,
-                    promptPolicy,
-                    sessionPageStateUpdate,
-                    signal,
-                    state: browserRunState,
                 });
-                const branchRestoreStillCurrent = branchRestoreGenerationAtStart === branchRestoreGeneration;
-                const resultDetails = isRecord(result.details) ? result.details : undefined;
-                const resultSessionName = typeof resultDetails?.sessionName === "string"
-                    ? resultDetails.sessionName
-                    : extractExplicitSessionName(toolArgs);
-                const resultNamespace = typeof resultDetails?.namespace === "string"
-                    ? resultDetails.namespace
-                    : selectedPlan.namespace;
-                if (branchRestoreStillCurrent) {
-                    const resultBatchCloseLifecycle = getSuccessfulBatchCloseLifecycle(resultDetails?.batchSteps);
-                    const resultSessionKey = getSessionContextKey(resultSessionName, resultNamespace) ?? resultSessionName;
-                    const managedSessionOutcome = isRecord(resultDetails?.managedSessionOutcome) ? resultDetails.managedSessionOutcome : undefined;
-                    const closeAllApplied = resultDetails?.closeAllApplied === true;
-                    const attachedSessionRemainsActive = result.isError !== true
-                        || ((attachedSessionRequested || attachedSessionKnown) && managedSessionOutcome?.activeAfter === true);
-                    const closesAttachedSession = (result.isError !== true && isCloseCommand(extractUpstreamCommandTokens(toolArgs)[0]))
-                        || resultBatchCloseLifecycle?.endsClosed === true;
-                    if (closeAllApplied) {
-                        deleteIdentityKeysInNamespace(attachedSessionKeys, resultNamespace);
-                        if (resultSessionKey && attachedSessionRemainsActive && (attachedSessionRequested || attachedSessionKnown) && resultBatchCloseLifecycle?.endsClosed === false) {
+                const callerOwnedSessionQueueKey = !serializeBrowserCommand && explicitSessionName
+                    ? getSessionContextKey(explicitSessionName, callerOwnedSessionNamespace) ?? explicitSessionName
+                    : undefined;
+                const runBrowserCommand = async () => {
+                    flushRecordingReservations();
+                    const branchRestoreGenerationAtStart = branchRestoreGeneration;
+                    const generationAtStart = branchStateGeneration;
+                    const sessionPageStateUpdate = sessionPageState.beginUpdate();
+                    const browserRunState = {
+                        activeRecordingReservations,
+                        artifactManifest,
+                        attachedSessionKeys,
+                        closedManagedSessionNames: new Set(),
+                        electronChildProcesses,
+                        electronLaunchRecords,
+                        ephemeralSessionSeed,
+                        freshSessionOrdinal,
+                        managedSessionActive,
+                        managedSessionBaseName,
+                        managedSessionCompatibilityWorkaround,
+                        managedSessionHeadedAutosaveDisabled,
+                        managedSessionHeadedAutosaveInterval,
+                        managedSessionCwd,
+                        managedSessionName,
+                        managedSessionNamespace,
+                        managedSessionRestoreState,
+                        networkRoutesBySession,
+                        ownedManagedSessions,
+                        sessionPageState,
+                        traceOwners,
+                    };
+                    const selectedPlan = buildExecutionPlan(toolArgs, {
+                        freshSessionName: createFreshSessionName(browserRunState.managedSessionBaseName, browserRunState.ephemeralSessionSeed, browserRunState.freshSessionOrdinal + 1),
+                        managedSessionActive: browserRunState.managedSessionActive,
+                        managedSessionCompatibilityWorkaround: browserRunState.managedSessionCompatibilityWorkaround,
+                        managedSessionName: browserRunState.managedSessionName,
+                        managedSessionNamespace: browserRunState.managedSessionNamespace,
+                        sessionMode: compiledElectron?.action === "launch" ? "fresh" : params.sessionMode ?? "auto",
+                        stdin: resolvedInput.toolStdin,
+                        browserIndependentReadConfirmation: readConfirmation?.capabilities?.readRequiresConfirmation === true,
+                    });
+                    const initialArtifactManifest = browserRunState.artifactManifest;
+                    const initialNetworkRoutesBySession = browserRunState.networkRoutesBySession;
+                    const attachedSessionRequested = isAttachedBrowserInvocation(toolArgs)
+                        || (resolvedInput.kind === "electron" && resolvedInput.compiledElectron.action === "launch");
+                    const allocatesFreshManagedSession = explicitSessionName === undefined
+                        && (params.sessionMode === "fresh" || (resolvedInput.kind === "electron" && resolvedInput.compiledElectron.action === "launch"));
+                    const reusableSessionKey = allocatesFreshManagedSession
+                        ? undefined
+                        : getSessionContextKey(selectedPlan.sessionName, selectedPlan.namespace)
+                            ?? getSessionContextKey(browserRunState.managedSessionName, browserRunState.managedSessionNamespace);
+                    const attachedSessionKnown = reusableSessionKey !== undefined && attachedSessionKeys.has(reusableSessionKey);
+                    let result = await runAgentBrowserTool({
+                        ctx,
+                        cwd: ctx.cwd,
+                        electronPostCommandStatusSettleMs: ELECTRON_POST_COMMAND_STATUS_SETTLE_MS,
+                        electronProfileIsolationDetails: ELECTRON_PROFILE_ISOLATION_DETAILS,
+                        implicitSessionCloseTimeoutMs,
+                        implicitSessionIdleTimeoutMs,
+                        input: resolvedInput,
+                        onUpdate,
+                        params,
+                        establishAttachedBrowserSession: attachedSessionRequested && !attachedSessionKnown,
+                        preserveAttachedBrowserSession: attachedSessionRequested || attachedSessionKnown,
+                        promptPolicy,
+                        sessionPageStateUpdate,
+                        signal,
+                        state: browserRunState,
+                    });
+                    const branchRestoreStillCurrent = branchRestoreGenerationAtStart === branchRestoreGeneration;
+                    const resultDetails = isRecord(result.details) ? result.details : undefined;
+                    const resultSessionName = typeof resultDetails?.sessionName === "string"
+                        ? resultDetails.sessionName
+                        : extractExplicitSessionName(toolArgs);
+                    const resultNamespace = typeof resultDetails?.namespace === "string"
+                        ? resultDetails.namespace
+                        : selectedPlan.namespace;
+                    if (branchRestoreStillCurrent) {
+                        const resultBatchCloseLifecycle = getSuccessfulBatchCloseLifecycle(resultDetails?.batchSteps);
+                        const resultSessionKey = getSessionContextKey(resultSessionName, resultNamespace) ?? resultSessionName;
+                        const managedSessionOutcome = isRecord(resultDetails?.managedSessionOutcome) ? resultDetails.managedSessionOutcome : undefined;
+                        const closeAllApplied = resultDetails?.closeAllApplied === true;
+                        const attachedSessionRemainsActive = result.isError !== true
+                            || ((attachedSessionRequested || attachedSessionKnown) && managedSessionOutcome?.activeAfter === true);
+                        const closesAttachedSession = (result.isError !== true && isCloseCommand(extractUpstreamCommandTokens(toolArgs)[0]))
+                            || resultBatchCloseLifecycle?.endsClosed === true;
+                        if (closeAllApplied) {
+                            deleteIdentityKeysInNamespace(attachedSessionKeys, resultNamespace);
+                            if (resultSessionKey && attachedSessionRemainsActive && (attachedSessionRequested || attachedSessionKnown) && resultBatchCloseLifecycle?.endsClosed === false) {
+                                attachedSessionKeys.add(resultSessionKey);
+                                result = { ...result, details: { ...(resultDetails ?? {}), attachedBrowserSession: true } };
+                            }
+                        }
+                        else if (resultSessionKey && closesAttachedSession)
+                            attachedSessionKeys.delete(resultSessionKey);
+                        else if (resultSessionKey && attachedSessionRemainsActive && (attachedSessionRequested || attachedSessionKnown)) {
                             attachedSessionKeys.add(resultSessionKey);
                             result = { ...result, details: { ...(resultDetails ?? {}), attachedBrowserSession: true } };
                         }
                     }
-                    else if (resultSessionKey && closesAttachedSession)
-                        attachedSessionKeys.delete(resultSessionKey);
-                    else if (resultSessionKey && attachedSessionRemainsActive && (attachedSessionRequested || attachedSessionKnown)) {
-                        attachedSessionKeys.add(resultSessionKey);
-                        result = { ...result, details: { ...(resultDetails ?? {}), attachedBrowserSession: true } };
-                    }
-                }
-                if (branchRestoreStillCurrent) {
-                    networkRoutesBySession = mergeBrowserRunMap(networkRoutesBySession, initialNetworkRoutesBySession, browserRunState.networkRoutesBySession);
-                    artifactManifest = mergeBrowserRunArtifactManifest(artifactManifest, initialArtifactManifest, browserRunState.artifactManifest);
-                    const handledBatchCloseKeys = syncRecordingReservationsFromResult(result);
-                    if (resultDetails?.closeAllApplied === true) {
-                        for (const [sessionKey, reservation] of [...activeRecordingReservations]) {
-                            if (isAgentBrowserSessionIdentityKeyInNamespace(sessionKey, resultNamespace)) {
-                                retireRecordingSession(reservation.sessionName, reservation.namespace);
+                    if (branchRestoreStillCurrent) {
+                        networkRoutesBySession = mergeBrowserRunMap(networkRoutesBySession, initialNetworkRoutesBySession, browserRunState.networkRoutesBySession);
+                        artifactManifest = mergeBrowserRunArtifactManifest(artifactManifest, initialArtifactManifest, browserRunState.artifactManifest);
+                        const handledBatchCloseKeys = syncRecordingReservationsFromResult(result);
+                        if (resultDetails?.closeAllApplied === true) {
+                            for (const [sessionKey, reservation] of [...activeRecordingReservations]) {
+                                if (isAgentBrowserSessionIdentityKeyInNamespace(sessionKey, resultNamespace)) {
+                                    retireRecordingSession(reservation.sessionName, reservation.namespace);
+                                }
                             }
                         }
+                        for (const closedSessionKey of browserRunState.closedManagedSessionNames) {
+                            if (handledBatchCloseKeys.has(closedSessionKey))
+                                continue;
+                            const reservation = activeRecordingReservations.get(closedSessionKey);
+                            if (reservation)
+                                retireRecordingSession(reservation.sessionName, reservation.namespace);
+                        }
+                        if (resultSessionName) {
+                            const reservation = activeRecordingReservations.get(getAgentBrowserSessionIdentityKey(resultSessionName, resultNamespace));
+                            if (reservation)
+                                result = appendActiveRecordingCleanupAction(result, reservation);
+                        }
+                        if (artifactManifest) {
+                            result = {
+                                ...result,
+                                details: {
+                                    ...(isRecord(result.details) ? result.details : {}),
+                                    artifactManifest: redactSensitiveValue(artifactManifest),
+                                    artifactRetentionSummary: formatSessionArtifactRetentionSummary(artifactManifest),
+                                },
+                            };
+                        }
                     }
-                    for (const closedSessionKey of browserRunState.closedManagedSessionNames) {
-                        if (handledBatchCloseKeys.has(closedSessionKey))
-                            continue;
-                        const reservation = activeRecordingReservations.get(closedSessionKey);
-                        if (reservation)
-                            retireRecordingSession(reservation.sessionName, reservation.namespace);
-                    }
-                    if (resultSessionName && resultReportsNoRecordingInProgress(result)) {
-                        retireRecordingSession(resultSessionName, resultNamespace);
-                    }
-                    if (resultSessionName) {
-                        const reservation = activeRecordingReservations.get(getAgentBrowserSessionIdentityKey(resultSessionName, resultNamespace));
-                        if (reservation)
-                            result = appendActiveRecordingCleanupAction(result, reservation);
-                    }
-                    if (artifactManifest) {
-                        result = {
-                            ...result,
-                            details: {
-                                ...(isRecord(result.details) ? result.details : {}),
-                                artifactManifest,
-                                artifactRetentionSummary: formatSessionArtifactRetentionSummary(artifactManifest),
-                            },
-                        };
-                    }
-                }
-                const branchStateStillCurrent = generationAtStart === branchStateGeneration;
-                if (serializeBrowserCommand || branchStateStillCurrent) {
-                    freshSessionOrdinal = Math.max(freshSessionOrdinal, browserRunState.freshSessionOrdinal);
-                    managedSessionActive = browserRunState.managedSessionActive;
-                    managedSessionCompatibilityWorkaround = browserRunState.managedSessionCompatibilityWorkaround;
-                    managedSessionHeadedAutosaveDisabled = browserRunState.managedSessionHeadedAutosaveDisabled === true;
-                    managedSessionHeadedAutosaveInterval = browserRunState.managedSessionHeadedAutosaveInterval;
-                    managedSessionCwd = browserRunState.managedSessionCwd;
-                    managedSessionName = browserRunState.managedSessionName;
-                    managedSessionNamespace = browserRunState.managedSessionNamespace;
-                    for (const closedSessionName of browserRunState.closedManagedSessionNames) {
-                        untrackOwnedManagedSession(ownedManagedSessions, closedSessionName);
+                    const branchStateStillCurrent = generationAtStart === branchStateGeneration;
+                    if (serializeBrowserCommand || branchStateStillCurrent) {
+                        freshSessionOrdinal = Math.max(freshSessionOrdinal, browserRunState.freshSessionOrdinal);
+                        managedSessionActive = browserRunState.managedSessionActive;
+                        managedSessionCompatibilityWorkaround = browserRunState.managedSessionCompatibilityWorkaround;
+                        managedSessionHeadedAutosaveDisabled = browserRunState.managedSessionHeadedAutosaveDisabled === true;
+                        managedSessionHeadedAutosaveInterval = browserRunState.managedSessionHeadedAutosaveInterval;
+                        managedSessionCwd = browserRunState.managedSessionCwd;
+                        managedSessionName = browserRunState.managedSessionName;
+                        managedSessionNamespace = browserRunState.managedSessionNamespace;
+                        for (const closedSessionName of browserRunState.closedManagedSessionNames) {
+                            untrackOwnedManagedSession(ownedManagedSessions, closedSessionName);
+                        }
+                        syncOwnedManagedSessionsFromResult(ownedManagedSessions, result, browserRunState.managedSessionCwd);
+                        mergeActiveElectronLaunchRecords(ownedElectronLaunchRecords, electronLaunchRecords, {
+                            branchOwnedLaunchIds: branchOwnedElectronLaunchIds,
+                            touchedLaunchIds: !result.isError
+                                ? getTouchedElectronLaunchIds(explicitSessionName ?? browserRunState.managedSessionName, electronLaunchRecords, resultNamespace)
+                                : undefined,
+                        });
+                        if (serializeBrowserCommand)
+                            branchStateGeneration += 1;
                     }
-                    syncOwnedManagedSessionsFromResult(ownedManagedSessions, result, browserRunState.managedSessionCwd);
-                    mergeActiveElectronLaunchRecords(ownedElectronLaunchRecords, electronLaunchRecords, {
-                        branchOwnedLaunchIds: branchOwnedElectronLaunchIds,
-                        touchedLaunchIds: !result.isError
-                            ? getTouchedElectronLaunchIds(explicitSessionName ?? browserRunState.managedSessionName, electronLaunchRecords, resultNamespace)
-                            : undefined,
-                    });
-                    if (serializeBrowserCommand)
-                        branchStateGeneration += 1;
-                }
-                return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, preserveTextContent: Array.isArray(params.args) && params.args.includes("--json"), result: warnRecordingPersistence(result) });
-            };
-            const closesAllSessions = commandClosesAllSessions(toolArgs, resolvedInput.toolStdin);
-            const runWithinSessionQueue = () => {
-                if (closesAllSessions)
-                    return managedSessionExecutionQueue.run(() => {
-                        const plan = buildExecutionPlan(toolArgs, {
-                            freshSessionName: createFreshSessionName(managedSessionBaseName, ephemeralSessionSeed, freshSessionOrdinal + 1),
-                            managedSessionActive,
-                            managedSessionCompatibilityWorkaround,
-                            managedSessionName,
-                            managedSessionNamespace,
-                            sessionMode: params.sessionMode ?? "auto",
+                    return applyAgentBrowserOutputPath({ cwd: ctx.cwd, outputPath, preserveTextContent: Array.isArray(params.args) && params.args.includes("--json"), result: warnRecordingPersistence(result) });
+                };
+                const closesAllSessions = commandClosesAllSessions(toolArgs, resolvedInput.toolStdin);
+                const runWithinSessionQueue = () => {
+                    if (closesAllSessions)
+                        return managedSessionExecutionQueue.run(() => {
+                            const plan = buildExecutionPlan(toolArgs, {
+                                freshSessionName: createFreshSessionName(managedSessionBaseName, ephemeralSessionSeed, freshSessionOrdinal + 1),
+                                managedSessionActive,
+                                managedSessionCompatibilityWorkaround,
+                                managedSessionName,
+                                managedSessionNamespace,
+                                sessionMode: params.sessionMode ?? "auto",
+                                stdin: resolvedInput.toolStdin,
+                            });
+                            return callerOwnedSessionExecutionQueues.runExclusive(plan.namespace, runBrowserCommand);
                         });
-                        return callerOwnedSessionExecutionQueues.runExclusive(plan.namespace, runBrowserCommand);
-                    });
-                if (serializeBrowserCommand)
-                    return managedSessionExecutionQueue.run(runBrowserCommand);
-                return callerOwnedSessionQueueKey
-                    ? callerOwnedSessionExecutionQueues.run(callerOwnedSessionQueueKey, callerOwnedSessionNamespace, runBrowserCommand)
-                    : runBrowserCommand();
-            };
-            if (!commandTouchesArtifactLifecycle(toolArgs, resolvedInput.toolStdin, outputPath))
-                return runWithinSessionQueue();
-            return artifactExecutionQueue.run(async () => {
-                const artifactValidationError = getArtifactPreflightValidationError({
-                    activeRecordingReservations: activeRecordingReservations.values(),
-                    args: toolArgs,
-                    cwd: ctx.cwd,
-                    outputPath,
-                    stdin: resolvedInput.toolStdin,
-                });
-                if (!artifactValidationError)
+                    if (serializeBrowserCommand)
+                        return managedSessionExecutionQueue.run(runBrowserCommand);
+                    return callerOwnedSessionQueueKey
+                        ? callerOwnedSessionExecutionQueues.run(callerOwnedSessionQueueKey, callerOwnedSessionNamespace, runBrowserCommand)
+                        : runBrowserCommand();
+                };
+                if (!commandTouchesArtifactLifecycle(toolArgs, resolvedInput.toolStdin, outputPath))
                     return runWithinSessionQueue();
-                flushRecordingReservations();
-                return applyAgentBrowserOutputPath({
-                    cwd: ctx.cwd,
-                    outputPath,
-                    result: warnRecordingPersistence(buildValidationFailureResult({
+                return artifactExecutionQueue.run(async () => {
+                    const artifactValidationError = getArtifactPreflightValidationError({
+                        activeRecordingReservations: activeRecordingReservations.values(),
+                        args: toolArgs,
+                        cwd: ctx.cwd,
+                        outputPath,
+                        stdin: resolvedInput.toolStdin,
+                    });
+                    if (!artifactValidationError)
+                        return runWithinSessionQueue();
+                    flushRecordingReservations();
+                    return warnRecordingPersistence(buildValidationFailureResult({
                         attemptedKind: resolvedInput.kind,
                         kind: "invalid",
                         redactedArgs: resolvedInput.redactedArgs,
@@ -1826,11 +1812,11 @@ export default function agentBrowserExtension(pi) {
                         toolArgs: resolvedInput.toolArgs,
                         toolStdin: resolvedInput.toolStdin,
                         validationError: artifactValidationError,
-                    })),
+                    }));
                 });
             });
         },
     };
-    pi.registerTool(agentBrowserTool);
+    pi.registerTool(beforeExecute ? { ...agentBrowserTool, executionMode: "sequential" } : agentBrowserTool);
     registerWebSearchToolIfAvailable(agentBrowserConfig);
 }