@steipete/oracle 0.10.0 → 0.11.0

package/dist/src/browser/index.js

@@ -3,22 +3,33 @@ 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 { 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, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.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)) {
@@ -35,16 +46,198 @@ function isCloudflareChallengeError(error) {
         return false;
     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;
@@ -77,6 +270,33 @@ async function runSubmissionWithRecovery({ prompt, attachments, fallbackSubmissi
 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) {
@@ -85,6 +305,13 @@ export async function runBrowserMode(options) {
     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);
@@ -95,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;
@@ -111,7 +339,13 @@ 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);
@@ -124,6 +358,18 @@ export async function runBrowserMode(options) {
             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);
@@ -135,9 +381,9 @@ 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);
     }
@@ -156,24 +402,42 @@ 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 {
@@ -188,6 +452,7 @@ export async function runBrowserMode(options) {
     }
     let client = null;
     let isolatedTargetId = null;
+    let ownsTarget = true;
     const startedAt = Date.now();
     let answerText = "";
     let answerMarkdown = "";
@@ -200,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, config.url, 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);
@@ -288,30 +576,37 @@ export async function runBrowserMode(options) {
                 },
             });
         }
-        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 () => {
@@ -413,18 +708,37 @@ export async function runBrowserMode(options) {
         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;
@@ -448,6 +762,8 @@ export async function runBrowserMode(options) {
             const baselineAssistantText = typeof baselineSnapshot?.text === "string" ? baselineSnapshot.text.trim() : "";
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
             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.");
@@ -540,7 +856,56 @@ export async function runBrowserMode(options) {
         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 expectedConversationId = () => lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
@@ -571,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 () => {
@@ -615,172 +992,280 @@ export async function runBrowserMode(options) {
                 });
             }
             const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
-            const rechecked = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()));
+            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 {
-            await updateConversationHint("assistant-wait", 15_000).catch(() => false);
-            answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()));
-        }
-        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(answer.text ?? "");
-            const baselinePrefix = baselineNormalized.length >= 80
-                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+            // Ensure we store the final conversation URL even if the UI updated late.
+            await updateConversationHint("post-response", 15_000);
+            const baselineNormalized = baselineAssistantText
+                ? normalizeForComparison(baselineAssistantText)
                 : "";
-            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;
+            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;
+                    }
                 }
             }
-        }
-        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}`);
+            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;
                 }
-            },
-        })).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, expectedConversationId()).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, 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) {
+            // 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));
+                }
+                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, expectedConversationId()).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");
         }
-        stopThinkingMonitor?.();
+        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;
@@ -789,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,
@@ -798,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,
@@ -828,6 +1318,12 @@ export async function runBrowserMode(options) {
                 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) {
@@ -865,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
@@ -898,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);
         }
     }
 }
@@ -1025,6 +1583,51 @@ async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
         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);
@@ -1036,8 +1639,30 @@ 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.`);
@@ -1045,7 +1670,6 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
         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}` : ""})`);
     return {
         port,
@@ -1063,7 +1687,10 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     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)
@@ -1072,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);
@@ -1087,12 +1723,55 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     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;
@@ -1107,10 +1786,17 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         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);
+        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({
@@ -1142,23 +1828,44 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         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 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.");
@@ -1221,7 +1928,54 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         });
         baselineTurns = submission.baselineTurns;
         baselineAssistantText = submission.baselineAssistantText;
-        stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
+        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,
+            };
+        }
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
         const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, " ").trim();
         const expectedConversationId = () => lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
@@ -1252,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 () => {
@@ -1285,6 +2051,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                     runtime: {
                         chromeHost: host,
                         chromePort: port,
+                        chromeBrowserWSEndpoint: browserWSEndpoint,
+                        chromeProfileRoot,
                         chromeTargetId: remoteTargetId ?? undefined,
                         tabUrl: lastUrl,
                         conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
@@ -1294,147 +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, expectedConversationId());
+            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 {
-            const conversationUrl = await readConversationUrl(Runtime).catch(() => null);
-            if (conversationUrl && isConversationUrl(conversationUrl)) {
-                lastUrl = conversationUrl;
-                await emitRuntimeHint();
-            }
-            answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId());
-        }
-        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(answer.text ?? "");
-            const baselinePrefix = baselineNormalized.length >= 80
-                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+            const baselineNormalized = baselineAssistantText
+                ? normalizeForComparison(baselineAssistantText)
                 : "";
-            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;
+            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;
+                    }
                 }
             }
-        }
-        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}`);
+            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");
                 }
-            },
-        }).catch(() => null);
-        answerMarkdown = copiedMarkdown ?? answerText;
-        ({ 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, expectedConversationId()).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",
-        });
-        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, 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;
+                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}`);
                     }
-                    if (stableCount >= 2) {
-                        break;
+                },
+            }).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;
+            }
+            // 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));
+                }
+                if (bestText) {
+                    logger("Recovered assistant response after detecting prompt echo");
+                    turnAnswerText = bestText;
+                    turnAnswerMarkdown = bestText;
                 }
-                await new Promise((resolve) => setTimeout(resolve, 300));
-            }
-            if (bestText) {
-                logger("Recovered assistant response after detecting prompt echo");
-                answerText = bestText;
-                answerMarkdown = 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;
         }
-        stopThinkingMonitor?.();
+        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,
+        });
         const durationMs = Date.now() - startedAt;
         const answerChars = answerText.length;
         const answerTokens = estimateTokenCount(answerMarkdown);
+        runStatus = "complete";
         return {
             answerText,
             answerMarkdown,
@@ -1442,18 +2316,23 @@ 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) {
@@ -1468,6 +2347,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             runtime: {
                 chromeHost: host,
                 chromePort: port,
+                chromeBrowserWSEndpoint: browserWSEndpoint,
+                chromeProfileRoot,
                 chromeTargetId: remoteTargetId ?? undefined,
                 tabUrl: lastUrl,
                 controllerPid: process.pid,
@@ -1476,15 +2357,29 @@ 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`);
@@ -1492,11 +2387,22 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
 }
 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") ||
@@ -1505,16 +2411,6 @@ export function isWebSocketClosureError(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}`;
-}
 async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, minTurnIndex, expectedConversationId) {
     try {
         return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
@@ -1697,74 +2593,6 @@ 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;
@@ -1832,59 +2660,3 @@ function shouldPreferSystemTmpDir(platform, tmpDir, homeDir) {
 export function shouldPreferSystemTmpDirForTest(platform, tmpDir, homeDir) {
     return shouldPreferSystemTmpDir(platform, tmpDir, homeDir);
 }
-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();
-        }
-        return text.trim();
-      }
-    }
-    return null;
-  })()`;
-}