pi-agent-browser-native 0.6.10 → 0.6.11

package/dist/extensions/agent-browser/lib/argv-grammar.js

@@ -81,7 +81,7 @@ export const COMMAND_VALUE_FLAGS = [
 export const OPTIONAL_GLOBAL_VALUE_FLAGS = new Set(["--restore"]);
 export const VALUE_FLAGS = new Set([...GLOBAL_VALUE_FLAGS, ...COMMAND_VALUE_FLAGS]);
 export const PREVALIDATED_VALUE_FLAGS = new Set(GLOBAL_VALUE_FLAGS);
-export const GLOBAL_VALUE_FLAGS_ALLOWING_DASH_VALUE = new Set(["--args"]);
+export const GLOBAL_VALUE_FLAGS_ALLOWING_DASH_VALUE = new Set(["--args", "--session"]);
 export const GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES = new Set([
     "--allow-file-access",
     "--annotate",

package/dist/extensions/agent-browser/lib/command-policy.js

@@ -1,4 +1,5 @@
 import { hasOnlyBooleanFlags, hasOnlyOptionFlags, isNonFlagToken, stripSessionlessShapeGlobalFlags } from "./argv-grammar.js";
+import { getUpstreamEffectiveBatchSteps } from "./orchestration/batch-stdin.js";
 const SESSIONLESS_AUTH_SUBCOMMANDS = new Set(["save", "list", "show", "delete", "remove"]);
 const PLUGIN_SESSIONLESS_SUBCOMMANDS = new Set(["list", "show", "add", "run"]);
 const EMPTY_BOOLEAN_FLAGS = new Set();
@@ -92,6 +93,44 @@ function isSessionlessCommand(commandTokens) {
         return isSessionlessStateCommand(normalizedTokens);
     return false;
 }
-export function needsManagedSession(descriptor) {
-    return !isSessionlessCommand(descriptor.upstreamCommandTokens);
+// undefined is a valid DOM read; null is invalid native syntax, which must not trigger page helpers.
+export function getExplicitReadUrl(commandTokens) {
+    if (commandTokens[0] !== "read")
+        return undefined;
+    let url;
+    let llms = false;
+    let outline = false;
+    for (let index = 1; index < commandTokens.length; index += 1) {
+        const token = commandTokens[index];
+        if (["--filter", "--llms", "--timeout"].includes(token)) {
+            const value = commandTokens[++index];
+            if (value === undefined)
+                return null;
+            if (token === "--llms") {
+                if (!["index", "full"].includes(value))
+                    return null;
+                llms = true;
+            }
+            if (token === "--timeout" && (!/^\+?\d+$/.test(value) || BigInt(value) === 0n || BigInt(value) > 18446744073709551615n))
+                return null;
+        }
+        else if (["--raw", "--require-md", "--outline", "--json"].includes(token)) {
+            if (token === "--outline")
+                outline = true;
+        }
+        else if (token.startsWith("--") || url !== undefined)
+            return null;
+        else
+            url = token;
+    }
+    return llms && outline ? null : url;
+}
+export function isBrowserIndependentRead(commandTokens, stdin) {
+    if (commandTokens[0] !== "batch")
+        return getExplicitReadUrl(commandTokens) !== undefined;
+    const steps = getUpstreamEffectiveBatchSteps(commandTokens, stdin);
+    return steps.length > 0 && steps.every((step) => getExplicitReadUrl(step) !== undefined);
+}
+export function needsManagedSession(descriptor, stdin) {
+    return !isSessionlessCommand(descriptor.upstreamCommandTokens) && !isBrowserIndependentRead(descriptor.upstreamCommandTokens, stdin);
 }

package/dist/extensions/agent-browser/lib/input-modes/params.js

@@ -138,7 +138,7 @@ export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = l
         outputPath: Type.Optional(Type.String({ description: "Workspace-relative or absolute result-data path; keep it distinct from screenshot, download, recording, and other browser artifact destinations.", minLength: 1 })),
         timeoutMs: Type.Optional(Type.Integer({ description: "Wrapper timeout in ms; exceed explicit waits. electron.list has no configurable timeout; other Electron actions use electron.timeoutMs.", minimum: 1 })),
         sessionMode: Type.Optional(StringEnum(["auto", "fresh"], {
-            description: "auto reuses the managed session; fresh starts one for launch-only flags, then makes it the managed session.",
+            description: "Native configured sessions win; otherwise auto reuses the managed session and fresh starts a new managed browser for launch-only flags.",
             default: DEFAULT_SESSION_MODE,
         })),
     }, {

package/dist/extensions/agent-browser/lib/input-modes/script.js

@@ -5,7 +5,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgvDescriptor } from "../argv-descriptor.js";
 import { getFlagName } from "../argv-grammar.js";
-import { needsManagedSession } from "../command-policy.js";
+import { isBrowserIndependentRead, needsManagedSession } from "../command-policy.js";
 import { isCloseCommand } from "../command-taxonomy.js";
 import { LAUNCH_SCOPED_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS } from "../launch-scoped-flags.js";
 import { isRecord } from "../parsing.js";
@@ -44,6 +44,7 @@ const SCRIPT_FORBIDDEN_FLAGS = new Set([
     ...MANAGED_RESTORE_INCOMPATIBLE_FLAGS.filter((flag) => flag !== SCRIPT_ALLOWED_LAUNCH_FLAG),
     "--namespace",
     "--session",
+    "--config",
 ]);
 export function compileAgentBrowserScript(input) {
     if (typeof input !== "string")
@@ -71,7 +72,7 @@ function getScriptCallPolicyError(args) {
         return "script browser calls cannot close, quit, or exit their isolated session.";
     if (SCRIPT_FORBIDDEN_COMMANDS.has(command))
         return `script browser calls cannot use ${command}.`;
-    if (!needsManagedSession(descriptor))
+    if (!needsManagedSession(descriptor) && !isBrowserIndependentRead(descriptor.upstreamCommandTokens))
         return `script browser calls cannot use sessionless/local command ${command}.`;
     for (const token of args) {
         const flag = getFlagName(token);

package/dist/extensions/agent-browser/lib/managed-session-restore.js

@@ -192,6 +192,12 @@ export function getOwnedManagedSessionCompatibilityEnv(options) {
     const explicitRawInterval = Object.hasOwn(callEnv, "AGENT_BROWSER_AUTOSAVE_INTERVAL_MS")
         ? callEnv.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS
         : parentEnv.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS;
+    if (ownedContext.reuseOnly) {
+        return explicitRawInterval === undefined && ownedContext.headedManagedAutosaveInterval !== undefined
+            && !agentBrowserExplicitConfigIsPresent({ ...parentEnv, ...callEnv }, options.args)
+            ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: ownedContext.headedManagedAutosaveInterval }
+            : {};
+    }
     const explicitIntervalMatches = resolveExplicitAutosaveInterval(explicitRawInterval) === ownedContext.headedManagedAutosaveInterval;
     return {
         ...(ownedContext.compatibilityUserAgent ? { AGENT_BROWSER_USER_AGENT: ownedContext.compatibilityUserAgent } : {}),
@@ -209,26 +215,33 @@ export function getManagedSessionRestoreProtectedEnv(options, restoreEnv) {
 }
 export function validateManagedSessionRestoreContextForSpawn(options) {
     const { namespace, ownedContext, parentEnv } = resolveManagedSessionRestorePolicy(options);
-    if (closesBrowserSession(options.args) || ownedContext?.restoreDecision !== "enabled")
+    if (closesBrowserSession(options.args) || ownedContext?.restoreDecision !== "enabled" || (ownedContext.reuseOnly && ownedContext.restoreSuppressed))
         return true;
     const ownedCwd = ownedContext.cwd ?? options.cwd;
     if (!ownedContext.restoreKey || !ownedContext.restoreScope || createManagedSessionRestoreKey(ownedCwd, ownedContext.restoreScope) !== ownedContext.restoreKey || !hasManagedSessionRestoreProjectIdentity(ownedCwd))
         return false;
     const effectiveEnv = { ...parentEnv, ...options.env };
-    if (isDisabledEnvFlag(effectiveEnv[MANAGED_SESSION_RESTORE_ENV]))
-        return false;
-    if (MANAGED_RESTORE_INCOMPATIBLE_ENVS.some((name) => !MANAGED_SESSION_RESTORE_SPAWN_PINNED_ENVS.has(name) && hasUpstreamEnvValue(effectiveEnv, name)))
-        return false;
-    if (MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS.some((name) => isUpstreamEnvFlagEnabled(effectiveEnv[name])))
-        return false;
-    if (options.env?.[AGENT_BROWSER_RESTORE_ENV] !== undefined && options.env[AGENT_BROWSER_RESTORE_ENV] !== ownedContext.restoreKey)
-        return false;
+    if (!ownedContext.reuseOnly) {
+        if (isDisabledEnvFlag(effectiveEnv[MANAGED_SESSION_RESTORE_ENV]))
+            return false;
+        if (MANAGED_RESTORE_INCOMPATIBLE_ENVS.some((name) => !MANAGED_SESSION_RESTORE_SPAWN_PINNED_ENVS.has(name) && hasUpstreamEnvValue(effectiveEnv, name)))
+            return false;
+        if (MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS.some((name) => isUpstreamEnvFlagEnabled(effectiveEnv[name])))
+            return false;
+        if (options.env?.[AGENT_BROWSER_RESTORE_ENV] !== undefined && options.env[AGENT_BROWSER_RESTORE_ENV] !== ownedContext.restoreKey)
+            return false;
+    }
     return ensureManagedSessionRestoreStorageIsSecure({ ...effectiveEnv, ...ownedContext.protectedStorageEnv }, process.platform, namespace);
 }
 export function getManagedSessionRestoreEnv(options) {
     const { namespace, owned, ownedContext, parentEnv, restoreState, sessionName } = resolveManagedSessionRestorePolicy(options);
     if (!owned || !restoreState || closesBrowserSession(options.args))
         return {};
+    if (ownedContext?.reuseOnly) {
+        return ownedContext.restoreKey && !ownedContext.restoreSuppressed && validateManagedSessionRestoreContextForSpawn(options)
+            ? { [AGENT_BROWSER_RESTORE_ENV]: ownedContext.restoreKey }
+            : {};
+    }
     if (ownedContext?.restoreDecision) {
         if (ownedContext.restoreDecision !== "enabled" || restoreState.isDisabled(sessionName, namespace) || !sessionName || !ownedContext.restoreKey || !validateManagedSessionRestoreContextForSpawn(options))
             return {};
@@ -244,7 +257,7 @@ export function getManagedSessionRestoreEnv(options) {
 /** Commit sticky suppression only after an owned-context subprocess has actually started. */
 export function commitManagedSessionRestoreSuppression(options) {
     const { namespace, owned, ownedContext, parentEnv, restoreState, sessionName } = resolveManagedSessionRestorePolicy(options);
-    if (!owned || !restoreState || closesBrowserSession(options.args))
+    if (!owned || !restoreState || ownedContext?.reuseOnly || closesBrowserSession(options.args))
         return;
     if (ownedContext?.restoreDecision) {
         const alreadyDisabled = restoreState.isDisabled(sessionName, namespace);
@@ -272,6 +285,23 @@ export function buildOwnedManagedSessionRestoreContext(options) {
     if (!owned)
         return undefined;
     const ownedCwd = owned.cwd ?? options.cwd;
+    if (options.reuseOnly) {
+        const env = { ...(options.parentEnv ?? getAgentBrowserProcessEnvironment()), ...options.env };
+        const enabled = !options.restoreState.isDisabled(owned.sessionName, owned.namespace);
+        const restoreScope = getManagedSessionRestoreScope(owned.sessionName);
+        const knownKey = options.restoreState.getDaemonRestoreKey(owned.sessionName, owned.namespace);
+        const restoreKey = knownKey === undefined && enabled && hasManagedSessionRestoreProjectIdentity(ownedCwd)
+            ? createManagedSessionRestoreKey(ownedCwd, restoreScope)
+            : knownKey;
+        return { ...owned, reuseOnly: true, restoreKey: restoreKey ?? undefined, restoreScope,
+            protectedStorageEnv: enabled ? getManagedSessionRestoreProtectedStorageEnv(true, env) : undefined,
+            restoreDecision: enabled ? "enabled" : undefined,
+            restoreSuppressed: managedSessionRestoreOptedOut(options) || agentBrowserExplicitConfigIsPresent(env, options.args)
+                || ["--restore", "--session-name"].some(flag => hasLaunchScopedFlagToken(options.args, flag))
+                || env.AGENT_BROWSER_RESTORE !== undefined || env.AGENT_BROWSER_SESSION_NAME !== undefined,
+            headedManagedAutosaveDisabled: options.headedManagedAutosaveDisabled,
+            headedManagedAutosaveInterval: options.headedManagedAutosaveInterval };
+    }
     const policyOptions = {
         args: options.args,
         cwd: ownedCwd,

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

@@ -1,6 +1,7 @@
 import { stat } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 import { isCloseCommand, isOpenNavigationCommand } from "../../command-taxonomy.js";
+import { isBrowserIndependentRead } from "../../command-policy.js";
 import { boundElectronProbeString } from "../../electron/cdp.js";
 import { executableExistsOnPath } from "../../executable-path.js";
 import { formatSessionArtifactRetentionSummary } from "../../results/artifact-manifest.js";
@@ -859,6 +860,8 @@ function buildTimeoutProgressSteps(options) {
     };
 }
 export async function collectTimeoutPartialProgress(options) {
+    if ((options.commandTokens[0] === "session" && options.commandTokens[1] === "info") || isBrowserIndependentRead(options.commandTokens, options.stdin))
+        return undefined;
     const rawSteps = getTimeoutProgressSteps(options.compiledJob, options.commandTokens, options.stdin);
     const artifacts = await collectTimeoutArtifactEvidence(options.cwd, rawSteps);
     const urlData = await runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName });

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

@@ -86,7 +86,7 @@ export function redactRecoveryHint(recoveryHint) {
 }
 export function buildJsonVisibleContent(options) {
     const { error, presentation, succeeded, warnings } = options;
-    const payload = redactSensitiveValue({ artifacts: presentation.artifacts, data: presentation.data, error, success: succeeded, warnings: warnings && warnings.length > 0 ? warnings : undefined });
+    const payload = redactSensitiveValue({ artifacts: presentation.artifacts, data: presentation.data, error, recordingRecovery: presentation.recordingRecovery, readConfirmation: presentation.readConfirmation, success: succeeded, warnings: warnings && warnings.length > 0 ? warnings : undefined });
     if (isRecord(payload) && isRecord(payload.data) && isRecord(presentation.data) && typeof presentation.data.wsUrl === "string")
         payload.data.wsUrl = presentation.data.wsUrl;
     const images = presentation.content.filter((item) => item.type === "image");
@@ -205,6 +205,8 @@ export async function prepareFinalResultRecoveryState(options) {
     return { categoryDetails, currentRefSnapshot, currentRefSnapshotInvalidation, noActivePageSnapshotFailure, richInputRecoveryDiagnostic, visibleRefFallbackDiagnostic, visibleRefFallbackSessionName };
 }
 function buildTimeoutPartialProgressNextActions(options) {
+    if (options.executionPlan.commandInfo.command === "session" && options.executionPlan.commandInfo.subcommand === "info")
+        return [];
     const retry = options.timeoutPartialProgress?.retryStep?.retry;
     const stepIndex = options.timeoutPartialProgress?.retryStep?.index;
     const freshSessionAbandoned = options.sessionMode === "fresh" && options.timeoutPartialProgress?.liveUrlRecovered !== true;
@@ -271,6 +273,8 @@ function buildDialogTimeoutNextActions(options) {
     ];
 }
 function buildResultNextActions(options) {
+    if (options.presentation.recordingRecovery || options.presentation.readConfirmation)
+        return options.presentation.nextActions;
     let nextActions = options.presentation.nextActions ? [...options.presentation.nextActions] : [];
     const append = (actions) => {
         if (actions && actions.length > 0)
@@ -371,7 +375,7 @@ function formatReadExecutionText(options, lifecycle) {
     const source = getReadSource(options);
     if (!source)
         return undefined;
-    return `Read execution: source ${source}; CLI started: ${options.processResult.agentBrowserStarted ? "yes" : "no"}; managed browser lifecycle active: ${lifecycle?.effectiveLaunch.browserLaunched === true ? "yes" : "no"}; managed session outcome: ${options.managedSessionOutcome?.status ?? "not managed"}.`;
+    return `Read execution: source ${source}; CLI started: ${options.processResult.agentBrowserStarted ? "yes" : "no"}; reported browserLaunched: ${lifecycle ? String(lifecycle.effectiveLaunch.browserLaunched) : "unknown"}; managed session outcome: ${options.managedSessionOutcome?.status ?? "not managed"}. An HTTP read does not establish shared-browser liveness; use session info for that.`;
 }
 function buildBrowserWindowStatus(options, lifecycle) {
     if (!options.headedLaunch || options.preserveAttachedBrowserSession || options.providerLaunch || !options.succeeded || lifecycle?.effectiveLaunch.browserLaunched !== true || !options.executionPlan.managedSessionName || !options.managedSessionOutcome || !["created", "replaced"].includes(options.managedSessionOutcome.status))
@@ -417,6 +421,8 @@ function buildAgentBrowserResultDetails(options, nextActions) {
         browserWindow,
         lifecycle,
         readSource: getReadSource(options),
+        recordingRecovery: options.presentation.recordingRecovery,
+        readConfirmation: options.presentation.readConfirmation,
         aboutBlankSessionMismatch: options.aboutBlankSessionMismatch,
         electronPostCommandHealth: options.electronPostCommandHealth,
         electronRefFreshness: options.electronRefFreshnessDiagnostic,

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

@@ -31,6 +31,7 @@ async function runAgentBrowserToolInContext(options) {
             const artifactRunStartedAtMs = Date.now();
             const processResult = await runAgentBrowserProcess({
                 args: prepared.processArgs,
+                browserIndependentReadConfirmation: prepared.readConfirmation !== undefined,
                 cwd: options.cwd,
                 env: ownedManagedSession
                     ? { AGENT_BROWSER_IDLE_TIMEOUT_MS: options.implicitSessionIdleTimeoutMs }

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

@@ -1,5 +1,6 @@
 import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS } from "../../../argv-grammar.js";
 import { isOpenNavigationCommand } from "../../../command-taxonomy.js";
+import { getExplicitReadUrl, isBrowserIndependentRead } from "../../../command-policy.js";
 import { getAgentBrowserProcessTimeoutMs } from "../../../process.js";
 import { getUpstreamEffectiveBatchSteps } from "../../batch-stdin.js";
 const POSITIONAL_VALUE_FLAGS = new Set([...VALUE_FLAGS, "--llms"]);
@@ -44,10 +45,10 @@ export function findFirstPositionalArgument(commandTokens) {
     return undefined;
 }
 function readUsesActivePageUrl(commandTokens) {
-    return findFirstPositionalArgument(commandTokens) === undefined && commandTokens.some((token) => token === "--require-md" || token === "--llms" || token.startsWith("--llms="));
+    return !isBrowserIndependentRead(commandTokens) && commandTokens.some((token) => token === "--require-md" || token === "--llms" || token.startsWith("--llms="));
 }
 function readRequestBudget(commandTokens, activePageUrl) {
-    const target = findFirstPositionalArgument(commandTokens) ?? activePageUrl;
+    const target = getExplicitReadUrl(commandTokens) ?? activePageUrl;
     if (target === undefined)
         return 1;
     let url;

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";
@@ -421,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,
@@ -428,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,
@@ -446,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");
@@ -471,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);
@@ -481,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,
@@ -500,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,
@@ -550,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"
@@ -573,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,
@@ -613,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;
@@ -1050,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,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 });