pi-agent-browser-native 0.6.9 → 0.6.11

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

@@ -1,7 +1,8 @@
 import { copyFile, mkdir } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
-import { getBooleanFlagValue, isUpstreamEnvFlagEnabled, projectUpstreamGlobalFlags } from "../../argv-grammar.js";
+import { extractExplicitSessionName, getBooleanFlagValue, isUpstreamEnvFlagEnabled, projectUpstreamGlobalFlags, resolveAgentBrowserNamespace } from "../../argv-grammar.js";
 import { isCloseCommand } from "../../command-taxonomy.js";
+import { isBrowserIndependentRead } from "../../command-policy.js";
 import { cleanupElectronLaunchResources } from "../../electron/cleanup.js";
 import { launchElectronApp } from "../../electron/launch.js";
 import { pathExists } from "../../fs-utils.js";
@@ -73,21 +74,19 @@ async function ensureArtifactParentDirectory(commandTokens, cwd) {
         return;
     await mkdir(dirname(resolve(cwd, requestedPath)), { recursive: true });
 }
-async function normalizeScreenshotPathInTokens(commandTokens, cwd) {
-    const scopedCommandTokens = extractCommandTokens(commandTokens);
-    const projection = projectUpstreamGlobalFlags(scopedCommandTokens);
-    const projectedPathTokenIndex = getScreenshotPathTokenIndex(projection.tokens);
-    const scopedPathTokenIndex = projectedPathTokenIndex === undefined ? undefined : projection.indices[projectedPathTokenIndex];
-    if (scopedPathTokenIndex === undefined) {
+async function normalizeScreenshotPathInTokens(commandTokens, cwd, batchStep = false) {
+    // Native batch rows skip outer CLI global-flag cleanup.
+    const projection = batchStep ? undefined : projectUpstreamGlobalFlags(commandTokens);
+    const pathIndex = getScreenshotPathTokenIndex(projection?.tokens ?? commandTokens);
+    const screenshotPathTokenIndex = pathIndex === undefined ? undefined : projection ? projection.indices[pathIndex] : pathIndex;
+    if (screenshotPathTokenIndex === undefined)
         return { tokens: commandTokens };
-    }
-    const screenshotPathTokenIndex = commandTokens.length - scopedCommandTokens.length + scopedPathTokenIndex;
     const requestedPath = commandTokens[screenshotPathTokenIndex];
     const absolutePath = resolve(cwd, requestedPath);
     await mkdir(dirname(absolutePath), { recursive: true });
     const tokens = [...commandTokens];
     tokens[screenshotPathTokenIndex] = absolutePath;
-    const terminatorIndex = tokens.indexOf("--");
+    const terminatorIndex = batchStep ? -1 : tokens.indexOf("--");
     if (terminatorIndex >= 0) {
         tokens.splice(terminatorIndex, 1);
     }
@@ -110,13 +109,12 @@ async function prepareBatchScreenshotPaths(args, stdin, cwd) {
         // prepare parent directories for the rows that will run and skip stdin
         // preparation (no directories for never-executed rows).
         for (const step of argumentSteps) {
-            const stepTokens = extractUpstreamCommandTokens(step);
-            await ensureArtifactParentDirectory(stepTokens, cwd);
-            if (stepTokens[0] === "screenshot") {
+            await ensureArtifactParentDirectory(step, cwd);
+            if (step[0] === "screenshot") {
                 // Reuse the screenshot path resolution for its parent-directory side
                 // effect only: raw strings are never rewritten, so the normalized
                 // tokens and path request are deliberately discarded.
-                await normalizeScreenshotPathInTokens(step, cwd);
+                await normalizeScreenshotPathInTokens(step, cwd, true);
             }
         }
         return undefined;
@@ -134,12 +132,11 @@ async function prepareBatchScreenshotPaths(args, stdin, cwd) {
         if (!Array.isArray(step) || !step.every((item) => typeof item === "string")) {
             return step;
         }
-        const upstreamStep = extractUpstreamCommandTokens(step);
-        await ensureArtifactParentDirectory(upstreamStep, cwd);
-        if (upstreamStep[0] !== "screenshot") {
+        await ensureArtifactParentDirectory(step, cwd);
+        if (step[0] !== "screenshot") {
             return step;
         }
-        const normalized = await normalizeScreenshotPathInTokens(step, cwd);
+        const normalized = await normalizeScreenshotPathInTokens(step, cwd, true);
         batchScreenshotPathRequests[index] = normalized.request;
         if (normalized.request) {
             changed = true;
@@ -425,6 +422,8 @@ export async function prepareBrowserRun(options) {
                 } };
         }
         const userRequestedJson = runtimeToolArgs.includes("--json");
+        const routedReadConfirmation = state.sessionPageState.findReadConfirmation(preparedArgs.args, resolveAgentBrowserNamespace(preparedArgs.args, agentBrowserProcessEnv.AGENT_BROWSER_NAMESPACE));
+        const readConfirmation = routedReadConfirmation?.capabilities?.readRequiresConfirmation === true ? routedReadConfirmation : undefined;
         let executionPlan = buildExecutionPlan(preparedArgs.args, {
             freshSessionName,
             managedSessionActive: state.managedSessionActive,
@@ -432,13 +431,14 @@ export async function prepareBrowserRun(options) {
             managedSessionName: state.managedSessionName,
             managedSessionNamespace: state.managedSessionNamespace,
             sessionMode,
+            stdin: runtimeToolStdin,
+            browserIndependentReadConfirmation: readConfirmation !== undefined,
         });
-        const idleTimeoutMismatch = getIdleTimeoutMismatch(preparedArgs.args, options.implicitSessionIdleTimeoutMs);
-        if (idleTimeoutMismatch)
-            executionPlan = { ...executionPlan, recoveryHint: undefined, validationError: idleTimeoutMismatch };
+        const browserIndependent = readConfirmation !== undefined || isBrowserIndependentRead(extractUpstreamCommandTokens(preparedArgs.args), runtimeToolStdin)
+            || (executionPlan.commandInfo.command === "session" && executionPlan.commandInfo.subcommand === "info");
         const ownedSessionKey = getSessionContextKey(executionPlan.sessionName, executionPlan.namespace);
         const plannedSessionPageState = sessionPageState.get(ownedSessionKey);
-        const pageTargetError = getPageTargetValidationError({
+        const pageTargetError = readConfirmation ? undefined : getPageTargetValidationError({
             args: executionPlan.effectiveArgs,
             currentPageUrl: plannedSessionPageState.tabTarget?.url,
             pageUrlUnknown: plannedSessionPageState.tabTargetUnknown === true,
@@ -450,13 +450,18 @@ export async function prepareBrowserRun(options) {
         const targetsCurrentManagedSession = state.managedSessionActive
             && ownedSessionKey === getSessionContextKey(state.managedSessionName, state.managedSessionNamespace);
         const targetsOffCurrentOwnedSession = recordedOwnedSession !== undefined && !targetsCurrentManagedSession;
+        const idleTimeoutMismatch = !browserIndependent && (executionPlan.managedSessionName || recordedOwnedSession || targetsCurrentManagedSession || (state.managedSessionActive && extractExplicitSessionName(preparedArgs.args) === undefined))
+            ? getIdleTimeoutMismatch(preparedArgs.args, options.implicitSessionIdleTimeoutMs)
+            : undefined;
+        if (idleTimeoutMismatch)
+            executionPlan = { ...executionPlan, recoveryHint: undefined, validationError: idleTimeoutMismatch };
         const offCurrentLaunchScopedFlags = targetsOffCurrentOwnedSession
             ? executionPlan.startupScopedFlags.filter((flag) => flag !== "--namespace")
             : [];
         const offCurrentCompatibilityUpgrade = targetsOffCurrentOwnedSession
             && executionPlan.compatibilityWorkaround !== undefined
             && recordedOwnedSession.compatibilityWorkaround === undefined;
-        if (targetsOffCurrentOwnedSession && canUseHeadlessCompatibilityUserAgent(preparedArgs.args, agentBrowserProcessEnv)) {
+        if (!browserIndependent && targetsOffCurrentOwnedSession && canUseHeadlessCompatibilityUserAgent(preparedArgs.args, agentBrowserProcessEnv)) {
             const compatibilityWorkaround = executionPlan.compatibilityWorkaround ?? recordedOwnedSession.compatibilityWorkaround;
             if (compatibilityWorkaround) {
                 const userAgentIndex = executionPlan.effectiveArgs.indexOf("--user-agent");
@@ -475,7 +480,7 @@ export async function prepareBrowserRun(options) {
             ?? (targetsCurrentManagedSession ? state.managedSessionHeadedAutosaveInterval : undefined);
         const explicitAutosaveInterval = resolveExplicitAutosaveInterval(agentBrowserProcessEnv.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
         const autosavePolicyChangeError = getRunningHeadedAutosavePolicyChangeError(retainedHeadedAutosaveInterval, isCloseCommand(executionPlan.commandInfo.command));
-        if (!executionPlan.validationError && autosavePolicyChangeError) {
+        if (!browserIndependent && !executionPlan.validationError && autosavePolicyChangeError) {
             executionPlan = { ...executionPlan, recoveryHint: undefined, validationError: autosavePolicyChangeError };
         }
         const headedLaunch = getBooleanFlagValue(executionPlan.effectiveArgs, "--headed") ?? isUpstreamEnvFlagEnabled(agentBrowserProcessEnv.AGENT_BROWSER_HEADED);
@@ -485,13 +490,14 @@ export async function prepareBrowserRun(options) {
         const compatibilityUserAgent = executionPlan.compatibilityWorkaround ? getDefaultHeadlessCompatUserAgent() : undefined;
         const compatibilityUserAgentApplied = compatibilityUserAgent !== undefined
             && executionPlan.effectiveArgs.some((token, index) => token === "--user-agent" && executionPlan.effectiveArgs[index + 1] === compatibilityUserAgent);
-        const ownedManagedSession = buildOwnedManagedSessionRestoreContext({
+        const ownedManagedSession = browserIndependent && !recordedOwnedSession && !targetsCurrentManagedSession ? undefined : buildOwnedManagedSessionRestoreContext({
             args: executionPlan.effectiveArgs,
+            reuseOnly: browserIndependent,
             cwd: recordedOwnedSession?.cwd ?? cwd,
             currentManagedSessionName: state.managedSessionName,
             currentManagedSessionNamespace: state.managedSessionNamespace,
-            headedManagedAutosaveDisabled,
-            headedManagedAutosaveInterval,
+            headedManagedAutosaveDisabled: browserIndependent ? retainedHeadedAutosaveDisabled : headedManagedAutosaveDisabled,
+            headedManagedAutosaveInterval: browserIndependent ? retainedHeadedAutosaveInterval : headedManagedAutosaveInterval,
             managedSessionName: executionPlan.managedSessionName,
             namespace: executionPlan.namespace,
             parentEnv: agentBrowserProcessEnv,
@@ -504,7 +510,7 @@ export async function prepareBrowserRun(options) {
         });
         let managedSessionDaemonInactive = false;
         let managedSessionCleanupOnlyReason;
-        if (!executionPlan.validationError && ownedManagedSession) {
+        if (!browserIndependent && !executionPlan.validationError && ownedManagedSession) {
             const closeCommand = isCloseCommand(executionPlan.commandInfo.command);
             const policy = await acquireOwnedManagedSessionDaemonPolicy({
                 context: ownedManagedSession,
@@ -554,7 +560,7 @@ export async function prepareBrowserRun(options) {
             const sessionTabPinningReason = priorSessionPageState.pinningReason;
             let priorRefSnapshotState = priorSessionPageState.refSnapshot;
             let priorRefSnapshotInvalidation = priorSessionPageState.refSnapshotInvalidation;
-            const coldManagedSession = (managedSessionDaemonInactive || priorSessionPageState.tabReopenPending === true)
+            const coldManagedSession = !browserIndependent && (managedSessionDaemonInactive || priorSessionPageState.tabReopenPending === true)
                 && recordedOwnedSession !== undefined
                 && sessionTabPinningReason === "restore"
                 && ownedManagedSession?.restoreDecision === "enabled"
@@ -577,7 +583,7 @@ export async function prepareBrowserRun(options) {
                 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,
+                pinningRequired: !readConfirmation && sessionTabPinningReason !== undefined && compiledQaPreset?.checks.url === undefined,
                 reopenPending: coldManagedSession,
                 sessionName: executionPlan.sessionName,
                 stdin: runtimeToolStdin,
@@ -617,7 +623,7 @@ export async function prepareBrowserRun(options) {
             const isCallerOwnedExplicitSession = () => executionPlan.sessionName !== undefined
                 && executionPlan.usedImplicitSession === false
                 && ownedManagedSession === undefined;
-            const requiresLivePageVerification = () => isCallerOwnedExplicitSession() || options.preserveAttachedBrowserSession === true;
+            const requiresLivePageVerification = () => !readConfirmation && (isCallerOwnedExplicitSession() || options.preserveAttachedBrowserSession === true);
             const verifyLivePage = async (request) => {
                 if (!request.requirement || !executionPlan.sessionName)
                     return;
@@ -1054,6 +1060,7 @@ export async function prepareBrowserRun(options) {
                     executionPlan,
                     ownedManagedSessionContext: ownedManagedSession,
                     preparedArgs,
+                    readConfirmation,
                     priorRefSnapshotState,
                     priorSessionTabTarget,
                     priorSessionTabTargetUnknown,

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

@@ -1,7 +1,7 @@
 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 { isBrowserIndependentRead, needsManagedSession } from "../../command-policy.js";
+import { deleteIdentityKeysInNamespace, getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "../../argv-grammar.js";
 import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle } from "../../batch-lifecycle.js";
 import { isCloseAllCommand, isCloseCommand, isOpenNavigationCommand, isRecordPageTransitionCommand, isUnverifiedPageTransitionCommand, isWindowOrDiffPageTransitionCommand } from "../../command-taxonomy.js";
 import { OPEN_RESULT_TAB_CORRECTION_FLAGS } from "../../launch-scoped-flags.js";
@@ -13,11 +13,13 @@ import { applyNetworkRouteRecords, buildNetworkRouteDiagnostics } from "../../re
 import { buildToolPresentation } from "../../results/presentation.js";
 import { compactLargePresentationOutput } from "../../results/presentation/large-output.js";
 import { extractEnvelopeErrorText, getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
+import { detectConfirmationRequired } from "../../results/confirmation.js";
 import { omitUpstreamLifecycle } from "../../results/presentation/common.js";
 import { getClipboardWritePayloadCandidates, redactClipboardPermissionEcho, redactClipboardPermissionErrorValue } from "../../results/presentation/errors.js";
 import { shouldCaptureSemanticActionNavigationSummary } from "../../results/presentation/semantic-action.js";
 import { buildPageTransitionRefSnapshotInvalidation, commandExplicitlyTargetsAboutBlank, getCommandRefSnapshotInvalidation, deriveSessionTabTarget, extractLatestRefSnapshotStateFromBatchResults, extractRefSnapshotFromData, extractSessionTabTargetFromBatchResults, extractSessionTabTargetFromCommandData, isAboutBlankSessionTabTarget, normalizeSessionTabTarget, } from "../../session-page-state.js";
 import { isRecord } from "../../parsing.js";
+import { buildReadConfirmationNextActions, nextReadConfirmation } from "../../read-confirmation.js";
 import { pruneOwnedManagedSessionRestoreSnapshots } from "../../managed-session-restore.js";
 import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
 import { createFreshSessionName, extractUpstreamCommandTokens, resolveManagedSessionState } from "../../runtime.js";
@@ -27,6 +29,7 @@ import { applyOpenResultTabCorrection, buildAboutBlankRecoveryHint, buildAboutBl
 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";
+import { mergeRecordingRecoveryPresentation, recoverRecordingStop } from "./recording-recovery.js";
 import { getPersistentSessionArtifactStore } from "./session-state.js";
 import { buildFinalAgentBrowserToolResult, buildRedactedPresentationContent, buildWrapperRecoveryHint, prepareFinalResultRecoveryState, redactExactSensitiveValue, } from "./final-result.js";
 async function repairScreenshotArtifact(options) {
@@ -108,12 +111,6 @@ function batchStartedManagedBrowser(data) {
 function withoutNamespaceEntries(entries, namespace) {
     return new Map([...entries].filter(([key]) => !isAgentBrowserSessionIdentityKeyInNamespace(key, namespace)));
 }
-function deleteNamespaceEntries(entries, namespace) {
-    for (const key of entries.keys()) {
-        if (isAgentBrowserSessionIdentityKeyInNamespace(key, namespace))
-            entries.delete(key);
-    }
-}
 function setNetworkRouteState(options) {
     if (!options.sessionName)
         return options.routesBySession;
@@ -167,7 +164,13 @@ export async function processBrowserOutput(input) {
         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;
+        const recordingStopRecovery = await recoverRecordingStop({
+            artifactManifest, artifactRunStartedAtMs: input.artifactRunStartedAtMs, commandTokens: prepared.commandTokens, cwd,
+            envelope: parsed.envelope, namespace: prepared.executionPlan.namespace, parseError, processResult,
+            reservation: prepared.executionPlan.sessionName ? state.activeRecordingReservations?.get(getAgentBrowserSessionIdentityKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace)) : undefined,
+            sessionName: prepared.executionPlan.sessionName, signal, stdin: prepared.runtimeToolStdin,
+        });
+        let presentationEnvelope = recordingStopRecovery?.envelope ?? parsed.envelope;
         let navigationSummary = undefined;
         let failedTransitionReverification = false;
         const repairedScreenshot = await repairScreenshotArtifact({ cwd, envelope: presentationEnvelope, request: prepared.preparedArgs.screenshotPathRequest });
@@ -184,6 +187,25 @@ export async function processBrowserOutput(input) {
             : 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 confirmationSessionName = prepared.executionPlan.sessionName ?? "default";
+        let readConfirmation = state.sessionPageState.getReadConfirmation(getAgentBrowserSessionIdentityKey(confirmationSessionName, prepared.executionPlan.namespace));
+        let readConfirmationEvent;
+        const confirmationRows = prepared.executionPlan.commandInfo.command === "batch" && Array.isArray(presentationEnvelope?.data)
+            ? presentationEnvelope.data.flatMap((row, index) => isRecord(row) ? [{ tokens: batchCommandSteps[index] ?? [], data: row.result, response: row, succeeded: row.success === true }] : [])
+            : [{ tokens: prepared.commandTokens, data: presentationEnvelope?.data, response: presentationEnvelope, succeeded: presentationEnvelope?.success === true }];
+        for (const row of confirmationRows) {
+            const transition = nextReadConfirmation({ commandTokens: row.tokens, current: readConfirmation, data: row.data, namespace: prepared.executionPlan.namespace, sessionName: confirmationSessionName, succeeded: row.succeeded });
+            if (transition) {
+                readConfirmationEvent = transition;
+                readConfirmation = transition;
+            }
+            if (row.tokens.length === 2 && row.tokens[0] === "confirm" && isRecord(row.data) && row.data.confirmed === true && row.data.action === "read" && isRecord(row.data.result) && row.data.result.success === false && row.response) {
+                row.response.success = false;
+                row.response.error = row.data.result.error;
+                if (presentationEnvelope)
+                    presentationEnvelope.success = false;
+            }
+        }
         const destinationTransition = dispatchedCommands.some((step) => {
             const [command, subcommand] = extractUpstreamCommandTokens(step);
             return isWindowOrDiffPageTransitionCommand(command, subcommand);
@@ -206,6 +228,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 browserIndependentRead = prepared.readConfirmation !== undefined || isBrowserIndependentRead(prepared.commandTokens, prepared.runtimeToolStdin);
         const processSucceeded = !processResult.timedOut && !processResult.aborted && !processResult.spawnError && processResult.exitCode === 0;
         const plainTextInspection = prepared.executionPlan.plainTextInspection && processSucceeded;
         const parseSucceeded = plainTextInspection || parseError === undefined;
@@ -213,7 +236,7 @@ export async function processBrowserOutput(input) {
             presentationEnvelope = { success: true, data: { alreadyEnabled: true, enabled: true, message: getEnvelopeErrorString(presentationEnvelope) ?? "Stream already enabled" } };
         }
         const envelopeSuccess = plainTextInspection ? true : presentationEnvelope?.success !== false;
-        let succeeded = processSucceeded && parseSucceeded && envelopeSuccess;
+        let succeeded = (processSucceeded && parseSucceeded && envelopeSuccess) || recordingStopRecovery?.recovery.healed === true;
         const inspectionText = plainTextInspection ? processResult.stdout.trim() : undefined;
         const sessionStateKey = getSessionContextKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace);
         const closeAllApplied = nestedBatchClosesAll || (directCloseAllRequested && succeeded);
@@ -223,8 +246,8 @@ export async function processBrowserOutput(input) {
         }
         if (closeAllApplied) {
             networkRoutesBySession = withoutNamespaceEntries(networkRoutesBySession, prepared.executionPlan.namespace);
-            deleteNamespaceEntries(state.attachedSessionKeys, prepared.executionPlan.namespace);
-            deleteNamespaceEntries(traceOwners, prepared.executionPlan.namespace);
+            deleteIdentityKeysInNamespace(state.attachedSessionKeys, prepared.executionPlan.namespace);
+            deleteIdentityKeysInNamespace(traceOwners, prepared.executionPlan.namespace);
             sessionPageState.clearNamespace(prepared.executionPlan.namespace);
             const retainedSessionKey = nestedBatchRemainsActive ? sessionStateKey : undefined;
             for (const [key, owner] of state.ownedManagedSessions) {
@@ -370,7 +393,7 @@ export async function processBrowserOutput(input) {
         let fillVerificationDiagnostic;
         let selectorTextVisibilityDiagnostics = [];
         let electronBroadGetTextScopeDiagnostics = [];
-        const timeoutPartialProgress = processResult.timedOut ? await collectTimeoutPartialProgress({ command: prepared.executionPlan.commandInfo.command, compiledJob: prepared.compiledJob, cwd, namespace: prepared.executionPlan.namespace, sessionName: prepared.executionPlan.sessionName, stdin: prepared.runtimeToolStdin }) : undefined;
+        const timeoutPartialProgress = processResult.timedOut && !recordingStopRecovery && !prepared.readConfirmation ? await collectTimeoutPartialProgress({ commandTokens: prepared.commandTokens, compiledJob: prepared.compiledJob, cwd, namespace: prepared.executionPlan.namespace, sessionName: prepared.executionPlan.sessionName, stdin: prepared.runtimeToolStdin }) : undefined;
         if (!currentSessionTabTarget && timeoutPartialProgress?.currentPage?.source === "live") {
             currentSessionTabTarget = normalizeSessionTabTarget(timeoutPartialProgress.currentPage);
         }
@@ -402,7 +425,7 @@ export async function processBrowserOutput(input) {
         const batchRefSnapshotState = prepared.executionPlan.commandInfo.command === "batch" ? extractLatestRefSnapshotStateFromBatchResults(presentationEnvelope?.data) : undefined;
         let currentRefSnapshot;
         let currentRefSnapshotInvalidation;
-        if (sessionStateKey) {
+        if (sessionStateKey && !browserIndependentRead) {
             const sessionClosed = (isCloseCommand(prepared.executionPlan.commandInfo.command) && succeeded) || nestedBatchClosed;
             if (sessionClosed) {
                 state.attachedSessionKeys.delete(sessionStateKey);
@@ -433,7 +456,7 @@ export async function processBrowserOutput(input) {
                     if (!tabUpdate.applied && succeeded)
                         sessionPageState.markPinning(sessionStateKey, "drift");
                 }
-                else if (processResult.agentBrowserStarted && (resultingPageState.pageUrlUnknown || resultingPageState.pageTargetMayHaveChanged)) {
+                else if (processResult.agentBrowserStarted && (resultingPageState.pageUrlUnknown || resultingPageState.pageTargetMayHaveChanged) && !(prepared.commandTokens[0] === "session" && prepared.commandTokens[1] === "info")) {
                     sessionPageState.markTabTargetUnknown({ sessionName: sessionStateKey, update: sessionPageStateUpdate });
                 }
                 const refSnapshot = unsettledWebMcpMutation
@@ -518,7 +541,7 @@ export async function processBrowserOutput(input) {
             managedSessionHeadedAutosaveDisabled = false;
             managedSessionHeadedAutosaveInterval = undefined;
         }
-        else if (managedTransitionSucceeded && executionTargetsManagedSession) {
+        else if (managedTransitionSucceeded && executionTargetsManagedSession && prepared.ownedManagedSessionContext && !prepared.ownedManagedSessionContext.reuseOnly) {
             managedSessionCompatibilityWorkaround = prepared.compatibilityWorkaround;
             managedSessionHeadedAutosaveDisabled = prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true;
             managedSessionHeadedAutosaveInterval = prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval;
@@ -636,7 +659,7 @@ 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({ sessionTabCorrection }) });
+        let errorText = recordingStopRecovery?.recovery.healed ? undefined : 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 && presentationEnvelope?.success === false && extractEnvelopeErrorText(presentationEnvelope.error) === undefined)
             presentationEnvelope = { ...presentationEnvelope, error: errorText };
         if (errorText) {
@@ -647,7 +670,21 @@ export async function processBrowserOutput(input) {
         }
         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 });
+        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` } : recordingStopRecovery && !recordingStopRecovery.batch ? recordingStopRecovery.presentation : 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, piCleanupOwnership: sessionStateKey && (state.ownedManagedSessions.has(sessionStateKey) || prepared.executionPlan.managedSessionName !== undefined) ? "wrapper-managed" : "caller-owned", sessionName: prepared.executionPlan.sessionName });
+        if (recordingStopRecovery)
+            presentation = mergeRecordingRecoveryPresentation(presentation, recordingStopRecovery);
+        const confirmation = readConfirmationEvent ?? prepared.readConfirmation;
+        if (confirmation) {
+            presentation.readConfirmation = confirmation;
+            if (confirmation.state !== "cleared" || !detectConfirmationRequired(presentationEnvelope?.data)) {
+                presentation.nextActions = buildReadConfirmationNextActions(confirmation, readConfirmationEvent?.state === "pending");
+            }
+            if (readConfirmationEvent?.state === "pending") {
+                presentation.resultCategory = "failure";
+                presentation.failureCategory = "confirmation-required";
+                presentation.successCategory = undefined;
+            }
+        }
         if (plainTextUpgrade && !succeeded && typeof presentationEnvelope?.data === "string") {
             presentation.data = presentationEnvelope.data;
             const errorContent = presentation.content[0];
@@ -757,13 +794,15 @@ export async function processBrowserOutput(input) {
         const evalPageUrl = evalNavigationSummary?.url ?? currentSessionTabTarget?.url ?? prepared.priorSessionTabTarget?.url ?? evalSessionTabUrl;
         const evalStdinHint = getEvalStdinHint({ command: prepared.executionPlan.commandInfo.command, data: presentationEnvelope?.data, stdin: prepared.runtimeToolStdin });
         const evalResultWarning = getEvalResultWarning({ command: prepared.executionPlan.commandInfo.command, data: presentationEnvelope?.data, navigationSummary: evalNavigationSummary, pageUrl: evalPageUrl, stdin: prepared.runtimeToolStdin });
+        if (readConfirmationEvent)
+            state.sessionPageState.applyReadConfirmation(readConfirmationEvent, sessionPageStateUpdate);
         const resultArtifactManifest = presentation.artifactManifest ?? artifactManifest;
         const artifactCleanup = await getArtifactCleanupGuidance({ command: prepared.executionPlan.commandInfo.command, cwd, manifest: resultArtifactManifest, succeeded });
         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."
+            ? "Page state: this wrapper conservatively invalidates earlier refs after recording starts and URL-bearing restarts. Take a fresh snapshot before continuing; this does not prove the page changed."
             : undefined;
         const sessionWarning = electronPostCommandHealth ? formatElectronPostCommandHealthText(electronPostCommandHealth) : electronSessionMismatch ? formatElectronSessionMismatchText(electronSessionMismatch) : aboutBlankSessionMismatch ? buildAboutBlankWarning(aboutBlankSessionMismatch) : undefined;
         const warningText = [sessionWarning, recordingPageWarning].filter(Boolean).join("\n\n") || undefined;
@@ -778,9 +817,10 @@ export async function processBrowserOutput(input) {
         const resultRetainsPreparedManagedSession = !managedSessionOutcome || (managedSessionOutcome.activeAfter
             && managedSessionOutcome.attemptedSessionName === managedSessionOutcome.currentSessionName);
         const resultHeadedManagedAutosaveDisabled = prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true
+            && !prepared.ownedManagedSessionContext.reuseOnly
             && resultRetainsPreparedManagedSession
             && !(commandClosesSession && succeeded);
-        const resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !(commandClosesSession && succeeded)
+        const resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !prepared.ownedManagedSessionContext?.reuseOnly && !(commandClosesSession && succeeded)
             ? prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval
             : undefined;
         const result = buildFinalAgentBrowserToolResult({ aboutBlankSessionMismatch, artifactCleanup, categoryDetails: finalRecoveryState.categoryDetails, clickDispatchDiagnostic, commandTokens: prepared.commandTokens, comboboxFocusDiagnostic, compiledNetworkSourceLookup: prepared.compiledNetworkSourceLookup, compiledSemanticAction: prepared.compiledSemanticAction, compatibilityWorkaround: prepared.compatibilityWorkaround, currentRefSnapshot, currentRefSnapshotInvalidation, currentSessionTabTarget, currentSessionTabTargetUnknown, electronBroadGetTextScopeDiagnostics, electronFailedConnectCleanup, electronHandoff, electronLaunch: prepared.electronLaunch, electronLaunchRecord, electronLaunchRecords, electronPostCommandHealth, electronProfileIsolationDetails: input.electronProfileIsolationDetails, electronRefFreshnessDiagnostic, electronSessionMismatch, errorText, evalResultWarning, evalStdinHint, exactSensitiveValues: prepared.exactSensitiveValues, executionPlan: prepared.executionPlan, fillVerificationDiagnostic, headedLaunch: prepared.headedLaunch, inspectionText, preserveAttachedBrowserSession: input.preserveAttachedBrowserSession === true, providerLaunch: prepared.providerLaunch, managedSessionHeadedAutosaveDisabled: resultHeadedManagedAutosaveDisabled || undefined, managedSessionHeadedAutosaveInterval: resultHeadedManagedAutosaveInterval, managedSessionOutcome, managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace), navigationSummary, networkSourceLookup, noActivePageSnapshotFailure: finalRecoveryState.noActivePageSnapshotFailure, openResultTabCorrection, overlayBlockerDiagnostic, parseError, parseFailureOutput, parseSucceeded, plainTextInspection, presentation, presentationEnvelope, priorSessionTabTarget: prepared.priorSessionTabTarget, processResult, qaAttachedTarget, qaPreset, recordingDependencyWarning, redactedArgs: prepared.redactedArgs, redactedCompiledElectron: prepared.redactedCompiledElectron, redactedCompiledJob: prepared.redactedCompiledJob, redactedCompiledNetworkSourceLookup: prepared.redactedCompiledNetworkSourceLookup, redactedCompiledQaPreset: prepared.redactedCompiledQaPreset, redactedCompiledSemanticAction: prepared.redactedCompiledSemanticAction, redactedCompiledSourceLookup: prepared.redactedCompiledSourceLookup, redactedContent, redactedProcessArgs: prepared.redactedProcessArgs, redactedRecoveryHint: prepared.redactedRecoveryHint, resultArtifactManifest, richInputRecoveryDiagnostic: finalRecoveryState.richInputRecoveryDiagnostic, scrollNoopDiagnostic, selectorTextVisibilityDiagnostics, sessionMode: prepared.sessionMode, sessionTabCorrection, sourceLookup, succeeded, timeoutPartialProgress, unsettledWebMcpMutation, userRequestedJson: prepared.userRequestedJson, visibleRefFallbackDiagnostic: finalRecoveryState.visibleRefFallbackDiagnostic, visibleRefFallbackSessionName: finalRecoveryState.visibleRefFallbackSessionName });

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

@@ -0,0 +1,161 @@
+import { resolve } from "node:path";
+import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
+import { getRecordCommandOperands } from "../../command-taxonomy.js";
+import { isRecord } from "../../parsing.js";
+import { isPendingRecordingArtifact, mergeSessionArtifactManifest } from "../../results/artifact-manifest.js";
+import { extractEnvelopeErrorText } from "../../results/envelope.js";
+import { appendUniqueAgentBrowserNextActions } from "../../results/next-actions.js";
+import { buildToolPresentation } from "../../results/presentation.js";
+import { buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts } from "../../results/presentation/artifacts.js";
+import { getRecordingReceipt } from "../../results/recording.js";
+import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
+import { runSessionCommandData } from "./session-state.js";
+function isStop(tokens) {
+    return tokens[0] === "record" && tokens[1] === "stop";
+}
+function receiptMatches(receipt, expected, nowMs) {
+    if (resolve(expected.cwd, receipt.path) !== expected.absolutePath)
+        return false;
+    if (expected.recordingId)
+        return receipt.recordingId === expected.recordingId;
+    const startedAtMs = Date.parse(receipt.capture.startedAt ?? "");
+    return expected.startedAtMs !== undefined && startedAtMs >= expected.startedAtMs && startedAtMs <= nowMs;
+}
+export async function recoverRecordingStop(options) {
+    const batch = options.commandTokens[0] === "batch";
+    const steps = batch ? getUpstreamEffectiveBatchSteps(options.commandTokens, options.stdin) : [options.commandTokens];
+    const rows = batch && Array.isArray(options.envelope?.data) ? options.envelope.data : undefined;
+    const stopIndex = steps.reduce((last, step, index) => isStop(step) && (options.processResult.timedOut
+        || /no recording in progress/i.test(extractEnvelopeErrorText(rows?.[index]?.error ?? options.envelope?.error) ?? "")) ? index : last, -1);
+    if (stopIndex < 0 || options.processResult.aborted || options.signal?.aborted || !options.processResult.agentBrowserStarted)
+        return undefined;
+    let expected = options.reservation;
+    for (let index = 0; index < stopIndex; index += 1) {
+        const step = steps[index];
+        if (step[0] !== "record" || !["start", "restart"].includes(step[1]))
+            continue;
+        const row = rows?.[index];
+        if (isRecord(row) && row.success === false)
+            continue;
+        const started = isRecord(row) && isRecord(row.result) ? row.result : undefined;
+        const path = typeof started?.path === "string" ? started.path : getRecordCommandOperands(step).path;
+        if (path && options.sessionName)
+            expected = {
+                absolutePath: resolve(options.cwd, path), cwd: options.cwd, path, namespace: options.namespace, sessionName: options.sessionName,
+                recordingId: typeof started?.recordingId === "string" ? started.recordingId : undefined, startedAtMs: options.artifactRunStartedAtMs,
+            };
+    }
+    const attemptError = options.processResult.timedOut
+        ? `Record stop timed out after ${options.processResult.timeoutMs} ms.`
+        : extractEnvelopeErrorText(rows?.[stopIndex]?.error ?? options.envelope?.error) ?? "Record stop did not return a receipt.";
+    const recovery = {
+        attempt: { success: false, exitCode: options.processResult.exitCode, timedOut: options.processResult.timedOut, error: attemptError, parseError: options.parseError },
+        expected, healed: false, namespace: options.namespace, sessionName: options.sessionName, source: "session-info", status: "unavailable",
+        reason: "Native session info did not provide a matching recording receipt. File presence alone cannot prove successful recording finalization.",
+    };
+    let info;
+    try {
+        info = await runSessionCommandData({ args: ["session", "info"], cwd: options.cwd, namespace: options.namespace, pinNamespace: true, sessionName: options.sessionName, signal: options.signal, timeoutMs: 2_000 });
+    }
+    catch (error) {
+        recovery.reason = `Native session info was unavailable: ${error instanceof Error ? error.message : String(error)}. File presence alone cannot prove successful recording finalization.`;
+    }
+    const runtime = isRecord(info) && isRecord(info.runtime) ? info.runtime : undefined;
+    const recordings = isRecord(runtime?.recording) ? runtime.recording : undefined;
+    const sameSession = isRecord(info) && typeof info.session === "string" && options.sessionName !== undefined
+        && getAgentBrowserSessionIdentityKey(info.session, typeof info.namespace === "string" ? info.namespace : undefined)
+            === getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace);
+    const current = getRecordingReceipt(recordings?.current);
+    let matchedData;
+    if (recordings && sameSession && expected) {
+        for (const candidate of [recordings.current, recordings.last]) {
+            const receipt = getRecordingReceipt(candidate);
+            if (!receipt || !receiptMatches(receipt, expected, Date.now()))
+                continue;
+            recovery.receipt = receipt;
+            matchedData = candidate;
+            break;
+        }
+        if (!recovery.receipt) {
+            recovery.status = "mismatch";
+            recovery.reason = "Native recording IDs, paths or capture windows did not match this attempt; unrelated receipt measurements were not used.";
+        }
+    }
+    else if (recordings && !sameSession) {
+        recovery.status = "mismatch";
+        recovery.reason = "Native session info reported a different namespace/session; its recording receipt was not used.";
+    }
+    const receipt = recovery.receipt;
+    const currentUsesSamePath = current && receipt && current.recordingId !== receipt.recordingId && expected
+        && resolve(expected.cwd, current.path) === expected.absolutePath;
+    const terminalMeasurements = receipt?.success === true && receipt.output.encoderSucceeded === true
+        && receipt.output.encodedFrames !== null && receipt.output.encodedFrames > 0
+        && receipt.file.exists === true && receipt.file.sizeBytes !== null && receipt.file.sizeBytes > 0
+        && Number.isFinite(Date.parse(receipt.capture.startedAt ?? "")) && Number.isFinite(Date.parse(receipt.capture.endedAt ?? ""))
+        && !currentUsesSamePath;
+    const data = matchedData ?? (expected ? { path: expected.absolutePath, recordingId: expected.recordingId, success: null } : undefined);
+    const presentation = await buildToolPresentation({
+        artifactManifest: options.artifactManifest, artifactMinUpdatedAtMs: expected?.startedAtMs ?? options.artifactRunStartedAtMs, artifactMaxUpdatedAtMs: Date.now(),
+        artifactRequest: expected ? { path: expected.path, absolutePath: expected.absolutePath, status: terminalMeasurements ? undefined : "unverified" } : undefined,
+        commandInfo: { command: "record", subcommand: "stop" }, cwd: expected?.cwd ?? options.cwd,
+        envelope: { success: receipt?.success === true, data }, namespace: options.namespace, sessionName: options.sessionName,
+        recordingPending: receipt ? receipt.success === null : options.processResult.timedOut,
+    });
+    const file = presentation.artifacts?.[0];
+    const stopVerified = terminalMeasurements && presentation.artifactVerification?.verified === true && file?.sizeBytes === receipt?.file.sizeBytes;
+    if (receipt) {
+        recovery.status = stopVerified ? "recovered" : receipt.success === null ? "pending" : receipt.success === false ? "failed" : "unverified";
+        recovery.reason = stopVerified ? "Native terminal success and encoder measurements match the expected recording and the verified file."
+            : receipt.success === null ? "The matching native take is still pending; no terminal success was reported."
+                : receipt.success === false ? `The matching native receipt reports failure: ${receipt.error ?? "unknown encoder/capture failure"}.`
+                    : currentUsesSamePath ? "Another active recording uses this path. The previous receipt cannot verify the new take's file."
+                        : "A matching receipt was found, but successful encoding and a matching fresh file could not both be verified.";
+    }
+    let envelope = options.envelope;
+    if (rows) {
+        const updatedRows = rows.map((row, index) => index === stopIndex && isRecord(row) ? { ...row, result: data, success: stopVerified === true, error: stopVerified ? undefined : row.error } : row);
+        recovery.healed = stopVerified === true && !options.processResult.timedOut && updatedRows.every(row => isRecord(row) && row.success === true);
+        envelope = { success: recovery.healed, data: updatedRows, error: recovery.healed ? undefined : options.envelope?.error };
+    }
+    else if (!batch) {
+        recovery.healed = stopVerified === true;
+        envelope = { success: recovery.healed, data, error: recovery.healed ? undefined : attemptError };
+    }
+    if (!recovery.healed) {
+        presentation.resultCategory = "failure";
+        presentation.failureCategory = options.processResult.timedOut ? "timeout" : "upstream-error";
+        presentation.successCategory = undefined;
+        presentation.summary = `${attemptError} ${recovery.reason}`;
+    }
+    const followups = options.sessionName && !recovery.healed ? [{
+            id: "inspect-recording-receipt", tool: "agent_browser", params: { args: ["--namespace", options.namespace ?? "", "--session", options.sessionName, "session", "info"] },
+            reason: "Inspect the native current/last recording receipts for this exact session.", safety: "Read-only status; does not launch or retarget the browser. Do not infer encoding success from an existing file.",
+        }] : [];
+    if (current && receipt && current.recordingId === receipt.recordingId && recovery.status === "pending" && options.sessionName)
+        followups.push({
+            id: "stop-pending-recording", tool: "agent_browser", params: { args: ["--namespace", options.namespace ?? "", "--session", options.sessionName, "record", "stop"] },
+            reason: `Finalize the still-current native recording ${receipt.recordingId}; it has not reported a terminal outcome.`, safety: "Run only while this same recording remains current. No repeated stop was dispatched during recovery.",
+        });
+    presentation.nextActions = followups;
+    presentation.recordingRecovery = recovery;
+    const text = `Recording receipt recovery (${recovery.status}): ${recovery.reason}\nOriginal attempt: ${attemptError}`;
+    presentation.content.unshift({ type: "text", text });
+    return { batch, envelope, partialBatch: batch && !rows, stopIndex, presentation, recovery };
+}
+export function mergeRecordingRecoveryPresentation(base, result) {
+    if (!result.batch)
+        return result.presentation;
+    const artifacts = result.partialBatch ? [...(base.artifacts ?? []), ...(result.presentation.artifacts ?? [])] : base.artifacts;
+    const laterRecording = base.batchSteps?.slice(result.stopIndex + 1).some(step => step.artifacts?.some(isPendingRecordingArtifact));
+    const unrelatedFailure = base.batchFailure && !isStop(base.batchFailure.failedStep.command ?? []);
+    const nextActions = (base.nextActions ?? []).filter(action => action.id === "stop-pending-recording" ? laterRecording : unrelatedFailure);
+    appendUniqueAgentBrowserNextActions(nextActions, result.presentation.nextActions);
+    return {
+        ...base, artifacts, artifactVerification: buildArtifactVerificationSummary(artifacts ?? []),
+        batchSteps: base.batchSteps?.map((step) => step.index === result.stopIndex ? { ...step, artifacts: result.presentation.artifacts, artifactVerification: result.presentation.artifactVerification } : step),
+        artifactManifest: result.partialBatch ? mergeSessionArtifactManifest({ base: base.artifactManifest, entries: buildManifestEntriesForFileArtifacts(result.presentation.artifacts ?? []) }) : base.artifactManifest,
+        content: [...base.content, ...(result.partialBatch ? result.presentation.content : result.presentation.content.slice(0, 1))],
+        nextActions,
+        recordingRecovery: result.recovery,
+    };
+}

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

@@ -1,13 +1,13 @@
 import { rm } from "node:fs/promises";
 import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
 import { parseArgvDescriptor } from "../../argv-descriptor.js";
-import { needsManagedSession } from "../../command-policy.js";
+import { isBrowserIndependentRead, needsManagedSession } from "../../command-policy.js";
 import { runAgentBrowserProcess } from "../../process.js";
 import { buildAgentBrowserNextActions } from "../../results/action-recommendations.js";
 import { parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { buildNextToolAction, withOptionalNamespaceArgs, withOptionalSessionArgs } from "../../results/next-actions.js";
 import { getSessionPageStateKey, isAboutBlankUrl, normalizeComparableUrl, targetsMatch, } from "../../session-page-state.js";
-import { isCloseCommand, isElectronPostCommandHealthCommand, isNavigationObservableCommandName, isOpenNavigationCommand, isRefGuardedCommand, isRefInvalidatingBatchCommand, isRecordPageTransitionCommand, isSessionTabPinningExcludedCommand, isSessionTabPostCommandCorrectionExcludedCommand, isWindowOrDiffPageTransitionCommand, } from "../../command-taxonomy.js";
+import { getRecordCommandOperands, isCloseCommand, isElectronPostCommandHealthCommand, isNavigationObservableCommandName, isOpenNavigationCommand, isRefGuardedCommand, isRefInvalidatingBatchCommand, isSessionTabPinningExcludedCommand, isSessionTabPostCommandCorrectionExcludedCommand, isWindowOrDiffPageTransitionCommand, } from "../../command-taxonomy.js";
 import { chooseOpenResultTabCorrection } from "../../runtime.js";
 import { isRecord, parseRefId } from "../../parsing.js";
 import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
@@ -424,10 +424,10 @@ export function commandChoosesSessionTabTarget(args) {
         || isWindowOrDiffPageTransitionCommand(command, subcommand)
         || (command === "a11y" && findFirstPositionalArgument(tokens) !== undefined)
         || (["vitals", "web-vitals"].includes(command) && tokens.slice(1).some((token) => !token.startsWith("--")))
-        || (isRecordPageTransitionCommand(tokens) && tokens[3] !== undefined);
+        || getRecordCommandOperands(tokens).url !== undefined;
 }
 export function shouldPinSessionTabForCommand(options) {
-    if (!options.pinningRequired || !options.sessionName || !options.command)
+    if (!options.pinningRequired || !options.sessionName || !options.command || isBrowserIndependentRead(options.commandTokens, options.stdin))
         return false;
     const steps = options.command === "batch" ? getUpstreamEffectiveBatchSteps(options.commandTokens, options.stdin) : [options.commandTokens];
     for (const step of steps) {
@@ -441,7 +441,7 @@ export function shouldPinSessionTabForCommand(options) {
             continue;
         if (command === "get" && subcommand === "url" && !options.reopenPending)
             continue;
-        if (command === "read" && findFirstPositionalArgument(tokens) !== undefined)
+        if (command === "record" && subcommand === "stop")
             continue;
         if (["console", "errors"].includes(command))
             continue;