pi-agent-browser-native 0.6.5 → 0.6.7

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare.js

@@ -16,13 +16,13 @@ import { buildAgentBrowserResultCategoryDetails } from "../../results/categories
 import { applyNamespaceToNextActions } from "../../results/next-actions.js";
 import { buildSessionAwareStaleRefNextActions, buildSessionTabRecoveryNextActions } from "../../results/recovery-next-actions.js";
 import { resolveVisibleRefActionFromSnapshot } from "../../results/selector-recovery.js";
-import { extractRefSnapshotFromData } from "../../session-page-state.js";
-import { buildExecutionPlan, canUseHeadlessCompatibilityUserAgent, createFreshSessionName, extractCommandTokens, extractUpstreamCommandTokens, getDefaultHeadlessCompatUserAgent, parseWaitCommandTokens, redactInvocationArgs, } from "../../runtime.js";
+import { buildPageTransitionRefSnapshotInvalidation, extractRefSnapshotFromData, normalizeComparableUrl } from "../../session-page-state.js";
+import { buildExecutionPlan, canUseHeadlessCompatibilityUserAgent, createFreshSessionName, extractCommandTokens, extractUpstreamCommandTokens, getDefaultHeadlessCompatUserAgent, parseWaitCommandTokens, redactInvocationArgs, redactSensitiveText, } from "../../runtime.js";
 import { buildOwnedManagedSessionRestoreContext, resolveExplicitAutosaveInterval, withOwnedManagedSessionContext, } from "../../managed-session-restore.js";
 import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
 import { getExplicitSessionPageVerificationRequirement, getPageTargetValidationError, } from "../../page-target-validation.js";
 import { acquireOwnedManagedSessionDaemonPolicy, getRunningHeadedAutosavePolicyChangeError } from "./managed-session-daemon-policy.js";
-import { applyOpenResultTabCorrection, buildManagedSessionOutcome, buildPinnedBatchPlan, buildSessionDetailFields, buildStaleRefPreflight, getSessionContextKey, extractStringResultField, collectAnySessionTabSelection, collectSessionTabSelection, getGuardedRefUsage, getTraceOwnerGuardMessage, runSessionCommandData, shouldPinSessionTabForCommand, } from "./session-state.js";
+import { buildManagedSessionOutcome, buildSessionDetailFields, buildStaleRefPreflight, getSessionContextKey, extractStringResultField, ensureSessionTabTarget, getGuardedRefUsage, getTraceOwnerGuardMessage, runSessionCommandData, shouldPinSessionTabForCommand, } from "./session-state.js";
 import { getUpstreamEffectiveBatchSteps, parseBatchStdinJsonArray } from "../batch-stdin.js";
 import { buildElectronHostFailureResult, formatAgentBrowserNextActionsText, getElectronLaunchFailureCategory, redactRecoveryHint } from "./final-result.js";
 import { prepareClickDispatchProbe } from "./click-dispatch.js";
