pi-agent-browser-native 0.6.10 → 0.6.12

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

@@ -1,6 +1,6 @@
 import { rm } from "node:fs/promises";
 import { parseArgvDescriptor } from "../../argv-descriptor.js";
-import { needsManagedSession } from "../../command-policy.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";
@@ -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) {
@@ -161,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 });
@@ -178,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);
@@ -200,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;
@@ -207,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);
@@ -364,7 +393,7 @@ export async function processBrowserOutput(input) {
         let fillVerificationDiagnostic;
         let selectorTextVisibilityDiagnostics = [];
         let electronBroadGetTextScopeDiagnostics = [];
-        const timeoutPartialProgress = processResult.timedOut ? await collectTimeoutPartialProgress({ commandTokens: prepared.commandTokens, 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);
         }
@@ -396,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);
@@ -427,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
@@ -512,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;
@@ -630,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) {
@@ -641,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];
@@ -751,6 +794,8 @@ 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"
@@ -772,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,7 +1,7 @@
 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";
@@ -427,7 +427,7 @@ export function commandChoosesSessionTabTarget(args) {
         || 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;

package/dist/extensions/agent-browser/lib/orchestration/input-plan.js

@@ -65,7 +65,7 @@ function normalizeExplicitEvalStdinArgs(args, stdin) {
     };
 }
 export function resolveAgentBrowserInput(options) {
-    const { getBatchPreflightValidationError, managedSessionActive, params } = options;
+    const { getBatchPreflightValidationError, params } = options;
     const semanticActionResult = params.semanticAction === undefined ? {} : compileAgentBrowserSemanticAction(params.semanticAction);
     const jobResult = params.job === undefined ? {} : compileAgentBrowserJob(params.job);
     const qaResult = params.qa === undefined ? {} : compileAgentBrowserQaPreset(params.qa);
@@ -126,9 +126,7 @@ export function resolveAgentBrowserInput(options) {
     const attachedQaSessionError = compiledQaPreset?.checks.attached
         ? params.sessionMode === "fresh"
             ? "qa.attached cannot be used with sessionMode=fresh; attach or launch a session first, then run qa.attached with the current session."
-            : !managedSessionActive
-                ? "qa.attached requires an active attached session. Run electron.launch or connect to an Electron debug port first."
-                : undefined
+            : undefined
         : undefined;
     const validationError = semanticActionResult.error
         ?? jobResult.error

package/dist/extensions/agent-browser/lib/orchestration/native-session-defaults.js

@@ -0,0 +1,68 @@
+import { readFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { extractExplicitSessionName, scanUpstreamGlobalFlagOccurrences } from "../argv-grammar.js";
+import { isRecord } from "../parsing.js";
+import { getAgentBrowserProcessEnvironment, withAgentBrowserProcessEnvironment } from "../process-environment.js";
+import { runAgentBrowserProcess } from "../process.js";
+import { parseAgentBrowserEnvelope } from "../results/envelope.js";
+import { isPlainTextInspectionArgs } from "../runtime.js";
+// Native `session` reports the resolved name, but not whether it was configured.
+// Read only identity presence/namespace; native validates the rest of its schema.
+async function readNativeIdentity(path, cwd, signal) {
+    let config;
+    try {
+        config = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+    if (!isRecord(config) || (typeof config.session !== "string" && typeof config.namespace !== "string"))
+        return {};
+    const result = await runAgentBrowserProcess({ args: ["--config", path, "--json", "session"], cwd, signal, timeoutMs: 5_000 });
+    try {
+        if (result.aborted || result.timedOut || result.spawnError)
+            throw new Error("Could not resolve native agent-browser session configuration; the browser command was not run.");
+        if (result.exitCode !== 0)
+            return {}; // Native ignores invalid discovered files; explicit files fail again in the actual command.
+        const parsed = await parseAgentBrowserEnvelope({ stdout: result.stdout, stdoutPath: result.stdoutSpillPath });
+        const data = parsed.envelope?.data;
+        if (!isRecord(data) || typeof data.session !== "string")
+            throw new Error("Native agent-browser session inspection returned no session name; the browser command was not run.");
+        return {
+            ...(typeof config.session === "string" ? { session: data.session } : {}),
+            ...(typeof config.namespace === "string" ? { namespace: config.namespace } : {}),
+        };
+    }
+    finally {
+        if (result.stdoutSpillPath)
+            await rm(result.stdoutSpillPath, { force: true });
+    }
+}
+export async function withNativeSessionDefaults(input, cwd, signal, run) {
+    if (input.kind === "electron" && input.compiledElectron.action === "launch")
+        return withAgentBrowserProcessEnvironment({ AGENT_BROWSER_SESSION: undefined }, () => run(input));
+    if (input.kind === "script" || input.kind === "electron" || isPlainTextInspectionArgs(input.toolArgs))
+        return run(input);
+    const env = getAgentBrowserProcessEnvironment();
+    const configArg = scanUpstreamGlobalFlagOccurrences(input.toolArgs, "--config")[0];
+    const configPath = configArg?.value ?? env.AGENT_BROWSER_CONFIG;
+    const paths = configPath !== undefined
+        ? [resolve(cwd, configPath)]
+        : [join(homedir(), ".agent-browser", "config.json"), join(cwd, "agent-browser.json")];
+    let identity = {};
+    for (const path of paths)
+        identity = { ...identity, ...await readNativeIdentity(path, cwd, signal) };
+    const session = env.AGENT_BROWSER_SESSION ?? identity.session;
+    const namespace = env.AGENT_BROWSER_NAMESPACE ?? identity.namespace;
+    let args = input.toolArgs;
+    if (session !== undefined && extractExplicitSessionName(args) === undefined)
+        args = ["--session", session, ...args];
+    const idleTimeout = scanUpstreamGlobalFlagOccurrences(args, "--idle-timeout").at(-1)?.value;
+    return withAgentBrowserProcessEnvironment({
+        ...(idleTimeout !== undefined ? { AGENT_BROWSER_IDLE_TIMEOUT_MS: idleTimeout } : {}),
+        ...(configPath !== undefined ? { AGENT_BROWSER_CONFIG: resolve(cwd, configPath) } : {}),
+        ...(session !== undefined ? { AGENT_BROWSER_SESSION: session } : {}),
+        ...(namespace !== undefined ? { AGENT_BROWSER_NAMESPACE: namespace } : {}),
+    }, () => run({ ...input, toolArgs: args }));
+}

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

@@ -2,6 +2,7 @@ import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { dirname, extname, isAbsolute, resolve } from "node:path";
 import { isRecord } from "../parsing.js";
 import { isSessionArtifactManifest } from "../results/artifact-manifest.js";
+import { parseCommandInfo, redactSensitiveValue } from "../runtime.js";
 export function normalizeRequestedOutputPath(path) {
     return path.startsWith("@") ? path.slice(1) : path;
 }
@@ -11,7 +12,21 @@ function getTextContent(result) {
         .map((item) => item.text)
         .join("\n\n") ?? "";
 }
+function getResultCommand(details) {
+    const args = Array.isArray(details?.args) && details.args.every(value => typeof value === "string") ? details.args : [];
+    return parseCommandInfo(args);
+}
+function isRecordingReceiptResult(result) {
+    const details = isRecord(result.details) ? result.details : undefined;
+    return details?.command === "record" || getResultCommand(details).command === "record" || details?.recordingRecovery !== undefined
+        || (Array.isArray(details?.batchSteps) && details.batchSteps.some((step) => isRecord(step) && Array.isArray(step.command) && step.command[0] === "record"));
+}
+export function canWriteAgentBrowserOutput(result) {
+    return isRecordingReceiptResult(result) || (!result.isError && !(isRecord(result.details) && result.details.resultCategory === "failure"));
+}
 function getOutputSource(result) {
+    if (isRecordingReceiptResult(result))
+        return "recording-receipt";
     return isRecord(result.details) && result.details.data !== undefined ? "details.data" : "content.text";
 }
 async function readCompactedSpill(path, manifest) {
@@ -42,17 +57,37 @@ async function rehydrateCompactedData(data, details, manifest) {
 }
 async function getOutputPayload(result) {
     const details = isRecord(result.details) ? result.details : undefined;
-    if (details?.data === undefined)
+    if (!details)
         return { source: "content.text", value: getTextContent(result) };
     const manifest = isSessionArtifactManifest(details.artifactManifest) ? details.artifactManifest : undefined;
-    return { source: "details.data", value: await rehydrateCompactedData(details.data, details, manifest) };
+    const data = await rehydrateCompactedData(details.data, details, manifest);
+    if (isRecordingReceiptResult(result)) {
+        const success = !result.isError && details.resultCategory !== "failure";
+        const recovery = isRecord(details.recordingRecovery) ? details.recordingRecovery : undefined;
+        const commandInfo = getResultCommand(details);
+        return { source: "recording-receipt", value: redactSensitiveValue({
+                success, error: details.error ?? (success ? null : details.summary ?? getTextContent(result)),
+                command: details.command ?? commandInfo.command, subcommand: details.subcommand ?? commandInfo.subcommand, sessionName: details.sessionName, namespace: details.namespace,
+                attempt: recovery?.attempt ?? { success, agentBrowserStarted: details.agentBrowserStarted ?? null, exitCode: details.exitCode ?? null, timedOut: details.timedOut === true, error: details.error ?? details.validationError ?? null, parseError: details.parseError ?? null },
+                data: data ?? null, artifacts: details.artifacts, artifactVerification: details.artifactVerification, recordingRecovery: recovery,
+            }) };
+    }
+    return data === undefined ? { source: "content.text", value: getTextContent(result) } : { source: "details.data", value: data };
 }
 function serializeOutputPayload(value) {
     return typeof value === "string" ? value : `${JSON.stringify(value, null, 2)}\n`;
 }
-function appendOutputFileNotice(result, message) {
+function appendOutputFileNotice(result, message, failed = false) {
     const content = [...(result.content ?? [])];
     if (content[0]?.type === "text") {
+        try {
+            const json = JSON.parse(content[0].text);
+            if (isRecord(json) && typeof json.success === "boolean") {
+                content[0] = { type: "text", text: JSON.stringify({ ...json, ...(failed ? { success: false, error: message } : {}), outputFileNotice: message }, null, 2) };
+                return content;
+            }
+        }
+        catch { }
         content[0] = { ...content[0], text: `${content[0].text}\n\n${message}` };
         return content;
     }
@@ -88,7 +123,7 @@ async function pathsReferToSameFile(left, right) {
 export async function applyAgentBrowserOutputPath(options) {
     if (!options.outputPath)
         return options.result;
-    if (options.result.isError || (isRecord(options.result.details) && options.result.details.resultCategory === "failure"))
+    if (!canWriteAgentBrowserOutput(options.result))
         return options.result;
     const requestedPath = normalizeRequestedOutputPath(options.outputPath);
     const absolutePath = isAbsolute(requestedPath) ? requestedPath : resolve(options.cwd, requestedPath);
@@ -102,7 +137,7 @@ export async function applyAgentBrowserOutputPath(options) {
         delete details.successCategory;
         return {
             ...options.result,
-            content: appendOutputFileNotice(options.result, `Output file rejected: ${message}`),
+            content: appendOutputFileNotice(options.result, `Output file rejected: ${message}`, true),
             details: { ...details, failureCategory: "validation-error", outputFile, resultCategory: "failure" },
             isError: true,
         };
@@ -133,7 +168,7 @@ export async function applyAgentBrowserOutputPath(options) {
             : { failureCategory: "upstream-error", outputFile, resultCategory: "failure" };
         return {
             ...options.result,
-            content: options.preserveTextContent ? options.result.content : appendOutputFileNotice(options.result, `Output file failed: ${requestedPath} (${message}).`),
+            content: appendOutputFileNotice(options.result, `Output file failed: ${requestedPath} (${message}).`, true),
             details,
             isError: true,
         };

package/dist/extensions/agent-browser/lib/page-target-validation.js

@@ -1,6 +1,6 @@
 import { parseArgvDescriptor } from "./argv-descriptor.js";
 import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS, } from "./argv-grammar.js";
-import { needsManagedSession } from "./command-policy.js";
+import { isBrowserIndependentRead, needsManagedSession } from "./command-policy.js";
 import { isUnverifiedPageTransitionCommand } from "./command-taxonomy.js";
 import { parseBatchCommandArgument, parseUserBatchStdin } from "./orchestration/batch-stdin.js";
 const UNVERIFIED_PAGE_MESSAGE = "The active page became unverified after a tab, attachment, history, script, or state-load transition. Run get url or navigate explicitly before page-content inspection.";
@@ -167,23 +167,27 @@ function isRecoveringPageTransitionCommand(command, subcommand) {
         && isUnverifiedPageTransitionCommand(command, subcommand);
 }
 function getUnverifiedPageError(options) {
-    if (!options.pageUrlUnknown)
+    const descriptor = parseArgvDescriptor(options.args);
+    if (!options.pageUrlUnknown || !needsManagedSession(descriptor))
         return undefined;
-    const { command, subcommand } = parseArgvDescriptor(options.args).commandInfo;
+    const { command, subcommand } = descriptor.commandInfo;
     const closesPage = ["close", "exit", "quit"].includes(command ?? "") || (command === "tab" && subcommand === "close");
     const inspectsTarget = (command === "tab" && subcommand === "list") || (command === "get" && subcommand === "url");
     const selectsTab = command === "tab" && subcommand !== undefined && !["close", "list", "new"].includes(subcommand);
     const settlesPendingWebMcp = command === "webmcp" && ["result", "cancel"].includes(subcommand ?? "");
+    const stopsRecording = command === "record" && subcommand === "stop";
     const handlesBlockingDialog = command === "dialog" && ["status", "accept", "dismiss"].includes(subcommand ?? "");
     const transitionsPage = options.allowUnverifiedPageTransitions === true && isRecoveringPageTransitionCommand(command, subcommand);
     const navigatesExplicitly = getExplicitNavigationTarget(options.args) !== undefined;
-    return closesPage || handlesBlockingDialog || inspectsTarget || selectsTab || settlesPendingWebMcp || transitionsPage || navigatesExplicitly || (options.trustedBatchTabSelection && command === "tab")
+    return closesPage || handlesBlockingDialog || inspectsTarget || selectsTab || settlesPendingWebMcp || stopsRecording || transitionsPage || navigatesExplicitly || (options.trustedBatchTabSelection && command === "tab")
         ? undefined
         : UNVERIFIED_PAGE_MESSAGE;
 }
 export function getPageTargetValidationError(options) {
     const descriptor = parseArgvDescriptor(options.args);
     const command = descriptor.commandInfo.command;
+    if (isBrowserIndependentRead(descriptor.upstreamCommandTokens, options.stdin))
+        return undefined;
     if (["close", "exit", "quit"].includes(command ?? ""))
         return undefined;
     if (command === "batch") {
@@ -254,7 +258,7 @@ export function getPageTargetValidationError(options) {
 }
 export function getExplicitSessionPageVerificationRequirement(options) {
     const descriptor = parseArgvDescriptor(options.args);
-    if (!needsManagedSession(descriptor))
+    if (!needsManagedSession(descriptor, options.stdin))
         return undefined;
     if (isRecoveringPageTransitionCommand(descriptor.commandInfo.command, descriptor.commandInfo.subcommand))
         return undefined;