@steipete/oracle 0.17.3 → 0.19.0

package/dist/src/browser/index.js

@@ -4,23 +4,26 @@ import os from "node:os";
 import net from "node:net";
 import { resolveBrowserConfig } from "./config.js";
 import { copyChromeProfile } from "./profileCopy.js";
-import { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, connectToRemoteChrome, connectWithNewTab, closeTab, createChromePageTarget, ensureChromePageTargetAfterClose, closeBlankChromeTabs, } from "./chromeLifecycle.js";
+import { BrowserCancellation, withoutBrowserCancellation } from "./cancellation.js";
+import { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, positionChromeWindowOnscreen, connectToRemoteChrome, connectWithNewTab, closeTab, createChromePageTarget, ensureChromePageTargetAfterClose, closeBlankChromeTabs, } from "./chromeLifecycle.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, captureComposerNavigationUrl, assertComposerPlusStayedInPlace, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
 import { INPUT_SELECTORS } from "./constants.js";
 import { uploadAttachmentViaDataTransfer } from "./actions/remoteFileTransfer.js";
 import { ensureThinkingTime } from "./actions/thinkingTime.js";
+import { throwIfAssistantUiError } from "./actions/assistantResponse.js";
 import { startThinkingStatusMonitor } from "./actions/thinkingStatus.js";
 import { activateDeepResearch, captureDeepResearchTargetKeys, waitForDeepResearchCompletion, waitForResearchPlanAutoConfirm, } from "./actions/deepResearch.js";
 import { estimateTokenCount, withRetries, delay } from "./utils.js";
 import { formatElapsed } from "../oracle/format.js";
 import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY } from "./constants.js";
