pi-agent-browser-native 0.6.6 → 0.6.8

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

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { extractUpstreamCommandTokens, parseCommandInfo } from "./argv-descriptor.js";
-import { canonicalizeAgentBrowserNamespace, extractExplicitNamespace, extractExplicitSessionName, extractRequestedRestoreKey, getAgentBrowserSessionIdentityKey, isUpstreamEnvFlagEnabled, scanUpstreamGlobalFlagOccurrences, } from "./argv-grammar.js";
+import { canonicalizeAgentBrowserNamespace, extractExplicitNamespace, extractExplicitSessionName, extractRequestedRestoreKey, getAgentBrowserSessionIdentityKey, isUpstreamEnvFlagEnabled, resolveAgentBrowserNamespace, scanUpstreamGlobalFlagOccurrences, } from "./argv-grammar.js";
 import { hasLaunchScopedFlagToken, MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS, MANAGED_RESTORE_INCOMPATIBLE_ENVS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS, } from "./launch-scoped-flags.js";
 import { createManagedSessionRestoreKey, ensureManagedSessionRestoreStorageIsSecure, getManagedSessionRestoreScope, getManagedSessionRestoreProtectedStorageEnv, hasManagedSessionRestoreProjectIdentity, resolveManagedSessionRestoreHome, } from "./managed-session-storage.js";
 import { parseUserBatchStdin } from "./orchestration/batch-stdin.js";
@@ -11,7 +11,7 @@ const AGENT_BROWSER_CONFIG_ENV = "AGENT_BROWSER_CONFIG";
 const AGENT_BROWSER_RESTORE_ENV = "AGENT_BROWSER_RESTORE";
 const MANAGED_SESSION_RESTORE_ENV = "PI_AGENT_BROWSER_MANAGED_SESSION_RESTORE";
 export const MANAGED_SESSION_NAME_PREFIX = "piab-";
-const MANAGED_SESSION_RESTORE_SPAWN_PINNED_ENVS = new Set([AGENT_BROWSER_CONFIG_ENV, AGENT_BROWSER_RESTORE_ENV, "AGENT_BROWSER_NAMESPACE"]);
+const MANAGED_SESSION_RESTORE_SPAWN_PINNED_ENVS = new Set([AGENT_BROWSER_CONFIG_ENV, AGENT_BROWSER_RESTORE_ENV]);
 function isDisabledEnvFlag(value) {
     if (value === undefined)
         return false;
@@ -86,12 +86,13 @@ export function resolveOwnedManagedSessionContext(options) {
     }
     return undefined;
 }