@@ -241,8 +241,8 @@ function getSamePageFreshnessPreflightFailure(options) {
     const { refIds } = options;
     if (refIds.length === 0)
         return undefined;
-    const previousUrl = options.previousSnapshot.target?.url;
-    const currentUrl = options.currentSnapshot.target?.url;
+    const previousUrl = normalizeComparableUrl(options.previousSnapshot.target?.url);
+    const currentUrl = normalizeComparableUrl(options.currentSnapshot.target?.url);
     if (!previousUrl || !currentUrl || previousUrl !== currentUrl || currentUrl === "about:blank")
         return undefined;
     const mismatchedRefs = refIds.filter((refId) => {
@@ -267,8 +267,8 @@ async function collectSamePageRefFreshnessPreflight(options) {
     const refIds = [...new Set(getGuardedRefUsage(options.commandTokens, options.stdin))];
     if (!options.previousSnapshot || !options.sessionName || refIds.length === 0)
         return undefined;
-    const previousUrl = options.previousSnapshot.target?.url;
-    const currentTargetUrl = options.currentTarget?.url;
+    const previousUrl = normalizeComparableUrl(options.previousSnapshot.target?.url);
+    const currentTargetUrl = normalizeComparableUrl(options.currentTarget?.url);
     if (currentTargetUrl === "about:blank" || (previousUrl && currentTargetUrl && previousUrl !== currentTargetUrl))
         return undefined;
     const snapshotData = await runSessionCommandData({ args: ["snapshot", "-i"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal });
@@ -401,7 +401,29 @@ export async function prepareBrowserRun(options) {
     let managedSessionPolicyLockTransferred = false;
     let electronLaunchTransferred = false;
     try {
-        const preparedArgs = await prepareAgentBrowserArgs(runtimeToolArgs, runtimeToolStdin, cwd);
+        let preparedArgs;
+        try {
+            preparedArgs = await prepareAgentBrowserArgs(runtimeToolArgs, runtimeToolStdin, cwd);
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            if (!(error instanceof Error) || !("syscall" in error) || error.syscall !== "mkdir" || !("path" in error) || typeof error.path !== "string")
+                throw error;
+            const guidance = "Choose a writable artifact path whose parent components are directories. Use absolute paths in raw batch artifact rows.";
+            const validationError = redactSensitiveText(`Could not prepare artifact directory ${error.path}: ${error.message}. ${guidance}`);
+            const nextActions = [{ artifactPath: redactSensitiveText(error.path), id: "verify-artifact-path", reason: guidance, safety: "The requested browser command did not run; inspect the directory with host file tools before retrying.", tool: "agent_browser" }];
+            return { kind: "early-result", result: {
+                    content: [{ type: "text", text: validationError }],
+                    details: {
+                        agentBrowserStarted: false,
+                        args: redactedArgs,
+                        nextActions,
+                        ...buildAgentBrowserResultCategoryDetails({ args: redactedArgs, succeeded: false, validationError }),
+                        validationError,
+                    },
+                    isError: true,
+                } };
+        }
         const userRequestedJson = runtimeToolArgs.includes("--json");
         let executionPlan = buildExecutionPlan(preparedArgs.args, {
             freshSessionName,
@@ -480,6 +502,8 @@ export async function prepareBrowserRun(options) {
             compatibilityUserAgent: compatibilityUserAgentApplied ? compatibilityUserAgent : undefined,
             wrapperInjectedUserAgent: compatibilityUserAgentApplied,
         });
+        let managedSessionDaemonInactive = false;
+        let managedSessionCleanupOnlyReason;
         if (!executionPlan.validationError && ownedManagedSession) {
             const closeCommand = isCloseCommand(executionPlan.commandInfo.command);
             const policy = await acquireOwnedManagedSessionDaemonPolicy({
@@ -488,7 +512,9 @@ export async function prepareBrowserRun(options) {
                 signal,
             });
             managedSessionPolicyLock = policy.lock;
+            managedSessionDaemonInactive = policy.daemonStatus === "inactive";
             if (policy.error) {
+                managedSessionCleanupOnlyReason = policy.cleanupOnlyReason;
                 executionPlan = {
                     ...executionPlan,
                     recoveryHint: undefined,
@@ -524,10 +550,68 @@ export async function prepareBrowserRun(options) {
             let priorSessionTabTarget = priorSessionPageState.tabTarget;
             let priorSessionTabTargetUnknown = priorSessionPageState.tabTargetUnknown;
             const sessionTabPinningReason = priorSessionPageState.pinningReason;
-            const priorRefSnapshotState = priorSessionPageState.refSnapshot;
-            const priorRefSnapshotInvalidation = priorSessionPageState.refSnapshotInvalidation;
+            let priorRefSnapshotState = priorSessionPageState.refSnapshot;
+            let priorRefSnapshotInvalidation = priorSessionPageState.refSnapshotInvalidation;
+            const coldManagedSession = (managedSessionDaemonInactive || priorSessionPageState.tabReopenPending === true)
+                && recordedOwnedSession !== undefined
+                && sessionTabPinningReason === "restore"
+                && ownedManagedSession?.restoreDecision === "enabled"
+                && !managedSessionRestoreDisabled()
+                && !options.preserveAttachedBrowserSession;
+            if (coldManagedSession && sessionStateKey) {
+                sessionPageState.setTabReopenPending({ pending: true, sessionName: sessionStateKey, update: options.sessionPageStateUpdate });
+                priorRefSnapshotState = undefined;
+                priorRefSnapshotInvalidation = buildPageTransitionRefSnapshotInvalidation("The managed browser shut down. Reopening its URL reloads the page; run snapshot -i before using page-scoped refs.");
+                sessionPageState.applyRefSnapshotInvalidation({ invalidation: priorRefSnapshotInvalidation, sessionName: sessionStateKey, update: options.sessionPageStateUpdate });
+            }
             let semanticActionVisibleRefResolution;
             let livePageVerified = false;
+            let sessionTabCorrection;
+            let sessionTabSelectionError;
+            const plannedCommandTokens = extractUpstreamCommandTokens(preparedArgs.args);
+            const knownStaleRef = buildStaleRefPreflight({ commandTokens: plannedCommandTokens, currentTarget: priorSessionTabTarget, refSnapshot: priorRefSnapshotState, refSnapshotInvalidation: priorRefSnapshotInvalidation, stdin: runtimeToolStdin });
+            const invalidStdin = validateStdinCommandContract({ command: executionPlan.commandInfo.command, commandTokens: plannedCommandTokens, stdin: runtimeToolStdin });
+            const pinSessionTab = shouldPinSessionTabForCommand({
+                command: executionPlan.commandInfo.command,
+                commandTokens: plannedCommandTokens,
+                // URL QA clears diagnostics before its explicit open; those clears do not need the old tab.
+                pinningRequired: sessionTabPinningReason !== undefined && compiledQaPreset?.checks.url === undefined,
+                reopenPending: coldManagedSession,
+                sessionName: executionPlan.sessionName,
+                stdin: runtimeToolStdin,
+            });
+            if (!executionPlan.validationError && !executionPlan.plainTextInspection && !knownStaleRef && !invalidStdin && priorSessionTabTarget && pinSessionTab) {
+                signal?.throwIfAborted();
+                const reopened = !coldManagedSession || await runSessionCommandData({
+                    args: ["open", priorSessionTabTarget.url], cwd, namespace: executionPlan.namespace, sessionName: executionPlan.sessionName, signal, timeoutMs: params.timeoutMs,
+                    onProcessResult: ({ agentBrowserStarted }) => {
+                        // A started open may have navigated even if its CLI was aborted before replying.
+                        if (agentBrowserStarted && sessionStateKey)
+                            sessionPageState.setTabReopenPending({ pending: false, sessionName: sessionStateKey, update: options.sessionPageStateUpdate });
+                    },
+                }) !== undefined;
+                const selection = signal?.aborted ? undefined : reopened
+                    ? await ensureSessionTabTarget({ cwd, namespace: executionPlan.namespace, sessionName: executionPlan.sessionName, signal, target: priorSessionTabTarget })
+                    : { error: "agent-browser could not reopen the remembered URL after the managed browser shut down. Navigate explicitly, then run snapshot -i before retrying." };
+                if (coldManagedSession && signal?.aborted) {
+                    const errorText = "agent_browser was aborted while reopening the remembered page. The requested command did not run.";
+                    return { kind: "early-result", result: {
+                            content: [{ type: "text", text: errorText }],
+                            details: {
+                                aborted: true, args: redactedArgs, command: executionPlan.commandInfo.command,
+                                effectiveArgs: redactInvocationArgs(executionPlan.effectiveArgs), sessionMode,
+                                ...buildSessionDetailFields(executionPlan.sessionName, executionPlan.usedImplicitSession, executionPlan.namespace, managedSessionRestoreDisabled()),
+                                ...buildAgentBrowserResultCategoryDetails({ args: redactedArgs, command: executionPlan.commandInfo.command, errorText, failureCategory: "aborted", succeeded: false }),
+                            },
+                            isError: true,
+                        } };
+                }
+                signal?.throwIfAborted();
+                sessionTabCorrection = selection?.correction;
+                sessionTabSelectionError = selection?.error;
+                if (selection?.error)
+                    executionPlan = { ...executionPlan, recoveryHint: undefined, validationError: selection.error };
+            }
             const isCallerOwnedExplicitSession = () => executionPlan.sessionName !== undefined
                 && executionPlan.usedImplicitSession === false
                 && ownedManagedSession === undefined;
@@ -655,7 +739,7 @@ export async function prepareBrowserRun(options) {
                 freshSessionOrdinal += 1;
             }
             if (executionPlan.validationError) {
-                const nextActions = applyNamespaceToNextActions(unsupportedScrollIntoViewRecovery?.nextActions, executionPlan.namespace);
+                const nextActions = applyNamespaceToNextActions(sessionTabSelectionError ? buildSessionTabRecoveryNextActions({ kind: "tab-drift", resultCategory: "failure", sessionName: executionPlan.sessionName, tabCorrection: sessionTabCorrection, target: priorSessionTabTarget }) : unsupportedScrollIntoViewRecovery?.nextActions, executionPlan.namespace);
                 const nextActionsText = formatAgentBrowserNextActionsText(nextActions);
                 return { kind: "early-result", statePatch, result: {
                         content: [{ type: "text", text: [executionPlan.validationError, nextActionsText].filter((text) => text !== undefined).join("\n\n") }],
@@ -667,11 +751,16 @@ export async function prepareBrowserRun(options) {
                             compiledSourceLookup: redactedCompiledSourceLookup,
                             compiledNetworkSourceLookup: redactedCompiledNetworkSourceLookup,
                             invalidValueFlag: executionPlan.invalidValueFlag,
+                            managedSessionCleanupOnlyReason,
+                            ...buildSessionDetailFields(executionPlan.sessionName, executionPlan.usedImplicitSession, executionPlan.namespace, managedSessionRestoreDisabled()),
+                            ...(managedSessionCleanupOnlyReason ? { namespace: ownedManagedSession?.namespace ?? "" } : {}),
                             nextActions,
                             sessionMode,
                             sessionRecoveryHint: redactedRecoveryHint,
                             startupScopedFlags: executionPlan.startupScopedFlags,
-                            ...buildAgentBrowserResultCategoryDetails({ args: redactedArgs, command: executionPlan.commandInfo.command, errorText: executionPlan.validationError, succeeded: false, validationError: executionPlan.validationError }),
+                            ...(sessionTabSelectionError ? { effectiveArgs: redactedEffectiveArgs, sessionTabCorrection } : {}),
+                            ...(coldManagedSession ? { refSnapshotInvalidation: priorRefSnapshotInvalidation } : {}),
+                            ...buildAgentBrowserResultCategoryDetails({ args: redactedArgs, command: executionPlan.commandInfo.command, errorText: executionPlan.validationError, failureCategory: sessionTabSelectionError ? "tab-drift" : undefined, succeeded: false, validationError: executionPlan.validationError }),
                             validationError: executionPlan.validationError,
                         },
                         isError: true,
@@ -911,109 +1000,9 @@ export async function prepareBrowserRun(options) {
             });
             if (directAnchorDownload)
                 return { kind: "early-result", statePatch: { ...statePatch, artifactManifest: directAnchorDownload.artifactManifest ?? statePatch.artifactManifest }, result: directAnchorDownload.result };
-            let pinnedBatchUnwrapMode;
-            let includePinnedNavigationSummary = false;
-            let sessionTabCorrection;
-            let processArgs = executionPlan.effectiveArgs;
-            let processStdin = preparedArgs.stdin ?? runtimeToolStdin;
-            if (priorSessionTabTarget &&
-                shouldPinSessionTabForCommand({
-                    command: executionPlan.commandInfo.command,
-                    commandTokens,
-                    pinningRequired: sessionTabPinningReason !== undefined,
-                    sessionName: executionPlan.sessionName,
-                    stdin: runtimeToolStdin,
-                })) {
-                const collectTabSelection = promptRefSnapshot && getGuardedRefUsage(commandTokens, runtimeToolStdin).length > 0 ? collectAnySessionTabSelection : collectSessionTabSelection;
-                const plannedSessionTabSelection = await collectTabSelection({
-                    cwd,
-                    namespace: executionPlan.namespace,
-                    sessionName: executionPlan.sessionName,
-                    signal,
-                    target: priorSessionTabTarget,
-                });
-                if (plannedSessionTabSelection && executionPlan.sessionName) {
-                    if (executionPlan.commandInfo.command === "eval" && runtimeToolStdin !== undefined) {
-                        const appliedSessionTabSelection = await applyOpenResultTabCorrection({
-                            correction: plannedSessionTabSelection,
-                            cwd,
-                            namespace: executionPlan.namespace,
-                            sessionName: executionPlan.sessionName,
-                            signal,
-                        });
-                        if (!appliedSessionTabSelection) {
-                            const error = "agent-browser could not re-select the intended tab before running the command.";
-                            return { kind: "early-result", statePatch, result: {
-                                    content: [{ type: "text", text: error }],
-                                    details: {
-                                        args: redactedArgs,
-                                        command: executionPlan.commandInfo.command,
-                                        compatibilityWorkaround,
-                                        effectiveArgs: redactedEffectiveArgs,
-                                        sessionMode,
-                                        sessionTabCorrection: plannedSessionTabSelection,
-                                        ...buildAgentBrowserResultCategoryDetails({ args: redactedEffectiveArgs, command: executionPlan.commandInfo.command, errorText: error, failureCategory: "tab-drift", succeeded: false, tabDrift: true, validationError: error }),
-                                        nextActions: applyNamespaceToNextActions(buildSessionTabRecoveryNextActions({
-                                            kind: "tab-drift",
-                                            resultCategory: "failure",
-                                            sessionName: executionPlan.sessionName,
-                                            tabCorrection: plannedSessionTabSelection,
-                                            target: priorSessionTabTarget,
-                                        }), executionPlan.namespace),
-                                        validationError: error,
-                                        ...buildSessionDetailFields(executionPlan.sessionName, executionPlan.usedImplicitSession, executionPlan.namespace, managedSessionRestoreDisabled()),
-                                    },
-                                    isError: true,
-                                } };
-                        }
-                        sessionTabCorrection = appliedSessionTabSelection;
-                    }
-                    else {
-                        const pinnedBatchPlan = buildPinnedBatchPlan({
-                            command: executionPlan.commandInfo.command,
-                            commandTokens,
-                            selectedTab: plannedSessionTabSelection.selectedTab,
-                            stdin: runtimeToolStdin,
-                        });
-                        if (pinnedBatchPlan && "error" in pinnedBatchPlan) {
-                            return { kind: "early-result", statePatch, result: {
-                                    content: [{ type: "text", text: pinnedBatchPlan.error }],
-                                    details: {
-                                        args: redactedArgs,
-                                        command: executionPlan.commandInfo.command,
-                                        compatibilityWorkaround,
-                                        effectiveArgs: redactedEffectiveArgs,
-                                        sessionMode,
-                                        sessionTabCorrection: plannedSessionTabSelection,
-                                        ...buildAgentBrowserResultCategoryDetails({ args: redactedEffectiveArgs, command: executionPlan.commandInfo.command, errorText: pinnedBatchPlan.error, failureCategory: "tab-drift", succeeded: false, tabDrift: true, validationError: pinnedBatchPlan.error }),
-                                        nextActions: applyNamespaceToNextActions(buildSessionTabRecoveryNextActions({
-                                            kind: "tab-drift",
-                                            resultCategory: "failure",
-                                            sessionName: executionPlan.sessionName,
-                                            tabCorrection: plannedSessionTabSelection,
-                                            target: priorSessionTabTarget,
-                                        }), executionPlan.namespace),
-                                        validationError: pinnedBatchPlan.error,
-                                        ...buildSessionDetailFields(executionPlan.sessionName, executionPlan.usedImplicitSession, executionPlan.namespace, managedSessionRestoreDisabled()),
-                                    },
-                                    isError: true,
-                                } };
-                        }
-                        if (pinnedBatchPlan) {
-                            sessionTabCorrection = plannedSessionTabSelection;
-                            // The rewritten batch must keep the caller's fail-fast semantics:
-                            // upstream reads only the exact --bail token, so re-emit it whenever
-                            // the original batch tokens carried it (argv or stdin/job/qa mode).
-                            const pinnedBailArgs = commandTokens.includes("--bail") ? ["--bail"] : [];
-                            processArgs = ["--json", ...(executionPlan.namespace !== undefined ? ["--namespace", executionPlan.namespace] : []), "--session", executionPlan.sessionName, "batch", ...pinnedBailArgs];
-                            processStdin = JSON.stringify(pinnedBatchPlan.steps);
-                            includePinnedNavigationSummary = pinnedBatchPlan.includeNavigationSummary;
-                            pinnedBatchUnwrapMode = pinnedBatchPlan.unwrapMode;
-                        }
-                    }
-                }
-            }
-            const clickDispatchProbe = pinnedBatchUnwrapMode === undefined && compiledElectron === undefined
+            const processArgs = executionPlan.effectiveArgs;
+            const processStdin = preparedArgs.stdin ?? runtimeToolStdin;
+            const clickDispatchProbe = compiledElectron === undefined
                 ? await prepareClickDispatchProbe({ commandTokens, cwd, namespace: executionPlan.namespace, refSnapshot: promptRefSnapshot, sessionName: executionPlan.sessionName, signal })
                 : undefined;
             let readTimeoutPageUrl = priorSessionTabTarget?.url;
@@ -1061,9 +1050,7 @@ export async function prepareBrowserRun(options) {
                     electronLaunch,
                     exactSensitiveValues,
                     executionPlan,
-                    includePinnedNavigationSummary,
                     ownedManagedSessionContext: ownedManagedSession,
-                    pinnedBatchUnwrapMode,
                     preparedArgs,
                     priorRefSnapshotState,
                     priorSessionTabTarget,

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output.js

@@ -1,7 +1,9 @@
 import { rm } from "node:fs/promises";
+import { parseArgvDescriptor } from "../../argv-descriptor.js";
+import { needsManagedSession } from "../../command-policy.js";
 import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "../../argv-grammar.js";
 import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle } from "../../batch-lifecycle.js";
-import { isCloseAllCommand, isCloseCommand, isOpenNavigationCommand, isUnverifiedPageTransitionCommand } from "../../command-taxonomy.js";
+import { isCloseAllCommand, isCloseCommand, isOpenNavigationCommand, isRecordPageTransitionCommand, isUnverifiedPageTransitionCommand, isWindowOrDiffPageTransitionCommand } from "../../command-taxonomy.js";
 import { OPEN_RESULT_TAB_CORRECTION_FLAGS } from "../../launch-scoped-flags.js";
 import { cleanupElectronLaunchResources, inspectElectronLaunchStatus } from "../../electron/cleanup.js";
 import { getResultingPageTargetState, commandRequiresLivePageVerification } from "../../page-target-validation.js";
@@ -9,6 +11,7 @@ import { analyzeNetworkSourceLookupResults, analyzeSourceLookupResults, redactNe
 import { analyzeQaPresetResults, analyzeQaPresetTimeout, buildQaCompactFailureText, buildQaCompactPassText, extractQaPageContext } from "../../input-modes/job.js";
 import { applyNetworkRouteRecords, buildNetworkRouteDiagnostics } from "../../results/network-routes.js";
 import { buildToolPresentation } from "../../results/presentation.js";
+import { compactLargePresentationOutput } from "../../results/presentation/large-output.js";
 import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { omitUpstreamLifecycle } from "../../results/presentation/common.js";
 import { getClipboardWritePayloadCandidates, redactClipboardPermissionEcho, redactClipboardPermissionErrorValue } from "../../results/presentation/errors.js";
@@ -20,7 +23,7 @@ import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
 import { createFreshSessionName, extractUpstreamCommandTokens, resolveManagedSessionState } from "../../runtime.js";
 import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
 import { closeManagedSession, inspectManagedSessionDaemon } from "./managed-session-daemon-policy.js";
-import { applyOpenResultTabCorrection, buildAboutBlankRecoveryHint, buildAboutBlankWarning, buildElectronPostCommandHealthDiagnostic, buildElectronRefFreshnessDiagnostic, buildElectronSessionMismatch, buildManagedSessionOutcome, collectOpenResultTabCorrection, collectSessionTabSelection, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, getSessionContextKey, getStaleRefArgs, mergeNavigationSummaryIntoData, shouldCaptureNavigationSummary, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, unwrapPinnedSessionBatchEnvelope, updateTraceOwnerState, } from "./session-state.js";
+import { applyOpenResultTabCorrection, buildAboutBlankRecoveryHint, buildAboutBlankWarning, buildElectronPostCommandHealthDiagnostic, buildElectronRefFreshnessDiagnostic, buildElectronSessionMismatch, buildManagedSessionOutcome, collectOpenResultTabCorrection, collectSessionTabSelection, commandChoosesSessionTabTarget, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, getSessionContextKey, getStaleRefArgs, mergeNavigationSummaryIntoData, shouldCaptureNavigationSummary, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, updateTraceOwnerState, } from "./session-state.js";
 import { collectClickDispatchDiagnostic } from "./click-dispatch.js";
 import { buildScrollNoopDiagnostic, collectComboboxFocusDiagnostic, collectElectronBroadGetTextScopeDiagnostics, collectElectronHandoff, collectFillVerificationDiagnostic, collectNavigationSummary, collectOverlayBlockerDiagnostic, collectQaAttachedTarget, collectSnapshotOverlayBlockerDiagnostic, collectRecordingDependencyWarning, collectScrollPositionSnapshot, collectSelectorTextVisibilityDiagnostics, collectTimeoutPartialProgress, sleepMs, formatQaAttachedTargetText, getArtifactCleanupGuidance, getEvalResultWarning, getEvalStdinHint, getSourceLookupElectronContext, } from "./diagnostics.js";
 import { repairScreenshotData } from "./prepare.js";
@@ -160,17 +163,13 @@ export async function processBrowserOutput(input) {
     let networkRoutesBySession = state.networkRoutesBySession;
     try {
         const persistentArtifactStore = getPersistentSessionArtifactStore(ctx);
-        const parsed = await parseAgentBrowserEnvelope({ stdout: processResult.stdout, stdoutPath: processResult.stdoutSpillPath });
+        // Native upgrade prints text even with --json; all other command shapes keep strict JSON parsing.
+        const plainTextUpgrade = !prepared.executionPlan.plainTextInspection && prepared.executionPlan.commandInfo.command === "upgrade" && !needsManagedSession(parseArgvDescriptor(prepared.runtimeToolArgs));
+        const parsed = await parseAgentBrowserEnvelope({ stdout: processResult.stdout, stdoutPath: processResult.stdoutSpillPath, plainText: plainTextUpgrade });
         let parseError = parsed.parseError;
         let presentationEnvelope = parsed.envelope;
         let navigationSummary = undefined;
         let failedTransitionReverification = false;
-        if (prepared.pinnedBatchUnwrapMode) {
-            const pinnedBatchResult = unwrapPinnedSessionBatchEnvelope({ envelope: parsed.envelope, includeNavigationSummary: prepared.includePinnedNavigationSummary, mode: prepared.pinnedBatchUnwrapMode });
-            parseError = pinnedBatchResult.parseError ?? parseError;
-            presentationEnvelope = pinnedBatchResult.envelope ?? presentationEnvelope;
-            navigationSummary = pinnedBatchResult.navigationSummary;
-        }
         const repairedScreenshot = await repairScreenshotArtifact({ cwd, envelope: presentationEnvelope, request: prepared.preparedArgs.screenshotPathRequest });
         presentationEnvelope = repairedScreenshot.envelope;
         const repairedBatchScreenshots = await repairBatchScreenshotArtifacts({ cwd, envelope: presentationEnvelope, requests: prepared.preparedArgs.batchScreenshotPathRequests });
@@ -180,6 +179,15 @@ export async function processBrowserOutput(input) {
         const batchCommandSteps = prepared.executionPlan.commandInfo.command === "batch"
             ? getUpstreamEffectiveBatchSteps(prepared.commandTokens, prepared.runtimeToolStdin)
             : [];
+        const dispatchedCommands = prepared.executionPlan.commandInfo.command !== "batch"
+            ? [prepared.commandTokens]
+            : Array.isArray(presentationEnvelope?.data)
+                ? presentationEnvelope.data.flatMap((row, index) => isRecord(row) ? [Array.isArray(row.command) && row.command.every((token) => typeof token === "string") ? row.command : batchCommandSteps[index] ?? []] : [])
+                : batchCommandSteps;
+        const destinationTransition = dispatchedCommands.some((step) => {
+            const [command, subcommand] = extractUpstreamCommandTokens(step);
+            return isWindowOrDiffPageTransitionCommand(command, subcommand);
+        });
         const nestedBatchClose = prepared.executionPlan.commandInfo.command === "batch"
             ? getSuccessfulBatchCloseLifecycle(presentationEnvelope?.data, batchCommandSteps)
             : undefined;
@@ -198,7 +206,7 @@ export async function processBrowserOutput(input) {
         const parseFailureOutput = parseError && processResult.stdoutSpillPath
             ? { fullOutputUnavailable: "Malformed upstream output was discarded because it may contain sensitive browser data." }
             : {};
-        const processSucceeded = !processResult.aborted && !processResult.spawnError && processResult.exitCode === 0;
+        const processSucceeded = !processResult.timedOut && !processResult.aborted && !processResult.spawnError && processResult.exitCode === 0;
         const plainTextInspection = prepared.executionPlan.plainTextInspection && processSucceeded;
         const parseSucceeded = plainTextInspection || parseError === undefined;
         if (isStreamEnableAlreadyEnabledNoop({ command: prepared.executionPlan.commandInfo.command, envelope: presentationEnvelope, processSucceeded, subcommand: prepared.executionPlan.commandInfo.subcommand })) {
@@ -209,6 +217,10 @@ export async function processBrowserOutput(input) {
         const inspectionText = plainTextInspection ? processResult.stdout.trim() : undefined;
         const sessionStateKey = getSessionContextKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace);
         const closeAllApplied = nestedBatchClosesAll || (directCloseAllRequested && succeeded);
+        if (sessionStateKey && processResult.agentBrowserStarted && sessionPageState.get(sessionStateKey).tabReopenPending === true) {
+            if (dispatchedCommands.some(commandChoosesSessionTabTarget))
+                sessionPageState.setTabReopenPending({ pending: false, sessionName: sessionStateKey, update: sessionPageStateUpdate });
+        }
         if (closeAllApplied) {
             networkRoutesBySession = withoutNamespaceEntries(networkRoutesBySession, prepared.executionPlan.namespace);
             deleteNamespaceEntries(state.attachedSessionKeys, prepared.executionPlan.namespace);
@@ -252,36 +264,32 @@ export async function processBrowserOutput(input) {
             }
         }
         const tabTransition = prepared.executionPlan.commandInfo.command === "tab" && prepared.executionPlan.commandInfo.subcommand !== undefined && !["list", "new"].includes(prepared.executionPlan.commandInfo.subcommand);
-        const resultingPageState = getResultingPageTargetState({
-            args: prepared.executionPlan.effectiveArgs,
-            currentPageUrl: prepared.priorSessionTabTarget?.url,
-            pageUrlUnknown: prepared.priorSessionTabTargetUnknown === true,
-            stdin: prepared.runtimeToolStdin,
-            trustedFirstBatchTabSelection: prepared.pinnedBatchUnwrapMode !== undefined,
-        });
+        // Non-page rows (including a failed prefix) cannot retire a cold target for a navigation that never ran.
+        const resultingPageState = sessionPageState.get(sessionStateKey).tabReopenPending === true
+            ? { currentPageUrl: prepared.priorSessionTabTarget?.url, pageTargetMayHaveChanged: false, pageUrlUnknown: prepared.priorSessionTabTargetUnknown === true }
+            : getResultingPageTargetState({
+                args: prepared.executionPlan.effectiveArgs,
+                executedBatchSteps: dispatchedCommands,
+                currentPageUrl: prepared.priorSessionTabTarget?.url,
+                pageUrlUnknown: prepared.priorSessionTabTargetUnknown === true,
+            });
         if (succeeded &&
-            !navigationSummary &&
             (shouldCaptureNavigationSummary(prepared.executionPlan.commandInfo.command, presentationEnvelope?.data, prepared.executionPlan.commandInfo.subcommand) ||
                 shouldCaptureSemanticActionNavigationSummary(prepared.compiledSemanticAction, presentationEnvelope?.data) ||
                 commandRequiresLivePageVerification(prepared.executionPlan.effectiveArgs, prepared.runtimeToolStdin) ||
-                tabTransition)) {
+                (destinationTransition && !nestedBatchClosed) || tabTransition)) {
             navigationSummary = await collectNavigationSummary({ cwd, namespace: prepared.executionPlan.namespace, priorTarget: prepared.priorSessionTabTarget, reusePriorTitle: !tabTransition, sessionName: prepared.executionPlan.sessionName, signal });
         }
-        // A failed eval/back/forward/reload/state-load/tab would otherwise drop the page to unverified and force the
-        // agent through a manual get url round trip. Probe the live URL ourselves instead: an observed page
-        // stays verified, and a failed
-        // probe preserves the existing unknown-target behavior.
+        // Failed transitions may already have changed the page; keep only a live observed URL.
         if (succeeded === false &&
-            !navigationSummary &&
             processResult.agentBrowserStarted &&
             !processResult.aborted &&
             !processResult.timedOut &&
-            prepared.executionPlan.commandInfo.command !== "batch" &&
-            isUnverifiedPageTransitionCommand(prepared.executionPlan.commandInfo.command, prepared.executionPlan.commandInfo.subcommand)) {
+            !nestedBatchClosed &&
+            (destinationTransition || (prepared.executionPlan.commandInfo.command !== "batch" &&
+                isUnverifiedPageTransitionCommand(prepared.executionPlan.commandInfo.command, prepared.executionPlan.commandInfo.subcommand)))) {
             navigationSummary = await collectNavigationSummary({ cwd, namespace: prepared.executionPlan.namespace, priorTarget: prepared.priorSessionTabTarget, sessionName: prepared.executionPlan.sessionName, signal });
-            // A failed transition command can still have mutated or replaced the document before throwing, so
-            // keeping the verified URL must not keep the prior snapshot refs (markTabTargetUnknown dropped
-            // them before this probe existed); invalidate so the next ref use requires a fresh snapshot.
+            // Re-verifying a failed transition's URL does not make its prior refs valid.
             failedTransitionReverification = navigationSummary !== undefined;
         }
         if (navigationSummary && presentationEnvelope && prepared.executionPlan.commandInfo.command !== "eval" && !Array.isArray(presentationEnvelope.data))
@@ -309,8 +317,9 @@ export async function processBrowserOutput(input) {
         const safeObservedSessionTabTarget = observedSessionTabTarget;
         let currentSessionTabTarget = safeObservedSessionTabTarget;
         if (!currentSessionTabTarget && nestedBatchClose === undefined) {
+            // Window/diff responses do not report the final URL; URL2 is intent, not redirect evidence.
             currentSessionTabTarget = resultingPageState.pageTargetMayHaveChanged
-                ? succeeded ? normalizeSessionTabTarget({ url: resultingPageState.currentPageUrl }) : undefined
+                ? succeeded && !destinationTransition ? normalizeSessionTabTarget({ url: resultingPageState.currentPageUrl }) : undefined
                 : deriveSessionTabTarget({ command: prepared.executionPlan.commandInfo.command, data: presentationEnvelope?.data, navigationSummary, previousTarget: prepared.priorSessionTabTarget, subcommand: prepared.executionPlan.commandInfo.subcommand });
         }
         let aboutBlankSessionMismatch;
@@ -318,7 +327,8 @@ export async function processBrowserOutput(input) {
         let electronRefFreshnessDiagnostic;
         let electronSessionMismatch;
         let electronStatusAfterCommand;
-        const shouldTreatAboutBlankAsMismatch = succeeded && !tabTransition && nestedBatchClose === undefined && prepared.priorSessionTabTarget !== undefined && !isAboutBlankSessionTabTarget(prepared.priorSessionTabTarget) && isAboutBlankSessionTabTarget(observedSessionTabTarget ?? currentSessionTabTarget) && !commandExplicitlyTargetsAboutBlank(prepared.commandTokens);
+        const explicitlyTargetsAboutBlank = dispatchedCommands.some((step) => commandExplicitlyTargetsAboutBlank(extractUpstreamCommandTokens(step)));
+        const shouldTreatAboutBlankAsMismatch = succeeded && !tabTransition && !destinationTransition && !explicitlyTargetsAboutBlank && nestedBatchClose === undefined && prepared.priorSessionTabTarget !== undefined && !isAboutBlankSessionTabTarget(prepared.priorSessionTabTarget) && isAboutBlankSessionTabTarget(observedSessionTabTarget ?? currentSessionTabTarget);
         let sessionTabCorrection = prepared.sessionTabCorrection;
         if (shouldTreatAboutBlankAsMismatch && prepared.priorSessionTabTarget) {
             const aboutBlankObservedTarget = observedSessionTabTarget ?? currentSessionTabTarget;
@@ -536,7 +546,7 @@ export async function processBrowserOutput(input) {
         if (sessionStateKey && succeeded) {
             if (openResultTabCorrection || sessionTabCorrection || aboutBlankSessionMismatch?.recoveryApplied)
                 sessionPageState.markPinning(sessionStateKey, "drift");
-            else if (prepared.sessionTabPinningReason === "restore")
+            else if (prepared.sessionTabPinningReason === "restore" && observedSessionTabTarget)
                 sessionPageState.clearRestorePinning(sessionStateKey);
         }
         if (replacedManagedSessionName) {
@@ -626,14 +636,23 @@ export async function processBrowserOutput(input) {
                 electronLaunchRecord = electronFailedConnectCleanup.record;
             }
         }
-        let errorText = getAgentBrowserErrorText({ aborted: processResult.aborted, command: prepared.executionPlan.commandInfo.command, effectiveArgs: prepared.redactedProcessArgs, envelope: presentationEnvelope, exitCode: processResult.exitCode, parseError, plainTextInspection, staleRefArgs: getStaleRefArgs(prepared.commandTokens, prepared.runtimeToolStdin), spawnError: processResult.spawnError, stderr: processResult.stderr, timedOut: processResult.timedOut, timeoutMs: processResult.timeoutMs, wrapperRecoveryHint: buildWrapperRecoveryHint({ pinnedBatchUnwrapMode: prepared.pinnedBatchUnwrapMode, sessionTabCorrection }) });
+        let errorText = getAgentBrowserErrorText({ aborted: processResult.aborted, command: prepared.executionPlan.commandInfo.command, effectiveArgs: prepared.redactedProcessArgs, envelope: presentationEnvelope, exitCode: processResult.exitCode, parseError, plainTextInspection, staleRefArgs: getStaleRefArgs(prepared.commandTokens, prepared.runtimeToolStdin), spawnError: processResult.spawnError, stderr: processResult.stderr, timedOut: processResult.timedOut, timeoutMs: processResult.timeoutMs, wrapperRecoveryHint: buildWrapperRecoveryHint({ sessionTabCorrection }) });
         if (errorText) {
             const clipboardWritePayloadCandidates = getClipboardWritePayloadCandidates(prepared.commandTokens);
             errorText = redactClipboardPermissionEcho(prepared.executionPlan.commandInfo, errorText);
             if (presentationEnvelope?.error !== undefined)
                 presentationEnvelope = { ...presentationEnvelope, error: redactClipboardPermissionErrorValue(prepared.executionPlan.commandInfo, presentationEnvelope.error, clipboardWritePayloadCandidates) };
         }
-        const presentation = plainTextInspection ? { artifacts: undefined, batchFailure: undefined, batchSteps: undefined, content: [{ type: "text", text: inspectionText ?? "" }], data: undefined, fullOutputPath: undefined, fullOutputPaths: undefined, imagePath: undefined, imagePaths: undefined, savedFile: undefined, savedFilePath: undefined, summary: `${prepared.redactedArgs.join(" ")} completed` } : await buildToolPresentation({ args: prepared.redactedProcessArgs, artifactManifest, artifactMaxUpdatedAtMs: Date.now(), artifactMinUpdatedAtMs: input.artifactRunStartedAtMs, artifactRequest: screenshotArtifactRequest, batchArtifactRequests: batchScreenshotArtifactRequests, commandInfo: prepared.executionPlan.commandInfo, compiledSemanticAction: prepared.compiledSemanticAction, cwd, envelope: presentationEnvelope, errorText, namespace: prepared.executionPlan.namespace, networkRouteDiagnostics, networkRoutes: activeNetworkRoutes, persistentArtifactStore, sessionName: prepared.executionPlan.sessionName });
+        if (plainTextUpgrade && errorText)
+            presentationEnvelope = { ...presentationEnvelope, success: false, error: errorText };
+        let presentation = plainTextInspection ? { artifacts: undefined, batchFailure: undefined, batchSteps: undefined, content: [{ type: "text", text: inspectionText ?? "" }], data: undefined, fullOutputPath: undefined, fullOutputPaths: undefined, imagePath: undefined, imagePaths: undefined, savedFile: undefined, savedFilePath: undefined, summary: `${prepared.redactedArgs.join(" ")} completed` } : await buildToolPresentation({ args: prepared.redactedProcessArgs, artifactManifest, artifactMaxUpdatedAtMs: Date.now(), artifactMinUpdatedAtMs: input.artifactRunStartedAtMs, artifactRequest: screenshotArtifactRequest, batchArtifactRequests: batchScreenshotArtifactRequests, commandInfo: prepared.executionPlan.commandInfo, compiledSemanticAction: prepared.compiledSemanticAction, cwd, envelope: presentationEnvelope, errorText, namespace: prepared.executionPlan.namespace, networkRouteDiagnostics, networkRoutes: activeNetworkRoutes, persistentArtifactStore, sessionName: prepared.executionPlan.sessionName });
+        if (plainTextUpgrade && !succeeded && typeof presentationEnvelope?.data === "string") {
+            presentation.data = presentationEnvelope.data;
+            const errorContent = presentation.content[0];
+            if (errorContent?.type === "text" && presentationEnvelope.data)
+                errorContent.text += `\n\n${presentationEnvelope.data}`;
+            presentation = await compactLargePresentationOutput({ artifactManifest, commandInfo: prepared.executionPlan.commandInfo, data: presentation.data, persistentArtifactStore, presentation });
+        }
         if (electronHandoff?.error && electronHandoff.failureCategory)
             presentation.failureCategory = electronHandoff.failureCategory;
         networkRoutesBySession = applyBatchNetworkRouteState({ data: presentationEnvelope?.data, routesBySession: networkRoutesBySession, sessionName: sessionStateKey, succeeded });
@@ -738,7 +757,14 @@ export async function processBrowserOutput(input) {
         const evalResultWarning = getEvalResultWarning({ command: prepared.executionPlan.commandInfo.command, data: presentationEnvelope?.data, navigationSummary: evalNavigationSummary, pageUrl: evalPageUrl, stdin: prepared.runtimeToolStdin });
         const resultArtifactManifest = presentation.artifactManifest ?? artifactManifest;
         const artifactCleanup = await getArtifactCleanupGuidance({ command: prepared.executionPlan.commandInfo.command, cwd, manifest: resultArtifactManifest, succeeded });
-        const warningText = electronPostCommandHealth ? formatElectronPostCommandHealthText(electronPostCommandHealth) : electronSessionMismatch ? formatElectronSessionMismatchText(electronSessionMismatch) : aboutBlankSessionMismatch ? buildAboutBlankWarning(aboutBlankSessionMismatch) : undefined;
+        const recordingTransitionReached = prepared.executionPlan.commandInfo.command === "batch"
+            ? presentation.batchSteps?.some((step) => isRecordPageTransitionCommand(extractUpstreamCommandTokens(step.command ?? [])))
+            : isRecordPageTransitionCommand(prepared.commandTokens);
+        const recordingPageWarning = processResult.agentBrowserStarted && !prepared.executionPlan.plainTextInspection && recordingTransitionReached
+            ? "Page state: this recording command can replace or navigate the active page, even on failure; prior in-page DOM and JavaScript state may not carry over. Take a fresh snapshot before continuing with page-scoped refs."
+            : undefined;
+        const sessionWarning = electronPostCommandHealth ? formatElectronPostCommandHealthText(electronPostCommandHealth) : electronSessionMismatch ? formatElectronSessionMismatchText(electronSessionMismatch) : aboutBlankSessionMismatch ? buildAboutBlankWarning(aboutBlankSessionMismatch) : undefined;
+        const warningText = [sessionWarning, recordingPageWarning].filter(Boolean).join("\n\n") || undefined;
         const redactedContent = buildRedactedPresentationContent({ exactSensitiveValues: prepared.exactSensitiveValues, plainTextInspection, presentation, presentationEnvelope, succeeded, userRequestedJson: prepared.userRequestedJson, warningText });
         const finalRecoveryState = await prepareFinalResultRecoveryState({ aboutBlankSessionMismatch, batchRefSnapshotState, commandTokens: prepared.commandTokens, compiledSemanticAction: prepared.compiledSemanticAction, currentRefSnapshot, currentRefSnapshotInvalidation, currentSessionTabTarget, cwd, electronPostCommandHealth, errorText, executionPlan: prepared.executionPlan, parseError, plainTextInspection, presentation, processResult, redactedProcessArgs: prepared.redactedProcessArgs, runtimeToolArgs: prepared.runtimeToolArgs, sessionPageState, sessionPageStateUpdate, sessionTabCorrection, signal, succeeded });
         currentRefSnapshot = finalRecoveryState.currentRefSnapshot;