@steipete/oracle 0.8.5 → 0.9.0

package/dist/src/browser/config.js

@@ -12,6 +12,13 @@ export const DEFAULT_BROWSER_CONFIG = {
     timeoutMs: 1_200_000,
     debugPort: null,
     inputTimeoutMs: 60_000,
+    assistantRecheckDelayMs: 0,
+    assistantRecheckTimeoutMs: 120_000,
+    reuseChromeWaitMs: 10_000,
+    profileLockTimeoutMs: 300_000,
+    autoReattachDelayMs: 0,
+    autoReattachIntervalMs: 0,
+    autoReattachTimeoutMs: 120_000,
     cookieSync: true,
     cookieNames: null,
     cookieSyncWaitMs: 0,
@@ -57,6 +64,13 @@ export function resolveBrowserConfig(config) {
         timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
         debugPort: config?.debugPort ?? debugPortEnv ?? DEFAULT_BROWSER_CONFIG.debugPort,
         inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
+        assistantRecheckDelayMs: config?.assistantRecheckDelayMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckDelayMs,
+        assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
+        reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
+        profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
+        autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
+        autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
+        autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
         cookieSync: config?.cookieSync ?? cookieSyncDefault,
         cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
         cookieSyncWaitMs: config?.cookieSyncWaitMs ?? DEFAULT_BROWSER_CONFIG.cookieSyncWaitMs,

package/dist/src/browser/constants.js

@@ -1,5 +1,5 @@
 export const CHATGPT_URL = 'https://chatgpt.com/';
-export const DEFAULT_MODEL_TARGET = 'GPT-5.2 Pro';
+export const DEFAULT_MODEL_TARGET = 'GPT-5.4 Pro';
 export const DEFAULT_MODEL_STRATEGY = 'select';
 export const COOKIE_URLS = ['https://chatgpt.com', 'https://chat.openai.com', 'https://atlas.openai.com'];
 export const INPUT_SELECTORS = [

package/dist/src/browser/index.js

@@ -5,7 +5,8 @@ import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
+import { INPUT_SELECTORS } from './constants.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
 import { ensureThinkingTime } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
@@ -13,9 +14,22 @@ 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, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
+import { cleanupStaleProfileState, acquireProfileRunLock, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
+import { runProviderSubmissionFlow } from './providerDomFlow.js';
+import { chatgptDomProvider } from './providers/index.js';
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
+function isCloudflareChallengeError(error) {
+    if (!(error instanceof BrowserAutomationError))
+        return false;
+    return error.details?.stage === 'cloudflare-challenge';
+}
+function shouldPreserveBrowserOnError(error, headless) {
+    return !headless && isCloudflareChallengeError(error);
+}
+export function shouldPreserveBrowserOnErrorForTest(error, headless) {
+    return shouldPreserveBrowserOnError(error, headless);
+}
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
@@ -96,7 +110,9 @@ export async function runBrowserMode(options) {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
     }
     const effectiveKeepBrowser = Boolean(config.keepBrowser);
-    const reusedChrome = manualLogin ? await maybeReuseRunningChrome(userDataDir, logger) : null;
+    const reusedChrome = manualLogin
+        ? await maybeReuseRunningChrome(userDataDir, logger, { waitForPortMs: config.reuseChromeWaitMs })
+        : null;
     const chrome = reusedChrome ??
         (await launchChrome({
             ...config,
@@ -132,9 +148,15 @@ export async function runBrowserMode(options) {
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
     let appliedCookies = 0;
+    let preserveBrowserOnError = false;
     try {
         try {
-            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost);
+            const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost, {
+                fallbackToDefault: !strictTabIsolation,
+                retries: strictTabIsolation ? 3 : 0,
+                retryDelayMs: 500,
+            });
             client = connection.client;
             isolatedTargetId = connection.targetId ?? null;
         }
@@ -346,6 +368,23 @@ export async function runBrowserMode(options) {
                 },
             }));
         }
+        const profileLockTimeoutMs = manualLogin ? (config.profileLockTimeoutMs ?? 0) : 0;
+        let profileLock = null;
+        const acquireProfileLockIfNeeded = async () => {
+            if (profileLockTimeoutMs <= 0)
+                return;
+            profileLock = await acquireProfileRunLock(userDataDir, {
+                timeoutMs: profileLockTimeoutMs,
+                logger,
+            });
+        };
+        const releaseProfileLockIfHeld = async () => {
+            if (!profileLock)
+                return;
+            const handle = profileLock;
+            profileLock = null;
+            await handle.release().catch(() => undefined);
+        };
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
             const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
@@ -388,17 +427,25 @@ export async function runBrowserMode(options) {
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
             // Learned: return baselineTurns so assistant polling can ignore earlier content.
             const sendAttachmentNames = attachmentWaitTimedOut ? [] : attachmentNames;
-            const committedTurns = await submitPrompt({
+            const providerState = {
                 runtime: Runtime,
                 input: Input,
-                attachmentNames: sendAttachmentNames,
-                baselineTurns: baselineTurns ?? undefined,
+                logger,
+                timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
-            }, prompt, logger);
-            if (typeof committedTurns === 'number' && Number.isFinite(committedTurns)) {
-                if (baselineTurns === null || committedTurns > baselineTurns) {
-                    baselineTurns = Math.max(0, committedTurns - 1);
-                }
+                baselineTurns: baselineTurns ?? undefined,
+                attachmentNames: sendAttachmentNames,
+            };
+            await runProviderSubmissionFlow(chatgptDomProvider, {
+                prompt,
+                evaluate: async () => undefined,
+                delay,
+                log: logger,
+                state: providerState,
+            });
+            const providerBaselineTurns = providerState.baselineTurns;
+            if (typeof providerBaselineTurns === 'number' && Number.isFinite(providerBaselineTurns)) {
+                baselineTurns = providerBaselineTurns;
             }
             if (attachmentNames.length > 0) {
                 if (attachmentWaitTimedOut) {
@@ -421,27 +468,33 @@ export async function runBrowserMode(options) {
         };
         let baselineTurns = null;
         let baselineAssistantText = null;
+        await acquireProfileLockIfNeeded();
         try {
-            const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
-            baselineTurns = submission.baselineTurns;
-            baselineAssistantText = submission.baselineAssistantText;
-        }
-        catch (error) {
-            const isPromptTooLarge = error instanceof BrowserAutomationError &&
-                error.details?.code === 'prompt-too-large';
-            if (fallbackSubmission && isPromptTooLarge) {
-                // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
-                logger('[browser] Inline prompt too large; retrying with file uploads.');
-                await raceWithDisconnect(clearPromptComposer(Runtime, logger));
-                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
-                const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+            try {
+                const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
                 baselineTurns = submission.baselineTurns;
                 baselineAssistantText = submission.baselineAssistantText;
             }
-            else {
-                throw error;
+            catch (error) {
+                const isPromptTooLarge = error instanceof BrowserAutomationError &&
+                    error.details?.code === 'prompt-too-large';
+                if (fallbackSubmission && isPromptTooLarge) {
+                    // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
+                    logger('[browser] Inline prompt too large; retrying with file uploads.');
+                    await raceWithDisconnect(clearPromptComposer(Runtime, logger));
+                    await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+                    const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+                    baselineTurns = submission.baselineTurns;
+                    baselineAssistantText = submission.baselineAssistantText;
+                }
+                else {
+                    throw error;
+                }
             }
         }
+        finally {
+            await releaseProfileLockIfHeld();
+        }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
         const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
@@ -468,7 +521,83 @@ export async function runBrowserMode(options) {
             }
             return null;
         };
-        let answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
+        let answer;
+        const recheckDelayMs = Math.max(0, config.assistantRecheckDelayMs ?? 0);
+        const recheckTimeoutMs = Math.max(0, config.assistantRecheckTimeoutMs ?? 0);
+        const attemptAssistantRecheck = async () => {
+            if (!recheckDelayMs)
+                return null;
+            logger(`[browser] Assistant response timed out; waiting ${formatElapsed(recheckDelayMs)} before rechecking conversation.`);
+            await raceWithDisconnect(delay(recheckDelayMs));
+            await updateConversationHint('assistant-recheck', 15_000).catch(() => false);
+            await captureRuntimeSnapshot().catch(() => undefined);
+            const conversationUrl = await readConversationUrl(Runtime);
+            if (conversationUrl && isConversationUrl(conversationUrl)) {
+                logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
+                await raceWithDisconnect(Page.navigate({ url: conversationUrl }));
+                await raceWithDisconnect(delay(1000));
+            }
+            // Validate session before attempting recheck - sessions can expire during the delay
+            const sessionValid = await validateChatGPTSession(Runtime, logger);
+            if (!sessionValid.valid) {
+                logger(`[browser] Session validation failed: ${sessionValid.reason}`);
+                // Update session metadata to indicate login is needed
+                await emitRuntimeHint();
+                throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Please sign in and retry.`, {
+                    stage: 'assistant-recheck',
+                    details: {
+                        conversationUrl: conversationUrl || lastUrl || null,
+                        sessionStatus: 'needs_login',
+                        validationReason: sessionValid.reason,
+                    },
+                    runtime: {
+                        chromePid: chrome.pid,
+                        chromePort: chrome.port,
+                        chromeHost,
+                        userDataDir,
+                        chromeTargetId: lastTargetId,
+                        tabUrl: lastUrl,
+                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        controllerPid: process.pid,
+                    },
+                });
+            }
+            const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
+            const rechecked = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined));
+            logger('Recovered assistant response after delayed recheck');
+            return rechecked;
+        };
+        try {
+            answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
+        }
+        catch (error) {
+            if (isAssistantResponseTimeoutError(error)) {
+                const rechecked = await attemptAssistantRecheck().catch(() => null);
+                if (rechecked) {
+                    answer = rechecked;
+                }
+                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);
+                }
+            }
+            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) : '';
@@ -624,6 +753,28 @@ export async function runBrowserMode(options) {
         stopThinkingMonitor?.();
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
+        if (shouldPreserveBrowserOnError(normalizedError, config.headless)) {
+            preserveBrowserOnError = true;
+            const runtime = {
+                chromePid: chrome.pid,
+                chromePort: chrome.port,
+                chromeHost,
+                userDataDir,
+                chromeTargetId: lastTargetId,
+                tabUrl: lastUrl,
+                controllerPid: process.pid,
+            };
+            const reuseProfileHint = `oracle --engine browser --browser-manual-login ` +
+                `--browser-manual-login-profile-dir ${JSON.stringify(userDataDir)}`;
+            await emitRuntimeHint();
+            logger('Cloudflare challenge detected; leaving browser open so you can complete the check.');
+            logger(`Reuse this browser profile with: ${reuseProfileHint}`);
+            throw new BrowserAutomationError('Cloudflare challenge detected. Complete the “Just a moment…” check in the open browser, then rerun.', {
+                stage: 'cloudflare-challenge',
+                runtime,
+                reuseProfileHint,
+            }, normalizedError);
+        }
         if (!socketClosed) {
             logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
             if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
@@ -658,12 +809,16 @@ export async function runBrowserMode(options) {
         catch {
             // ignore
         }
-        if (!effectiveKeepBrowser && isolatedTargetId && chrome?.port) {
+        // 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) {
             await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
         }
         removeDialogHandler?.();
         removeTerminationHooks?.();
-        if (!effectiveKeepBrowser) {
+        const keepBrowserOpen = effectiveKeepBrowser || preserveBrowserOnError;
+        if (!keepBrowserOpen) {
             if (!connectionClosedUnexpectedly) {
                 try {
                     await chrome.kill();
@@ -817,11 +972,20 @@ async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
         details: { url: lastUrl || '(empty)' },
     });
 }
-async function maybeReuseRunningChrome(userDataDir, logger) {
-    const port = await readDevToolsPort(userDataDir);
+async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
+    const waitForPortMs = Math.max(0, options.waitForPortMs ?? 0);
+    let port = await readDevToolsPort(userDataDir);
+    if (!port && waitForPortMs > 0) {
+        const deadline = Date.now() + waitForPortMs;
+        logger(`Waiting up to ${formatElapsed(waitForPortMs)} for shared Chrome to appear...`);
+        while (!port && Date.now() < deadline) {
+            await delay(250);
+            port = await readDevToolsPort(userDataDir);
+        }
+    }
     if (!port)
         return null;
-    const probe = await verifyDevToolsReachable({ port });
+    const probe = await (options.probe ?? verifyDevToolsReachable)({ port });
     if (!probe.ok) {
         logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${probe.error}); launching new Chrome.`);
         // Safe cleanup: remove stale DevToolsActivePort; only remove lock files if this was an Oracle-owned pid that died.
@@ -961,17 +1125,25 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 logger('All attachments uploaded');
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
-            const committedTurns = await submitPrompt({
+            const providerState = {
                 runtime: Runtime,
                 input: Input,
-                attachmentNames,
-                baselineTurns: baselineTurns ?? undefined,
+                logger,
+                timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
-            }, prompt, logger);
-            if (typeof committedTurns === 'number' && Number.isFinite(committedTurns)) {
-                if (baselineTurns === null || committedTurns > baselineTurns) {
-                    baselineTurns = Math.max(0, committedTurns - 1);
-                }
+                baselineTurns: baselineTurns ?? undefined,
+                attachmentNames,
+            };
+            await runProviderSubmissionFlow(chatgptDomProvider, {
+                prompt,
+                evaluate: async () => undefined,
+                delay,
+                log: logger,
+                state: providerState,
+            });
+            const providerBaselineTurns = providerState.baselineTurns;
+            if (typeof providerBaselineTurns === 'number' && Number.isFinite(providerBaselineTurns)) {
+                baselineTurns = providerBaselineTurns;
             }
             return { baselineTurns, baselineAssistantText };
         };
@@ -1023,7 +1195,87 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             return null;
         };
-        let answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
+        let answer;
+        const recheckDelayMs = Math.max(0, config.assistantRecheckDelayMs ?? 0);
+        const recheckTimeoutMs = Math.max(0, config.assistantRecheckTimeoutMs ?? 0);
+        const attemptAssistantRecheck = async () => {
+            if (!recheckDelayMs)
+                return null;
+            logger(`[browser] Assistant response timed out; waiting ${formatElapsed(recheckDelayMs)} before rechecking conversation.`);
+            await delay(recheckDelayMs);
+            const conversationUrl = await readConversationUrl(Runtime);
+            if (conversationUrl && isConversationUrl(conversationUrl)) {
+                lastUrl = conversationUrl;
+                logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
+                await Page.navigate({ url: conversationUrl });
+                await delay(1000);
+            }
+            // Validate session before attempting recheck - sessions can expire during the delay
+            const sessionValid = await validateChatGPTSession(Runtime, logger);
+            if (!sessionValid.valid) {
+                logger(`[browser] Session validation failed: ${sessionValid.reason}`);
+                // Update session metadata to indicate login is needed
+                await emitRuntimeHint();
+                throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Please sign in and retry.`, {
+                    stage: 'assistant-recheck',
+                    details: {
+                        conversationUrl: conversationUrl || lastUrl || null,
+                        sessionStatus: 'needs_login',
+                        validationReason: sessionValid.reason,
+                    },
+                    runtime: {
+                        chromeHost: host,
+                        chromePort: port,
+                        chromeTargetId: remoteTargetId ?? undefined,
+                        tabUrl: lastUrl,
+                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        controllerPid: process.pid,
+                    },
+                });
+            }
+            await emitRuntimeHint();
+            const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
+            const rechecked = await waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined);
+            logger('Recovered assistant response after delayed recheck');
+            return rechecked;
+        };
+        try {
+            answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
+        }
+        catch (error) {
+            if (isAssistantResponseTimeoutError(error)) {
+                const rechecked = await attemptAssistantRecheck().catch(() => null);
+                if (rechecked) {
+                    answer = rechecked;
+                }
+                else {
+                    try {
+                        const conversationUrl = await readConversationUrl(Runtime);
+                        if (conversationUrl) {
+                            lastUrl = conversationUrl;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                    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;
+            }
+        }
         const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
         if (baselineNormalized) {
             const normalizedAnswer = normalizeForComparison(answer.text ?? '');
@@ -1178,11 +1430,15 @@ export { estimateTokenCount } from './utils.js';
 export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from './config.js';
 export { syncCookies } from './cookies.js';
 export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from './pageActions.js';
-function isWebSocketClosureError(error) {
+export async function maybeReuseRunningChromeForTest(userDataDir, logger, options = {}) {
+    return maybeReuseRunningChrome(userDataDir, logger, options);
+}
+export function isWebSocketClosureError(error) {
     const message = error.message.toLowerCase();
     return (message.includes('websocket connection closed') ||
         message.includes('websocket is closed') ||
         message.includes('websocket error') ||
+        message.includes('inspected target navigated or closed') ||
         message.includes('target closed'));
 }
 export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
@@ -1222,6 +1478,17 @@ function shouldReloadAfterAssistantError(error) {
         message.includes('timeout') ||
         message.includes('capture assistant response'));
 }
+function isAssistantResponseTimeoutError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    if (!message)
+        return false;
+    return (message.includes('assistant-response') ||
+        message.includes('assistant response') ||
+        message.includes('watchdog') ||
+        message.includes('capture assistant response'));
+}
 async function readConversationUrl(Runtime) {
     try {
         const currentUrl = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
@@ -1231,6 +1498,110 @@ async function readConversationUrl(Runtime) {
         return null;
     }
 }
+/**
+ * Validates that the ChatGPT session is still active by checking for login CTAs
+ * and textarea availability. Sessions can expire during long delays (e.g., recheck).
+ *
+ * @param Runtime - Chrome Runtime client
+ * @param logger - Browser logger for diagnostics
+ * @returns SessionValidationResult indicating if session is valid and reason if not
+ */
+async function validateChatGPTSession(Runtime, logger) {
+    try {
+        const outcome = await Runtime.evaluate({
+            expression: buildSessionValidationExpression(),
+            awaitPromise: true,
+            returnByValue: true,
+        });
+        const result = outcome.result?.value;
+        if (!result) {
+            return { valid: false, reason: 'Failed to evaluate session state' };
+        }
+        if (result.onAuthPage) {
+            return { valid: false, reason: 'Redirected to auth page' };
+        }
+        if (result.hasLoginCta) {
+            return { valid: false, reason: 'Login button detected on page' };
+        }
+        if (!result.hasTextarea) {
+            return { valid: false, reason: 'Prompt textarea not available' };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[browser] Session validation error: ${message}`);
+        return { valid: false, reason: `Validation error: ${message}` };
+    }
+}
+function buildSessionValidationExpression() {
+    const selectorLiteral = JSON.stringify(INPUT_SELECTORS);
+    return `(async () => {
+    const pageUrl = typeof location === 'object' && location?.href ? location.href : null;
+    const onAuthPage =
+      typeof location === 'object' &&
+      typeof location.pathname === 'string' &&
+      /^\\/(auth|login|signin)/i.test(location.pathname);
+
+    // Check for login CTAs (similar to ensureLoggedIn logic)
+    const hasLoginCta = (() => {
+      const candidates = Array.from(
+        document.querySelectorAll(
+          [
+            'a[href*="/auth/login"]',
+            'a[href*="/auth/signin"]',
+            'button[type="submit"]',
+            'button[data-testid*="login"]',
+            'button[data-testid*="log-in"]',
+            'button[data-testid*="sign-in"]',
+            'button[data-testid*="signin"]',
+            'button',
+            'a',
+          ].join(','),
+        ),
+      );
+      const textMatches = (text) => {
+        if (!text) return false;
+        const normalized = text.toLowerCase().trim();
+        return ['log in', 'login', 'sign in', 'signin', 'continue with'].some((needle) =>
+          normalized.startsWith(needle),
+        );
+      };
+      for (const node of candidates) {
+        if (!(node instanceof HTMLElement)) continue;
+        const label =
+          node.textContent?.trim() ||
+          node.getAttribute('aria-label') ||
+          node.getAttribute('title') ||
+          '';
+        if (textMatches(label)) {
+          return true;
+        }
+      }
+      return false;
+    })();
+
+    // Check for textarea availability
+    const hasTextarea = (() => {
+      const selectors = ${selectorLiteral};
+      for (const selector of selectors) {
+        const node = document.querySelector(selector);
+        if (node) {
+          return true;
+        }
+      }
+      return false;
+    })();
+
+    return {
+      valid: !onAuthPage && !hasLoginCta && hasTextarea,
+      hasLoginCta,
+      hasTextarea,
+      onAuthPage,
+      pageUrl,
+    };
+  })()`;
+}
 async function readConversationTurnCount(Runtime, logger) {
     const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const attempts = 4;