@steipete/oracle 0.9.0 → 0.11.0

package/dist/src/browser/index.js

@@ -1,43 +1,317 @@
-import { mkdtemp, rm, mkdir } from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import net from 'node:net';
-import { resolveBrowserConfig } from './config.js';
-import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from './chromeLifecycle.js';
-import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, 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 { estimateTokenCount, withRetries, delay } from './utils.js';
-import { formatElapsed } from '../oracle/format.js';
-import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from './constants.js';
-import { BrowserAutomationError } from '../oracle/errors.js';
-import { alignPromptEchoPair, buildPromptEchoMatcher } from './reattachHelpers.js';
-import { cleanupStaleProfileState, acquireProfileRunLock, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
-import { runProviderSubmissionFlow } from './providerDomFlow.js';
-import { chatgptDomProvider } from './providers/index.js';
-export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
-export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
+import { mkdtemp, rm, mkdir } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import net from "node:net";
+import { resolveBrowserConfig } from "./config.js";
+import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
+import { syncCookies } from "./cookies.js";
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, 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 { startThinkingStatusMonitor } from "./actions/thinkingStatus.js";
+import { activateDeepResearch, waitForDeepResearchCompletion, waitForResearchPlanAutoConfirm, } from "./actions/deepResearch.js";
+import { estimateTokenCount, withRetries, delay } from "./utils.js";
+import { formatElapsed } from "../oracle/format.js";
+import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from "./constants.js";
+import { BrowserAutomationError } from "../oracle/errors.js";
+import { alignPromptEchoPair, buildPromptEchoMatcher } from "./reattachHelpers.js";
+import { cleanupStaleProfileState, acquireProfileRunLock, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, terminateRecordedChromeForProfile, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
+import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
+import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
+import { collectGeneratedImageArtifacts } from "./chatgptImages.js";
+import { runProviderSubmissionFlow } from "./providerDomFlow.js";
+import { chatgptDomProvider } from "./providers/index.js";
+import { resolveAttachRunningConnection } from "./attachRunning.js";
+import { connectToExistingChatGptTab } from "./liveTabs.js";
+import { captureBrowserDiagnostics } from "./domDebug.js";
+import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./actions/archiveConversation.js";
+import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
+export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
+export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
+export { formatThinkingLog, formatThinkingWaitingLog, buildThinkingStatusExpressionForTest, readThinkingStatusForTest, sanitizeThinkingText, startThinkingStatusMonitorForTest, } from "./actions/thinkingStatus.js";
+function redactBrowserConfigForDebugLog(config) {
+    const redacted = { ...config };
+    if (Array.isArray(config.inlineCookies)) {
+        redacted.inlineCookies = `[redacted:${config.inlineCookies.length} cookies]`;
+        redacted.inlineCookieCount = config.inlineCookies.length;
+    }
+    return redacted;
+}
+export function redactBrowserConfigForDebugLogForTest(config) {
+    return redactBrowserConfigForDebugLog(config);
+}
 function isCloudflareChallengeError(error) {
     if (!(error instanceof BrowserAutomationError))
         return false;
-    return error.details?.stage === 'cloudflare-challenge';
+    return error.details?.stage === "cloudflare-challenge";
+}
+function isReattachableCaptureError(error) {
+    if (!(error instanceof BrowserAutomationError))
+        return false;
+    const stage = error.details?.stage;
+    return stage === "assistant-timeout" || stage === "assistant-recheck";
+}
+function classifyPreservedBrowserError(error, headless) {
+    if (headless)
+        return null;
+    if (isCloudflareChallengeError(error))
+        return "cloudflare-challenge";
+    if (isReattachableCaptureError(error))
+        return "reattachable-capture";
+    return null;
 }
 function shouldPreserveBrowserOnError(error, headless) {
-    return !headless && isCloudflareChallengeError(error);
+    return classifyPreservedBrowserError(error, headless) !== null;
 }
 export function shouldPreserveBrowserOnErrorForTest(error, headless) {
     return shouldPreserveBrowserOnError(error, headless);
 }
+export function classifyPreservedBrowserErrorForTest(error, headless) {
+    return classifyPreservedBrowserError(error, headless);
+}
+function shouldSkipThinkingTimeSelection(desiredModel, thinkingTime) {
+    if (thinkingTime !== "extended" || !desiredModel) {
+        return false;
+    }
+    const normalized = desiredModel.toLowerCase();
+    return (normalized === "gpt-5.5-pro" ||
+        normalized.includes("gpt-5.5 pro") ||
+        normalized.includes("gpt 5.5 pro") ||
+        normalized.includes("gpt 5 5 pro"));
+}
+export function shouldSkipThinkingTimeSelectionForTest(desiredModel, thinkingTime) {
+    return shouldSkipThinkingTimeSelection(desiredModel, thinkingTime);
+}
+function listIgnoredRemoteChromeFlags(config) {
+    return [
+        config.headless ? "--browser-headless" : null,
+        config.hideWindow ? "--browser-hide-window" : null,
+        config.keepBrowser ? "--browser-keep-browser" : null,
+        !config.attachRunning && config.chromePath ? "--browser-chrome-path" : null,
+    ].filter((value) => Boolean(value));
+}
+function hasBrowserErrorCode(error, code) {
+    return (error instanceof BrowserAutomationError &&
+        error.details?.code === code);
+}
+async function saveOptionalArtifact(operation, logger) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[browser] Failed to save session artifact: ${message}`);
+        return null;
+    }
+}
+async function waitForAssistantOrGeneratedImageResponse(params) {
+    if (!params.imageOutputRequested) {
+        return params.waitForText();
+    }
+    params.logger("[browser] Waiting for ChatGPT generated image response.");
+    const response = await pollGeneratedImageOrTextAssistantResponse(params.Runtime, params.timeoutMs, params.minTurnIndex, params.expectedConversationId);
+    if (response) {
+        if (response.html?.includes("/backend-api/estuary/content?id=file_")) {
+            params.logger("[browser] Captured generated image response before text appeared.");
+        }
+        return response;
+    }
+    throw new Error("assistant response timeout while waiting for generated image or text");
+}
+async function attemptAssistantRecheckOrRethrow(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof BrowserAutomationError) {
+            throw error;
+        }
+        return null;
+    }
+}
+async function pollGeneratedImageOrTextAssistantResponse(Runtime, timeoutMs, minTurnIndex, expectedConversationId) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        let snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId).catch(() => null);
+        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_")) {
+                snapshot = relaxedSnapshot;
+            }
+        }
+        const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
+        const html = typeof snapshot?.html === "string" ? snapshot.html : "";
+        const hasGeneratedImage = html.includes("/backend-api/estuary/content?id=file_");
+        if (text && (hasGeneratedImage || !isImageOnlyUiChromeText(text))) {
+            return {
+                text,
+                html,
+                meta: {
+                    turnId: snapshot?.turnId ?? undefined,
+                    messageId: snapshot?.messageId ?? undefined,
+                },
+            };
+        }
+        await delay(750);
+    }
+    return null;
+}
+function isImageOnlyUiChromeText(text) {
+    const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+    return (normalized.length === 0 ||
+        normalized === "edit" ||
+        normalized === "stopped thinking" ||
+        normalized === "stopped thinking edit");
+}
+function normalizeBrowserFollowUpPrompts(values) {
+    return (values ?? []).map((entry) => entry.trim()).filter(Boolean);
+}
+export function formatBrowserTurnTranscript(turns) {
+    if (turns.length <= 1) {
+        const turn = turns[0];
+        return {
+            answerText: turn?.answerText ?? "",
+            answerMarkdown: turn?.answerMarkdown ?? turn?.answerText ?? "",
+        };
+    }
+    const answerMarkdown = turns
+        .map((turn, index) => {
+        const label = turn.label.trim() || `Turn ${index + 1}`;
+        const prompt = turn.prompt?.trim();
+        const promptBlock = prompt ? `\n\n### Prompt\n\n${prompt}` : "";
+        const answer = (turn.answerMarkdown || turn.answerText).trim() || "_No text captured._";
+        return `## ${label}${promptBlock}\n\n### Answer\n\n${answer}`;
+    })
+        .join("\n\n")
+        .trim();
+    return {
+        answerText: answerMarkdown,
+        answerMarkdown,
+    };
+}
+async function maybeArchiveCompletedConversation({ Runtime, logger, config, conversationUrl, followUpCount, requiredArtifactsSaved, }) {
+    const decision = resolveBrowserArchiveDecision({
+        mode: config.archiveConversations,
+        chatgptUrl: config.chatgptUrl ?? config.url,
+        conversationUrl,
+        researchMode: config.researchMode,
+        followUpCount,
+    });
+    if (!decision.shouldArchive) {
+        logger(`[browser] ChatGPT archive skipped (${decision.reason}).`);
+        return {
+            mode: decision.mode,
+            attempted: false,
+            archived: false,
+            reason: decision.reason,
+            conversationUrl: conversationUrl ?? undefined,
+        };
+    }
+    if (!requiredArtifactsSaved) {
+        logger("[browser] ChatGPT archive skipped (artifact-save-failed).");
+        return {
+            mode: decision.mode,
+            attempted: false,
+            archived: false,
+            reason: "artifact-save-failed",
+            conversationUrl: conversationUrl ?? undefined,
+        };
+    }
+    return archiveChatGptConversation(Runtime, logger, {
+        mode: decision.mode,
+        conversationUrl,
+    }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[browser] ChatGPT archive failed (${message}).`);
+        return {
+            mode: decision.mode,
+            attempted: true,
+            archived: false,
+            reason: "archive-failed",
+            conversationUrl: conversationUrl ?? undefined,
+            error: message,
+        };
+    });
+}
+export function maybeArchiveCompletedConversationForTest(args) {
+    return maybeArchiveCompletedConversation(args);
+}
+async function runSubmissionWithRecovery({ prompt, attachments, fallbackSubmission, submit, reloadPromptComposer, prepareFallbackSubmission, logger, }) {
+    let currentPrompt = prompt;
+    let currentAttachments = attachments;
+    let retriedDeadComposer = false;
+    let usedFallbackSubmission = false;
+    while (true) {
+        try {
+            return await submit(currentPrompt, currentAttachments);
+        }
+        catch (error) {
+            const isDeadComposer = hasBrowserErrorCode(error, "dead-composer");
+            if (isDeadComposer && !retriedDeadComposer) {
+                retriedDeadComposer = true;
+                await reloadPromptComposer();
+                continue;
+            }
+            const isPromptTooLarge = hasBrowserErrorCode(error, "prompt-too-large");
+            if (fallbackSubmission && isPromptTooLarge && !usedFallbackSubmission) {
+                usedFallbackSubmission = true;
+                logger("[browser] Inline prompt too large; retrying with file uploads.");
+                await prepareFallbackSubmission();
+                currentPrompt = fallbackSubmission.prompt;
+                currentAttachments = fallbackSubmission.attachments;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+export async function runSubmissionWithRecoveryForTest(args) {
+    return runSubmissionWithRecovery(args);
+}
+function resolveRemoteTabLeaseProfileDir(config) {
+    if (!config.remoteChrome || !config.manualLogin || !config.manualLoginProfileDir) {
+        return null;
+    }
+    return path.resolve(config.manualLoginProfileDir);
+}
+export function resolveRemoteTabLeaseProfileDirForTest(config) {
+    return resolveRemoteTabLeaseProfileDir(config);
+}
+async function closeRemoteConnectionAfterRun(options) {
+    if (options.connectionClosedUnexpectedly) {
+        return;
+    }
+    if (!options.connection) {
+        await options.client?.close();
+        return;
+    }
+    if (options.runStatus === "complete") {
+        await options.connection.close();
+    }
+    else {
+        await options.client?.close();
+    }
+}
+function shouldCloseOwnedRunTargetAfterRun(options) {
+    return options.runStatus === "complete" && options.ownsTarget && !options.keepBrowser;
+}
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
-        throw new Error('Prompt text is required when using browser mode.');
+        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 followUpPrompts = normalizeBrowserFollowUpPrompts(options.followUpPrompts);
+    if (config.researchMode === "deep" && followUpPrompts.length > 0) {
+        throw new BrowserAutomationError("Browser follow-ups are not supported with Deep Research mode. Put the full research plan into the initial prompt or run a normal browser consult for multi-turn review.", {
+            stage: "browser-follow-ups",
+            details: { researchMode: "deep", followUps: followUpPrompts.length },
+        });
+    }
     const logger = options.log ?? ((_message) => { });
     if (logger.verbose === undefined) {
         logger.verbose = Boolean(config.debug);
@@ -48,8 +322,9 @@ export async function runBrowserMode(options) {
     const runtimeHintCb = options.runtimeHintCb;
     let lastTargetId;
     let lastUrl;
+    let tabLease = null;
     const emitRuntimeHint = async () => {
-        if (!runtimeHintCb || !chrome?.port) {
+        if (!chrome?.port) {
             return;
         }
         const conversationId = lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
@@ -64,19 +339,37 @@ export async function runBrowserMode(options) {
             controllerPid: process.pid,
         };
         try {
-            await runtimeHintCb(hint);
+            await runtimeHintCb?.(hint);
+            await tabLease?.update({
+                chromeHost,
+                chromePort: chrome.port,
+                chromeTargetId: lastTargetId,
+                tabUrl: lastUrl,
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             logger(`Failed to persist runtime hint: ${message}`);
         }
     };
-    if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') {
+    if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") {
         logger(`[browser-mode] config: ${JSON.stringify({
-            ...config,
+            ...redactBrowserConfigForDebugLog(config),
             promptLength: promptText.length,
         })}`);
     }
+    for (const line of formatBrowserControlPlan(describeBrowserControlPlan(config), "browser")) {
+        logger(line);
+    }
+    if (config.attachRunning) {
+        const attached = await resolveAttachRunningConnection(config, logger);
+        config = {
+            ...config,
+            remoteChrome: { host: attached.host, port: attached.port },
+            remoteChromeBrowserWSEndpoint: attached.browserWSEndpoint,
+            remoteChromeProfileRoot: attached.profileRoot,
+        };
+    }
     if (!config.remoteChrome && !config.manualLogin) {
         const preferredPort = config.debugPort ?? DEFAULT_DEBUG_PORT;
         const availablePort = await pickAvailableDebugPort(preferredPort, logger);
@@ -88,19 +381,19 @@ export async function runBrowserMode(options) {
     // Remote Chrome mode - connect to existing browser
     if (config.remoteChrome) {
         // Warn about ignored local-only options
-        if (config.headless || config.hideWindow || config.keepBrowser || config.chromePath) {
-            logger('Note: --remote-chrome ignores local Chrome flags ' +
-                '(--browser-headless, --browser-hide-window, --browser-keep-browser, --browser-chrome-path).');
+        const ignoredFlags = listIgnoredRemoteChromeFlags(config);
+        if (ignoredFlags.length > 0) {
+            logger(`Note: --remote-chrome ignores local Chrome flags (${ignoredFlags.join(", ")}).`);
         }
         return runRemoteBrowserMode(promptText, attachments, config, logger, options);
     }
     const manualLogin = Boolean(config.manualLogin);
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
-        : path.join(os.homedir(), '.oracle', 'browser-profile');
+        : path.join(os.homedir(), ".oracle", "browser-profile");
     const userDataDir = manualLogin
         ? manualProfileDir
-        : await mkdtemp(path.join(await resolveUserDataBaseDir(), 'oracle-browser-'));
+        : await mkdtemp(path.join(await resolveUserDataBaseDir(), "oracle-browser-"));
     if (manualLogin) {
         // Learned: manual login reuses a persistent profile so cookies/SSO survive.
         await mkdir(userDataDir, { recursive: true });
@@ -109,27 +402,47 @@ export async function runBrowserMode(options) {
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
     }
+    if (manualLogin) {
+        tabLease = await acquireBrowserTabLease(userDataDir, {
+            maxConcurrentTabs: config.maxConcurrentTabs,
+            timeoutMs: config.timeoutMs,
+            logger,
+            sessionId: options.sessionId,
+        });
+    }
     const effectiveKeepBrowser = Boolean(config.keepBrowser);
-    const reusedChrome = manualLogin
-        ? await maybeReuseRunningChrome(userDataDir, logger, { waitForPortMs: config.reuseChromeWaitMs })
-        : null;
-    const chrome = reusedChrome ??
-        (await launchChrome({
-            ...config,
-            remoteChrome: config.remoteChrome,
-        }, userDataDir, logger));
-    const chromeHost = chrome.host ?? '127.0.0.1';
-    // Persist profile state so future manual-login runs can reuse this Chrome.
-    if (manualLogin && chrome.port) {
-        await writeDevToolsActivePort(userDataDir, chrome.port);
-        if (!reusedChrome && chrome.pid) {
-            await writeChromePid(userDataDir, chrome.pid);
+    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);
         }
+        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',
+            isInFlight: () => runStatus !== "complete",
             emitRuntimeHint,
             preserveUserDataDir: manualLogin,
         });
@@ -139,11 +452,12 @@ export async function runBrowserMode(options) {
     }
     let client = null;
     let isolatedTargetId = null;
+    let ownsTarget = true;
     const startedAt = Date.now();
-    let answerText = '';
-    let answerMarkdown = '';
-    let answerHtml = '';
-    let runStatus = 'attempted';
+    let answerText = "";
+    let answerMarkdown = "";
+    let answerHtml = "";
+    let runStatus = "attempted";
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
@@ -151,14 +465,37 @@ export async function runBrowserMode(options) {
     let preserveBrowserOnError = false;
     try {
         try {
-            const strictTabIsolation = Boolean(manualLogin && reusedChrome);
-            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost, {
-                fallbackToDefault: !strictTabIsolation,
-                retries: strictTabIsolation ? 3 : 0,
-                retryDelayMs: 500,
-            });
-            client = connection.client;
-            isolatedTargetId = connection.targetId ?? null;
+            if (config.browserTabRef) {
+                const attached = await connectToExistingChatGptTab({
+                    host: chromeHost,
+                    port: chrome.port,
+                    ref: config.browserTabRef,
+                });
+                client = attached.client;
+                isolatedTargetId = attached.targetId ?? null;
+                lastTargetId = attached.targetId ?? undefined;
+                lastUrl = attached.tab.url || lastUrl;
+                ownsTarget = false;
+                logger(`Attached to existing ChatGPT tab ${attached.targetId}${attached.tab.url ? ` (${attached.tab.url})` : ""}`);
+            }
+            else {
+                const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+                const connection = await connectWithNewTab(chrome.port, logger, config.url, chromeHost, {
+                    fallbackToDefault: !strictTabIsolation,
+                    retries: strictTabIsolation ? 3 : 0,
+                    retryDelayMs: 500,
+                });
+                client = connection.client;
+                isolatedTargetId = connection.targetId ?? null;
+                ownsTarget = true;
+            }
+            if (tabLease && isolatedTargetId) {
+                await tabLease.update({
+                    chromeHost,
+                    chromePort: chrome.port,
+                    chromeTargetId: isolatedTargetId,
+                });
+            }
         }
         catch (error) {
             const hint = describeDevtoolsFirewallHint(chromeHost, chrome.port);
@@ -168,10 +505,10 @@ export async function runBrowserMode(options) {
             throw error;
         }
         const disconnectPromise = new Promise((_, reject) => {
-            client?.on('disconnect', () => {
+            client?.on("disconnect", () => {
                 connectionClosedUnexpectedly = true;
-                logger('Chrome window closed; attempting to abort run.');
-                reject(new Error('Chrome window closed before oracle finished. Please keep it open until completion.'));
+                logger("Chrome window closed; attempting to abort run.");
+                reject(new Error("Chrome window closed before oracle finished. Please keep it open until completion."));
             });
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
@@ -180,7 +517,7 @@ export async function runBrowserMode(options) {
             await hideChromeWindow(chrome, logger);
         }
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
-        if (DOM && typeof DOM.enable === 'function') {
+        if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
@@ -192,13 +529,13 @@ export async function runBrowserMode(options) {
         const cookieSyncEnabled = config.cookieSync && (!manualLogin || manualLoginCookieSync);
         if (cookieSyncEnabled) {
             if (manualLoginCookieSync) {
-                logger('Manual login mode: seeding persistent profile with cookies from your Chrome profile.');
+                logger("Manual login mode: seeding persistent profile with cookies from your Chrome profile.");
             }
             if (!config.inlineCookies) {
-                logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.');
+                logger("Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.");
             }
             else {
-                logger('Applying inline cookies (skipping Chrome profile read and Keychain prompt)');
+                logger("Applying inline cookies (skipping Chrome profile read and Keychain prompt)");
             }
             // Learned: always sync cookies before the first navigation so /backend-api/me succeeds.
             const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
@@ -210,53 +547,66 @@ export async function runBrowserMode(options) {
             });
             appliedCookies = cookieCount;
             if (config.inlineCookies && cookieCount === 0) {
-                throw new Error('No inline cookies were applied; aborting before navigation.');
+                throw new Error("No inline cookies were applied; aborting before navigation.");
             }
             logger(cookieCount > 0
                 ? config.inlineCookies
                     ? `Applied ${cookieCount} inline cookies`
-                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
+                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? "Default"}`
                 : config.inlineCookies
-                    ? 'No inline cookies applied; continuing without session reuse'
-                    : 'No Chrome cookies found; continuing without session reuse');
+                    ? "No inline cookies applied; continuing without session reuse"
+                    : "No Chrome cookies found; continuing without session reuse");
         }
         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 sync (--browser-manual-login enabled); reuse the opened profile after signing in."