-import { BrowserAutomationError } from "../oracle/errors.js";
+import { BrowserAutomationError, BrowserRunCancelledError } from "../oracle/errors.js";
+import { buildAttachmentBasenameCollisionDetails, findAttachmentBasenameCollisions, formatAttachmentBasenameCollisionMessage, } from "./attachmentValidation.js";
 import { alignPromptEchoPair, buildPromptEchoMatcher } from "./reattachHelpers.js";
 import { buildConversationTurnCountExpression } from "./conversationTurns.js";
 import { cleanupStaleProfileState, acquireProfileRunLock, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, terminateRecordedChromeForProfile, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
 import { connectionLostUserMessage, isRecoverableChromeDisconnect, probeChromeTargetLiveness, } from "./cdpLiveness.js";
-import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
+import { acquireBrowserTabLease } from "./tabLeaseRegistry.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
 import { collectGeneratedImageArtifacts } from "./chatgptImages.js";
 import { collectChatGptFileArtifacts } from "./chatgptFiles.js";
@@ -32,7 +35,7 @@ import { captureBrowserDiagnostics } from "./domDebug.js";
 import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./actions/archiveConversation.js";
 import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
-import { shouldSyncBrowserCookies } from "./policies.js";
+import { CHROME_COOKIE_SYNC_WARNING, shouldSyncBrowserCookies } from "./policies.js";
 import { createConversationUrlMonitor, } from "./conversationUrlMonitor.js";
 import { extractStableConversationIdFromUrl as extractConversationIdFromUrl, isStableConversationUrl as isConversationUrl, } from "./conversationUrl.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
@@ -58,7 +61,7 @@ function isReattachableCaptureError(error) {
     if (!(error instanceof BrowserAutomationError))
         return false;
     const stage = error.details?.stage;
-    return stage === "assistant-timeout" || stage === "assistant-recheck";
+    return (stage === "assistant-timeout" || stage === "assistant-recheck" || stage === "assistant-ui-error");
 }
 function classifyPreservedBrowserError(error, headless) {
     if (headless)
@@ -86,6 +89,11 @@ export function shouldPreserveBrowserOnErrorForTest(error, headless) {
 export function classifyPreservedBrowserErrorForTest(error, headless) {
     return classifyPreservedBrowserError(error, headless);
 }
+function shouldApplyThinkingTimeSelection(config) {
+    // Deep Research uses the same effort picker, so research mode must not
+    // suppress an explicitly configured thinking-time selection.
+    return config.thinkingTime !== undefined;
+}
 const MAX_CHATGPT_UI_WARNING_CHARS = 300;
 const MAX_CHATGPT_UI_WARNINGS = 3;
 function classifyChatGptUiWarningText(text) {
@@ -318,6 +326,17 @@ function hasBrowserErrorCode(error, code) {
     return (error instanceof BrowserAutomationError &&
         error.details?.code === code);
 }
+function assertUniqueAttachmentBasenames(attachments, options) {
+    const collisions = findAttachmentBasenameCollisions(attachments);
+    if (collisions.length === 0)
+        return;
+    const collisionDetails = buildAttachmentBasenameCollisionDetails(collisions, (attachment) => attachment.displayPath || attachment.path);
+    throw new BrowserAutomationError(formatAttachmentBasenameCollisionMessage(options.subject, collisionDetails.collisions), {
+        stage: options.stage,
+        code: "attachment-basename-collision",
+        ...collisionDetails,
+    });
+}
 async function saveOptionalArtifact(operation, logger) {
     try {
         return await operation();
@@ -357,10 +376,12 @@ async function pollGeneratedImageOrTextAssistantResponse(Runtime, timeoutMs, min
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         let snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId).catch(() => null);
+        throwIfAssistantUiError(snapshot);
         if (!snapshot && typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex)) {
             const relaxedSnapshot = await readAssistantSnapshot(Runtime, undefined, expectedConversationId).catch(() => null);
             const relaxedHtml = typeof relaxedSnapshot?.html === "string" ? relaxedSnapshot.html : "";
-            if (relaxedHtml.includes("/backend-api/estuary/content?id=file_")) {
+            if (!relaxedSnapshot?.uiError &&
+                relaxedHtml.includes("/backend-api/estuary/content?id=file_")) {
                 snapshot = relaxedSnapshot;
             }
         }
@@ -491,6 +512,13 @@ async function runSubmissionWithRecovery({ prompt, attachments, fallbackSubmissi
             if (fallbackSubmission && isPromptTooLarge && !usedFallbackSubmission) {
                 usedFallbackSubmission = true;
                 logger("[browser] Inline prompt too large; retrying with file uploads.");
+                if (fallbackSubmission.prepare) {
+                    await fallbackSubmission.prepare();
+                }
+                assertUniqueAttachmentBasenames(fallbackSubmission.attachments, {
+                    stage: "upload-fallback",
+                    subject: "The inline prompt was too large, but its upload fallback",
+                });
                 await prepareFallbackSubmission();
                 currentPrompt = fallbackSubmission.prompt;
                 currentAttachments = fallbackSubmission.attachments;
@@ -541,9 +569,11 @@ async function closeRemoteConnectionAfterRun(options) {
     }
 }
 function shouldCloseOwnedRunTargetAfterRun(options) {
-    return (options.runStatus === "complete" &&
-        options.ownsTarget &&
-        (Boolean(options.closeOwnedTabOnComplete) || !options.keepBrowser));
+    return (options.ownsTarget &&
+        ((options.runStatus === "cancelled" &&
+            (options.closeOwnedTabOnCancel ?? !options.keepBrowser)) ||
+            (options.runStatus === "complete" &&
+                (Boolean(options.closeOwnedTabOnComplete) || !options.keepBrowser))));
 }
 function shouldCleanupBlankTabsAfterLastLease(options) {
     return (options.runStatus === "complete" &&
@@ -553,6 +583,79 @@ function shouldCleanupBlankTabsAfterLastLease(options) {
         options.keepBrowser &&
         Boolean(options.chromePort));
 }
+async function releaseLocalBrowserTabLease(options) {
+    let decisionObserved = false;
+    let keepBrowserOpen = false;
+    let terminationHandled = false;
+    let otherLeasesRemain = false;
+    let releaseError;
+    try {
+        await options.lease.release({
+            onRelease: async ({ isLastLease }) => {
+                decisionObserved = true;
+                if (!isLastLease) {
+                    // Record this before any best-effort tab cleanup so a cleanup failure can
+                    // never fall through into terminating Chrome used by another lease.
+                    keepBrowserOpen = true;
+                    otherLeasesRemain = true;
+                }
+                await options.closeOwnedRunTarget().catch(() => undefined);
+                if (!isLastLease) {
+                    return;
+                }
+                await options.cleanupBlankTabs().catch(() => undefined);
+                if (options.terminateSharedChrome) {
+                    options.logger(`[browser] ChatGPT browser slot ${options.lease.id.slice(0, 8)} is final; ` +
+                        `terminating shared Chrome (${formatBrowserLeaseDiagnostics(options)}).`);
+                    const terminated = await options.terminateSharedChrome().catch(() => false);
+                    if (terminated) {
+                        terminationHandled = true;
+                    }
+                    else {
+                        // A reused Chrome handle may have a no-op kill implementation. Never
+                        // claim cleanup or fall through into an unverified lock-free kill.
+                        keepBrowserOpen = true;
+                        options.logger("[browser] Could not verify shared Chrome termination; leaving it available for reuse.");
+                    }
+                }
+            },
+        });
+    }
+    catch (error) {
+        releaseError = error instanceof Error ? error : new Error(String(error));
+        if (!terminationHandled)
+            keepBrowserOpen = true;
+        options.logger(`[browser] Failed to release the ChatGPT browser slot registry lock; restart Oracle/Codex MCP before another browser run: ${releaseError.message}`);
+    }
+    if (!decisionObserved) {
+        options.logger("[browser] Could not verify final ChatGPT tab lease; leaving shared Chrome running.");
+        return {
+            keepBrowserOpen: true,
+            terminationHandled: false,
+            ...(releaseError ? { releaseError } : {}),
+        };
+    }
+    if (otherLeasesRemain) {
+        options.logger(`[browser] Other ChatGPT tab leases still active; leaving shared Chrome running; ` +
+            `browser slot ${options.lease.id.slice(0, 8)} is non-final ` +
+            `(${formatBrowserLeaseDiagnostics(options)}).`);
+    }
+    return {
+        keepBrowserOpen,
+        terminationHandled,
+        ...(releaseError ? { releaseError } : {}),
+    };
+}
+function formatBrowserLeaseDiagnostics(options) {
+    return [
+        `session=${options.sessionId ?? "unknown"}`,
+        `controllerPid=${process.pid}`,
+        `chromePid=${options.chromePid ?? "unknown"}`,
+        `chromePort=${options.chromePort ?? "unknown"}`,
+        `target=${options.chromeTargetId ?? "unknown"}`,
+        `launch=${options.launchDisposition ?? "unknown"}`,
+    ].join("; ");
+}
 function buildSkippedModelSelectionEvidence(desiredModel, strategy) {
     return {
         requestedModel: desiredModel ?? null,
@@ -565,11 +668,25 @@ function buildSkippedModelSelectionEvidence(desiredModel, strategy) {
     };
 }
 export async function runBrowserMode(options) {
+    const cancellation = new BrowserCancellation(options.signal, options.log);
+    try {
+        cancellation.check();
+        return await cancellation.run(() => runBrowserModeInternal(options, cancellation));
+    }
+    finally {
+        cancellation.dispose();
+    }
+}
+async function runBrowserModeInternal(options, cancellation) {
+    const attachments = options.attachments ?? [];
+    assertUniqueAttachmentBasenames(attachments, {
+        stage: "upload",
+        subject: "Browser upload",
+    });
     const promptText = options.prompt?.trim();
     if (!promptText) {
         throw new Error("Prompt text is required when using browser mode.");
     }
-    const attachments = options.attachments ?? [];
     const fallbackSubmission = options.fallbackSubmission;
     let config = resolveBrowserConfig(options.config);
     const usingCopiedProfile = Boolean(config.copyProfileSource);
@@ -596,6 +713,7 @@ export async function runBrowserMode(options) {
     let lastUrl;
     let promptSubmitted = false;
     let modelSelectionEvidence;
+    let thinkingSelectionEvidence;
     let tabLease = null;
     let conversationUrlMonitor = null;
     const emitRuntimeHint = async () => {
@@ -646,7 +764,7 @@ export async function runBrowserMode(options) {
         logger(line);
     }
     if (config.attachRunning) {
-        const attached = await resolveAttachRunningConnection(config, logger);
+        const attached = await cancellation.call(() => resolveAttachRunningConnection(config, logger));
         config = {
             ...config,
             remoteChrome: { host: attached.host, port: attached.port },
@@ -656,7 +774,7 @@ export async function runBrowserMode(options) {
     }
     if (!config.remoteChrome && !config.manualLogin) {
         const preferredPort = config.debugPort ?? DEFAULT_DEBUG_PORT;
-        const availablePort = await pickAvailableDebugPort(preferredPort, logger);
+        const availablePort = await cancellation.call(() => pickAvailableDebugPort(preferredPort, logger));
         if (availablePort !== preferredPort) {
             logger(`DevTools port ${preferredPort} busy; using ${availablePort} to avoid attaching to stray Chrome.`);
         }
@@ -669,7 +787,7 @@ export async function runBrowserMode(options) {
         if (ignoredFlags.length > 0) {
             logger(`Note: --remote-chrome ignores local Chrome flags (${ignoredFlags.join(", ")}).`);
         }
-        return runRemoteBrowserMode(promptText, attachments, config, logger, options);
+        return runRemoteBrowserMode(promptText, attachments, config, logger, options, cancellation);
     }
     const manualLogin = Boolean(config.manualLogin);
     if (manualLogin && usingCopiedProfile) {
@@ -683,70 +801,82 @@ export async function runBrowserMode(options) {
         : defaultManualLoginProfileDir();
     const userDataDir = manualLogin
         ? manualProfileDir
-        : await mkdtemp(path.join(await resolveUserDataBaseDir(), "oracle-browser-"));
+        : await cancellation.acquire(async () => mkdtemp(path.join(await resolveUserDataBaseDir(), "oracle-browser-")), (dir) => rm(dir, { recursive: true, force: true }));
     const effectiveKeepBrowser = Boolean(config.keepBrowser);
-    if (manualLogin) {
-        // Learned: manual login reuses a persistent profile so cookies/SSO survive.
-        await mkdir(userDataDir, { recursive: true });
-        logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
-        await assertManualLoginProfileReadyForRun({
-            userDataDir,
-            keepBrowser: effectiveKeepBrowser,
-        });
-    }
-    else if (config.copyProfileSource) {
-        const copiedProfileDirectory = await copyChromeProfile(config.copyProfileSource, userDataDir, config.chromeProfile);
-        config = { ...config, chromeProfile: copiedProfileDirectory };
-        logger(`Seeded temporary Chrome profile ${copiedProfileDirectory} from ${config.copyProfileSource} (copy-profile mode; signed-in session reused without manual login)`);
+    try {
+        if (manualLogin) {
+            // Learned: manual login reuses a persistent profile so cookies/SSO survive.
+            await cancellation.call(() => mkdir(userDataDir, { recursive: true }));
+            logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+            await cancellation.call(() => assertManualLoginProfileReadyForRun({ userDataDir, keepBrowser: effectiveKeepBrowser }));
+        }
+        else if (config.copyProfileSource) {
+            const copying = copyChromeProfile(config.copyProfileSource, userDataDir, config.chromeProfile);
+            const copiedProfileDirectory = await cancellation.race(copying.finally(async () => {
+                if (options.signal?.aborted)
+                    await withoutBrowserCancellation(() => rm(userDataDir, { recursive: true, force: true }));
+            }));
+            config = { ...config, chromeProfile: copiedProfileDirectory };
+            logger(`Seeded temporary Chrome profile ${copiedProfileDirectory} from ${config.copyProfileSource} (copy-profile mode; signed-in session reused without manual login)`);
+        }
+        else {
+            logger(`Created temporary Chrome profile at ${userDataDir}`);
+        }
     }
-    else {
-        logger(`Created temporary Chrome profile at ${userDataDir}`);
+    catch (error) {
+        if (!manualLogin)
+            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
     }
     if (manualLogin) {
-        tabLease = await acquireBrowserTabLease(userDataDir, {
+        tabLease = await cancellation.acquire(() => acquireBrowserTabLease(userDataDir, {
             maxConcurrentTabs: config.maxConcurrentTabs,
             timeoutMs: config.timeoutMs,
             logger,
             sessionId: options.sessionId,
-        });
+            signal: options.signal,
+        }), (lease) => lease.release());
     }
     let acquiredChrome;
     try {
-        acquiredChrome = manualLogin
-            ? await acquireManualLoginChromeForRun(userDataDir, config, logger, options.sessionId)
-            : {
-                chrome: await launchChrome({
-                    ...config,
-                    remoteChrome: config.remoteChrome,
-                }, userDataDir, logger),
-                reusedChrome: null,
-            };
-    }
-    catch (error) {
-        if (tabLease) {
-            const handle = tabLease;
-            tabLease = null;
-            await handle.release().catch(() => undefined);
+        if (manualLogin) {
+            acquiredChrome = await cancellation.acquire(() => acquireManualLoginChromeForRun(userDataDir, config, logger, options.sessionId), async ({ chrome }) => {
+                detachKeptChromeProcess(chrome);
+            });
         }
-        if (usingCopiedProfile) {
-            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+        else {
+            const launched = await cancellation.acquire(() => launchChrome({ ...config, remoteChrome: config.remoteChrome }, userDataDir, logger), async (chrome) => {
+                try {
+                    await chrome.kill();
+                }
+                finally {
+                    await rm(userDataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+                }
+            });
+            acquiredChrome = { chrome: launched, reusedChrome: null };
         }
+    }
+    catch (error) {
+        await withoutBrowserCancellation(async () => {
+            if (tabLease) {
+                const handle = tabLease;
+                tabLease = null;
+                await handle.release().catch(() => undefined);
+            }
+            if (!manualLogin)
+                await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+        });
         throw error;
     }
     const { chrome, reusedChrome } = acquiredChrome;
     const chromeHost = chrome.host ?? "127.0.0.1";
-    if (tabLease) {
-        await tabLease.update({
-            chromeHost,
-            chromePort: chrome.port,
-        });
-    }
     let removeTerminationHooks = null;
     try {
         removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
             isInFlight: () => runStatus !== "complete",
             emitRuntimeHint,
             preserveUserDataDir: manualLogin,
+            preserveSharedChromeOnSignal: manualLogin,
             // copy-profile is a throwaway copy of a signed-in profile; never leave it on disk.
             forceProfileCleanup: usingCopiedProfile,
         });
@@ -768,14 +898,17 @@ export async function runBrowserMode(options) {
     let appliedCookies = 0;
     let preserveBrowserOnError = false;
     try {
+        if (tabLease)
+            await cancellation.call(() => tabLease.update({ chromeHost, chromePort: chrome.port }));
         try {
             if (config.browserTabRef) {
-                const attached = await connectToExistingChatGptTab({
+                const tabRef = config.browserTabRef;
+                const attached = await cancellation.acquire(() => connectToExistingChatGptTab({
                     host: chromeHost,
                     port: chrome.port,
-                    ref: config.browserTabRef,
-                });
-                client = attached.client;
+                    ref: tabRef,
+                }), (attached) => attached.client.close());
+                client = cancellation.client(attached.client);
                 isolatedTargetId = attached.targetId ?? null;
                 lastTargetId = attached.targetId ?? undefined;
                 lastUrl = attached.tab.url || lastUrl;
@@ -785,12 +918,16 @@ export async function runBrowserMode(options) {
             else {
                 const strictTabIsolation = Boolean(manualLogin && reusedChrome);
                 const devtoolsRetries = manualLogin ? 6 : 0;
-                const connection = await connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
+                const connection = await cancellation.acquire(() => connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
                     fallbackToDefault: !strictTabIsolation,
                     retries: devtoolsRetries,
                     retryDelayMs: 500,
+                }), async (connection) => {
+                    await connection.client.close().catch(() => undefined);
+                    if (connection.targetId)
+                        await closeTab(chrome.port, connection.targetId, logger, chromeHost);
                 });
-                client = connection.client;
+                client = cancellation.client(connection.client);
                 isolatedTargetId = connection.targetId ?? null;
                 ownsTarget = true;
             }
@@ -846,7 +983,7 @@ export async function runBrowserMode(options) {
                 })();
             });
         });
-        const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
+        const raceWithDisconnect = (promise) => cancellation.race(Promise.race([promise, disconnectPromise]));
         const { Network, Page, Runtime, Input, DOM, Target } = client;
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
         if (DOM && typeof DOM.enable === "function") {
@@ -854,7 +991,12 @@ export async function runBrowserMode(options) {
         }
         await Promise.all(domainEnablers);
         if (!config.headless && config.hideWindow) {
-            await positionChromeWindowOffscreen(client, logger);
+            await positionChromeWindowOffscreen(client, userDataDir, logger);
+        }
+        else if (!config.headless) {
+            // Persistent profiles can retain bounds from a prior hidden run. Visible
+            // local runs must actively restore the Oracle-owned Chrome window.
+            await positionChromeWindowOnscreen(client, userDataDir, logger);
         }
         // The send button is clicked with trusted CDP input events at viewport
         // coordinates, which ChatGPT silently drops when the window is hidden or
@@ -874,6 +1016,7 @@ export async function runBrowserMode(options) {
                 logger("Manual login mode: seeding persistent profile with cookies from your Chrome profile.");
             }
             if (!config.inlineCookies) {
+                logger(CHROME_COOKIE_SYNC_WARNING);
                 logger("Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.");
             }
             else {
@@ -902,7 +1045,7 @@ export async function runBrowserMode(options) {
         else {
             logger(manualLogin
                 ? "Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in."
-                : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
+                : "Skipping Chrome cookie copy (disabled by default; use --browser-cookie-sync to opt in).");
         }
         await clearStaleChatGptConversationCookies(Network, Target, logger, {
             preserveConversationIds: [
@@ -1075,16 +1218,14 @@ export async function runBrowserMode(options) {
                 : "Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
-        // Handle thinking time selection if specified. Deep Research owns its own effort flow.
-        const thinkingTime = config.thinkingTime;
-        if (thinkingTime && !deepResearch) {
+        if (shouldApplyThinkingTimeSelection(config)) {
             const thinkingTargetModel = modelStrategy === "select" ? config.desiredModel : null;
-            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger, thinkingTargetModel), {
+            thinkingSelectionEvidence = await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, config.thinkingTime, logger, thinkingTargetModel), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Thinking time (${config.thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             }));
@@ -1094,9 +1235,12 @@ export async function runBrowserMode(options) {
         const acquireProfileLockIfNeeded = async () => {
             if (profileLockTimeoutMs <= 0)
                 return;
-            profileLock = await acquireProfileRunLock(userDataDir, {
+            profileLock = await cancellation.acquire(() => acquireProfileRunLock(userDataDir, {
                 timeoutMs: profileLockTimeoutMs,
                 logger,
+                signal: options.signal,
+            }), async (lock) => {
+                await lock?.release();
             });
         };
         const releaseProfileLockIfHeld = async () => {
@@ -1104,7 +1248,7 @@ export async function runBrowserMode(options) {
                 return;
             const handle = profileLock;
             profileLock = null;
-            await handle.release().catch(() => undefined);
+            await withoutBrowserCancellation(() => handle.release()).catch(() => undefined);
         };
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
@@ -1115,17 +1259,20 @@ export async function runBrowserMode(options) {
                 generatedBundle: a.generatedBundle === true,
             }));
             let inputOnlyAttachments = false;
+            let attachmentNavigationUrl;
             await raceWithDisconnect(clearPromptComposer(Runtime, logger));
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
                     throw new Error("Chrome DOM domain unavailable while uploading attachments.");
                 }
+                attachmentNavigationUrl = await raceWithDisconnect(captureComposerNavigationUrl(Runtime));
                 await clearComposerAttachments(Runtime, 5_000, logger);
                 for (let attachmentIndex = 0; attachmentIndex < submissionAttachments.length; attachmentIndex += 1) {
                     const attachment = submissionAttachments[attachmentIndex];
+                    await raceWithDisconnect(assertComposerPlusStayedInPlace(Runtime, attachmentNavigationUrl));
                     logger(`Uploading attachment: ${attachment.displayPath}`);
-                    const uiConfirmed = await uploadAttachmentFile({ runtime: Runtime, dom: DOM, input: Input }, attachment, logger, { expectedCount: attachmentIndex + 1 });
+                    const uiConfirmed = await uploadAttachmentFile({ runtime: Runtime, dom: DOM, input: Input }, attachment, logger, { expectedCount: attachmentIndex + 1, navigationUrl: attachmentNavigationUrl });
                     if (!uiConfirmed) {
                         inputOnlyAttachments = true;
                     }
@@ -1157,12 +1304,14 @@ export async function runBrowserMode(options) {
             const providerState = {
                 runtime: Runtime,
                 input: Input,
+                page: Page,
                 logger,
                 timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 attachmentTimeoutMs: config.attachmentTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
                 attachmentNames: attachmentExpectations,
+                attachmentNavigationUrl,
                 onPromptSubmitted: markPromptSubmitted,
             };
             const deepResearchTargetBaseline = deepResearch && client
@@ -1277,6 +1426,7 @@ export async function runBrowserMode(options) {
                 artifacts: savedArtifacts,
                 archive,
                 modelSelection: modelSelectionEvidence,
+                thinkingSelection: thinkingSelectionEvidence,
                 tookMs: durationMs,
                 answerTokens: tokens,
                 answerChars: researchResult.text.length,
@@ -1301,6 +1451,7 @@ export async function runBrowserMode(options) {
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
                 const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                throwIfAssistantUiError(snapshot);
                 const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text) {
                     const normalized = normalizeForComparison(text);
@@ -1528,6 +1679,7 @@ export async function runBrowserMode(options) {
                 let stableCount = 0;
                 while (Date.now() < deadline) {
                     const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                    throwIfAssistantUiError(snapshot);
                     const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                     const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
                     if (!isStillEcho) {
@@ -1557,6 +1709,7 @@ export async function runBrowserMode(options) {
                 let stableCycles = 0;
                 while (Date.now() < deadline) {
                     const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                    throwIfAssistantUiError(snapshot);
                     const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                     if (text && text.length > bestText.length) {
                         bestText = text;
@@ -1711,6 +1864,7 @@ export async function runBrowserMode(options) {
             savedFiles: fileArtifacts.savedFiles,
             archive,
             modelSelection: modelSelectionEvidence,
+            thinkingSelection: thinkingSelectionEvidence,
             tookMs: durationMs,
             answerTokens,
             answerChars,
@@ -1726,6 +1880,10 @@ export async function runBrowserMode(options) {
         };
     }
     catch (error) {
+        if (options.signal?.aborted || error instanceof BrowserRunCancelledError) {
+            runStatus = "cancelled";
+            throw new BrowserRunCancelledError();
+        }
         const normalizedError = error instanceof Error ? error : new Error(String(error));
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
@@ -1812,150 +1970,154 @@ export async function runBrowserMode(options) {
         }, normalizedError);
     }
     finally {
-        await conversationUrlMonitor?.stop();
-        try {
-            if (!connectionClosedUnexpectedly) {
-                await client?.close();
-            }
-        }
-        catch {
-            // ignore
-        }
-        // Close the isolated tab once the response has been fully captured to prevent
-        // tab accumulation across repeated runs. Keep the tab open on incomplete runs
-        // so reattach can recover the response.
-        const shouldCloseOwnedRunTarget = shouldCloseOwnedRunTargetAfterRun({
-            runStatus,
-            ownsTarget,
-            keepBrowser: effectiveKeepBrowser,
-            closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
-        });
-        let keepBrowserOpen = shouldKeepLocalBrowserOpen({
-            effectiveKeepBrowser,
-            preserveBrowserOnError,
-            usingCopiedProfile,
-        });
-        let cleanupProfileLock = null;
-        let terminatedRecordedChrome = false;
-        let otherActiveBrowserTabLeases = null;
-        const hasOtherActiveLeases = async () => {
-            if (!manualLogin || !tabLease) {
-                return false;
-            }
-            if (otherActiveBrowserTabLeases === null) {
-                otherActiveBrowserTabLeases = await hasOtherActiveBrowserTabLeases(userDataDir, tabLease.id);
-            }
-            return otherActiveBrowserTabLeases;
-        };
-        if (!keepBrowserOpen && manualLogin && tabLease) {
-            const cleanupLockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
-            if (cleanupLockTimeoutMs > 0) {
-                cleanupProfileLock = await acquireProfileRunLock(userDataDir, {
-                    timeoutMs: cleanupLockTimeoutMs,
-                    logger,
-                    sessionId: options.sessionId,
-                }).catch(() => null);
-            }
-            keepBrowserOpen = await hasOtherActiveLeases().catch(() => false);
-            if (keepBrowserOpen) {
-                logger("[browser] Other ChatGPT tab leases still active; leaving shared Chrome running.");
-            }
-            else if (reusedChrome && !connectionClosedUnexpectedly) {
-                terminatedRecordedChrome = await terminateRecordedChromeForProfile(userDataDir, logger).catch(() => false);
-            }
-        }
-        const closeOwnedRunTarget = async () => {
-            if (!shouldCloseOwnedRunTarget || !isolatedTargetId || !chrome?.port) {
-                return;
-            }
-            const safeToClose = !effectiveKeepBrowser ||
-                Boolean(await ensureChromePageTargetAfterClose(chrome.port, isolatedTargetId, logger, chromeHost));
-            if (!safeToClose) {
-                logger(`[browser] Leaving completed browser tab open because Chrome has no replacement page target.`);
-                return;
-            }
-            const closeConfirmed = await closeTab(chrome.port, isolatedTargetId, logger, chromeHost);
-            if (!closeConfirmed && effectiveKeepBrowser) {
-                const replacementTargetId = await createChromePageTarget(chrome.port, logger, chromeHost);
-                if (!replacementTargetId) {
-                    logger(`[browser] Chrome page retention could not be verified after closing ${isolatedTargetId}.`);
+        await withoutBrowserCancellation(async () => {
+            stopThinkingMonitor?.();
+            await conversationUrlMonitor?.stop();
+            try {
+                if (!connectionClosedUnexpectedly) {
+                    await client?.close();
                 }
             }
-        };
-        const cleanupBlankTabs = async () => {
-            if (!shouldCleanupBlankTabsAfterLastLease({
+            catch {
+                // ignore
+            }
+            // Close the isolated tab once the response has been fully captured to prevent
+            // tab accumulation across repeated runs. Keep the tab open on incomplete runs
+            // so reattach can recover the response.
+            const shouldCloseOwnedRunTarget = shouldCloseOwnedRunTargetAfterRun({
                 runStatus,
                 ownsTarget,
-                connectionClosedUnexpectedly,
-                manualLogin,
                 keepBrowser: effectiveKeepBrowser,
-                chromePort: chrome?.port,
-            }) ||
-                !chrome?.port) {
-                return;
-            }
-            await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
-                excludeTargetIds: [isolatedTargetId, lastTargetId],
-                preserveOneBlank: true,
+                closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
+                closeOwnedTabOnCancel: options.closeOwnedTabOnCancel,
             });
-        };
-        if (tabLease) {
-            const handle = tabLease;
-            tabLease = null;
-            const onRelease = async ({ isLastLease }) => {
-                await closeOwnedRunTarget();
-                if (isLastLease) {
-                    await cleanupBlankTabs();
+            let keepBrowserOpen = (manualLogin && runStatus === "cancelled") ||
+                shouldKeepLocalBrowserOpen({
+                    effectiveKeepBrowser,
+                    preserveBrowserOnError,
+                    usingCopiedProfile,
+                });
+            let cleanupProfileLock = null;
+            let browserTerminationHandledByLease = false;
+            let tabLeaseReleaseError;
+            if (!keepBrowserOpen && manualLogin && tabLease) {
+                const cleanupLockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
+                if (cleanupLockTimeoutMs > 0) {
+                    cleanupProfileLock = await acquireProfileRunLock(userDataDir, {
+                        timeoutMs: cleanupLockTimeoutMs,
+                        logger,
+                        sessionId: options.sessionId,
+                    }).catch(() => null);
                 }
-            };
-            await handle.release({ onRelease }).catch(() => undefined);
-        }
-        else {
-            await closeOwnedRunTarget();
-            await cleanupBlankTabs();
-        }
-        removeDialogHandler?.();
-        removeTerminationHooks?.();
-        if (!keepBrowserOpen) {
-            if (!connectionClosedUnexpectedly) {
-                try {
-                    if (!terminatedRecordedChrome) {
-                        await chrome.kill();
-                    }
+            }
+            const closeOwnedRunTarget = async () => {
+                if (!shouldCloseOwnedRunTarget || !isolatedTargetId || !chrome?.port) {
+                    return;
                 }
-                catch {
-                    // ignore kill failures
+                const safeToClose = !keepBrowserOpen ||
+                    Boolean(await ensureChromePageTargetAfterClose(chrome.port, isolatedTargetId, logger, chromeHost));
+                if (!safeToClose) {
+                    logger(`[browser] Leaving completed browser tab open because Chrome has no replacement page target.`);
+                    return;
                 }
-            }
-            if (manualLogin) {
-                const shouldCleanup = await shouldCleanupManualLoginProfileState(userDataDir, logger.verbose ? logger : undefined, {
+                const closeConfirmed = await closeTab(chrome.port, isolatedTargetId, logger, chromeHost);
+                if (!closeConfirmed && keepBrowserOpen) {
+                    const replacementTargetId = await createChromePageTarget(chrome.port, logger, chromeHost);
+                    if (!replacementTargetId) {
+                        logger(`[browser] Chrome page retention could not be verified after closing ${isolatedTargetId}.`);
+                    }
+                }
+            };
+            const cleanupBlankTabs = async () => {
+                if (!shouldCleanupBlankTabsAfterLastLease({
+                    runStatus,
+                    ownsTarget,
                     connectionClosedUnexpectedly,
-                    host: chromeHost,
+                    manualLogin,
+                    keepBrowser: effectiveKeepBrowser,
+                    chromePort: chrome?.port,
+                }) ||
+                    !chrome?.port) {
+                    return;
+                }
+                await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
+                    excludeTargetIds: [isolatedTargetId, lastTargetId],
+                    preserveOneBlank: true,
+                });
+            };
+            if (tabLease) {
+                const handle = tabLease;
+                tabLease = null;
+                const terminateSharedChrome = !keepBrowserOpen && manualLogin && !connectionClosedUnexpectedly
+                    ? async () => terminateRecordedChromeForProfile(userDataDir, logger).catch(() => false)
+                    : undefined;
+                const releaseResult = await releaseLocalBrowserTabLease({
+                    lease: handle,
+                    closeOwnedRunTarget,
+                    cleanupBlankTabs,
+                    terminateSharedChrome,
+                    sessionId: options.sessionId,
+                    chromePid: chrome.pid,
+                    chromePort: chrome.port,
+                    chromeTargetId: isolatedTargetId,
+                    launchDisposition: reusedChrome ? "reused" : "launched",
+                    logger,
                 });
-                if (shouldCleanup) {
-                    // Preserve the persistent manual-login profile, but clear stale reattach hints.
-                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
+                keepBrowserOpen ||= releaseResult.keepBrowserOpen;
+                browserTerminationHandledByLease = releaseResult.terminationHandled;
+                tabLeaseReleaseError = releaseResult.releaseError;
+            }
+            else {
+                await closeOwnedRunTarget();
+                await cleanupBlankTabs();
+            }
+            removeDialogHandler?.();
+            removeTerminationHooks?.();
+            if (!keepBrowserOpen) {
+                if (!connectionClosedUnexpectedly) {
+                    try {
+                        if (!browserTerminationHandledByLease) {
+                            await chrome.kill();
+                        }
+                    }
+                    catch {
+                        // ignore kill failures
+                    }
+                }
+                if (manualLogin) {
+                    const shouldCleanup = await shouldCleanupManualLoginProfileState(userDataDir, logger.verbose ? logger : undefined, {
+                        connectionClosedUnexpectedly,
+                        host: chromeHost,
+                    });
+                    if (shouldCleanup) {
+                        // Preserve the persistent manual-login profile, but clear stale reattach hints.
+                        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
+                    }
+                }
+                else {
+                    await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+                }
+                if (!connectionClosedUnexpectedly) {
+                    const totalSeconds = (Date.now() - startedAt) / 1000;
+                    logger(`Cleanup ${runStatus} • ${totalSeconds.toFixed(1)}s total`);
                 }
             }
             else {
-                await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+                detachKeptChromeProcess(chrome);
+                if (!connectionClosedUnexpectedly) {
+                    logger(`Chrome left running on port ${chrome.port} with profile ${userDataDir}`);
+                }
             }
-            if (!connectionClosedUnexpectedly) {
-                const totalSeconds = (Date.now() - startedAt) / 1000;
-                logger(`Cleanup ${runStatus} • ${totalSeconds.toFixed(1)}s total`);
+            if (cleanupProfileLock) {
+                const handle = cleanupProfileLock;
+                cleanupProfileLock = null;
+                await handle.release().catch(() => undefined);
             }
-        }
-        else {
-            detachKeptChromeProcess(chrome);
-            if (!connectionClosedUnexpectedly) {
-                logger(`Chrome left running on port ${chrome.port} with profile ${userDataDir}`);
+            if (tabLeaseReleaseError) {
+                // oxlint-disable-next-line eslint/no-unsafe-finally -- This cleanup failure must override a successful browser result or a live MCP owner can remain locked.
+                throw new Error("Failed to release the ChatGPT browser slot registry lock; restart Oracle/Codex MCP before another browser run.", { cause: tabLeaseReleaseError });
             }
-        }
-        if (cleanupProfileLock) {
-            const handle = cleanupProfileLock;
-            cleanupProfileLock = null;
-            await handle.release().catch(() => undefined);
-        }
+        });
     }
 }
 const DEFAULT_DEBUG_PORT = 9222;
@@ -2189,7 +2351,7 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
         process: undefined,
     };
 }
-async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
+async function runRemoteBrowserMode(promptText, attachments, config, logger, options, cancellation) {
     const remoteChromeConfig = config.remoteChrome;
     if (!remoteChromeConfig) {
         throw new Error("Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.");
@@ -2202,6 +2364,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let lastUrl;
     let promptSubmitted = false;
     let modelSelectionEvidence;
+    let thinkingSelectionEvidence;
     let attachedExistingTab = false;
     let ownsTarget = true;
     let conversationUrlMonitor = null;
@@ -2258,22 +2421,24 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             : resolveRemoteTabLeaseProfileDir(config);
         if (remoteLeaseProfileDir) {
             await mkdir(remoteLeaseProfileDir, { recursive: true });
-            tabLease = await acquireBrowserTabLease(remoteLeaseProfileDir, {
+            tabLease = await cancellation.acquire(() => acquireBrowserTabLease(remoteLeaseProfileDir, {
                 maxConcurrentTabs: config.maxConcurrentTabs,
                 timeoutMs: config.timeoutMs,
                 logger,
                 sessionId: options.sessionId,
                 chromeHost: host,
                 chromePort: port,
-            });
+                signal: options.signal,
+            }), (lease) => lease.release());
         }
         if (config.browserTabRef) {
-            const attached = await connectToExistingChatGptTab({
+            const tabRef = config.browserTabRef;
+            const attached = await cancellation.acquire(() => connectToExistingChatGptTab({
                 host,
                 port,
-                ref: config.browserTabRef,
-            });
-            client = attached.client;
+                ref: tabRef,
+            }), (attached) => attached.client.close());
+            client = cancellation.client(attached.client);
             remoteTargetId = attached.targetId ?? null;
             lastUrl = attached.tab.url || lastUrl;
             attachedExistingTab = true;
@@ -2281,10 +2446,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             logger(`Attached to existing remote ChatGPT tab ${attached.targetId}${attached.tab.url ? ` (${attached.tab.url})` : ""}`);
         }
         else {
-            connection = await connectToRemoteChrome(host, port, logger, "about:blank", browserWSEndpoint, {
-                approvalWaitMs: config.attachRunning && browserWSEndpoint ? 20_000 : undefined,
-            });
-            client = connection.client;
+            connection = await cancellation.acquire(() => connectToRemoteChrome(host, port, logger, "about:blank", browserWSEndpoint, {
+                approvalWaitMs: browserWSEndpoint ? config.approvalWaitMs : undefined,
+                fallbackToDefault: false,
+            }), (connection) => connection.close());
+            client = cancellation.client(connection.client);
             remoteTargetId = connection.targetId ?? null;
             ownsTarget = true;
         }
@@ -2393,16 +2559,14 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 : "Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
-        // Handle thinking time selection if specified. Deep Research owns its own effort flow.
-        const thinkingTime = config.thinkingTime;
-        if (thinkingTime && !deepResearch) {
+        if (shouldApplyThinkingTimeSelection(config)) {
             const thinkingTargetModel = modelStrategy === "select" ? config.desiredModel : null;
-            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger, thinkingTargetModel), {
+            thinkingSelectionEvidence = await withRetries(() => ensureThinkingTime(Runtime, config.thinkingTime, logger, thinkingTargetModel), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Thinking time (${config.thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             });
@@ -2415,17 +2579,20 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 name: path.basename(a.path),
                 generatedBundle: a.generatedBundle === true,
             }));
+            let attachmentNavigationUrl;
             await clearPromptComposer(Runtime, logger);
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
                     throw new Error("Chrome DOM domain unavailable while uploading attachments.");
                 }
+                attachmentNavigationUrl = await captureComposerNavigationUrl(Runtime);
                 await clearComposerAttachments(Runtime, 5_000, logger);
                 // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
                 for (const attachment of submissionAttachments) {
+                    await assertComposerPlusStayedInPlace(Runtime, attachmentNavigationUrl);
                     logger(`Uploading attachment: ${attachment.displayPath}`);
-                    await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+                    await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM, navigationUrl: attachmentNavigationUrl }, attachment, logger);
                     await delay(500);
                 }
                 // Scale timeout based on number of files: base 30s + 15s per additional file
@@ -2453,12 +2620,14 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             const providerState = {
                 runtime: Runtime,
                 input: Input,
+                page: Page,
                 logger,
                 timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 attachmentTimeoutMs: config.attachmentTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
                 attachmentNames: attachmentExpectations,
+                attachmentNavigationUrl,
                 onPromptSubmitted: markPromptSubmitted,
             };
             const deepResearchTargetBaseline = deepResearch && client
@@ -2549,6 +2718,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 artifacts: savedArtifacts,
                 archive,
                 modelSelection: modelSelectionEvidence,
+                thinkingSelection: thinkingSelectionEvidence,
                 tookMs: durationMs,
                 answerTokens: tokens,
                 answerChars: researchResult.text.length,
@@ -2571,6 +2741,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
                 const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                throwIfAssistantUiError(snapshot);
                 const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text) {
                     const normalized = normalizeForComparison(text);
@@ -2792,6 +2963,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 let stableCount = 0;
                 while (Date.now() < deadline) {
                     const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                    throwIfAssistantUiError(snapshot);
                     const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                     const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
                     if (!isStillEcho) {
@@ -2955,10 +3127,15 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             savedFiles: fileArtifacts.savedFiles,
             archive,
             modelSelection: modelSelectionEvidence,
+            thinkingSelection: thinkingSelectionEvidence,
             controllerPid: process.pid,
         };
     }
     catch (error) {
+        if (options.signal?.aborted || error instanceof BrowserRunCancelledError) {
+            runStatus = "cancelled";
+            throw new BrowserRunCancelledError();
+        }
         const normalizedError = error instanceof Error ? error : new Error(String(error));
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
@@ -2996,57 +3173,61 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         });
     }
     finally {
-        await conversationUrlMonitor?.stop();
-        try {
-            await closeRemoteConnectionAfterRun({
-                connectionClosedUnexpectedly,
-                connection,
-                client,
-                runStatus,
-            });
-        }
-        catch {
-            // ignore
-        }
-        removeDialogHandler?.();
-        const keepRemoteBrowser = Boolean(config.keepBrowser);
-        const shouldCloseOwnedRemoteTarget = shouldCloseOwnedRunTargetAfterRun({
-            runStatus,
-            ownsTarget,
-            keepBrowser: keepRemoteBrowser,
-            closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
-        });
-        const closeOwnedRemoteTarget = async () => {
-            if (!shouldCloseOwnedRemoteTarget || !remoteTargetId) {
-                return;
+        await withoutBrowserCancellation(async () => {
+            stopThinkingMonitor?.();
+            await conversationUrlMonitor?.stop();
+            try {
+                await closeRemoteConnectionAfterRun({
+                    connectionClosedUnexpectedly,
+                    connection,
+                    client,
+                    runStatus,
+                });
             }
-            const safeToClose = !keepRemoteBrowser ||
-                Boolean(await ensureChromePageTargetAfterClose(port, remoteTargetId, logger, host));
-            if (!safeToClose) {
-                logger(`[browser] Leaving completed remote browser tab open because Chrome has no replacement page target.`);
-                return;
+            catch {
+                // ignore
             }
-            const closeConfirmed = await closeTab(port, remoteTargetId, logger, host);
-            if (!closeConfirmed && keepRemoteBrowser) {
-                const replacementTargetId = await createChromePageTarget(port, logger, host);
-                if (!replacementTargetId) {
-                    logger(`[browser] Remote Chrome page retention could not be verified after closing ${remoteTargetId}.`);
+            removeDialogHandler?.();
+            const keepRemoteBrowser = Boolean(config.keepBrowser);
+            const shouldCloseOwnedRemoteTarget = shouldCloseOwnedRunTargetAfterRun({
+                runStatus,
+                ownsTarget,
+                keepBrowser: keepRemoteBrowser,
+                closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
+                closeOwnedTabOnCancel: options.closeOwnedTabOnCancel,
+            });
+            const closeOwnedRemoteTarget = async () => {
+                if (!shouldCloseOwnedRemoteTarget || !remoteTargetId) {
+                    return;
                 }
+                const safeToClose = !keepRemoteBrowser ||
+                    Boolean(await ensureChromePageTargetAfterClose(port, remoteTargetId, logger, host));
+                if (!safeToClose) {
+                    logger(`[browser] Leaving completed remote browser tab open because Chrome has no replacement page target.`);
+                    return;
+                }
+                const closeConfirmed = await closeTab(port, remoteTargetId, logger, host);
+                if (!closeConfirmed && keepRemoteBrowser) {
+                    const replacementTargetId = await createChromePageTarget(port, logger, host);
+                    if (!replacementTargetId) {
+                        logger(`[browser] Remote Chrome page retention could not be verified after closing ${remoteTargetId}.`);
+                    }
+                }
+            };
+            if (tabLease) {
+                const handle = tabLease;
+                tabLease = null;
+                await handle
+                    .release({ onRelease: async () => closeOwnedRemoteTarget() })
+                    .catch(() => undefined);
             }
-        };
-        if (tabLease) {
-            const handle = tabLease;
-            tabLease = null;
-            await handle
-                .release({ onRelease: async () => closeOwnedRemoteTarget() })
-                .catch(() => undefined);
-        }
-        else {
-            await closeOwnedRemoteTarget();
-        }
-        // Don't kill remote Chrome - it's not ours to manage
-        const totalSeconds = (Date.now() - startedAt) / 1000;
-        logger(`Remote session complete • ${totalSeconds.toFixed(1)}s total`);
+            else {
+                await closeOwnedRemoteTarget();
+            }
+            // Don't kill remote Chrome - it's not ours to manage
+            const totalSeconds = (Date.now() - startedAt) / 1000;
+            logger(`Remote session complete • ${totalSeconds.toFixed(1)}s total`);
+        });
     }
 }
 export { estimateTokenCount } from "./utils.js";
@@ -3065,10 +3246,13 @@ export const __test__ = {
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
     normalizeAuthenticatedModelSelectionError,
+    pollGeneratedImageOrTextAssistantResponse,
     resolveManualLoginWaitMs,
+    shouldApplyThinkingTimeSelection,
     shouldCleanupBlankTabsAfterLastLease,
     shouldCloseOwnedRunTargetAfterRun,
     shouldKeepLocalBrowserOpen,
+    releaseLocalBrowserTabLease,
     waitForAssistantResponseWithReload,
 };
 export { syncCookies } from "./cookies.js";