-function ownedContextMatches(sessionName, namespace) {
+function ownedContextMatches(sessionName, args) {
     const owned = ownedManagedSessionStorage.getStore();
-    return owned && sessionName === owned.sessionName && canonicalizeAgentBrowserNamespace(namespace) === owned.namespace ? owned : undefined;
+    return owned && sessionName === owned.sessionName
+        && canonicalizeAgentBrowserNamespace(resolveAgentBrowserNamespace(args, owned.namespace)) === owned.namespace ? owned : undefined;
 }
 export function isOwnedManagedSessionTarget(args) {
-    return ownedContextMatches(extractExplicitSessionName(args), extractExplicitNamespace(args)) !== undefined;
+    return ownedContextMatches(extractExplicitSessionName(args), args) !== undefined;
 }
 function hasExplicitConfigArg(args) {
     return scanUpstreamGlobalFlagOccurrences(args, "--config").length > 0;
@@ -141,7 +142,7 @@ function managedSessionRestoreOptedOut(options) {
     const effectiveEnv = { ...(options.parentEnv ?? getAgentBrowserProcessEnvironment()), ...options.env };
     return isDisabledEnvFlag(effectiveEnv[MANAGED_SESSION_RESTORE_ENV]);
 }
-function isManagedSessionRestoreIncompatible(options) {
+function isManagedSessionRestoreIncompatible(options, namespace = extractExplicitNamespace(options.args)) {
     if (hasManagedSessionRestoreLaunchConflict(options))
         return true;
     if (managedSessionRestoreOptedOut(options))
@@ -152,13 +153,13 @@ function isManagedSessionRestoreIncompatible(options) {
         return true;
     if (options.cwd && agentBrowserConfigBlocksManagedRestore(options.cwd, effectiveEnv, args))
         return true;
-    return !ensureManagedSessionRestoreStorageIsSecure(effectiveEnv, process.platform, extractExplicitNamespace(args));
+    return !ensureManagedSessionRestoreStorageIsSecure(effectiveEnv, process.platform, namespace);
 }
 function resolveManagedSessionRestorePolicy(options) {
     const parentEnv = options.parentEnv ?? getAgentBrowserProcessEnvironment();
     const sessionName = extractExplicitSessionName(options.args);
-    const namespace = extractExplicitNamespace(options.args);
-    const ownedContext = ownedContextMatches(sessionName, namespace);
+    const ownedContext = ownedContextMatches(sessionName, options.args);
+    const namespace = ownedContext ? ownedContext.namespace : extractExplicitNamespace(options.args);
     const restoreState = ownedContext?.restoreState ?? options.restoreState;
     const owned = (options.ownedManagedSession || ownedContext !== undefined) && restoreState !== undefined;
     return { namespace, owned, ownedContext, parentEnv, restoreState, sessionName };
@@ -234,7 +235,7 @@ export function getManagedSessionRestoreEnv(options) {
         return { [AGENT_BROWSER_RESTORE_ENV]: ownedContext.restoreKey };
     }
     const policyOptions = { ...options, parentEnv };
-    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions))
+    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions, namespace))
         return {};
     if (restoreState.isDisabled(sessionName, namespace) || !sessionName)
         return {};
@@ -263,7 +264,7 @@ export function commitManagedSessionRestoreSuppression(options) {
         return;
     }
     const policyOptions = { ...options, parentEnv };
-    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions))
+    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions, namespace))
         restoreState.disable(sessionName, namespace);
 }
 export function buildOwnedManagedSessionRestoreContext(options) {
@@ -281,7 +282,7 @@ export function buildOwnedManagedSessionRestoreContext(options) {
     };
     const optedOut = managedSessionRestoreOptedOut(policyOptions);
     const projectIdentityAvailable = !optedOut && hasManagedSessionRestoreProjectIdentity(ownedCwd);
-    const incompatible = !optedOut && isManagedSessionRestoreIncompatible(policyOptions);
+    const incompatible = !optedOut && isManagedSessionRestoreIncompatible(policyOptions, owned.namespace);
     const enabled = !optedOut && !incompatible;
     const effectiveEnv = { ...(options.parentEnv ?? getAgentBrowserProcessEnvironment()), ...options.env };
     const restoreScope = getManagedSessionRestoreScope(owned.sessionName);

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

@@ -1,45 +1,28 @@
-import { isRecord } from "../../parsing.js";
+import { isRecord, parseRefId } from "../../parsing.js";
 import { redactSensitiveText } from "../../runtime.js";
 import { withOptionalSessionArgs } from "../../results/next-actions.js";
 import { runSessionCommandData } from "./session-state.js";
 const CLICK_DISPATCH_MARKER_PREFIX = "__piAgentBrowserClickDispatchProbe_";
 const CLICK_DISPATCH_CLEANUP_TIMEOUT_MS = 2_000;
 const ACCESSIBLE_REF_CLICK_DISPATCH_ROLES = new Set(["button", "checkbox", "menuitem", "radio", "switch", "tab"]);
-function parseClickRefId(selector) {
-    const trimmed = selector.trim();
-    const candidate = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed.startsWith("ref=") ? trimmed.slice(4) : trimmed;
-    return /^e\d+$/.test(candidate) ? candidate : undefined;
-}
 function normalizeAccessibleName(name) {
     return name.replace(/\s+/g, " ").trim().toLowerCase();
 }
-function getAccessibleRefDuplicateIndex(refSnapshot, refId, role, name) {
-    if (!refSnapshot?.refs)
-        return undefined;
-    const normalizedRole = role.toLowerCase();
-    const normalizedName = normalizeAccessibleName(name);
-    const matchingRefIds = refSnapshot.refIds.filter((candidateRefId) => {
-        const candidate = refSnapshot.refs?.[candidateRefId];
-        return candidate?.role.toLowerCase() === normalizedRole && normalizeAccessibleName(candidate.name) === normalizedName;
-    });
-    if (matchingRefIds.length <= 1)
-        return undefined;
-    const duplicateIndex = matchingRefIds.indexOf(refId);
-    return duplicateIndex >= 0 ? duplicateIndex : undefined;
-}
 function getClickDispatchProbeTarget(commandTokens, refSnapshot) {
     if (commandTokens[0] !== "click" || commandTokens.includes("--new-tab"))
         return undefined;
     const selector = commandTokens[1];
     if (!selector || selector.startsWith("-"))
         return undefined;
-    const refId = parseClickRefId(selector);
+    const refId = parseRefId(selector);
     if (refId) {
         const ref = refSnapshot?.refs?.[refId];
         if (!ref || !ACCESSIBLE_REF_CLICK_DISPATCH_ROLES.has(ref.role))
             return undefined;
-        const duplicateIndex = getAccessibleRefDuplicateIndex(refSnapshot, refId, ref.role, ref.name);
-        return { ...(duplicateIndex === undefined ? {} : { duplicateIndex }), kind: "accessible", name: ref.name, refId, role: ref.role };
+        const matchingRefs = Object.values(refSnapshot?.refs ?? {}).filter((candidate) => candidate.role.toLowerCase() === ref.role.toLowerCase() && normalizeAccessibleName(candidate.name) === normalizeAccessibleName(ref.name));
+        if (matchingRefs.length !== 1)
+            return undefined;
+        return { kind: "accessible", name: ref.name, refId, role: ref.role };
     }
     if (selector.startsWith("xpath="))
         return { kind: "xpath", selector: selector.slice("xpath=".length) };
@@ -58,7 +41,6 @@ function buildClickDispatchProbeInstallScript(probe) {
   const normalize = (value) => String(value ?? "").replace(/\\s+/g, " ").trim();
   const expectedRole = ${JSON.stringify(target.role)};
   const expectedName = normalize(${JSON.stringify(target.name)});
-  const duplicateIndex = ${JSON.stringify(target.duplicateIndex)};
   const inferRole = (element) => {
     const explicit = element.getAttribute("role");
     if (explicit) return explicit;
@@ -81,7 +63,6 @@ function buildClickDispatchProbeInstallScript(probe) {
     return element.getClientRects().length > 0;
   };
   const candidates = Array.from(document.querySelectorAll("button,a[href],input,select,textarea,summary,[role],[onclick],[tabindex]")).filter((element) => inferRole(element) === expectedRole && inferName(element) === expectedName && isVisible(element));
-  if (typeof duplicateIndex === "number") return candidates[duplicateIndex] || null;
   return candidates.length === 1 ? candidates[0] : null;
 })()`;
     return `(() => {

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

@@ -4,7 +4,7 @@ import { isCloseCommand, isOpenNavigationCommand } from "../../command-taxonomy.
 import { boundElectronProbeString } from "../../electron/cdp.js";
 import { executableExistsOnPath } from "../../executable-path.js";
 import { formatSessionArtifactRetentionSummary } from "../../results/artifact-manifest.js";
-import { buildNextToolAction, withOptionalSessionArgs } from "../../results/next-actions.js";
+import { buildInspectOverlayStateAction, buildNextToolAction, withOptionalSessionArgs } from "../../results/next-actions.js";
 import { buildVisibleRefFallbackDiagnosticFromSnapshot, getVisibleRefFallbackTarget } from "../../results/selector-recovery.js";
 import { extractRefSnapshotFromData, isAboutBlankUrl, normalizeComparableUrl } from "../../session-page-state.js";
 import { extractUpstreamCommandTokens, parseWaitCommandTokens, redactInvocationArgs, redactSensitiveText } from "../../runtime.js";
@@ -266,7 +266,7 @@ export function formatOverlayBlockerText(diagnostic) {
     return ["Possible overlay blockers:", ...diagnostic.candidates.map((candidate) => `- ${candidate.ref}${candidate.role ? ` ${candidate.role}` : ""}${candidate.name ? ` ${JSON.stringify(candidate.name)}` : ""}: ${candidate.reason}`)].join("\n");
 }
 export function buildOverlayBlockerNextActions(options) {
-    return [{ id: "inspect-overlay-state", params: { args: withOptionalSessionArgs(options.sessionName, ["snapshot", "-i"]) }, reason: "Refresh interactive refs and inspect whether an overlay, banner, modal, or dialog is blocking the intended click.", safety: "Read-only inspection; use current refs from this snapshot before interacting.", tool: "agent_browser" }, ...options.diagnostic.candidates.map((candidate, index) => ({ id: `try-overlay-blocker-candidate-${index + 1}`, params: { args: withOptionalSessionArgs(options.sessionName, candidate.args) }, reason: candidate.reason, safety: "Only click this if the candidate is clearly a close/dismiss control for an overlay that blocks the intended workflow.", tool: "agent_browser" }))];
+    return [buildInspectOverlayStateAction(options.sessionName), ...options.diagnostic.candidates.map((candidate, index) => ({ id: `try-overlay-blocker-candidate-${index + 1}`, params: { args: withOptionalSessionArgs(options.sessionName, candidate.args) }, reason: candidate.reason, safety: "Only click this if the candidate is clearly a close/dismiss control for an overlay that blocks the intended workflow.", tool: "agent_browser" }))];
 }
 export function collectSnapshotOverlayBlockerDiagnostic(data) {
     const candidates = getOverlayBlockerCandidates(data);

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

@@ -54,10 +54,9 @@ export function buildSemanticActionCandidateActions(compiled) {
     return [];
 }
 export function buildWrapperRecoveryHint(options) {
-    const wrapperManagedContexts = [options.sessionTabCorrection ? "session tab correction" : undefined, options.pinnedBatchUnwrapMode ? "pinned batch routing" : undefined].filter((item) => item !== undefined);
-    if (wrapperManagedContexts.length === 0)
+    if (!options.sessionTabCorrection)
         return undefined;
-    return `Wrapper recovery hint: this call used ${wrapperManagedContexts.join(" and ")}. Inspect details.effectiveArgs and details.sessionTabCorrection; if the selected tab looks wrong, run tab list for the same session before retrying.`;
+    return "Wrapper recovery hint: this call used session tab correction. Inspect details.effectiveArgs and details.sessionTabCorrection; if the selected tab looks wrong, run tab list for the same session before retrying.";
 }
 export function redactExactSensitiveText(text, sensitiveValues) {
     let redacted = text;

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

@@ -1,14 +1,22 @@
 import { runAgentBrowserProcess, withAttachedBrowserSessionContext } from "../../process.js";
+import { isRecord } from "../../parsing.js";
 import { withOwnedManagedSessionContext } from "../../managed-session-restore.js";
 import { cleanupClickDispatchProbe } from "./click-dispatch.js";
-import { applyBrowserRunStatePatch } from "./session-state.js";
+import { applyBrowserRunStatePatch, getSessionContextKey } from "./session-state.js";
 import { buildMissingBinaryFailureResult } from "./final-result.js";
 import { prepareBrowserRun } from "./prepare.js";
 import { processBrowserOutput } from "./process-output.js";
 export { closeManagedSession } from "./managed-session-daemon-policy.js";
 export { getSessionContextKey } from "./session-state.js";
 export async function runAgentBrowserTool(options) {
-    return await withAttachedBrowserSessionContext(options.preserveAttachedBrowserSession === true, () => runAgentBrowserToolInContext(options));
+    const result = await withAttachedBrowserSessionContext(options.preserveAttachedBrowserSession === true, () => runAgentBrowserToolInContext(options));
+    const details = isRecord(result.details) ? result.details : undefined;
+    const sessionKey = getSessionContextKey(typeof details?.sessionName === "string" ? details.sessionName : undefined, typeof details?.namespace === "string" ? details.namespace : undefined);
+    const page = options.state.sessionPageState.get(sessionKey);
+    return page.tabReopenPending === undefined ? result : {
+        ...result,
+        details: { ...details, sessionTabReopenPending: page.tabReopenPending, ...(page.refSnapshotInvalidation ? { refSnapshotInvalidation: page.refSnapshotInvalidation } : {}) },
+    };
 }
 async function runAgentBrowserToolInContext(options) {
     const preparedResult = await prepareBrowserRun(options);
@@ -34,7 +42,6 @@ async function runAgentBrowserToolInContext(options) {
                 signal: options.signal,
                 stdin: prepared.processStdin,
                 timeoutMs: prepared.processTimeoutMs,
-                trustedFirstBatchTabSelection: prepared.pinnedBatchUnwrapMode !== undefined,
             });
             const missingBinaryResult = await buildMissingBinaryFailureResult({
                 compatibilityWorkaround: prepared.compatibilityWorkaround,

package/dist/extensions/agent-browser/lib/orchestration/browser-run/managed-session-daemon-policy.js

@@ -100,6 +100,9 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
         return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches
             ? {
+                cleanupOnlyReason: daemon.status === "active" && restoreDisabledPolicyNeedsProvenance && !hasKnownDaemonRestoreKey
+                    ? "restore-disabled-daemon-without-provenance"
+                    : undefined,
                 daemonStatus: daemon.status,
                 error: [
                     "This wrapper-owned session's live daemon does not match the requested managed-restore policy.",

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

@@ -25,7 +25,7 @@ function findCommandTimeoutMs(commandTokens) {
     const firstWaitArgument = commandTokens[0] === "wait" ? commandTokens[1] : undefined;
     return firstWaitArgument && !firstWaitArgument.startsWith("-") ? parseMillisecondsToken(firstWaitArgument) : undefined;
 }
-function findFirstPositionalArgument(commandTokens) {
+export function findFirstPositionalArgument(commandTokens) {
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
         const flag = token.split("=", 1)[0];

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

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