+                : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
         }
         if (cookieSyncEnabled && !manualLogin && (appliedCookies ?? 0) === 0 && !config.inlineCookies) {
             // Learned: if the profile has no ChatGPT cookies, browser mode will just bounce to login.
             // Fail early so the user knows to sign in.
-            throw new BrowserAutomationError('No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. ' +
-                'Make sure ChatGPT is signed in in the selected profile, use --browser-manual-login / inline cookies, ' +
-                'or retry with --browser-cookie-wait 5s if Keychain prompts are slow.', {
-                stage: 'execute-browser',
+            throw new BrowserAutomationError("No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. " +
+                "Make sure ChatGPT is signed in in the selected profile, use --browser-manual-login / inline cookies, " +
+                "or retry with --browser-cookie-wait 5s if Keychain prompts are slow.", {
+                stage: "execute-browser",
                 details: {
-                    profile: config.chromeProfile ?? 'Default',
+                    profile: config.chromeProfile ?? "Default",
                     cookiePath: config.chromeCookiePath ?? null,
-                    hint: 'If macOS Keychain prompts or denies access, run oracle from a GUI session or use --copy/--render for the manual flow.',
+                    hint: "If macOS Keychain prompts or denies access, run oracle from a GUI session or use --copy/--render for the manual flow.",
                 },
             });
         }
-        const baseUrl = CHATGPT_URL;
-        // First load the base ChatGPT homepage to satisfy potential interstitials,
-        // then hop to the requested URL if it differs.
-        await raceWithDisconnect(navigateToChatGPT(Page, Runtime, baseUrl, logger));
-        await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
-        // Learned: login checks must happen on the base domain before jumping into project URLs.
-        await raceWithDisconnect(waitForLogin({ runtime: Runtime, logger, appliedCookies, manualLogin, timeoutMs: config.timeoutMs }));
-        if (config.url !== baseUrl) {
-            await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
-                url: config.url,
-                fallbackUrl: baseUrl,
-                timeoutMs: config.inputTimeoutMs,
-                headless: config.headless,
-                logger,
-            }));
+        if (config.browserTabRef) {
+            await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
+            await raceWithDisconnect(ensureLoggedIn(Runtime, logger));
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
         }
         else {
-            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+            const baseUrl = CHATGPT_URL;
+            // First load the base ChatGPT homepage to satisfy potential interstitials,
+            // then hop to the requested URL if it differs.
+            await raceWithDisconnect(navigateToChatGPT(Page, Runtime, baseUrl, logger));
+            await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
+            // Learned: login checks must happen on the base domain before jumping into project URLs.
+            await raceWithDisconnect(waitForLogin({
+                runtime: Runtime,
+                logger,
+                appliedCookies,
+                manualLogin,
+                timeoutMs: config.timeoutMs,
+            }));
+            if (config.url !== baseUrl) {
+                await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
+                    url: config.url,
+                    fallbackUrl: baseUrl,
+                    timeoutMs: config.inputTimeoutMs,
+                    headless: config.headless,
+                    logger,
+                }));
+            }
+            else {
+                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+            }
         }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         const captureRuntimeSnapshot = async () => {
@@ -272,10 +622,10 @@ export async function runBrowserMode(options) {
             }
             try {
                 const { result } = await Runtime.evaluate({
-                    expression: 'location.href',
+                    expression: "location.href",
                     returnByValue: true,
                 });
-                if (typeof result?.value === 'string') {
+                if (typeof result?.value === "string") {
                     lastUrl = result.value;
                 }
             }
@@ -286,7 +636,7 @@ export async function runBrowserMode(options) {
                 logger(`[browser] url = ${lastUrl}`);
             }
             if (chrome?.port) {
-                const suffix = lastTargetId ? ` target=${lastTargetId}` : '';
+                const suffix = lastTargetId ? ` target=${lastTargetId}` : "";
                 if (lastUrl) {
                     logger(`[reattach] chrome port=${chrome.port} host=${chromeHost} url=${lastUrl}${suffix}`);
                 }
@@ -304,8 +654,11 @@ export async function runBrowserMode(options) {
             const start = Date.now();
             while (Date.now() - start < timeoutMs) {
                 try {
-                    const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
-                    if (typeof result?.value === 'string' && result.value.includes('/c/')) {
+                    const { result } = await Runtime.evaluate({
+                        expression: "location.href",
+                        returnByValue: true,
+                    });
+                    if (typeof result?.value === "string" && result.value.includes("/c/")) {
                         lastUrl = result.value;
                         logger(`[browser] conversation url (${label}) = ${lastUrl}`);
                         await emitRuntimeHint();
@@ -333,7 +686,7 @@ export async function runBrowserMode(options) {
         };
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
-        if (config.desiredModel && modelStrategy !== 'ignore') {
+        if (config.desiredModel && modelStrategy !== "ignore") {
             await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
@@ -345,28 +698,47 @@ export async function runBrowserMode(options) {
             })).catch((error) => {
                 const base = error instanceof Error ? error.message : String(error);
                 const hint = appliedCookies === 0
-                    ? ' No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON).'
-                    : '';
+                    ? " No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON)."
+                    : "";
                 throw new Error(`${base}${hint}`);
             });
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        else if (modelStrategy === 'ignore') {
-            logger('Model picker: skipped (strategy=ignore)');
+        else if (modelStrategy === "ignore") {
+            logger("Model picker: skipped (strategy=ignore)");
         }
-        // Handle thinking time selection if specified
+        const deepResearch = config.researchMode === "deep";
+        // Handle thinking time selection if specified. Deep Research owns its own effort flow.
         const thinkingTime = config.thinkingTime;
-        if (thinkingTime) {
-            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+        if (thinkingTime && !deepResearch) {
+            if (shouldSkipThinkingTimeSelection(config.desiredModel, thinkingTime)) {
+                logger("Thinking time: Pro Extended (via model selection)");
+            }
+            else {
+                await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+                    retries: 2,
+                    delayMs: 300,
+                    onRetry: (attempt, error) => {
+                        if (options.verbose) {
+                            logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        }
+                    },
+                }));
+            }
+        }
+        if (deepResearch) {
+            await raceWithDisconnect(withRetries(() => activateDeepResearch(Runtime, Input, logger), {
                 retries: 2,
-                delayMs: 300,
+                delayMs: 500,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Deep Research activation attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             }));
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+            logger(`Prompt textarea ready (after Deep Research activation, ${promptText.length.toLocaleString()} chars queued)`);
         }
         const profileLockTimeoutMs = manualLogin ? (config.profileLockTimeoutMs ?? 0) : 0;
         let profileLock = null;
@@ -387,13 +759,14 @@ export async function runBrowserMode(options) {
         };
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
-            const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
+            const baselineAssistantText = typeof baselineSnapshot?.text === "string" ? baselineSnapshot.text.trim() : "";
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
-            let attachmentWaitTimedOut = false;
             let inputOnlyAttachments = false;
+            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.');
+                    throw new Error("Chrome DOM domain unavailable while uploading attachments.");
                 }
                 await clearComposerAttachments(Runtime, 5_000, logger);
                 for (let attachmentIndex = 0; attachmentIndex < submissionAttachments.length; attachmentIndex += 1) {
@@ -409,24 +782,11 @@ export async function runBrowserMode(options) {
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
                 const perFileTimeout = 20_000;
                 const waitBudget = Math.max(baseTimeout, 45_000) + (submissionAttachments.length - 1) * perFileTimeout;
-                try {
-                    await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-                    logger('All attachments uploaded');
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (/Attachments did not finish uploading before timeout/i.test(message)) {
-                        attachmentWaitTimedOut = true;
-                        logger(`[browser] Attachment upload timed out after ${Math.round(waitBudget / 1000)}s; continuing without confirmation.`);
-                    }
-                    else {
-                        throw error;
-                    }
-                }
+                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                logger("All attachments uploaded");
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
             // Learned: return baselineTurns so assistant polling can ignore earlier content.
-            const sendAttachmentNames = attachmentWaitTimedOut ? [] : attachmentNames;
             const providerState = {
                 runtime: Runtime,
                 input: Input,
@@ -434,7 +794,7 @@ export async function runBrowserMode(options) {
                 timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
-                attachmentNames: sendAttachmentNames,
+                attachmentNames,
             };
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
@@ -444,76 +804,131 @@ export async function runBrowserMode(options) {
                 state: providerState,
             });
             const providerBaselineTurns = providerState.baselineTurns;
-            if (typeof providerBaselineTurns === 'number' && Number.isFinite(providerBaselineTurns)) {
+            if (typeof providerBaselineTurns === "number" && Number.isFinite(providerBaselineTurns)) {
                 baselineTurns = providerBaselineTurns;
             }
             if (attachmentNames.length > 0) {
-                if (attachmentWaitTimedOut) {
-                    logger('Attachment confirmation timed out; skipping user-turn attachment verification.');
-                }
-                else if (inputOnlyAttachments) {
-                    logger('Attachment UI did not render before send; skipping user-turn attachment verification.');
+                if (inputOnlyAttachments) {
+                    logger("Attachment UI did not render before send; skipping user-turn attachment verification.");
                 }
                 else {
-                    const verified = await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger);
+                    const verified = await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger, {
+                        minTurnIndex: baselineTurns ?? undefined,
+                        expectedPrompt: prompt,
+                        expectedConversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    });
                     if (!verified) {
-                        throw new Error('Sent user message did not expose attachment UI after upload.');
+                        logger("Sent user message did not expose attachment UI; continuing after upload check.");
+                    }
+                    else {
+                        logger("Verified attachments present on sent user message");
                     }
-                    logger('Verified attachments present on sent user message');
                 }
             }
             // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
-            scheduleConversationHint('post-submit', config.timeoutMs ?? 120_000);
+            scheduleConversationHint("post-submit", config.timeoutMs ?? 120_000);
             return { baselineTurns, baselineAssistantText };
         };
+        const reloadPromptComposer = async () => {
+            logger("[browser] Composer became unresponsive; reloading page and retrying once.");
+            await raceWithDisconnect(Page.reload({ ignoreCache: true }));
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+        };
         let baselineTurns = null;
         let baselineAssistantText = null;
         await acquireProfileLockIfNeeded();
         try {
-            try {
-                const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
-                baselineTurns = submission.baselineTurns;
-                baselineAssistantText = submission.baselineAssistantText;
-            }
-            catch (error) {
-                const isPromptTooLarge = error instanceof BrowserAutomationError &&
-                    error.details?.code === 'prompt-too-large';
-                if (fallbackSubmission && isPromptTooLarge) {
-                    // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
-                    logger('[browser] Inline prompt too large; retrying with file uploads.');
+            const submission = await runSubmissionWithRecovery({
+                prompt: promptText,
+                attachments,
+                fallbackSubmission,
+                submit: (submissionPrompt, submissionAttachments) => raceWithDisconnect(submitOnce(submissionPrompt, submissionAttachments)),
+                reloadPromptComposer,
+                prepareFallbackSubmission: async () => {
                     await raceWithDisconnect(clearPromptComposer(Runtime, logger));
                     await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
-                    const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
-                    baselineTurns = submission.baselineTurns;
-                    baselineAssistantText = submission.baselineAssistantText;
-                }
-                else {
-                    throw error;
-                }
-            }
+                },
+                logger,
+            });
+            baselineTurns = submission.baselineTurns;
+            baselineAssistantText = submission.baselineAssistantText;
         }
         finally {
             await releaseProfileLockIfHeld();
         }
-        stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
+        const imageArtifactMinTurnIndex = baselineTurns;
+        if (deepResearch) {
+            await raceWithDisconnect(waitForResearchPlanAutoConfirm(Runtime, logger));
+            const researchResult = await raceWithDisconnect(waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client));
+            await updateConversationHint("post-deep-research", 15_000).catch(() => false);
+            runStatus = "complete";
+            const durationMs = Date.now() - startedAt;
+            const tokens = estimateTokenCount(researchResult.text);
+            const reportArtifact = await saveOptionalArtifact(() => saveDeepResearchReportArtifact({
+                sessionId: options.sessionId,
+                reportMarkdown: researchResult.text,
+                conversationUrl: lastUrl,
+                logger,
+            }), logger);
+            const transcriptArtifact = await saveOptionalArtifact(() => saveBrowserTranscriptArtifact({
+                sessionId: options.sessionId,
+                prompt: promptText,
+                answerMarkdown: researchResult.text,
+                conversationUrl: lastUrl,
+                artifacts: appendArtifacts(undefined, [reportArtifact]),
+                logger,
+            }), logger);
+            const savedArtifacts = appendArtifacts(undefined, [reportArtifact, transcriptArtifact]);
+            const archive = await maybeArchiveCompletedConversation({
+                Runtime,
+                logger,
+                config,
+                conversationUrl: lastUrl,
+                followUpCount: 0,
+                requiredArtifactsSaved: Boolean(reportArtifact && transcriptArtifact),
+            });
+            return {
+                answerText: researchResult.text,
+                answerMarkdown: researchResult.text,
+                answerHtml: researchResult.html,
+                artifacts: savedArtifacts,
+                archive,
+                tookMs: durationMs,
+                answerTokens: tokens,
+                answerChars: researchResult.text.length,
+                chromePid: chrome.pid,
+                chromePort: chrome.port,
+                chromeHost,
+                userDataDir,
+                chromeTargetId: lastTargetId,
+                tabUrl: lastUrl,
+                conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                controllerPid: process.pid,
+            };
+        }
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
-        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, " ").trim();
+        const expectedConversationId = () => lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
         const waitForFreshAssistantResponse = async (baselineNormalized, timeoutMs) => {
             const baselinePrefix = baselineNormalized.length >= 80
                 ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
+                : "";
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text) {
                     const normalized = normalizeForComparison(text);
-                    const isBaseline = normalized === baselineNormalized || (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
+                    const isBaseline = normalized === baselineNormalized ||
+                        (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
                     if (!isBaseline) {
                         return {
                             text,
                             html: snapshot?.html ?? undefined,
-                            meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+                            meta: {
+                                turnId: snapshot?.turnId ?? undefined,
+                                messageId: snapshot?.messageId ?? undefined,
+                            },
                         };
                     }
                 }
@@ -521,7 +936,19 @@ export async function runBrowserMode(options) {
             }
             return null;
         };
-        let answer;
+        const waitWithThinkingMonitor = async (operation) => {
+            stopThinkingMonitor?.();
+            stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, {
+                intervalMs: options.heartbeatIntervalMs,
+            });
+            try {
+                return await operation();
+            }
+            finally {
+                stopThinkingMonitor?.();
+                stopThinkingMonitor = null;
+            }
+        };
         const recheckDelayMs = Math.max(0, config.assistantRecheckDelayMs ?? 0);
         const recheckTimeoutMs = Math.max(0, config.assistantRecheckTimeoutMs ?? 0);
         const attemptAssistantRecheck = async () => {
@@ -529,7 +956,7 @@ export async function runBrowserMode(options) {
                 return null;
             logger(`[browser] Assistant response timed out; waiting ${formatElapsed(recheckDelayMs)} before rechecking conversation.`);
             await raceWithDisconnect(delay(recheckDelayMs));
-            await updateConversationHint('assistant-recheck', 15_000).catch(() => false);
+            await updateConversationHint("assistant-recheck", 15_000).catch(() => false);
             await captureRuntimeSnapshot().catch(() => undefined);
             const conversationUrl = await readConversationUrl(Runtime);
             if (conversationUrl && isConversationUrl(conversationUrl)) {
@@ -544,12 +971,12 @@ export async function runBrowserMode(options) {
                 // Update session metadata to indicate login is needed
                 await emitRuntimeHint();
                 throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
-                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || "unknown"}. ` +
                     `Please sign in and retry.`, {
-                    stage: 'assistant-recheck',
+                    stage: "assistant-recheck",
                     details: {
                         conversationUrl: conversationUrl || lastUrl || null,
-                        sessionStatus: 'needs_login',
+                        sessionStatus: "needs_login",
                         validationReason: sessionValid.reason,
                     },
                     runtime: {
@@ -565,170 +992,281 @@ export async function runBrowserMode(options) {
                 });
             }
             const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
-            const rechecked = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined));
-            logger('Recovered assistant response after delayed recheck');
+            const rechecked = await waitWithThinkingMonitor(() => raceWithDisconnect(waitForAssistantOrGeneratedImageResponse({
+                Runtime,
+                waitForText: () => waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()),
+                timeoutMs,
+                logger,
+                minTurnIndex: baselineTurns ?? undefined,
+                expectedConversationId: expectedConversationId(),
+                imageOutputRequested,
+            })));
+            logger("Recovered assistant response after delayed recheck");
             return rechecked;
         };
-        try {
-            answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
-        }
-        catch (error) {
-            if (isAssistantResponseTimeoutError(error)) {
-                const rechecked = await attemptAssistantRecheck().catch(() => null);
-                if (rechecked) {
-                    answer = rechecked;
+        const imageOutputRequested = Boolean(options.generateImagePath ||
+            options.outputPath ||
+            options.generateImage);
+        const captureAssistantTurn = async (turnPrompt, label) => {
+            let turnAnswer;
+            try {
+                await updateConversationHint("assistant-wait", 15_000).catch(() => false);
+                turnAnswer = await waitWithThinkingMonitor(() => raceWithDisconnect(waitForAssistantOrGeneratedImageResponse({
+                    Runtime,
+                    waitForText: () => waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()),
+                    timeoutMs: config.timeoutMs,
+                    logger,
+                    minTurnIndex: baselineTurns ?? undefined,
+                    expectedConversationId: expectedConversationId(),
+                    imageOutputRequested,
+                })));
+            }
+            catch (error) {
+                if (isAssistantResponseTimeoutError(error)) {
+                    const rechecked = await attemptAssistantRecheckOrRethrow(attemptAssistantRecheck);
+                    if (rechecked) {
+                        turnAnswer = rechecked;
+                    }
+                    else {
+                        await updateConversationHint("assistant-timeout", 15_000).catch(() => false);
+                        await captureRuntimeSnapshot().catch(() => undefined);
+                        const diagnostics = await captureBrowserDiagnostics(Runtime, logger, "assistant-timeout", {
+                            Page,
+                            sessionId: options.sessionId,
+                        }).catch(() => undefined);
+                        const runtime = {
+                            chromePid: chrome.pid,
+                            chromePort: chrome.port,
+                            chromeHost,
+                            userDataDir,
+                            chromeTargetId: lastTargetId,
+                            tabUrl: lastUrl,
+                            conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                            controllerPid: process.pid,
+                        };
+                        throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime, diagnostics }, error);
+                    }
                 }
                 else {
-                    await updateConversationHint('assistant-timeout', 15_000).catch(() => false);
-                    await captureRuntimeSnapshot().catch(() => undefined);
-                    const runtime = {
-                        chromePid: chrome.pid,
-                        chromePort: chrome.port,
-                        chromeHost,
-                        userDataDir,
-                        chromeTargetId: lastTargetId,
-                        tabUrl: lastUrl,
-                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
-                        controllerPid: process.pid,
-                    };
-                    throw new BrowserAutomationError('Assistant response timed out before completion; reattach later to capture the answer.', { stage: 'assistant-timeout', runtime }, error);
+                    throw error;
                 }
             }
-            else {
-                throw error;
+            // Ensure we store the final conversation URL even if the UI updated late.
+            await updateConversationHint("post-response", 15_000);
+            const baselineNormalized = baselineAssistantText
+                ? normalizeForComparison(baselineAssistantText)
+                : "";
+            if (baselineNormalized) {
+                const normalizedAnswer = normalizeForComparison(turnAnswer.text ?? "");
+                const baselinePrefix = baselineNormalized.length >= 80
+                    ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+                    : "";
+                const isBaseline = normalizedAnswer === baselineNormalized ||
+                    (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
+                if (isBaseline) {
+                    logger("Detected stale assistant response; waiting for new response...");
+                    const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
+                    if (refreshed) {
+                        turnAnswer = refreshed;
+                    }
+                }
             }
-        }
-        // Ensure we store the final conversation URL even if the UI updated late.
-        await updateConversationHint('post-response', 15_000);
-        const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
-        if (baselineNormalized) {
-            const normalizedAnswer = normalizeForComparison(answer.text ?? '');
-            const baselinePrefix = baselineNormalized.length >= 80
-                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
-            const isBaseline = normalizedAnswer === baselineNormalized ||
-                (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
-            if (isBaseline) {
-                logger('Detected stale assistant response; waiting for new response...');
-                const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
-                if (refreshed) {
-                    answer = refreshed;
+            let turnAnswerText = turnAnswer.text;
+            const turnAnswerHtml = turnAnswer.html ?? "";
+            const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
+                const attempt = await captureAssistantMarkdown(Runtime, turnAnswer.meta, logger);
+                if (!attempt) {
+                    throw new Error("copy-missing");
+                }
+                return attempt;
+            }, {
+                retries: 2,
+                delayMs: 350,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Markdown capture attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            })).catch(() => null);
+            let turnAnswerMarkdown = copiedMarkdown ?? turnAnswerText;
+            const promptEchoMatcher = buildPromptEchoMatcher(turnPrompt);
+            ({ answerText: turnAnswerText, answerMarkdown: turnAnswerMarkdown } =
+                await maybeRecoverLongAssistantResponse({
+                    runtime: Runtime,
+                    baselineTurns,
+                    answerText: turnAnswerText,
+                    answerMarkdown: turnAnswerMarkdown,
+                    logger,
+                    allowMarkdownUpdate: !copiedMarkdown,
+                }));
+            // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
+            const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+            const finalText = typeof finalSnapshot?.text === "string" ? finalSnapshot.text.trim() : "";
+            if (finalText && finalText !== turnPrompt.trim()) {
+                const trimmedMarkdown = turnAnswerMarkdown.trim();
+                const finalIsEcho = promptEchoMatcher ? promptEchoMatcher.isEcho(finalText) : false;
+                const lengthDelta = finalText.length - trimmedMarkdown.length;
+                const missingCopy = !copiedMarkdown && lengthDelta >= 0;
+                const likelyTruncatedCopy = copiedMarkdown &&
+                    trimmedMarkdown.length > 0 &&
+                    lengthDelta >= Math.max(12, Math.floor(trimmedMarkdown.length * 0.75));
+                if ((missingCopy || likelyTruncatedCopy) && !finalIsEcho && finalText !== trimmedMarkdown) {
+                    logger("Refreshed assistant response via final DOM snapshot");
+                    turnAnswerText = finalText;
+                    turnAnswerMarkdown = finalText;
                 }
             }
-        }
-        answerText = answer.text;
-        answerHtml = answer.html ?? '';
-        const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
-            const attempt = await captureAssistantMarkdown(Runtime, answer.meta, logger);
-            if (!attempt) {
-                throw new Error('copy-missing');
-            }
-            return attempt;
-        }, {
-            retries: 2,
-            delayMs: 350,
-            onRetry: (attempt, error) => {
-                if (options.verbose) {
-                    logger(`[retry] Markdown capture attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+            // Detect prompt echo using normalized comparison (whitespace-insensitive).
+            const alignedEcho = alignPromptEchoPair(turnAnswerText, turnAnswerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
+                text: "Aligned assistant response text to copied markdown after prompt echo",
+                markdown: "Aligned assistant markdown to response text after prompt echo",
+            });
+            turnAnswerText = alignedEcho.answerText;
+            turnAnswerMarkdown = alignedEcho.answerMarkdown;
+            const isPromptEcho = alignedEcho.isEcho;
+            if (isPromptEcho) {
+                logger("Detected prompt echo in response; waiting for actual assistant response...");
+                const deadline = Date.now() + 15_000;
+                let bestText = null;
+                let stableCount = 0;
+                while (Date.now() < deadline) {
+                    const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                    const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
+                    const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
+                    if (!isStillEcho) {
+                        if (!bestText || text.length > bestText.length) {
+                            bestText = text;
+                            stableCount = 0;
+                        }
+                        else if (text === bestText) {
+                            stableCount += 1;
+                        }
+                        if (stableCount >= 2) {
+                            break;
+                        }
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 300));
                 }
-            },
-        })).catch(() => null);
-        answerMarkdown = copiedMarkdown ?? answerText;
-        const promptEchoMatcher = buildPromptEchoMatcher(promptText);
-        ({ answerText, answerMarkdown } = await maybeRecoverLongAssistantResponse({
-            runtime: Runtime,
-            baselineTurns,
-            answerText,
-            answerMarkdown,
-            logger,
-            allowMarkdownUpdate: !copiedMarkdown,
-        }));
-        // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
-        const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-        const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
-        if (finalText && finalText !== promptText.trim()) {
-            const trimmedMarkdown = answerMarkdown.trim();
-            const finalIsEcho = promptEchoMatcher ? promptEchoMatcher.isEcho(finalText) : false;
-            const lengthDelta = finalText.length - trimmedMarkdown.length;
-            const missingCopy = !copiedMarkdown && lengthDelta >= 0;
-            const likelyTruncatedCopy = copiedMarkdown &&
-                trimmedMarkdown.length > 0 &&
-                lengthDelta >= Math.max(12, Math.floor(trimmedMarkdown.length * 0.75));
-            if ((missingCopy || likelyTruncatedCopy) && !finalIsEcho && finalText !== trimmedMarkdown) {
-                logger('Refreshed assistant response via final DOM snapshot');
-                answerText = finalText;
-                answerMarkdown = finalText;
-            }
-        }
-        // Detect prompt echo using normalized comparison (whitespace-insensitive).
-        const alignedEcho = alignPromptEchoPair(answerText, answerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
-            text: 'Aligned assistant response text to copied markdown after prompt echo',
-            markdown: 'Aligned assistant markdown to response text after prompt echo',
-        });
-        answerText = alignedEcho.answerText;
-        answerMarkdown = alignedEcho.answerMarkdown;
-        const isPromptEcho = alignedEcho.isEcho;
-        if (isPromptEcho) {
-            logger('Detected prompt echo in response; waiting for actual assistant response...');
-            const deadline = Date.now() + 15_000;
-            let bestText = null;
-            let stableCount = 0;
-            while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
-                const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
-                if (!isStillEcho) {
-                    if (!bestText || text.length > bestText.length) {
+                if (bestText) {
+                    logger("Recovered assistant response after detecting prompt echo");
+                    turnAnswerText = bestText;
+                    turnAnswerMarkdown = bestText;
+                }
+            }
+            const minAnswerChars = 16;
+            if (turnAnswerText.trim().length > 0 && turnAnswerText.trim().length < minAnswerChars) {
+                const deadline = Date.now() + 12_000;
+                let bestText = turnAnswerText.trim();
+                let stableCycles = 0;
+                while (Date.now() < deadline) {
+                    const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                    const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
+                    if (text && text.length > bestText.length) {
                         bestText = text;
-                        stableCount = 0;
+                        stableCycles = 0;
                     }
-                    else if (text === bestText) {
-                        stableCount += 1;
+                    else {
+                        stableCycles += 1;
                     }
-                    if (stableCount >= 2) {
+                    if (stableCycles >= 3 && bestText.length >= minAnswerChars) {
                         break;
                     }
+                    await delay(400);
                 }
-                await new Promise((resolve) => setTimeout(resolve, 300));
-            }
-            if (bestText) {
-                logger('Recovered assistant response after detecting prompt echo');
-                answerText = bestText;
-                answerMarkdown = bestText;
-            }
-        }
-        const minAnswerChars = 16;
-        if (answerText.trim().length > 0 && answerText.trim().length < minAnswerChars) {
-            const deadline = Date.now() + 12_000;
-            let bestText = answerText.trim();
-            let stableCycles = 0;
-            while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
-                if (text && text.length > bestText.length) {
-                    bestText = text;
-                    stableCycles = 0;
-                }
-                else {
-                    stableCycles += 1;
-                }
-                if (stableCycles >= 3 && bestText.length >= minAnswerChars) {
-                    break;
+                if (bestText.length > turnAnswerText.trim().length) {
+                    logger("Refreshed short assistant response from latest DOM snapshot");
+                    turnAnswerText = bestText;
+                    turnAnswerMarkdown = bestText;
                 }
-                await delay(400);
             }
-            if (bestText.length > answerText.trim().length) {
-                logger('Refreshed short assistant response from latest DOM snapshot');
-                answerText = bestText;
-                answerMarkdown = bestText;
+            return {
+                label,
+                answerText: turnAnswerText,
+                answerMarkdown: turnAnswerMarkdown,
+                answerHtml: turnAnswerHtml,
+            };
+        };
+        const turns = [];
+        const initialTurn = await captureAssistantTurn(promptText, "Initial response");
+        turns.push(initialTurn);
+        answerText = initialTurn.answerText;
+        answerMarkdown = initialTurn.answerMarkdown;
+        answerHtml = initialTurn.answerHtml;
+        for (let index = 0; index < followUpPrompts.length; index += 1) {
+            const followUpPrompt = followUpPrompts[index];
+            logger(`[browser] Sending follow-up ${index + 1}/${followUpPrompts.length}`);
+            await acquireProfileLockIfNeeded();
+            try {
+                await raceWithDisconnect(clearPromptComposer(Runtime, logger));
+                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+                const submission = await runSubmissionWithRecovery({
+                    prompt: followUpPrompt,
+                    attachments: [],
+                    submit: (submissionPrompt, submissionAttachments) => raceWithDisconnect(submitOnce(submissionPrompt, submissionAttachments)),
+                    reloadPromptComposer,
+                    prepareFallbackSubmission: async () => {
+                        await raceWithDisconnect(clearPromptComposer(Runtime, logger));
+                        await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+                    },
+                    logger,
+                });
+                baselineTurns = submission.baselineTurns;
+                baselineAssistantText = submission.baselineAssistantText;
+            }
+            finally {
+                await releaseProfileLockIfHeld();
             }
+            const turn = await captureAssistantTurn(followUpPrompt, `Follow-up ${index + 1}`);
+            turns.push({ ...turn, prompt: followUpPrompt });
+            answerText = turn.answerText;
+            answerMarkdown = turn.answerMarkdown;
+            answerHtml = turn.answerHtml;
+        }
+        if (turns.length > 1) {
+            const formatted = formatBrowserTurnTranscript(turns);
+            answerText = formatted.answerText;
+            answerMarkdown = formatted.answerMarkdown;
+            answerHtml = "";
         }
         if (connectionClosedUnexpectedly) {
             // Bail out on mid-run disconnects so the session stays reattachable.
-            throw new Error('Chrome disconnected before completion');
+            throw new Error("Chrome disconnected before completion");
         }
-        stopThinkingMonitor?.();
-        runStatus = 'complete';
+        const imageArtifacts = await collectGeneratedImageArtifacts({
+            Runtime,
+            Network,
+            logger,
+            minTurnIndex: imageArtifactMinTurnIndex,
+            sessionId: options.sessionId,
+            generateImagePath: options.generateImagePath,
+            outputPath: options.outputPath,
+            answerText,
+            waitTimeoutMs: options.config?.timeoutMs,
+        });
+        answerText = imageArtifacts.answerText || answerText;
+        if (imageArtifacts.markdownSuffix) {
+            answerMarkdown += imageArtifacts.markdownSuffix;
+        }
+        const savedImageArtifacts = appendArtifacts(undefined, imageArtifacts.savedImages);
+        const transcriptArtifact = await saveOptionalArtifact(() => saveBrowserTranscriptArtifact({
+            sessionId: options.sessionId,
+            prompt: promptText,
+            answerMarkdown,
+            conversationUrl: lastUrl,
+            artifacts: savedImageArtifacts,
+            logger,
+        }), logger);
+        const savedArtifacts = appendArtifacts(savedImageArtifacts, [transcriptArtifact]);
+        const archive = await maybeArchiveCompletedConversation({
+            Runtime,
+            logger,
+            config,
+            conversationUrl: lastUrl,
+            followUpCount: followUpPrompts.length,
+            requiredArtifactsSaved: Boolean(transcriptArtifact) &&
+                imageArtifacts.savedImages.length === imageArtifacts.imageCount,
+        });
+        runStatus = "complete";
         const durationMs = Date.now() - startedAt;
         const answerChars = answerText.length;
         const answerTokens = estimateTokenCount(answerMarkdown);
@@ -736,6 +1274,10 @@ export async function runBrowserMode(options) {
             answerText,
             answerMarkdown,
             answerHtml: answerHtml.length > 0 ? answerHtml : undefined,
+            artifacts: savedArtifacts,
+            generatedImages: imageArtifacts.generatedImages,
+            savedImages: imageArtifacts.savedImages,
+            archive,
             tookMs: durationMs,
             answerTokens,
             answerChars,
@@ -745,15 +1287,16 @@ export async function runBrowserMode(options) {
             userDataDir,
             chromeTargetId: lastTargetId,
             tabUrl: lastUrl,
+            conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
             controllerPid: process.pid,
         };
     }
     catch (error) {
         const normalizedError = error instanceof Error ? error : new Error(String(error));
-        stopThinkingMonitor?.();
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
-        if (shouldPreserveBrowserOnError(normalizedError, config.headless)) {
+        const preservedErrorKind = classifyPreservedBrowserError(normalizedError, config.headless);
+        if (preservedErrorKind === "cloudflare-challenge") {
             preserveBrowserOnError = true;
             const runtime = {
                 chromePid: chrome.pid,
@@ -767,28 +1310,34 @@ export async function runBrowserMode(options) {
             const reuseProfileHint = `oracle --engine browser --browser-manual-login ` +
                 `--browser-manual-login-profile-dir ${JSON.stringify(userDataDir)}`;
             await emitRuntimeHint();
-            logger('Cloudflare challenge detected; leaving browser open so you can complete the check.');
+            logger("Cloudflare challenge detected; leaving browser open so you can complete the check.");
             logger(`Reuse this browser profile with: ${reuseProfileHint}`);
-            throw new BrowserAutomationError('Cloudflare challenge detected. Complete the “Just a moment…” check in the open browser, then rerun.', {
-                stage: 'cloudflare-challenge',
+            throw new BrowserAutomationError("Cloudflare challenge detected. Complete the “Just a moment…” check in the open browser, then rerun.", {
+                stage: "cloudflare-challenge",
                 runtime,
                 reuseProfileHint,
             }, normalizedError);
         }
+        if (preservedErrorKind === "reattachable-capture") {
+            preserveBrowserOnError = true;
+            await emitRuntimeHint();
+            logger("Assistant capture incomplete; leaving browser open for reattach.");
+            throw normalizedError;
+        }
         if (!socketClosed) {
             logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
-            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
                 logger(normalizedError.stack);
             }
             throw normalizedError;
         }
-        if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+        if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
             logger(`Chrome window closed before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
         await emitRuntimeHint();
-        throw new BrowserAutomationError('Chrome window closed before oracle finished. Please keep it open until completion.', {
-            stage: 'connection-lost',
+        throw new BrowserAutomationError("Chrome window closed before oracle finished. Please keep it open until completion.", {
+            stage: "connection-lost",
             runtime: {
                 chromePid: chrome.pid,
                 chromePort: chrome.port,
@@ -812,16 +1361,70 @@ export async function runBrowserMode(options) {
         // 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.
-        if (runStatus === 'complete' && isolatedTargetId && chrome?.port) {
+        if (shouldCloseOwnedRunTargetAfterRun({
+            runStatus,
+            ownsTarget,
+            keepBrowser: effectiveKeepBrowser,
+        }) &&
+            isolatedTargetId &&
+            chrome?.port) {
             await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
         }
+        let keepBrowserOpen = effectiveKeepBrowser || preserveBrowserOnError;
+        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 (runStatus === "complete" &&
+            manualLogin &&
+            !connectionClosedUnexpectedly &&
+            chrome?.port &&
+            ownsTarget) {
+            const otherLeasesActive = await hasOtherActiveLeases().catch(() => true);
+            if (!otherLeasesActive) {
+                await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
+                    excludeTargetIds: [isolatedTargetId, lastTargetId],
+                }).catch(() => undefined);
+            }
+        }
+        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);
+            }
+        }
+        if (tabLease) {
+            const handle = tabLease;
+            tabLease = null;
+            await handle.release().catch(() => undefined);
+        }
         removeDialogHandler?.();
         removeTerminationHooks?.();
-        const keepBrowserOpen = effectiveKeepBrowser || preserveBrowserOnError;
         if (!keepBrowserOpen) {
             if (!connectionClosedUnexpectedly) {
                 try {
-                    await chrome.kill();
+                    if (!terminatedRecordedChrome) {
+                        await chrome.kill();
+                    }
                 }
                 catch {
                     // ignore kill failures
@@ -834,7 +1437,7 @@ export async function runBrowserMode(options) {
                 });
                 if (shouldCleanup) {
                     // Preserve the persistent manual-login profile, but clear stale reattach hints.
-                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'never' }).catch(() => undefined);
+                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
                 }
             }
             else {
@@ -845,8 +1448,16 @@ export async function runBrowserMode(options) {
                 logger(`Cleanup ${runStatus} • ${totalSeconds.toFixed(1)}s total`);
             }
         }
-        else if (!connectionClosedUnexpectedly) {
-            logger(`Chrome left running on port ${chrome.port} with profile ${userDataDir}`);
+        else {
+            detachKeptChromeProcess(chrome);
+            if (!connectionClosedUnexpectedly) {
+                logger(`Chrome left running on port ${chrome.port} with profile ${userDataDir}`);
+            }
+        }
+        if (cleanupProfileLock) {
+            const handle = cleanupProfileLock;
+            cleanupProfileLock = null;
+            await handle.release().catch(() => undefined);
         }
     }
 }
@@ -866,28 +1477,28 @@ async function pickAvailableDebugPort(preferredPort, logger) {
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
         const server = net.createServer();
-        server.once('error', () => resolve(false));
-        server.once('listening', () => {
+        server.once("error", () => resolve(false));
+        server.once("listening", () => {
             server.close(() => resolve(true));
         });
-        server.listen(port, '127.0.0.1');
+        server.listen(port, "127.0.0.1");
     });
 }
 async function findEphemeralPort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
-        server.once('error', (error) => {
+        server.once("error", (error) => {
             server.close();
             reject(error);
         });
-        server.listen(0, '127.0.0.1', () => {
+        server.listen(0, "127.0.0.1", () => {
             const address = server.address();
-            if (address && typeof address === 'object') {
+            if (address && typeof address === "object") {
                 const port = address.port;
                 server.close(() => resolve(port));
             }
             else {
-                server.close(() => reject(new Error('Failed to acquire ephemeral port')));
+                server.close(() => reject(new Error("Failed to acquire ephemeral port")));
             }
         });
     });
@@ -906,20 +1517,20 @@ async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, time
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const loginDetected = message?.toLowerCase().includes('login button');
-            const sessionMissing = message?.toLowerCase().includes('session not detected');
+            const loginDetected = message?.toLowerCase().includes("login button");
+            const sessionMissing = message?.toLowerCase().includes("session not detected");
             if (!loginDetected && !sessionMissing) {
                 throw error;
             }
             const now = Date.now();
             if (now - lastNotice > 5000) {
-                logger('Manual login mode: please sign into chatgpt.com in the opened Chrome window; waiting for session to appear...');
+                logger("Manual login mode: please sign into chatgpt.com in the opened Chrome window; waiting for session to appear...");
                 lastNotice = now;
             }
             await delay(1000);
         }
     }
-    throw new Error('Manual login mode timed out waiting for ChatGPT session; please sign in and retry.');
+    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
 }
 async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answerText, answerMarkdown, logger, allowMarkdownUpdate, }) {
     // Learned: long streaming responses can still be rendering after initial capture.
@@ -933,7 +1544,7 @@ async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answe
     let bestText = answerText;
     for (let i = 0; i < 5; i++) {
         const laterSnapshot = await readAssistantSnapshot(runtime, baselineTurns ?? undefined).catch(() => null);
-        const laterText = typeof laterSnapshot?.text === 'string' ? laterSnapshot.text.trim() : '';
+        const laterText = typeof laterSnapshot?.text === "string" ? laterSnapshot.text.trim() : "";
         if (laterText.length > bestLength) {
             bestLength = laterText.length;
             bestText = laterText;
@@ -954,24 +1565,69 @@ async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answe
 }
 async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
     const deadline = Date.now() + timeoutMs;
-    let lastUrl = '';
+    let lastUrl = "";
     while (Date.now() < deadline) {
         const { result } = await runtime.evaluate({
             expression: 'typeof location === "object" && location.href ? location.href : ""',
             returnByValue: true,
         });
-        const url = typeof result?.value === 'string' ? result.value : '';
+        const url = typeof result?.value === "string" ? result.value : "";
         lastUrl = url;
         if (/^https?:\/\//i.test(url)) {
             return url;
         }
         await delay(250);
     }
-    throw new BrowserAutomationError('ChatGPT session not detected; page never left new tab.', {
-        stage: 'execute-browser',
-        details: { url: lastUrl || '(empty)' },
+    throw new BrowserAutomationError("ChatGPT session not detected; page never left new tab.", {
+        stage: "execute-browser",
+        details: { url: lastUrl || "(empty)" },
     });
 }
+function detachKeptChromeProcess(chrome) {
+    try {
+        chrome.process?.unref();
+    }
+    catch {
+        // Best-effort only; cleanup should not mask the original browser result.
+    }
+}
+async function acquireManualLoginChromeForRun(userDataDir, config, logger, sessionId, deps = {}) {
+    const maybeReuse = deps.maybeReuse ?? maybeReuseRunningChrome;
+    const launch = deps.launch ?? launchChrome;
+    const lockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
+    let launchLock = null;
+    if (lockTimeoutMs > 0) {
+        launchLock = await acquireProfileRunLock(userDataDir, {
+            timeoutMs: lockTimeoutMs,
+            logger,
+            sessionId,
+        });
+    }
+    try {
+        const reusedChrome = await maybeReuse(userDataDir, logger, {
+            waitForPortMs: config.reuseChromeWaitMs,
+        });
+        const chrome = reusedChrome ??
+            (await launch({
+                ...config,
+                remoteChrome: config.remoteChrome,
+            }, userDataDir, logger));
+        // Persist while the launch lock is still held so parallel callers reuse
+        // this Chrome instead of racing to start another one on the same profile.
+        if (chrome.port) {
+            await writeDevToolsActivePort(userDataDir, chrome.port);
+            if (!reusedChrome && chrome.pid) {
+                await writeChromePid(userDataDir, chrome.pid);
+            }
+        }
+        return { chrome, reusedChrome };
+    }
+    finally {
+        if (launchLock) {
+            await launchLock.release().catch(() => undefined);
+        }
+    }
+}
 async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
     const waitForPortMs = Math.max(0, options.waitForPortMs ?? 0);
     let port = await readDevToolsPort(userDataDir);
@@ -983,17 +1639,38 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
             port = await readDevToolsPort(userDataDir);
         }
     }
-    if (!port)
-        return null;
+    let pid = await readChromePid(userDataDir);
+    if (!port) {
+        const discovered = await findRunningChromeDebugTargetForProfile(userDataDir);
+        if (!discovered)
+            return null;
+        const discoveredProbe = await (options.probe ?? verifyDevToolsReachable)({
+            port: discovered.port,
+        });
+        if (!discoveredProbe.ok) {
+            logger(`Discovered Chrome for ${userDataDir} on port ${discovered.port} but it was unreachable (${discoveredProbe.error}); launching new Chrome.`);
+            return null;
+        }
+        await writeDevToolsActivePort(userDataDir, discovered.port);
+        await writeChromePid(userDataDir, discovered.pid);
+        port = discovered.port;
+        pid = discovered.pid;
+        logger(`Discovered running Chrome for ${userDataDir}; reusing (DevTools port ${port}, pid ${pid})`);
+        return {
+            port,
+            pid,
+            kill: async () => { },
+            process: undefined,
+        };
+    }
     const probe = await (options.probe ?? verifyDevToolsReachable)({ port });
     if (!probe.ok) {
         logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${probe.error}); launching new Chrome.`);
         // Safe cleanup: remove stale DevToolsActivePort; only remove lock files if this was an Oracle-owned pid that died.
-        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'if_oracle_pid_dead' });
+        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "if_oracle_pid_dead" });
         return null;
     }
-    const pid = await readChromePid(userDataDir);
-    logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
+    logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ""})`);
     return {
         port,
         pid: pid ?? undefined,
@@ -1004,13 +1681,16 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
 async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
     const remoteChromeConfig = config.remoteChrome;
     if (!remoteChromeConfig) {
-        throw new Error('Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.');
+        throw new Error("Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.");
     }
     const { host, port } = remoteChromeConfig;
     logger(`Connecting to remote Chrome at ${host}:${port}`);
     let client = null;
     let remoteTargetId = null;
+    let tabLease = null;
     let lastUrl;
+    let attachedExistingTab = false;
+    let ownsTarget = true;
     const runtimeHintCb = options.runtimeHintCb;
     const emitRuntimeHint = async () => {
         if (!runtimeHintCb)
@@ -1019,10 +1699,19 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await runtimeHintCb({
                 chromePort: port,
                 chromeHost: host,
+                chromeBrowserWSEndpoint: browserWSEndpoint,
+                chromeProfileRoot,
                 chromeTargetId: remoteTargetId ?? undefined,
                 tabUrl: lastUrl,
+                conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
                 controllerPid: process.pid,
             });
+            await tabLease?.update({
+                chromeHost: host,
+                chromePort: port,
+                chromeTargetId: remoteTargetId ?? undefined,
+                tabUrl: lastUrl,
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -1030,41 +1719,91 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
     };
     const startedAt = Date.now();
-    let answerText = '';
-    let answerMarkdown = '';
-    let answerHtml = '';
+    let answerText = "";
+    let answerMarkdown = "";
+    let answerHtml = "";
     let connectionClosedUnexpectedly = false;
+    let runStatus = "attempted";
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
+    let connection = null;
+    const browserWSEndpoint = config.remoteChromeBrowserWSEndpoint ?? undefined;
+    const chromeProfileRoot = config.remoteChromeProfileRoot ?? undefined;
     try {
-        const connection = await connectToRemoteChrome(host, port, logger, config.url);
-        client = connection.client;
-        remoteTargetId = connection.targetId ?? null;
+        const remoteLeaseProfileDir = config.browserTabRef
+            ? null
+            : resolveRemoteTabLeaseProfileDir(config);
+        if (remoteLeaseProfileDir) {
+            await mkdir(remoteLeaseProfileDir, { recursive: true });
+            tabLease = await acquireBrowserTabLease(remoteLeaseProfileDir, {
+                maxConcurrentTabs: config.maxConcurrentTabs,
+                timeoutMs: config.timeoutMs,
+                logger,
+                sessionId: options.sessionId,
+                chromeHost: host,
+                chromePort: port,
+            });
+        }
+        if (config.browserTabRef) {
+            const attached = await connectToExistingChatGptTab({
+                host,
+                port,
+                ref: config.browserTabRef,
+            });
+            client = attached.client;
+            remoteTargetId = attached.targetId ?? null;
+            lastUrl = attached.tab.url || lastUrl;
+            attachedExistingTab = true;
+            ownsTarget = false;
+            logger(`Attached to existing remote ChatGPT tab ${attached.targetId}${attached.tab.url ? ` (${attached.tab.url})` : ""}`);
+        }
+        else {
+            connection = await connectToRemoteChrome(host, port, logger, config.url, browserWSEndpoint, {
+                approvalWaitMs: config.attachRunning && browserWSEndpoint ? 20_000 : undefined,
+            });
+            client = connection.client;
+            remoteTargetId = connection.targetId ?? null;
+            ownsTarget = true;
+        }
+        if (tabLease && remoteTargetId) {
+            await tabLease.update({
+                chromeHost: host,
+                chromePort: port,
+                chromeTargetId: remoteTargetId,
+            });
+        }
         await emitRuntimeHint();
         const markConnectionLost = () => {
             connectionClosedUnexpectedly = true;
         };
-        client.on('disconnect', markConnectionLost);
+        client.on("disconnect", markConnectionLost);
         const { Network, Page, Runtime, Input, DOM } = client;
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
-        if (DOM && typeof DOM.enable === 'function') {
+        if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         // Skip cookie sync for remote Chrome - it already has cookies
-        logger('Skipping cookie sync for remote Chrome (using existing session)');
-        await navigateToChatGPT(Page, Runtime, config.url, logger);
-        await ensureNotBlocked(Runtime, config.headless, logger);
-        await ensureLoggedIn(Runtime, logger, { remoteSession: true });
-        await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        logger("Skipping cookie sync for remote Chrome (using existing session)");
+        if (!attachedExistingTab) {
+            await navigateToChatGPT(Page, Runtime, config.url, logger);
+            await ensureNotBlocked(Runtime, config.headless, logger);
+            await ensureLoggedIn(Runtime, logger, { remoteSession: true });
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        }
+        else {
+            await ensureNotBlocked(Runtime, config.headless, logger);
+            await ensureLoggedIn(Runtime, logger, { remoteSession: true });
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         try {
             const { result } = await Runtime.evaluate({
-                expression: 'location.href',
+                expression: "location.href",
                 returnByValue: true,
             });
-            if (typeof result?.value === 'string') {
+            if (typeof result?.value === "string") {
                 lastUrl = result.value;
             }
             await emitRuntimeHint();
@@ -1073,7 +1812,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             // ignore
         }
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
-        if (config.desiredModel && modelStrategy !== 'ignore') {
+        if (config.desiredModel && modelStrategy !== "ignore") {
             await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
@@ -1086,29 +1825,50 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        else if (modelStrategy === 'ignore') {
-            logger('Model picker: skipped (strategy=ignore)');
+        else if (modelStrategy === "ignore") {
+            logger("Model picker: skipped (strategy=ignore)");
         }
-        // Handle thinking time selection if specified
+        const deepResearch = config.researchMode === "deep";
+        // Handle thinking time selection if specified. Deep Research owns its own effort flow.
         const thinkingTime = config.thinkingTime;
-        if (thinkingTime) {
-            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+        if (thinkingTime && !deepResearch) {
+            if (shouldSkipThinkingTimeSelection(config.desiredModel, thinkingTime)) {
+                logger("Thinking time: Pro Extended (via model selection)");
+            }
+            else {
+                await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+                    retries: 2,
+                    delayMs: 300,
+                    onRetry: (attempt, error) => {
+                        if (options.verbose) {
+                            logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        }
+                    },
+                });
+            }
+        }
+        if (deepResearch) {
+            await withRetries(() => activateDeepResearch(Runtime, Input, logger), {
                 retries: 2,
-                delayMs: 300,
+                delayMs: 500,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Deep Research activation attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             });
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+            logger(`Prompt textarea ready (after Deep Research activation, ${promptText.length.toLocaleString()} chars queued)`);
         }
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
-            const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
+            const baselineAssistantText = typeof baselineSnapshot?.text === "string" ? baselineSnapshot.text.trim() : "";
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            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.');
+                    throw new Error("Chrome DOM domain unavailable while uploading attachments.");
                 }
                 await clearComposerAttachments(Runtime, 5_000, logger);
                 // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
@@ -1122,7 +1882,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 const perFileTimeout = 15_000;
                 const waitBudget = Math.max(baseTimeout, 30_000) + (submissionAttachments.length - 1) * perFileTimeout;
                 await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-                logger('All attachments uploaded');
+                logger("All attachments uploaded");
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
             const providerState = {
@@ -1142,52 +1902,103 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 state: providerState,
             });
             const providerBaselineTurns = providerState.baselineTurns;
-            if (typeof providerBaselineTurns === 'number' && Number.isFinite(providerBaselineTurns)) {
+            if (typeof providerBaselineTurns === "number" && Number.isFinite(providerBaselineTurns)) {
                 baselineTurns = providerBaselineTurns;
             }
             return { baselineTurns, baselineAssistantText };
         };
+        const reloadPromptComposer = async () => {
+            logger("[browser] Composer became unresponsive; reloading page and retrying once.");
+            await Page.reload({ ignoreCache: true });
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        };
         let baselineTurns = null;
         let baselineAssistantText = null;
-        try {
-            const submission = await submitOnce(promptText, attachments);
-            baselineTurns = submission.baselineTurns;
-            baselineAssistantText = submission.baselineAssistantText;
-        }
-        catch (error) {
-            const isPromptTooLarge = error instanceof BrowserAutomationError &&
-                error.details?.code === 'prompt-too-large';
-            if (options.fallbackSubmission && isPromptTooLarge) {
-                logger('[browser] Inline prompt too large; retrying with file uploads.');
+        const submission = await runSubmissionWithRecovery({
+            prompt: promptText,
+            attachments,
+            fallbackSubmission: options.fallbackSubmission,
+            submit: submitOnce,
+            reloadPromptComposer,
+            prepareFallbackSubmission: async () => {
                 await clearPromptComposer(Runtime, logger);
                 await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
-                const submission = await submitOnce(options.fallbackSubmission.prompt, options.fallbackSubmission.attachments);
-                baselineTurns = submission.baselineTurns;
-                baselineAssistantText = submission.baselineAssistantText;
-            }
-            else {
-                throw error;
-            }
+            },
+            logger,
+        });
+        baselineTurns = submission.baselineTurns;
+        baselineAssistantText = submission.baselineAssistantText;
+        const imageArtifactMinTurnIndex = baselineTurns;
+        if (deepResearch) {
+            await waitForResearchPlanAutoConfirm(Runtime, logger);
+            const researchResult = await waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client);
+            await emitRuntimeHint();
+            const durationMs = Date.now() - startedAt;
+            const tokens = estimateTokenCount(researchResult.text);
+            const reportArtifact = await saveOptionalArtifact(() => saveDeepResearchReportArtifact({
+                sessionId: options.sessionId,
+                reportMarkdown: researchResult.text,
+                conversationUrl: lastUrl,
+                logger,
+            }), logger);
+            const transcriptArtifact = await saveOptionalArtifact(() => saveBrowserTranscriptArtifact({
+                sessionId: options.sessionId,
+                prompt: promptText,
+                answerMarkdown: researchResult.text,
+                conversationUrl: lastUrl,
+                artifacts: appendArtifacts(undefined, [reportArtifact]),
+                logger,
+            }), logger);
+            const savedArtifacts = appendArtifacts(undefined, [reportArtifact, transcriptArtifact]);
+            const archive = await maybeArchiveCompletedConversation({
+                Runtime,
+                logger,
+                config,
+                conversationUrl: lastUrl,
+                followUpCount: 0,
+                requiredArtifactsSaved: Boolean(reportArtifact && transcriptArtifact),
+            });
+            runStatus = "complete";
+            return {
+                answerText: researchResult.text,
+                answerMarkdown: researchResult.text,
+                answerHtml: researchResult.html,
+                artifacts: savedArtifacts,
+                archive,
+                tookMs: durationMs,
+                answerTokens: tokens,
+                answerChars: researchResult.text.length,
+                chromePort: port,
+                chromeHost: host,
+                chromeTargetId: remoteTargetId ?? undefined,
+                tabUrl: lastUrl,
+                conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                controllerPid: process.pid,
+            };
         }
-        stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
-        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, " ").trim();
+        const expectedConversationId = () => lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
         const waitForFreshAssistantResponse = async (baselineNormalized, timeoutMs) => {
             const baselinePrefix = baselineNormalized.length >= 80
                 ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
+                : "";
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text) {
                     const normalized = normalizeForComparison(text);
-                    const isBaseline = normalized === baselineNormalized || (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
+                    const isBaseline = normalized === baselineNormalized ||
+                        (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
                     if (!isBaseline) {
                         return {
                             text,
                             html: snapshot?.html ?? undefined,
-                            meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+                            meta: {
+                                turnId: snapshot?.turnId ?? undefined,
+                                messageId: snapshot?.messageId ?? undefined,
+                            },
                         };
                     }
                 }
@@ -1195,7 +2006,19 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             return null;
         };
-        let answer;
+        const waitWithThinkingMonitor = async (operation) => {
+            stopThinkingMonitor?.();
+            stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, {
+                intervalMs: options.heartbeatIntervalMs,
+            });
+            try {
+                return await operation();
+            }
+            finally {
+                stopThinkingMonitor?.();
+                stopThinkingMonitor = null;
+            }
+        };
         const recheckDelayMs = Math.max(0, config.assistantRecheckDelayMs ?? 0);
         const recheckTimeoutMs = Math.max(0, config.assistantRecheckTimeoutMs ?? 0);
         const attemptAssistantRecheck = async () => {
@@ -1217,17 +2040,19 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 // Update session metadata to indicate login is needed
                 await emitRuntimeHint();
                 throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
-                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || "unknown"}. ` +
                     `Please sign in and retry.`, {
-                    stage: 'assistant-recheck',
+                    stage: "assistant-recheck",
                     details: {
                         conversationUrl: conversationUrl || lastUrl || null,
-                        sessionStatus: 'needs_login',
+                        sessionStatus: "needs_login",
                         validationReason: sessionValid.reason,
                     },
                     runtime: {
                         chromeHost: host,
                         chromePort: port,
+                        chromeBrowserWSEndpoint: browserWSEndpoint,
+                        chromeProfileRoot,
                         chromeTargetId: remoteTargetId ?? undefined,
                         tabUrl: lastUrl,
                         conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
@@ -1237,140 +2062,253 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             await emitRuntimeHint();
             const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
-            const rechecked = await waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined);
-            logger('Recovered assistant response after delayed recheck');
+            const rechecked = await waitWithThinkingMonitor(() => waitForAssistantOrGeneratedImageResponse({
+                Runtime,
+                waitForText: () => waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()),
+                timeoutMs,
+                logger,
+                minTurnIndex: baselineTurns ?? undefined,
+                expectedConversationId: expectedConversationId(),
+                imageOutputRequested,
+            }));
+            logger("Recovered assistant response after delayed recheck");
             return rechecked;
         };
-        try {
-            answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
-        }
-        catch (error) {
-            if (isAssistantResponseTimeoutError(error)) {
-                const rechecked = await attemptAssistantRecheck().catch(() => null);
-                if (rechecked) {
-                    answer = rechecked;
+        const imageOutputRequested = Boolean(options.generateImagePath ||
+            options.outputPath ||
+            options.generateImage);
+        const captureAssistantTurn = async (turnPrompt, label) => {
+            let turnAnswer;
+            try {
+                const conversationUrl = await readConversationUrl(Runtime).catch(() => null);
+                if (conversationUrl && isConversationUrl(conversationUrl)) {
+                    lastUrl = conversationUrl;
+                    await emitRuntimeHint();
                 }
-                else {
-                    try {
-                        const conversationUrl = await readConversationUrl(Runtime);
-                        if (conversationUrl) {
-                            lastUrl = conversationUrl;
-                        }
+                turnAnswer = await waitWithThinkingMonitor(() => waitForAssistantOrGeneratedImageResponse({
+                    Runtime,
+                    waitForText: () => waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()),
+                    timeoutMs: config.timeoutMs,
+                    logger,
+                    minTurnIndex: baselineTurns ?? undefined,
+                    expectedConversationId: expectedConversationId(),
+                    imageOutputRequested,
+                }));
+            }
+            catch (error) {
+                if (isAssistantResponseTimeoutError(error)) {
+                    const rechecked = await attemptAssistantRecheckOrRethrow(attemptAssistantRecheck);
+                    if (rechecked) {
+                        turnAnswer = rechecked;
                     }
-                    catch {
-                        // ignore
+                    else {
+                        try {
+                            const conversationUrl = await readConversationUrl(Runtime);
+                            if (conversationUrl) {
+                                lastUrl = conversationUrl;
+                            }
+                        }
+                        catch {
+                            // ignore
+                        }
+                        await emitRuntimeHint();
+                        const diagnostics = await captureBrowserDiagnostics(Runtime, logger, "assistant-timeout", {
+                            Page,
+                            sessionId: options.sessionId,
+                        }).catch(() => undefined);
+                        const runtime = {
+                            chromePort: port,
+                            chromeHost: host,
+                            chromeBrowserWSEndpoint: browserWSEndpoint,
+                            chromeProfileRoot,
+                            chromeTargetId: remoteTargetId ?? undefined,
+                            tabUrl: lastUrl,
+                            conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                            controllerPid: process.pid,
+                        };
+                        throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime, diagnostics }, error);
                     }
-                    await emitRuntimeHint();
-                    const runtime = {
-                        chromePort: port,
-                        chromeHost: host,
-                        chromeTargetId: remoteTargetId ?? undefined,
-                        tabUrl: lastUrl,
-                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
-                        controllerPid: process.pid,
-                    };
-                    throw new BrowserAutomationError('Assistant response timed out before completion; reattach later to capture the answer.', { stage: 'assistant-timeout', runtime }, error);
+                }
+                else {
+                    throw error;
                 }
             }
-            else {
-                throw error;
+            const baselineNormalized = baselineAssistantText
+                ? normalizeForComparison(baselineAssistantText)
+                : "";
+            if (baselineNormalized) {
+                const normalizedAnswer = normalizeForComparison(turnAnswer.text ?? "");
+                const baselinePrefix = baselineNormalized.length >= 80
+                    ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+                    : "";
+                const isBaseline = normalizedAnswer === baselineNormalized ||
+                    (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
+                if (isBaseline) {
+                    logger("Detected stale assistant response; waiting for new response...");
+                    const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
+                    if (refreshed) {
+                        turnAnswer = refreshed;
+                    }
+                }
             }
-        }
-        const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
-        if (baselineNormalized) {
-            const normalizedAnswer = normalizeForComparison(answer.text ?? '');
-            const baselinePrefix = baselineNormalized.length >= 80
-                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
-            const isBaseline = normalizedAnswer === baselineNormalized ||
-                (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
-            if (isBaseline) {
-                logger('Detected stale assistant response; waiting for new response...');
-                const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
-                if (refreshed) {
-                    answer = refreshed;
+            let turnAnswerText = turnAnswer.text;
+            const turnAnswerHtml = turnAnswer.html ?? "";
+            const copiedMarkdown = await withRetries(async () => {
+                const attempt = await captureAssistantMarkdown(Runtime, turnAnswer.meta, logger);
+                if (!attempt) {
+                    throw new Error("copy-missing");
                 }
+                return attempt;
+            }, {
+                retries: 2,
+                delayMs: 350,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Markdown capture attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            }).catch(() => null);
+            let turnAnswerMarkdown = copiedMarkdown ?? turnAnswerText;
+            ({ answerText: turnAnswerText, answerMarkdown: turnAnswerMarkdown } =
+                await maybeRecoverLongAssistantResponse({
+                    runtime: Runtime,
+                    baselineTurns,
+                    answerText: turnAnswerText,
+                    answerMarkdown: turnAnswerMarkdown,
+                    logger,
+                    allowMarkdownUpdate: !copiedMarkdown,
+                }));
+            // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
+            const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+            const finalText = typeof finalSnapshot?.text === "string" ? finalSnapshot.text.trim() : "";
+            if (finalText &&
+                finalText !== turnAnswerMarkdown.trim() &&
+                finalText !== turnPrompt.trim() &&
+                finalText.length >= turnAnswerMarkdown.trim().length) {
+                logger("Refreshed assistant response via final DOM snapshot");
+                turnAnswerText = finalText;
+                turnAnswerMarkdown = finalText;
             }
-        }
-        answerText = answer.text;
-        answerHtml = answer.html ?? '';
-        const copiedMarkdown = await withRetries(async () => {
-            const attempt = await captureAssistantMarkdown(Runtime, answer.meta, logger);
-            if (!attempt) {
-                throw new Error('copy-missing');
-            }
-            return attempt;
-        }, {
-            retries: 2,
-            delayMs: 350,
-            onRetry: (attempt, error) => {
-                if (options.verbose) {
-                    logger(`[retry] Markdown capture attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+            // Detect prompt echo using normalized comparison (whitespace-insensitive).
+            const promptEchoMatcher = buildPromptEchoMatcher(turnPrompt);
+            const alignedEcho = alignPromptEchoPair(turnAnswerText, turnAnswerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
+                text: "Aligned assistant response text to copied markdown after prompt echo",
+                markdown: "Aligned assistant markdown to response text after prompt echo",
+            });
+            turnAnswerText = alignedEcho.answerText;
+            turnAnswerMarkdown = alignedEcho.answerMarkdown;
+            const isPromptEcho = alignedEcho.isEcho;
+            if (isPromptEcho) {
+                logger("Detected prompt echo in response; waiting for actual assistant response...");
+                const deadline = Date.now() + 15_000;
+                let bestText = null;
+                let stableCount = 0;
+                while (Date.now() < deadline) {
+                    const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                    const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
+                    const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
+                    if (!isStillEcho) {
+                        if (!bestText || text.length > bestText.length) {
+                            bestText = text;
+                            stableCount = 0;
+                        }
+                        else if (text === bestText) {
+                            stableCount += 1;
+                        }
+                        if (stableCount >= 2) {
+                            break;
+                        }
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 300));
                 }
-            },
-        }).catch(() => null);
-        answerMarkdown = copiedMarkdown ?? answerText;
-        ({ answerText, answerMarkdown } = await maybeRecoverLongAssistantResponse({
-            runtime: Runtime,
-            baselineTurns,
+                if (bestText) {
+                    logger("Recovered assistant response after detecting prompt echo");
+                    turnAnswerText = bestText;
+                    turnAnswerMarkdown = bestText;
+                }
+            }
+            return {
+                label,
+                answerText: turnAnswerText,
+                answerMarkdown: turnAnswerMarkdown,
+                answerHtml: turnAnswerHtml,
+            };
+        };
+        const followUpPrompts = normalizeBrowserFollowUpPrompts(options.followUpPrompts);
+        const turns = [];
+        const initialTurn = await captureAssistantTurn(promptText, "Initial response");
+        turns.push(initialTurn);
+        answerText = initialTurn.answerText;
+        answerMarkdown = initialTurn.answerMarkdown;
+        answerHtml = initialTurn.answerHtml;
+        for (let index = 0; index < followUpPrompts.length; index += 1) {
+            const followUpPrompt = followUpPrompts[index];
+            logger(`[browser] Sending follow-up ${index + 1}/${followUpPrompts.length}`);
+            await clearPromptComposer(Runtime, logger);
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+            const submission = await runSubmissionWithRecovery({
+                prompt: followUpPrompt,
+                attachments: [],
+                submit: submitOnce,
+                reloadPromptComposer,
+                prepareFallbackSubmission: async () => {
+                    await clearPromptComposer(Runtime, logger);
+                    await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                },
+                logger,
+            });
+            baselineTurns = submission.baselineTurns;
+            baselineAssistantText = submission.baselineAssistantText;
+            const turn = await captureAssistantTurn(followUpPrompt, `Follow-up ${index + 1}`);
+            turns.push({ ...turn, prompt: followUpPrompt });
+            answerText = turn.answerText;
+            answerMarkdown = turn.answerMarkdown;
+            answerHtml = turn.answerHtml;
+        }
+        if (turns.length > 1) {
+            const formatted = formatBrowserTurnTranscript(turns);
+            answerText = formatted.answerText;
+            answerMarkdown = formatted.answerMarkdown;
+            answerHtml = "";
+        }
+        const imageArtifacts = await collectGeneratedImageArtifacts({
+            Runtime,
+            Network,
+            logger,
+            minTurnIndex: imageArtifactMinTurnIndex,
+            sessionId: options.sessionId,
+            generateImagePath: options.generateImagePath,
+            outputPath: options.outputPath,
             answerText,
+            waitTimeoutMs: options.config?.timeoutMs,
+        });
+        answerText = imageArtifacts.answerText || answerText;
+        if (imageArtifacts.markdownSuffix) {
+            answerMarkdown += imageArtifacts.markdownSuffix;
+        }
+        const savedImageArtifacts = appendArtifacts(undefined, imageArtifacts.savedImages);
+        const transcriptArtifact = await saveOptionalArtifact(() => saveBrowserTranscriptArtifact({
+            sessionId: options.sessionId,
+            prompt: promptText,
             answerMarkdown,
+            conversationUrl: lastUrl,
+            artifacts: savedImageArtifacts,
             logger,
-            allowMarkdownUpdate: !copiedMarkdown,
-        }));
-        // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
-        const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-        const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
-        if (finalText &&
-            finalText !== answerMarkdown.trim() &&
-            finalText !== promptText.trim() &&
-            finalText.length >= answerMarkdown.trim().length) {
-            logger('Refreshed assistant response via final DOM snapshot');
-            answerText = finalText;
-            answerMarkdown = finalText;
-        }
-        // Detect prompt echo using normalized comparison (whitespace-insensitive).
-        const promptEchoMatcher = buildPromptEchoMatcher(promptText);
-        const alignedEcho = alignPromptEchoPair(answerText, answerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
-            text: 'Aligned assistant response text to copied markdown after prompt echo',
-            markdown: 'Aligned assistant markdown to response text after prompt echo',
+        }), logger);
+        const savedArtifacts = appendArtifacts(savedImageArtifacts, [transcriptArtifact]);
+        const archive = await maybeArchiveCompletedConversation({
+            Runtime,
+            logger,
+            config,
+            conversationUrl: lastUrl,
+            followUpCount: followUpPrompts.length,
+            requiredArtifactsSaved: Boolean(transcriptArtifact) &&
+                imageArtifacts.savedImages.length === imageArtifacts.imageCount,
         });
-        answerText = alignedEcho.answerText;
-        answerMarkdown = alignedEcho.answerMarkdown;
-        const isPromptEcho = alignedEcho.isEcho;
-        if (isPromptEcho) {
-            logger('Detected prompt echo in response; waiting for actual assistant response...');
-            const deadline = Date.now() + 15_000;
-            let bestText = null;
-            let stableCount = 0;
-            while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
-                const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
-                if (!isStillEcho) {
-                    if (!bestText || text.length > bestText.length) {
-                        bestText = text;
-                        stableCount = 0;
-                    }
-                    else if (text === bestText) {
-                        stableCount += 1;
-                    }
-                    if (stableCount >= 2) {
-                        break;
-                    }
-                }
-                await new Promise((resolve) => setTimeout(resolve, 300));
-            }
-            if (bestText) {
-                logger('Recovered assistant response after detecting prompt echo');
-                answerText = bestText;
-                answerMarkdown = bestText;
-            }
-        }
-        stopThinkingMonitor?.();
         const durationMs = Date.now() - startedAt;
         const answerChars = answerText.length;
         const answerTokens = estimateTokenCount(answerMarkdown);
+        runStatus = "complete";
         return {
             answerText,
             answerMarkdown,
@@ -1378,32 +2316,39 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             tookMs: durationMs,
             answerTokens,
             answerChars,
+            browserTransport: "cdp",
             chromePid: undefined,
             chromePort: port,
             chromeHost: host,
+            chromeBrowserWSEndpoint: browserWSEndpoint,
+            chromeProfileRoot,
             userDataDir: undefined,
             chromeTargetId: remoteTargetId ?? undefined,
             tabUrl: lastUrl,
+            conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+            artifacts: savedArtifacts,
+            archive,
             controllerPid: process.pid,
         };
     }
     catch (error) {
         const normalizedError = error instanceof Error ? error : new Error(String(error));
-        stopThinkingMonitor?.();
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
         if (!socketClosed) {
             logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
-            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
                 logger(normalizedError.stack);
             }
             throw normalizedError;
         }
-        throw new BrowserAutomationError('Remote Chrome connection lost before Oracle finished.', {
-            stage: 'connection-lost',
+        throw new BrowserAutomationError("Remote Chrome connection lost before Oracle finished.", {
+            stage: "connection-lost",
             runtime: {
                 chromeHost: host,
                 chromePort: port,
+                chromeBrowserWSEndpoint: browserWSEndpoint,
+                chromeProfileRoot,
                 chromeTargetId: remoteTargetId ?? undefined,
                 tabUrl: lastUrl,
                 controllerPid: process.pid,
@@ -1412,48 +2357,63 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     }
     finally {
         try {
-            if (!connectionClosedUnexpectedly && client) {
-                await client.close();
-            }
+            await closeRemoteConnectionAfterRun({
+                connectionClosedUnexpectedly,
+                connection,
+                client,
+                runStatus,
+            });
         }
         catch {
             // ignore
         }
         removeDialogHandler?.();
-        await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
+        if (tabLease) {
+            const handle = tabLease;
+            tabLease = null;
+            await handle.release().catch(() => undefined);
+        }
+        if (shouldCloseOwnedRunTargetAfterRun({
+            runStatus,
+            ownsTarget,
+            keepBrowser: Boolean(config.keepBrowser),
+        })) {
+            await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
+        }
         // 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';
-export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from './config.js';
-export { syncCookies } from './cookies.js';
-export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from './pageActions.js';
+export { estimateTokenCount } from "./utils.js";
+export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from "./config.js";
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    closeRemoteConnectionAfterRun,
+    detachKeptChromeProcess,
+    isImageOnlyUiChromeText,
+    listIgnoredRemoteChromeFlags,
+    shouldCloseOwnedRunTargetAfterRun,
+};
+export { syncCookies } from "./cookies.js";
+export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from "./pageActions.js";
 export async function maybeReuseRunningChromeForTest(userDataDir, logger, options = {}) {
     return maybeReuseRunningChrome(userDataDir, logger, options);
 }
+export async function acquireManualLoginChromeForRunForTest(userDataDir, config, logger, sessionId, deps) {
+    return acquireManualLoginChromeForRun(userDataDir, config, logger, sessionId, deps);
+}
 export function isWebSocketClosureError(error) {
     const message = error.message.toLowerCase();
-    return (message.includes('websocket connection closed') ||
-        message.includes('websocket is closed') ||
-        message.includes('websocket error') ||
-        message.includes('inspected target navigated or closed') ||
-        message.includes('target closed'));
-}
-export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
-    const elapsedMs = now - startedAt;
-    const elapsedText = formatElapsed(elapsedMs);
-    const progress = Math.min(1, elapsedMs / 600_000); // soft target: 10 minutes
-    const pct = Math.round(progress * 100)
-        .toString()
-        .padStart(3, ' ');
-    const statusLabel = message ? ` — ${message}` : '';
-    return `${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
+    return (message.includes("websocket connection closed") ||
+        message.includes("websocket is closed") ||
+        message.includes("websocket error") ||
+        message.includes("inspected target navigated or closed") ||
+        message.includes("target closed"));
 }
-async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, minTurnIndex) {
+async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, minTurnIndex, expectedConversationId) {
     try {
-        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
     catch (error) {
         if (!shouldReloadAfterAssistantError(error)) {
@@ -1463,20 +2423,20 @@ async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logg
         if (!conversationUrl || !isConversationUrl(conversationUrl)) {
             throw error;
         }
-        logger('Assistant response stalled; reloading conversation and retrying once');
+        logger("Assistant response stalled; reloading conversation and retrying once");
         await Page.navigate({ url: conversationUrl });
         await delay(1000);
-        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
 }
 function shouldReloadAfterAssistantError(error) {
     if (!(error instanceof Error))
         return false;
     const message = error.message.toLowerCase();
-    return (message.includes('assistant-response') ||
-        message.includes('watchdog') ||
-        message.includes('timeout') ||
-        message.includes('capture assistant response'));
+    return (message.includes("assistant-response") ||
+        message.includes("watchdog") ||
+        message.includes("timeout") ||
+        message.includes("capture assistant response"));
 }
 function isAssistantResponseTimeoutError(error) {
     if (!(error instanceof Error))
@@ -1484,15 +2444,15 @@ function isAssistantResponseTimeoutError(error) {
     const message = error.message.toLowerCase();
     if (!message)
         return false;
-    return (message.includes('assistant-response') ||
-        message.includes('assistant response') ||
-        message.includes('watchdog') ||
-        message.includes('capture assistant response'));
+    return (message.includes("assistant-response") ||
+        message.includes("assistant response") ||
+        message.includes("watchdog") ||
+        message.includes("capture assistant response"));
 }
 async function readConversationUrl(Runtime) {
     try {
-        const currentUrl = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
-        return typeof currentUrl.result?.value === 'string' ? currentUrl.result.value : null;
+        const currentUrl = await Runtime.evaluate({ expression: "location.href", returnByValue: true });
+        return typeof currentUrl.result?.value === "string" ? currentUrl.result.value : null;
     }
     catch {
         return null;
@@ -1515,16 +2475,16 @@ async function validateChatGPTSession(Runtime, logger) {
         });
         const result = outcome.result?.value;
         if (!result) {
-            return { valid: false, reason: 'Failed to evaluate session state' };
+            return { valid: false, reason: "Failed to evaluate session state" };
         }
         if (result.onAuthPage) {
-            return { valid: false, reason: 'Redirected to auth page' };
+            return { valid: false, reason: "Redirected to auth page" };
         }
         if (result.hasLoginCta) {
-            return { valid: false, reason: 'Login button detected on page' };
+            return { valid: false, reason: "Login button detected on page" };
         }
         if (!result.hasTextarea) {
-            return { valid: false, reason: 'Prompt textarea not available' };
+            return { valid: false, reason: "Prompt textarea not available" };
         }
         return { valid: true };
     }
@@ -1611,9 +2571,9 @@ async function readConversationTurnCount(Runtime, logger) {
                 expression: `document.querySelectorAll(${selectorLiteral}).length`,
                 returnByValue: true,
             });
-            const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+            const raw = typeof result?.value === "number" ? result.value : Number(result?.value);
             if (!Number.isFinite(raw)) {
-                throw new Error('Turn count not numeric');
+                throw new Error("Turn count not numeric");
             }
             return Math.max(0, Math.floor(raw));
         }
@@ -1633,93 +2593,25 @@ async function readConversationTurnCount(Runtime, logger) {
 function isConversationUrl(url) {
     return /\/c\/[a-z0-9-]+/i.test(url);
 }
-function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false) {
-    let stopped = false;
-    let pending = false;
-    let lastMessage = null;
-    const startedAt = Date.now();
-    const interval = setInterval(async () => {
-        // stop flag flips asynchronously
-        if (stopped || pending) {
-            return;
-        }
-        pending = true;
-        try {
-            const nextMessage = await readThinkingStatus(Runtime);
-            if (nextMessage && nextMessage !== lastMessage) {
-                lastMessage = nextMessage;
-                let locatorSuffix = '';
-                if (includeDiagnostics) {
-                    try {
-                        const snapshot = await readAssistantSnapshot(Runtime);
-                        locatorSuffix = ` | assistant-turn=${snapshot ? 'present' : 'missing'}`;
-                    }
-                    catch {
-                        locatorSuffix = ' | assistant-turn=error';
-                    }
-                }
-                logger(formatThinkingLog(startedAt, Date.now(), nextMessage, locatorSuffix));
-            }
-        }
-        catch {
-            // ignore DOM polling errors
-        }
-        finally {
-            pending = false;
-        }
-    }, 1500);
-    interval.unref?.();
-    return () => {
-        // multiple callers may race to stop
-        if (stopped) {
-            return;
-        }
-        stopped = true;
-        clearInterval(interval);
-    };
-}
-async function readThinkingStatus(Runtime) {
-    const expression = buildThinkingStatusExpression();
-    try {
-        const { result } = await Runtime.evaluate({ expression, returnByValue: true });
-        const value = typeof result.value === 'string' ? result.value.trim() : '';
-        const sanitized = sanitizeThinkingText(value);
-        return sanitized || null;
-    }
-    catch {
-        return null;
-    }
-}
-function sanitizeThinkingText(raw) {
-    if (!raw) {
-        return '';
-    }
-    const trimmed = raw.trim();
-    const prefixPattern = /^(pro thinking)\s*[•:\-–—]*\s*/i;
-    if (prefixPattern.test(trimmed)) {
-        return trimmed.replace(prefixPattern, '').trim();
-    }
-    return trimmed;
-}
 function describeDevtoolsFirewallHint(host, port) {
     if (!isWsl())
         return null;
     return [
         `DevTools port ${host}:${port} is blocked from WSL.`,
-        '',
-        'PowerShell (admin):',
+        "",
+        "PowerShell (admin):",
         `New-NetFirewallRule -DisplayName 'Chrome DevTools ${port}' -Direction Inbound -Action Allow -Protocol TCP -LocalPort ${port}`,
         "New-NetFirewallRule -DisplayName 'Chrome DevTools (chrome.exe)' -Direction Inbound -Action Allow -Program 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' -Protocol TCP",
-        '',
-        'Re-run the same oracle command after adding the rule.',
-    ].join('\n');
+        "",
+        "Re-run the same oracle command after adding the rule.",
+    ].join("\n");
 }
 function isWsl() {
-    if (process.platform !== 'linux')
+    if (process.platform !== "linux")
         return false;
     if (process.env.WSL_DISTRO_NAME)
         return true;
-    return os.release().toLowerCase().includes('microsoft');
+    return os.release().toLowerCase().includes("microsoft");
 }
 function extractConversationIdFromUrl(url) {
     const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
@@ -1729,9 +2621,9 @@ async function resolveUserDataBaseDir() {
     // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
     if (isWsl()) {
         const candidates = [
-            '/mnt/c/Users/Public/AppData/Local/Temp',
-            '/mnt/c/Temp',
-            '/mnt/c/Windows/Temp',
+            "/mnt/c/Users/Public/AppData/Local/Temp",
+            "/mnt/c/Temp",
+            "/mnt/c/Windows/Temp",
         ];
         for (const candidate of candidates) {
             try {
@@ -1743,53 +2635,28 @@ async function resolveUserDataBaseDir() {
             }
         }
     }
-    return os.tmpdir();
-}
-function buildThinkingStatusExpression() {
-    const selectors = [
-        'span.loading-shimmer',
-        'span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary',
-        '[data-testid*="thinking"]',
-        '[data-testid*="reasoning"]',
-        '[role="status"]',
-        '[aria-live="polite"]',
-    ];
-    const keywords = ['pro thinking', 'thinking', 'reasoning', 'clarifying', 'planning', 'drafting', 'summarizing'];
-    const selectorLiteral = JSON.stringify(selectors);
-    const keywordsLiteral = JSON.stringify(keywords);
-    return `(() => {
-    const selectors = ${selectorLiteral};
-    const keywords = ${keywordsLiteral};
-    const nodes = new Set();
-    for (const selector of selectors) {
-      document.querySelectorAll(selector).forEach((node) => nodes.add(node));
-    }
-    document.querySelectorAll('[data-testid]').forEach((node) => nodes.add(node));
-    for (const node of nodes) {
-      if (!(node instanceof HTMLElement)) {
-        continue;
-      }
-      const text = node.textContent?.trim();
-      if (!text) {
-        continue;
-      }
-      const classLabel = (node.className || '').toLowerCase();
-      const dataLabel = ((node.getAttribute('data-testid') || '') + ' ' + (node.getAttribute('aria-label') || ''))
-        .toLowerCase();
-      const normalizedText = text.toLowerCase();
-      const matches = keywords.some((keyword) =>
-        normalizedText.includes(keyword) || classLabel.includes(keyword) || dataLabel.includes(keyword)
-      );
-      if (matches) {
-        const shimmerChild = node.querySelector(
-          'span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary',
-        );
-        if (shimmerChild?.textContent?.trim()) {
-          return shimmerChild.textContent.trim();
+    const tmpDir = os.tmpdir();
+    if (shouldPreferSystemTmpDir(process.platform, tmpDir, os.homedir())) {
+        try {
+            await mkdir("/tmp", { recursive: true });
+            return "/tmp";
+        }
+        catch {
+            // Fall back to the inherited tmpdir if /tmp is unavailable.
         }
-        return text.trim();
-      }
     }
-    return null;
-  })()`;
+    return tmpDir;
+}
+function shouldPreferSystemTmpDir(platform, tmpDir, homeDir) {
+    if (platform !== "linux" || !tmpDir || !homeDir)
+        return false;
+    const relativeToHome = path.relative(homeDir, tmpDir);
+    if (!relativeToHome || relativeToHome.startsWith("..") || path.isAbsolute(relativeToHome)) {
+        return false;
+    }
+    const firstSegment = relativeToHome.split(path.sep, 1)[0];
+    return Boolean(firstSegment?.startsWith("."));
+}
+export function shouldPreferSystemTmpDirForTest(platform, tmpDir, homeDir) {
+    return shouldPreferSystemTmpDir(platform, tmpDir, homeDir);
 }