@steipete/oracle 0.12.1 → 0.14.0

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,188 @@ 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 createAssistantTimeoutError(params) {
+    const [uiWarning] = await collectChatGptUiWarnings(params.Runtime);
+    if (!uiWarning) {
+        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);
+    }
+    params.logger(`[browser] ChatGPT UI warning detected (${uiWarning.type}): ${uiWarning.message}`);
+    return new BrowserAutomationError(`ChatGPT displayed a ${formatChatGptUiWarningType(uiWarning.type)} warning while waiting for the assistant: ${uiWarning.message}`, {
+        stage: "assistant-timeout",
+        code: "chatgpt-ui-warning",
+        uiWarning,
+        runtime: params.runtime,
+        diagnostics: params.diagnostics,
+    }, params.cause);
+}
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -273,6 +450,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 +500,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.", {
@@ -596,9 +787,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 +816,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 +833,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 +923,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 +942,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 +997,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));
@@ -800,7 +1022,8 @@ export async function runBrowserMode(options) {
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
                 const perFileTimeout = 20_000;
                 const waitBudget = Math.max(baseTimeout, 45_000) + (submissionAttachments.length - 1) * perFileTimeout;
-                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                const attachmentWaitBudget = Math.max(config.attachmentTimeoutMs ?? 0, waitBudget);
+                await waitForAttachmentCompletion(Runtime, attachmentWaitBudget, attachmentNames, logger);
                 logger("All attachments uploaded");
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
@@ -811,10 +1034,14 @@ export async function runBrowserMode(options) {
                 logger,
                 timeoutMs: config.timeoutMs,
                 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,
@@ -847,7 +1074,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.");
@@ -856,6 +1083,7 @@ export async function runBrowserMode(options) {
         };
         let baselineTurns = null;
         let baselineAssistantText = null;
+        let deepResearchTargetKeys = [];
         await acquireProfileLockIfNeeded();
         try {
             const submission = await runSubmissionWithRecovery({
@@ -872,6 +1100,7 @@ export async function runBrowserMode(options) {
             });
             baselineTurns = submission.baselineTurns;
             baselineAssistantText = submission.baselineAssistantText;
+            deepResearchTargetKeys = submission.deepResearchTargetKeys ?? [];
         }
         finally {
             await releaseProfileLockIfHeld();
@@ -879,7 +1108,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;
@@ -1068,7 +1297,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 {
@@ -1257,6 +1492,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,
@@ -1271,16 +1509,28 @@ export async function runBrowserMode(options) {
         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,
@@ -1288,7 +1538,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;
@@ -1301,6 +1552,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,
@@ -1674,13 +1927,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);
@@ -1828,16 +2091,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 {
@@ -1854,7 +2121,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,
@@ -1867,9 +2134,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.
@@ -1903,6 +2172,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) {
@@ -1920,7 +2193,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
                 const perFileTimeout = 15_000;
                 const waitBudget = Math.max(baseTimeout, 30_000) + (submissionAttachments.length - 1) * perFileTimeout;
-                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                const attachmentWaitBudget = Math.max(config.attachmentTimeoutMs ?? 0, waitBudget);
+                await waitForAttachmentCompletion(Runtime, attachmentWaitBudget, attachmentNames, logger);
                 logger("All attachments uploaded");
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
@@ -1930,10 +2204,14 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 logger,
                 timeoutMs: config.timeoutMs,
                 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,
@@ -1946,7 +2224,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.");
@@ -1955,6 +2233,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         };
         let baselineTurns = null;
         let baselineAssistantText = null;
+        let deepResearchTargetKeys = [];
         const submission = await runSubmissionWithRecovery({
             prompt: promptText,
             attachments,
@@ -1969,10 +2248,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);
@@ -2171,7 +2451,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 {
@@ -2316,7 +2602,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,
@@ -2331,16 +2621,28 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         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,
@@ -2348,7 +2650,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;
@@ -2373,6 +2676,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,
@@ -2439,8 +2746,12 @@ export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from "./config.js";
 export const __test__ = {
     assertManualLoginProfileReadyForRun,
     closeRemoteConnectionAfterRun,
+    classifyChatGptUiWarningText,
+    collectChatGptUiWarnings,
+    createAssistantTimeoutError,
     detachKeptChromeProcess,
     formatManualLoginSetupCommand,
+    isAssistantResponseTimeoutError,
     isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
@@ -2496,7 +2807,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"));