@steipete/oracle 0.13.0 → 0.14.1

package/dist/src/browser/index.js

@@ -5,12 +5,12 @@ import net from "node:net";
 import { resolveBrowserConfig } from "./config.js";
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
 import { syncCookies } from "./cookies.js";
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, 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 { activateDeepResearch, captureDeepResearchTargetKeys, 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";
@@ -20,6 +20,7 @@ import { cleanupStaleProfileState, acquireProfileRunLock, findRunningChromeDebug
 import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
 import { collectGeneratedImageArtifacts } from "./chatgptImages.js";
+import { collectChatGptFileArtifacts } from "./chatgptFiles.js";
 import { runProviderSubmissionFlow } from "./providerDomFlow.js";
 import { chatgptDomProvider } from "./providers/index.js";
 import { resolveAttachRunningConnection } from "./attachRunning.js";
@@ -71,12 +72,207 @@ export function shouldPreserveBrowserOnErrorForTest(error, headless) {
 export function classifyPreservedBrowserErrorForTest(error, headless) {
     return classifyPreservedBrowserError(error, headless);
 }
-// NOTE: Previously, shouldSkipThinkingTimeSelection() would skip the thinking
-// time UI step when desiredModel was gpt-5.5-pro and thinkingTime was "extended",
-// assuming that selecting "Pro Extended" in the old UI already implied Extended
-// effort. This is wrong for lower-tier plans ($100/mo Pro) where selecting "Pro"
-// defaults to Standard effort. ensureThinkingTime() already handles the
-// "already-selected" case as a no-op, so always attempting it is safe.
+const MAX_CHATGPT_UI_WARNING_CHARS = 300;
+const MAX_CHATGPT_UI_WARNINGS = 3;
+function classifyChatGptUiWarningText(text) {
+    const normalized = text.toLowerCase();
+    if (/\btoo many requests\b/.test(normalized) ||
+        /\bsending too many requests\b/.test(normalized) ||
+        /\btoo quickly\b/.test(normalized) ||
+        /\btemporarily limited access\b/.test(normalized) ||
+        /\bplease wait a few minutes\b/.test(normalized) ||
+        /\brate limit(?:ed)?\b/.test(normalized) ||
+        /\bslow down\b/.test(normalized)) {
+        return "rate_limit";
+    }
+    if (/\btemporarily unavailable\b/.test(normalized) ||
+        /\bsomething went wrong\b/.test(normalized) ||
+        /\bfailed to generate\b/.test(normalized) ||
+        /\btry again later\b/.test(normalized)) {
+        return "temporary_unavailable";
+    }
+    if (/\bverify you are human\b/.test(normalized) ||
+        /\bunusual activity\b/.test(normalized) ||
+        /\bcloudflare\b/.test(normalized) ||
+        /\bchallenge\b/.test(normalized) ||
+        /\blogin required\b/.test(normalized) ||
+        /\bsign in\b/.test(normalized)) {
+        return "auth_or_challenge";
+    }
+    return null;
+}
+function sanitizeChatGptUiWarningText(text) {
+    return text
+        .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[redacted-email]")
+        .replace(/\b((?:access|auth|session)[-_ ]?token|token)\s*[:=]\s*["']?[^\s"',;]+/gi, "$1=[redacted]")
+        .replace(/\b(?:sk-(?:ant-|or-)?|xai-)[A-Za-z0-9_-]{8,}\b/g, "[redacted-token]");
+}
+function normalizeUiWarningCandidate(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const candidate = value;
+    const text = typeof candidate.text === "string"
+        ? sanitizeChatGptUiWarningText(candidate.text.replace(/\s+/g, " ").trim())
+        : "";
+    if (!text)
+        return null;
+    return {
+        text: text.slice(0, MAX_CHATGPT_UI_WARNING_CHARS),
+        source: typeof candidate.source === "string" ? candidate.source : null,
+        role: typeof candidate.role === "string" ? candidate.role : null,
+        ariaLive: typeof candidate.ariaLive === "string" ? candidate.ariaLive : null,
+        selector: typeof candidate.selector === "string" ? candidate.selector : null,
+    };
+}
+async function collectChatGptUiWarnings(Runtime) {
+    try {
+        const { result } = await Runtime.evaluate({
+            awaitPromise: true,
+            returnByValue: true,
+            expression: `(() => {
+        const warningPattern = /too many requests|sending too many requests|too quickly|temporarily limited access|please wait a few minutes|rate limit|rate limited|slow down|try again later|temporarily unavailable|something went wrong|failed to generate|verify you are human|unusual activity|cloudflare|challenge|login required|sign in/i;
+        const selectors = [
+          '[role="alert"]',
+          '[role="status"]',
+          '[role="dialog"]',
+          '[aria-live]',
+          '[data-testid*="toast" i]',
+          '[data-testid*="banner" i]',
+          '[data-testid*="error" i]',
+          '[class*="toast" i]',
+          '[class*="banner" i]'
+        ];
+        const isVisible = (element) => {
+          if (!(element instanceof HTMLElement)) return false;
+          let current = element;
+          while (current) {
+            const currentStyle = window.getComputedStyle(current);
+            if (
+              !currentStyle ||
+              currentStyle.display === 'none' ||
+              currentStyle.visibility === 'hidden' ||
+              currentStyle.visibility === 'collapse' ||
+              Number.parseFloat(currentStyle.opacity || '1') === 0
+            ) {
+              return false;
+            }
+            current = current.parentElement;
+          }
+          const rect = element.getBoundingClientRect();
+          return rect.width > 0 && rect.height > 0;
+        };
+        const describe = (element, source, selector = null) => ({
+          text: (element.innerText || element.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 1000),
+          source,
+          selector,
+          role: element.getAttribute('role'),
+          ariaLive: element.getAttribute('aria-live')
+        });
+        const out = [];
+        const seen = new Set();
+        const warningContainers = [];
+        const overlapsWarningContainer = (element) => warningContainers.some((container) => (
+          container !== element && (container.contains(element) || element.contains(container))
+        ));
+        const add = (element, entry) => {
+          if (!entry.text || !warningPattern.test(entry.text)) return;
+          const key = entry.text + '|' + (entry.role || '') + '|' + (entry.ariaLive || '');
+          if (seen.has(key)) return;
+          seen.add(key);
+          warningContainers.push(element);
+          out.push(entry);
+        };
+        for (const selector of selectors) {
+          if (out.length >= 5) break;
+          let elements = [];
+          try {
+            elements = Array.from(document.querySelectorAll(selector));
+          } catch {
+            elements = [];
+          }
+          for (const element of elements) {
+            if (out.length >= 5) break;
+            if (overlapsWarningContainer(element)) continue;
+            if (isVisible(element)) add(element, describe(element, 'selector', selector));
+          }
+        }
+        return out.slice(0, 5);
+      })()`,
+        });
+        const rawWarnings = Array.isArray(result?.value) ? result.value : [];
+        const warnings = [];
+        const seen = new Set();
+        for (const raw of rawWarnings) {
+            const candidate = normalizeUiWarningCandidate(raw);
+            if (!candidate)
+                continue;
+            const type = classifyChatGptUiWarningText(candidate.text);
+            if (!type)
+                continue;
+            const key = `${type}:${candidate.text}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            warnings.push({
+                type,
+                message: candidate.text,
+                source: candidate.source,
+                role: candidate.role,
+                ariaLive: candidate.ariaLive,
+                selector: candidate.selector,
+            });
+            if (warnings.length >= MAX_CHATGPT_UI_WARNINGS)
+                break;
+        }
+        return warnings;
+    }
+    catch {
+        return [];
+    }
+}
+function formatChatGptUiWarningType(type) {
+    switch (type) {
+        case "rate_limit":
+            return "rate-limit";
+        case "temporary_unavailable":
+            return "temporary-unavailable";
+        case "auth_or_challenge":
+            return "authentication/challenge";
+    }
+}
+async function createChatGptUiWarningError(params) {
+    const [uiWarning] = await collectChatGptUiWarnings(params.Runtime);
+    if (!uiWarning)
+        return null;
+    params.logger(`[browser] ChatGPT UI warning detected (${uiWarning.type}): ${uiWarning.message}`);
+    return new BrowserAutomationError(`ChatGPT displayed a ${formatChatGptUiWarningType(uiWarning.type)} warning while waiting for ${params.waitTarget}: ${uiWarning.message}`, {
+        stage: params.stage,
+        code: "chatgpt-ui-warning",
+        uiWarning,
+        runtime: params.runtime,
+        diagnostics: params.diagnostics,
+    }, params.cause);
+}
+async function throwChatGptUiWarningIfPresent(params) {
+    const error = await createChatGptUiWarningError(params);
+    if (error)
+        throw error;
+}
+async function createAssistantTimeoutError(params) {
+    const warningError = await createChatGptUiWarningError({
+        Runtime: params.Runtime,
+        logger: params.logger,
+        runtime: params.runtime,
+        stage: "assistant-timeout",
+        waitTarget: "the assistant",
+        diagnostics: params.diagnostics,
+        cause: params.cause,
+    });
+    if (!warningError) {
+        return new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime: params.runtime, diagnostics: params.diagnostics }, params.cause);
+    }
+    return warningError;
+}
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -157,7 +353,8 @@ function isImageOnlyUiChromeText(text) {
     return (normalized.length === 0 ||
         normalized === "edit" ||
         normalized === "stopped thinking" ||
-        normalized === "stopped thinking edit");
+        normalized === "stopped thinking edit" ||
+        /^thought for \d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s+edit$/.test(normalized));
 }
 function normalizeBrowserFollowUpPrompts(values) {
     return (values ?? []).map((entry) => entry.trim()).filter(Boolean);
@@ -273,6 +470,19 @@ function resolveRemoteTabLeaseProfileDir(config) {
 export function resolveRemoteTabLeaseProfileDirForTest(config) {
     return resolveRemoteTabLeaseProfileDir(config);
 }
+function isLocalChromeHost(host) {
+    const normalized = host
+        .trim()
+        .toLowerCase()
+        .replace(/^\[|\]$/g, "");
+    if (normalized === "localhost" || normalized === "::1") {
+        return true;
+    }
+    return net.isIPv4(normalized) && normalized.startsWith("127.");
+}
+export function isLocalChromeHostForTest(host) {
+    return isLocalChromeHost(host);
+}
 async function closeRemoteConnectionAfterRun(options) {
     if (options.connectionClosedUnexpectedly) {
         return;
@@ -310,6 +520,7 @@ export async function runBrowserMode(options) {
     const attachments = options.attachments ?? [];
     const fallbackSubmission = options.fallbackSubmission;
     let config = resolveBrowserConfig(options.config);
+    const isResumingConversation = Boolean(config.resumeConversationUrl);
     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.", {
@@ -499,9 +710,10 @@ export async function runBrowserMode(options) {
             }
             else {
                 const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+                const devtoolsRetries = manualLogin ? 6 : 0;
                 const connection = await connectWithNewTab(chrome.port, logger, config.url, chromeHost, {
                     fallbackToDefault: !strictTabIsolation,
-                    retries: strictTabIsolation ? 3 : 0,
+                    retries: devtoolsRetries,
                     retryDelayMs: 500,
                 });
                 client = connection.client;
@@ -596,9 +808,18 @@ export async function runBrowserMode(options) {
             });
         }
         if (config.browserTabRef) {
+            if (isResumingConversation) {
+                await raceWithDisconnect(navigateToChatGPT(Page, Runtime, config.resumeConversationUrl, logger));
+            }
             await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
             await raceWithDisconnect(ensureLoggedIn(Runtime, logger));
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+            if (isResumingConversation) {
+                await raceWithDisconnect(waitForResumedConversationHydration(Runtime, config.inputTimeoutMs, logger, {
+                    requirePriorTurns: true,
+                    expectedConversationUrl: config.resumeConversationUrl,
+                }));
+            }
         }
         else {
             const baseUrl = CHATGPT_URL;
@@ -616,7 +837,12 @@ export async function runBrowserMode(options) {
                 profileDir: userDataDir,
                 keepBrowser: effectiveKeepBrowser,
             }));
-            if (config.url !== baseUrl) {
+            if (isResumingConversation) {
+                await raceWithDisconnect(navigateToChatGPT(Page, Runtime, config.resumeConversationUrl, logger));
+                await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
+                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+            }
+            else if (config.url !== baseUrl) {
                 await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
                     url: config.url,
                     fallbackUrl: baseUrl,
@@ -628,6 +854,17 @@ export async function runBrowserMode(options) {
             else {
                 await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             }
+            if (isResumingConversation) {
+                // A resumed thread loads its prior history after navigation; ChatGPT can reset the
+                // composer mid-hydration and wipe a freshly-typed prompt. Wait for hydration to settle
+                // and re-confirm the composer before the prompt is typed/submitted below. Wrapped in
+                // raceWithDisconnect so a dropped client aborts immediately instead of polling to the
+                // hydration deadline. Shared with the remote path via the same helper.
+                await raceWithDisconnect(waitForResumedConversationHydration(Runtime, config.inputTimeoutMs, logger, {
+                    requirePriorTurns: true,
+                    expectedConversationUrl: config.resumeConversationUrl,
+                }));
+            }
         }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         const captureRuntimeSnapshot = async () => {
@@ -707,7 +944,7 @@ export async function runBrowserMode(options) {
         };
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
-        if (config.desiredModel && modelStrategy !== "ignore") {
+        if (config.desiredModel && modelStrategy !== "ignore" && !isResumingConversation) {
             modelSelectionEvidence = await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
@@ -726,9 +963,11 @@ export async function runBrowserMode(options) {
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        else if (modelStrategy === "ignore") {
+        else if (modelStrategy === "ignore" || isResumingConversation) {
             modelSelectionEvidence = buildSkippedModelSelectionEvidence(config.desiredModel, modelStrategy);
-            logger("Model picker: skipped (strategy=ignore)");
+            logger(isResumingConversation
+                ? "Model picker: skipped (resumed conversation)"
+                : "Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
         // Handle thinking time selection if specified. Deep Research owns its own effort flow.
@@ -779,6 +1018,10 @@ export async function runBrowserMode(options) {
             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));
+            const attachmentExpectations = submissionAttachments.map((a) => ({
+                name: path.basename(a.path),
+                generatedBundle: a.generatedBundle === true,
+            }));
             let inputOnlyAttachments = false;
             await raceWithDisconnect(clearPromptComposer(Runtime, logger));
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
@@ -814,9 +1057,12 @@ export async function runBrowserMode(options) {
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 attachmentTimeoutMs: config.attachmentTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
-                attachmentNames,
+                attachmentNames: attachmentExpectations,
                 onPromptSubmitted: markPromptSubmitted,
             };
+            const deepResearchTargetKeys = deepResearch && client
+                ? await captureDeepResearchTargetKeys(client).catch(() => [])
+                : undefined;
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
                 evaluate: async () => undefined,
@@ -849,7 +1095,7 @@ export async function runBrowserMode(options) {
             }
             // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
             scheduleConversationHint("post-submit", config.timeoutMs ?? 120_000);
-            return { baselineTurns, baselineAssistantText };
+            return { baselineTurns, baselineAssistantText, deepResearchTargetKeys };
         };
         const reloadPromptComposer = async () => {
             logger("[browser] Composer became unresponsive; reloading page and retrying once.");
@@ -858,6 +1104,7 @@ export async function runBrowserMode(options) {
         };
         let baselineTurns = null;
         let baselineAssistantText = null;
+        let deepResearchTargetKeys = [];
         await acquireProfileLockIfNeeded();
         try {
             const submission = await runSubmissionWithRecovery({
@@ -874,6 +1121,7 @@ export async function runBrowserMode(options) {
             });
             baselineTurns = submission.baselineTurns;
             baselineAssistantText = submission.baselineAssistantText;
+            deepResearchTargetKeys = submission.deepResearchTargetKeys ?? [];
         }
         finally {
             await releaseProfileLockIfHeld();
@@ -881,7 +1129,7 @@ export async function runBrowserMode(options) {
         const imageArtifactMinTurnIndex = baselineTurns;
         if (deepResearch) {
             await raceWithDisconnect(waitForResearchPlanAutoConfirm(Runtime, logger));
-            const researchResult = await raceWithDisconnect(waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client));
+            const researchResult = await raceWithDisconnect(waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client, { ignoredTargetKeys: deepResearchTargetKeys }));
             await updateConversationHint("post-deep-research", 15_000).catch(() => false);
             runStatus = "complete";
             const durationMs = Date.now() - startedAt;
@@ -1070,7 +1318,13 @@ export async function runBrowserMode(options) {
                             promptSubmitted,
                             controllerPid: process.pid,
                         };
-                        throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime, diagnostics }, error);
+                        throw await createAssistantTimeoutError({
+                            Runtime,
+                            logger,
+                            runtime,
+                            diagnostics,
+                            cause: error,
+                        });
                     }
                 }
                 else {
@@ -1259,6 +1513,9 @@ export async function runBrowserMode(options) {
             throw new Error("Chrome disconnected before completion");
         }
         const imageArtifacts = await collectGeneratedImageArtifacts({
+            Browser: client.Browser,
+            Client: client,
+            Page,
             Runtime,
             Network,
             logger,
@@ -1268,21 +1525,50 @@ export async function runBrowserMode(options) {
             outputPath: options.outputPath,
             answerText,
             waitTimeoutMs: options.config?.timeoutMs,
+            checkBlockingUiWarning: () => throwChatGptUiWarningIfPresent({
+                Runtime,
+                logger,
+                stage: "image-artifact-wait",
+                waitTarget: "generated image artifacts",
+                runtime: {
+                    chromePid: chrome.pid,
+                    chromePort: chrome.port,
+                    chromeHost,
+                    userDataDir,
+                    chromeTargetId: lastTargetId,
+                    tabUrl: lastUrl,
+                    conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    promptSubmitted,
+                    controllerPid: process.pid,
+                },
+            }),
         });
         answerText = imageArtifacts.answerText || answerText;
         if (imageArtifacts.markdownSuffix) {
             answerMarkdown += imageArtifacts.markdownSuffix;
         }
+        const fileArtifacts = await collectChatGptFileArtifacts({
+            Browser: client.Browser,
+            Client: client,
+            Page,
+            Runtime,
+            Network,
+            answerText: [answerText, answerMarkdown, answerHtml].filter(Boolean).join("\n"),
+            logger,
+            minTurnIndex: imageArtifactMinTurnIndex,
+            sessionId: options.sessionId,
+        });
         const savedImageArtifacts = appendArtifacts(undefined, imageArtifacts.savedImages);
+        const savedBrowserArtifacts = appendArtifacts(savedImageArtifacts, fileArtifacts.savedFiles);
         const transcriptArtifact = await saveOptionalArtifact(() => saveBrowserTranscriptArtifact({
             sessionId: options.sessionId,
             prompt: promptText,
             answerMarkdown,
             conversationUrl: lastUrl,
-            artifacts: savedImageArtifacts,
+            artifacts: savedBrowserArtifacts,
             logger,
         }), logger);
-        const savedArtifacts = appendArtifacts(savedImageArtifacts, [transcriptArtifact]);
+        const savedArtifacts = appendArtifacts(savedBrowserArtifacts, [transcriptArtifact]);
         const archive = await maybeArchiveCompletedConversation({
             Runtime,
             logger,
@@ -1290,7 +1576,8 @@ export async function runBrowserMode(options) {
             conversationUrl: lastUrl,
             followUpCount: followUpPrompts.length,
             requiredArtifactsSaved: Boolean(transcriptArtifact) &&
-                imageArtifacts.savedImages.length === imageArtifacts.imageCount,
+                imageArtifacts.savedImages.length === imageArtifacts.imageCount &&
+                fileArtifacts.savedFiles.length === fileArtifacts.fileCount,
         });
         runStatus = "complete";
         const durationMs = Date.now() - startedAt;
@@ -1303,6 +1590,8 @@ export async function runBrowserMode(options) {
             artifacts: savedArtifacts,
             generatedImages: imageArtifacts.generatedImages,
             savedImages: imageArtifacts.savedImages,
+            downloadableFiles: fileArtifacts.files,
+            savedFiles: fileArtifacts.savedFiles,
             archive,
             modelSelection: modelSelectionEvidence,
             tookMs: durationMs,
@@ -1676,13 +1965,23 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
     let pid = await readChromePid(userDataDir);
     if (!port) {
         const discovered = await findRunningChromeDebugTargetForProfile(userDataDir);
-        if (!discovered)
+        if (!discovered) {
+            if (pid) {
+                logger(`No reachable Chrome DevTools target found for ${userDataDir}; clearing stale profile state before launching new Chrome.`);
+                await cleanupStaleProfileState(userDataDir, logger, {
+                    lockRemovalMode: "if_oracle_pid_dead",
+                });
+            }
             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.`);
+            await cleanupStaleProfileState(userDataDir, logger, {
+                lockRemovalMode: "if_oracle_pid_dead",
+            });
             return null;
         }
         await writeDevToolsActivePort(userDataDir, discovered.port);
@@ -1830,16 +2129,20 @@ 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)");
-        if (!attachedExistingTab) {
+        if (config.resumeConversationUrl) {
+            await navigateToChatGPT(Page, Runtime, config.resumeConversationUrl, logger);
+        }
+        else 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);
+        await ensureNotBlocked(Runtime, config.headless, logger);
+        await ensureLoggedIn(Runtime, logger, { remoteSession: true });
+        await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        if (config.resumeConversationUrl) {
+            await waitForResumedConversationHydration(Runtime, config.inputTimeoutMs, logger, {
+                requirePriorTurns: true,
+                expectedConversationUrl: config.resumeConversationUrl,
+            });
         }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         try {
@@ -1856,7 +2159,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             // ignore
         }
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
-        if (config.desiredModel && modelStrategy !== "ignore") {
+        if (config.desiredModel && modelStrategy !== "ignore" && !config.resumeConversationUrl) {
             modelSelectionEvidence = await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
@@ -1869,9 +2172,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        else if (modelStrategy === "ignore") {
+        else if (modelStrategy === "ignore" || config.resumeConversationUrl) {
             modelSelectionEvidence = buildSkippedModelSelectionEvidence(config.desiredModel, modelStrategy);
-            logger("Model picker: skipped (strategy=ignore)");
+            logger(config.resumeConversationUrl
+                ? "Model picker: skipped (resumed conversation)"
+                : "Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
         // Handle thinking time selection if specified. Deep Research owns its own effort flow.
@@ -1905,6 +2210,10 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             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));
+            const attachmentExpectations = submissionAttachments.map((a) => ({
+                name: path.basename(a.path),
+                generatedBundle: a.generatedBundle === true,
+            }));
             await clearPromptComposer(Runtime, logger);
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             if (submissionAttachments.length > 0) {
@@ -1935,9 +2244,12 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 attachmentTimeoutMs: config.attachmentTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
-                attachmentNames,
+                attachmentNames: attachmentExpectations,
                 onPromptSubmitted: markPromptSubmitted,
             };
+            const deepResearchTargetKeys = deepResearch && client
+                ? await captureDeepResearchTargetKeys(client).catch(() => [])
+                : undefined;
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
                 evaluate: async () => undefined,
@@ -1950,7 +2262,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             if (typeof providerBaselineTurns === "number" && Number.isFinite(providerBaselineTurns)) {
                 baselineTurns = providerBaselineTurns;
             }
-            return { baselineTurns, baselineAssistantText };
+            return { baselineTurns, baselineAssistantText, deepResearchTargetKeys };
         };
         const reloadPromptComposer = async () => {
             logger("[browser] Composer became unresponsive; reloading page and retrying once.");
@@ -1959,6 +2271,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         };
         let baselineTurns = null;
         let baselineAssistantText = null;
+        let deepResearchTargetKeys = [];
         const submission = await runSubmissionWithRecovery({
             prompt: promptText,
             attachments,
@@ -1973,10 +2286,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         });
         baselineTurns = submission.baselineTurns;
         baselineAssistantText = submission.baselineAssistantText;
+        deepResearchTargetKeys = submission.deepResearchTargetKeys ?? [];
         const imageArtifactMinTurnIndex = baselineTurns;
         if (deepResearch) {
             await waitForResearchPlanAutoConfirm(Runtime, logger);
-            const researchResult = await waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client);
+            const researchResult = await waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client, { ignoredTargetKeys: deepResearchTargetKeys });
             await emitRuntimeHint();
             const durationMs = Date.now() - startedAt;
             const tokens = estimateTokenCount(researchResult.text);
@@ -2175,7 +2489,13 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                             promptSubmitted,
                             controllerPid: process.pid,
                         };
-                        throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime, diagnostics }, error);
+                        throw await createAssistantTimeoutError({
+                            Runtime,
+                            logger,
+                            runtime,
+                            diagnostics,
+                            cause: error,
+                        });
                     }
                 }
                 else {
@@ -2320,7 +2640,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             answerMarkdown = formatted.answerMarkdown;
             answerHtml = "";
         }
+        const canSaveBrowserDownloadsLocally = isLocalChromeHost(host);
         const imageArtifacts = await collectGeneratedImageArtifacts({
+            Browser: canSaveBrowserDownloadsLocally ? client.Browser : undefined,
+            Client: canSaveBrowserDownloadsLocally ? client : undefined,
+            Page: canSaveBrowserDownloadsLocally ? Page : undefined,
             Runtime,
             Network,
             logger,
@@ -2330,21 +2654,50 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             outputPath: options.outputPath,
             answerText,
             waitTimeoutMs: options.config?.timeoutMs,
+            checkBlockingUiWarning: () => throwChatGptUiWarningIfPresent({
+                Runtime,
+                logger,
+                stage: "image-artifact-wait",
+                waitTarget: "generated image artifacts",
+                runtime: {
+                    chromePort: port,
+                    chromeHost: host,
+                    chromeBrowserWSEndpoint: browserWSEndpoint,
+                    chromeProfileRoot,
+                    chromeTargetId: remoteTargetId ?? undefined,
+                    tabUrl: lastUrl,
+                    conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    promptSubmitted,
+                    controllerPid: process.pid,
+                },
+            }),
         });
         answerText = imageArtifacts.answerText || answerText;
         if (imageArtifacts.markdownSuffix) {
             answerMarkdown += imageArtifacts.markdownSuffix;
         }
+        const fileArtifacts = await collectChatGptFileArtifacts({
+            Browser: client.Browser,
+            Client: client,
+            Page,
+            Runtime,
+            Network,
+            answerText: [answerText, answerMarkdown, answerHtml].filter(Boolean).join("\n"),
+            logger,
+            minTurnIndex: imageArtifactMinTurnIndex,
+            sessionId: options.sessionId,
+        });
         const savedImageArtifacts = appendArtifacts(undefined, imageArtifacts.savedImages);
+        const savedBrowserArtifacts = appendArtifacts(savedImageArtifacts, fileArtifacts.savedFiles);
         const transcriptArtifact = await saveOptionalArtifact(() => saveBrowserTranscriptArtifact({
             sessionId: options.sessionId,
             prompt: promptText,
             answerMarkdown,
             conversationUrl: lastUrl,
-            artifacts: savedImageArtifacts,
+            artifacts: savedBrowserArtifacts,
             logger,
         }), logger);
-        const savedArtifacts = appendArtifacts(savedImageArtifacts, [transcriptArtifact]);
+        const savedArtifacts = appendArtifacts(savedBrowserArtifacts, [transcriptArtifact]);
         const archive = await maybeArchiveCompletedConversation({
             Runtime,
             logger,
@@ -2352,7 +2705,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             conversationUrl: lastUrl,
             followUpCount: followUpPrompts.length,
             requiredArtifactsSaved: Boolean(transcriptArtifact) &&
-                imageArtifacts.savedImages.length === imageArtifacts.imageCount,
+                imageArtifacts.savedImages.length === imageArtifacts.imageCount &&
+                fileArtifacts.savedFiles.length === fileArtifacts.fileCount,
         });
         const durationMs = Date.now() - startedAt;
         const answerChars = answerText.length;
@@ -2377,6 +2731,10 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
             promptSubmitted,
             artifacts: savedArtifacts,
+            generatedImages: imageArtifacts.generatedImages,
+            savedImages: imageArtifacts.savedImages,
+            downloadableFiles: fileArtifacts.files,
+            savedFiles: fileArtifacts.savedFiles,
             archive,
             modelSelection: modelSelectionEvidence,
             controllerPid: process.pid,
@@ -2443,8 +2801,12 @@ export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from "./config.js";
 export const __test__ = {
     assertManualLoginProfileReadyForRun,
     closeRemoteConnectionAfterRun,
+    classifyChatGptUiWarningText,
+    collectChatGptUiWarnings,
+    createAssistantTimeoutError,
     detachKeptChromeProcess,
     formatManualLoginSetupCommand,
+    isAssistantResponseTimeoutError,
     isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
@@ -2500,7 +2862,8 @@ function isAssistantResponseTimeoutError(error) {
     const message = error.message.toLowerCase();
     if (!message)
         return false;
-    return (message.includes("assistant-response") ||
+    return (message === "response timeout" ||
+        message.includes("assistant-response") ||
         message.includes("assistant response") ||
         message.includes("watchdog") ||
         message.includes("capture assistant response"));