@steipete/oracle 0.8.6 → 0.10.0

package/dist/src/browser/index.js

@@ -1,26 +1,86 @@
-import { mkdtemp, rm, mkdir } from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import net from 'node:net';
-import { resolveBrowserConfig } from './config.js';
-import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from './chromeLifecycle.js';
-import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
-import { INPUT_SELECTORS } from './constants.js';
-import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
-import { ensureThinkingTime } from './actions/thinkingTime.js';
-import { estimateTokenCount, withRetries, delay } from './utils.js';
-import { formatElapsed } from '../oracle/format.js';
-import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from './constants.js';
-import { BrowserAutomationError } from '../oracle/errors.js';
-import { alignPromptEchoPair, buildPromptEchoMatcher } from './reattachHelpers.js';
-import { cleanupStaleProfileState, acquireProfileRunLock, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
-export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
-export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
+import { mkdtemp, rm, mkdir } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import net from "node:net";
+import { resolveBrowserConfig } from "./config.js";
+import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from "./chromeLifecycle.js";
+import { syncCookies } from "./cookies.js";
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
+import { INPUT_SELECTORS } from "./constants.js";
+import { uploadAttachmentViaDataTransfer } from "./actions/remoteFileTransfer.js";
+import { ensureThinkingTime } from "./actions/thinkingTime.js";
+import { estimateTokenCount, withRetries, delay } from "./utils.js";
+import { formatElapsed } from "../oracle/format.js";
+import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from "./constants.js";
+import { BrowserAutomationError } from "../oracle/errors.js";
+import { alignPromptEchoPair, buildPromptEchoMatcher } from "./reattachHelpers.js";
+import { cleanupStaleProfileState, acquireProfileRunLock, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
+import { runProviderSubmissionFlow } from "./providerDomFlow.js";
+import { chatgptDomProvider } from "./providers/index.js";
+export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
+export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
+function redactBrowserConfigForDebugLog(config) {
+    const redacted = { ...config };
+    if (Array.isArray(config.inlineCookies)) {
+        redacted.inlineCookies = `[redacted:${config.inlineCookies.length} cookies]`;
+        redacted.inlineCookieCount = config.inlineCookies.length;
+    }
+    return redacted;
+}
+export function redactBrowserConfigForDebugLogForTest(config) {
+    return redactBrowserConfigForDebugLog(config);
+}
+function isCloudflareChallengeError(error) {
+    if (!(error instanceof BrowserAutomationError))
+        return false;
+    return error.details?.stage === "cloudflare-challenge";
+}
+function shouldPreserveBrowserOnError(error, headless) {
+    return !headless && isCloudflareChallengeError(error);
+}
+export function shouldPreserveBrowserOnErrorForTest(error, headless) {
+    return shouldPreserveBrowserOnError(error, headless);
+}
+function hasBrowserErrorCode(error, code) {
+    return (error instanceof BrowserAutomationError &&
+        error.details?.code === code);
+}
+async function runSubmissionWithRecovery({ prompt, attachments, fallbackSubmission, submit, reloadPromptComposer, prepareFallbackSubmission, logger, }) {
+    let currentPrompt = prompt;
+    let currentAttachments = attachments;
+    let retriedDeadComposer = false;
+    let usedFallbackSubmission = false;
+    while (true) {
+        try {
+            return await submit(currentPrompt, currentAttachments);
+        }
+        catch (error) {
+            const isDeadComposer = hasBrowserErrorCode(error, "dead-composer");
+            if (isDeadComposer && !retriedDeadComposer) {
+                retriedDeadComposer = true;
+                await reloadPromptComposer();
+                continue;
+            }
+            const isPromptTooLarge = hasBrowserErrorCode(error, "prompt-too-large");
+            if (fallbackSubmission && isPromptTooLarge && !usedFallbackSubmission) {
+                usedFallbackSubmission = true;
+                logger("[browser] Inline prompt too large; retrying with file uploads.");
+                await prepareFallbackSubmission();
+                currentPrompt = fallbackSubmission.prompt;
+                currentAttachments = fallbackSubmission.attachments;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+export async function runSubmissionWithRecoveryForTest(args) {
+    return runSubmissionWithRecovery(args);
+}
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
-        throw new Error('Prompt text is required when using browser mode.');
+        throw new Error("Prompt text is required when using browser mode.");
     }
     const attachments = options.attachments ?? [];
     const fallbackSubmission = options.fallbackSubmission;
@@ -58,9 +118,9 @@ export async function runBrowserMode(options) {
             logger(`Failed to persist runtime hint: ${message}`);
         }
     };
-    if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') {
+    if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") {
         logger(`[browser-mode] config: ${JSON.stringify({
-            ...config,
+            ...redactBrowserConfigForDebugLog(config),
             promptLength: promptText.length,
         })}`);
     }
@@ -76,18 +136,18 @@ export async function runBrowserMode(options) {
     if (config.remoteChrome) {
         // Warn about ignored local-only options
         if (config.headless || config.hideWindow || config.keepBrowser || config.chromePath) {
-            logger('Note: --remote-chrome ignores local Chrome flags ' +
-                '(--browser-headless, --browser-hide-window, --browser-keep-browser, --browser-chrome-path).');
+            logger("Note: --remote-chrome ignores local Chrome flags " +
+                "(--browser-headless, --browser-hide-window, --browser-keep-browser, --browser-chrome-path).");
         }
         return runRemoteBrowserMode(promptText, attachments, config, logger, options);
     }
     const manualLogin = Boolean(config.manualLogin);
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
-        : path.join(os.homedir(), '.oracle', 'browser-profile');
+        : path.join(os.homedir(), ".oracle", "browser-profile");
     const userDataDir = manualLogin
         ? manualProfileDir
-        : await mkdtemp(path.join(await resolveUserDataBaseDir(), 'oracle-browser-'));
+        : await mkdtemp(path.join(await resolveUserDataBaseDir(), "oracle-browser-"));
     if (manualLogin) {
         // Learned: manual login reuses a persistent profile so cookies/SSO survive.
         await mkdir(userDataDir, { recursive: true });
@@ -98,14 +158,16 @@ export async function runBrowserMode(options) {
     }
     const effectiveKeepBrowser = Boolean(config.keepBrowser);
     const reusedChrome = manualLogin
-        ? await maybeReuseRunningChrome(userDataDir, logger, { waitForPortMs: config.reuseChromeWaitMs })
+        ? await maybeReuseRunningChrome(userDataDir, logger, {
+            waitForPortMs: config.reuseChromeWaitMs,
+        })
         : null;
     const chrome = reusedChrome ??
         (await launchChrome({
             ...config,
             remoteChrome: config.remoteChrome,
         }, userDataDir, logger));
-    const chromeHost = chrome.host ?? '127.0.0.1';
+    const chromeHost = chrome.host ?? "127.0.0.1";
     // Persist profile state so future manual-login runs can reuse this Chrome.
     if (manualLogin && chrome.port) {
         await writeDevToolsActivePort(userDataDir, chrome.port);
@@ -116,7 +178,7 @@ export async function runBrowserMode(options) {
     let removeTerminationHooks = null;
     try {
         removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
-            isInFlight: () => runStatus !== 'complete',
+            isInFlight: () => runStatus !== "complete",
             emitRuntimeHint,
             preserveUserDataDir: manualLogin,
         });
@@ -127,18 +189,19 @@ export async function runBrowserMode(options) {
     let client = null;
     let isolatedTargetId = null;
     const startedAt = Date.now();
-    let answerText = '';
-    let answerMarkdown = '';
-    let answerHtml = '';
-    let runStatus = 'attempted';
+    let answerText = "";
+    let answerMarkdown = "";
+    let answerHtml = "";
+    let runStatus = "attempted";
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
     let appliedCookies = 0;
+    let preserveBrowserOnError = false;
     try {
         try {
             const strictTabIsolation = Boolean(manualLogin && reusedChrome);
-            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost, {
+            const connection = await connectWithNewTab(chrome.port, logger, config.url, chromeHost, {
                 fallbackToDefault: !strictTabIsolation,
                 retries: strictTabIsolation ? 3 : 0,
                 retryDelayMs: 500,
@@ -154,10 +217,10 @@ export async function runBrowserMode(options) {
             throw error;
         }
         const disconnectPromise = new Promise((_, reject) => {
-            client?.on('disconnect', () => {
+            client?.on("disconnect", () => {
                 connectionClosedUnexpectedly = true;
-                logger('Chrome window closed; attempting to abort run.');
-                reject(new Error('Chrome window closed before oracle finished. Please keep it open until completion.'));
+                logger("Chrome window closed; attempting to abort run.");
+                reject(new Error("Chrome window closed before oracle finished. Please keep it open until completion."));
             });
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
@@ -166,7 +229,7 @@ export async function runBrowserMode(options) {
             await hideChromeWindow(chrome, logger);
         }
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
-        if (DOM && typeof DOM.enable === 'function') {
+        if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
@@ -178,13 +241,13 @@ export async function runBrowserMode(options) {
         const cookieSyncEnabled = config.cookieSync && (!manualLogin || manualLoginCookieSync);
         if (cookieSyncEnabled) {
             if (manualLoginCookieSync) {
-                logger('Manual login mode: seeding persistent profile with cookies from your Chrome profile.');
+                logger("Manual login mode: seeding persistent profile with cookies from your Chrome profile.");
             }
             if (!config.inlineCookies) {
-                logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.');
+                logger("Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.");
             }
             else {
-                logger('Applying inline cookies (skipping Chrome profile read and Keychain prompt)');
+                logger("Applying inline cookies (skipping Chrome profile read and Keychain prompt)");
             }
             // Learned: always sync cookies before the first navigation so /backend-api/me succeeds.
             const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
@@ -196,32 +259,32 @@ export async function runBrowserMode(options) {
             });
             appliedCookies = cookieCount;
             if (config.inlineCookies && cookieCount === 0) {
-                throw new Error('No inline cookies were applied; aborting before navigation.');
+                throw new Error("No inline cookies were applied; aborting before navigation.");
             }
             logger(cookieCount > 0
                 ? config.inlineCookies
                     ? `Applied ${cookieCount} inline cookies`
-                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
+                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? "Default"}`
                 : config.inlineCookies
-                    ? 'No inline cookies applied; continuing without session reuse'
-                    : 'No Chrome cookies found; continuing without session reuse');
+                    ? "No inline cookies applied; continuing without session reuse"
+                    : "No Chrome cookies found; continuing without session reuse");
         }
         else {
             logger(manualLogin
-                ? 'Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in.'
-                : 'Skipping Chrome cookie sync (--browser-no-cookie-sync)');
+                ? "Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in."
+                : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
         }
         if (cookieSyncEnabled && !manualLogin && (appliedCookies ?? 0) === 0 && !config.inlineCookies) {
             // Learned: if the profile has no ChatGPT cookies, browser mode will just bounce to login.
             // Fail early so the user knows to sign in.
-            throw new BrowserAutomationError('No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. ' +
-                'Make sure ChatGPT is signed in in the selected profile, use --browser-manual-login / inline cookies, ' +
-                'or retry with --browser-cookie-wait 5s if Keychain prompts are slow.', {
-                stage: 'execute-browser',
+            throw new BrowserAutomationError("No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. " +
+                "Make sure ChatGPT is signed in in the selected profile, use --browser-manual-login / inline cookies, " +
+                "or retry with --browser-cookie-wait 5s if Keychain prompts are slow.", {
+                stage: "execute-browser",
                 details: {
-                    profile: config.chromeProfile ?? 'Default',
+                    profile: config.chromeProfile ?? "Default",
                     cookiePath: config.chromeCookiePath ?? null,
-                    hint: 'If macOS Keychain prompts or denies access, run oracle from a GUI session or use --copy/--render for the manual flow.',
+                    hint: "If macOS Keychain prompts or denies access, run oracle from a GUI session or use --copy/--render for the manual flow.",
                 },
             });
         }
@@ -231,7 +294,13 @@ export async function runBrowserMode(options) {
         await raceWithDisconnect(navigateToChatGPT(Page, Runtime, baseUrl, logger));
         await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
         // Learned: login checks must happen on the base domain before jumping into project URLs.
-        await raceWithDisconnect(waitForLogin({ runtime: Runtime, logger, appliedCookies, manualLogin, timeoutMs: config.timeoutMs }));
+        await raceWithDisconnect(waitForLogin({
+            runtime: Runtime,
+            logger,
+            appliedCookies,
+            manualLogin,
+            timeoutMs: config.timeoutMs,
+        }));
         if (config.url !== baseUrl) {
             await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
                 url: config.url,
@@ -258,10 +327,10 @@ export async function runBrowserMode(options) {
             }
             try {
                 const { result } = await Runtime.evaluate({
-                    expression: 'location.href',
+                    expression: "location.href",
                     returnByValue: true,
                 });
-                if (typeof result?.value === 'string') {
+                if (typeof result?.value === "string") {
                     lastUrl = result.value;
                 }
             }
@@ -272,7 +341,7 @@ export async function runBrowserMode(options) {
                 logger(`[browser] url = ${lastUrl}`);
             }
             if (chrome?.port) {
-                const suffix = lastTargetId ? ` target=${lastTargetId}` : '';
+                const suffix = lastTargetId ? ` target=${lastTargetId}` : "";
                 if (lastUrl) {
                     logger(`[reattach] chrome port=${chrome.port} host=${chromeHost} url=${lastUrl}${suffix}`);
                 }
@@ -290,8 +359,11 @@ export async function runBrowserMode(options) {
             const start = Date.now();
             while (Date.now() - start < timeoutMs) {
                 try {
-                    const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
-                    if (typeof result?.value === 'string' && result.value.includes('/c/')) {
+                    const { result } = await Runtime.evaluate({
+                        expression: "location.href",
+                        returnByValue: true,
+                    });
+                    if (typeof result?.value === "string" && result.value.includes("/c/")) {
                         lastUrl = result.value;
                         logger(`[browser] conversation url (${label}) = ${lastUrl}`);
                         await emitRuntimeHint();
@@ -319,7 +391,7 @@ export async function runBrowserMode(options) {
         };
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
-        if (config.desiredModel && modelStrategy !== 'ignore') {
+        if (config.desiredModel && modelStrategy !== "ignore") {
             await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
@@ -331,15 +403,15 @@ export async function runBrowserMode(options) {
             })).catch((error) => {
                 const base = error instanceof Error ? error.message : String(error);
                 const hint = appliedCookies === 0
-                    ? ' No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON).'
-                    : '';
+                    ? " No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON)."
+                    : "";
                 throw new Error(`${base}${hint}`);
             });
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        else if (modelStrategy === 'ignore') {
-            logger('Model picker: skipped (strategy=ignore)');
+        else if (modelStrategy === "ignore") {
+            logger("Model picker: skipped (strategy=ignore)");
         }
         // Handle thinking time selection if specified
         const thinkingTime = config.thinkingTime;
@@ -373,13 +445,12 @@ export async function runBrowserMode(options) {
         };
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
-            const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
+            const baselineAssistantText = typeof baselineSnapshot?.text === "string" ? baselineSnapshot.text.trim() : "";
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
-            let attachmentWaitTimedOut = false;
             let inputOnlyAttachments = false;
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
-                    throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+                    throw new Error("Chrome DOM domain unavailable while uploading attachments.");
                 }
                 await clearComposerAttachments(Runtime, 5_000, logger);
                 for (let attachmentIndex = 0; attachmentIndex < submissionAttachments.length; attachmentIndex += 1) {
@@ -395,103 +466,104 @@ export async function runBrowserMode(options) {
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
                 const perFileTimeout = 20_000;
                 const waitBudget = Math.max(baseTimeout, 45_000) + (submissionAttachments.length - 1) * perFileTimeout;
-                try {
-                    await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-                    logger('All attachments uploaded');
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (/Attachments did not finish uploading before timeout/i.test(message)) {
-                        attachmentWaitTimedOut = true;
-                        logger(`[browser] Attachment upload timed out after ${Math.round(waitBudget / 1000)}s; continuing without confirmation.`);
-                    }
-                    else {
-                        throw error;
-                    }
-                }
+                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                logger("All attachments uploaded");
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
             // Learned: return baselineTurns so assistant polling can ignore earlier content.
-            const sendAttachmentNames = attachmentWaitTimedOut ? [] : attachmentNames;
-            const 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,
+            };
+            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) {
-                    logger('Attachment confirmation timed out; skipping user-turn attachment verification.');
-                }
-                else if (inputOnlyAttachments) {
-                    logger('Attachment UI did not render before send; skipping user-turn attachment verification.');
+                if (inputOnlyAttachments) {
+                    logger("Attachment UI did not render before send; skipping user-turn attachment verification.");
                 }
                 else {
-                    const verified = await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger);
+                    const verified = await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger, {
+                        minTurnIndex: baselineTurns ?? undefined,
+                        expectedPrompt: prompt,
+                        expectedConversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    });
                     if (!verified) {
-                        throw new Error('Sent user message did not expose attachment UI after upload.');
+                        logger("Sent user message did not expose attachment UI; continuing after upload check.");
+                    }
+                    else {
+                        logger("Verified attachments present on sent user message");
                     }
-                    logger('Verified attachments present on sent user message');
                 }
             }
             // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
-            scheduleConversationHint('post-submit', config.timeoutMs ?? 120_000);
+            scheduleConversationHint("post-submit", config.timeoutMs ?? 120_000);
             return { baselineTurns, baselineAssistantText };
         };
+        const reloadPromptComposer = async () => {
+            logger("[browser] Composer became unresponsive; reloading page and retrying once.");
+            await raceWithDisconnect(Page.reload({ ignoreCache: true }));
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+        };
         let baselineTurns = null;
         let baselineAssistantText = null;
         await acquireProfileLockIfNeeded();
         try {
-            try {
-                const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
-                baselineTurns = submission.baselineTurns;
-                baselineAssistantText = submission.baselineAssistantText;
-            }
-            catch (error) {
-                const isPromptTooLarge = error instanceof BrowserAutomationError &&
-                    error.details?.code === 'prompt-too-large';
-                if (fallbackSubmission && isPromptTooLarge) {
-                    // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
-                    logger('[browser] Inline prompt too large; retrying with file uploads.');
+            const submission = await runSubmissionWithRecovery({
+                prompt: promptText,
+                attachments,
+                fallbackSubmission,
+                submit: (submissionPrompt, submissionAttachments) => raceWithDisconnect(submitOnce(submissionPrompt, submissionAttachments)),
+                reloadPromptComposer,
+                prepareFallbackSubmission: async () => {
                     await raceWithDisconnect(clearPromptComposer(Runtime, logger));
                     await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
-                    const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
-                    baselineTurns = submission.baselineTurns;
-                    baselineAssistantText = submission.baselineAssistantText;
-                }
-                else {
-                    throw error;
-                }
-            }
+                },
+                logger,
+            });
+            baselineTurns = submission.baselineTurns;
+            baselineAssistantText = submission.baselineAssistantText;
         }
         finally {
             await releaseProfileLockIfHeld();
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
-        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, " ").trim();
+        const expectedConversationId = () => lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
         const waitForFreshAssistantResponse = async (baselineNormalized, timeoutMs) => {
             const baselinePrefix = baselineNormalized.length >= 80
                 ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
+                : "";
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text) {
                     const normalized = normalizeForComparison(text);
-                    const isBaseline = normalized === baselineNormalized || (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
+                    const isBaseline = normalized === baselineNormalized ||
+                        (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
                     if (!isBaseline) {
                         return {
                             text,
                             html: snapshot?.html ?? undefined,
-                            meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+                            meta: {
+                                turnId: snapshot?.turnId ?? undefined,
+                                messageId: snapshot?.messageId ?? undefined,
+                            },
                         };
                     }
                 }
@@ -507,7 +579,7 @@ export async function runBrowserMode(options) {
                 return null;
             logger(`[browser] Assistant response timed out; waiting ${formatElapsed(recheckDelayMs)} before rechecking conversation.`);
             await raceWithDisconnect(delay(recheckDelayMs));
-            await updateConversationHint('assistant-recheck', 15_000).catch(() => false);
+            await updateConversationHint("assistant-recheck", 15_000).catch(() => false);
             await captureRuntimeSnapshot().catch(() => undefined);
             const conversationUrl = await readConversationUrl(Runtime);
             if (conversationUrl && isConversationUrl(conversationUrl)) {
@@ -522,12 +594,12 @@ export async function runBrowserMode(options) {
                 // Update session metadata to indicate login is needed
                 await emitRuntimeHint();
                 throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
-                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || "unknown"}. ` +
                     `Please sign in and retry.`, {
-                    stage: 'assistant-recheck',
+                    stage: "assistant-recheck",
                     details: {
                         conversationUrl: conversationUrl || lastUrl || null,
-                        sessionStatus: 'needs_login',
+                        sessionStatus: "needs_login",
                         validationReason: sessionValid.reason,
                     },
                     runtime: {
@@ -543,12 +615,13 @@ export async function runBrowserMode(options) {
                 });
             }
             const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
-            const rechecked = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined));
-            logger('Recovered assistant response after delayed recheck');
+            const rechecked = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()));
+            logger("Recovered assistant response after delayed recheck");
             return rechecked;
         };
         try {
-            answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
+            await updateConversationHint("assistant-wait", 15_000).catch(() => false);
+            answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()));
         }
         catch (error) {
             if (isAssistantResponseTimeoutError(error)) {
@@ -557,7 +630,7 @@ export async function runBrowserMode(options) {
                     answer = rechecked;
                 }
                 else {
-                    await updateConversationHint('assistant-timeout', 15_000).catch(() => false);
+                    await updateConversationHint("assistant-timeout", 15_000).catch(() => false);
                     await captureRuntimeSnapshot().catch(() => undefined);
                     const runtime = {
                         chromePid: chrome.pid,
@@ -569,7 +642,7 @@ export async function runBrowserMode(options) {
                         conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
                         controllerPid: process.pid,
                     };
-                    throw new BrowserAutomationError('Assistant response timed out before completion; reattach later to capture the answer.', { stage: 'assistant-timeout', runtime }, error);
+                    throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime }, error);
                 }
             }
             else {
@@ -577,17 +650,19 @@ export async function runBrowserMode(options) {
             }
         }
         // Ensure we store the final conversation URL even if the UI updated late.
-        await updateConversationHint('post-response', 15_000);
-        const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
+        await updateConversationHint("post-response", 15_000);
+        const baselineNormalized = baselineAssistantText
+            ? normalizeForComparison(baselineAssistantText)
+            : "";
         if (baselineNormalized) {
-            const normalizedAnswer = normalizeForComparison(answer.text ?? '');
+            const normalizedAnswer = normalizeForComparison(answer.text ?? "");
             const baselinePrefix = baselineNormalized.length >= 80
                 ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
+                : "";
             const isBaseline = normalizedAnswer === baselineNormalized ||
                 (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
             if (isBaseline) {
-                logger('Detected stale assistant response; waiting for new response...');
+                logger("Detected stale assistant response; waiting for new response...");
                 const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
                 if (refreshed) {
                     answer = refreshed;
@@ -595,11 +670,11 @@ export async function runBrowserMode(options) {
             }
         }
         answerText = answer.text;
-        answerHtml = answer.html ?? '';
+        answerHtml = answer.html ?? "";
         const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
             const attempt = await captureAssistantMarkdown(Runtime, answer.meta, logger);
             if (!attempt) {
-                throw new Error('copy-missing');
+                throw new Error("copy-missing");
             }
             return attempt;
         }, {
@@ -622,8 +697,8 @@ export async function runBrowserMode(options) {
             allowMarkdownUpdate: !copiedMarkdown,
         }));
         // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
-        const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-        const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
+        const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+        const finalText = typeof finalSnapshot?.text === "string" ? finalSnapshot.text.trim() : "";
         if (finalText && finalText !== promptText.trim()) {
             const trimmedMarkdown = answerMarkdown.trim();
             const finalIsEcho = promptEchoMatcher ? promptEchoMatcher.isEcho(finalText) : false;
@@ -633,27 +708,27 @@ export async function runBrowserMode(options) {
                 trimmedMarkdown.length > 0 &&
                 lengthDelta >= Math.max(12, Math.floor(trimmedMarkdown.length * 0.75));
             if ((missingCopy || likelyTruncatedCopy) && !finalIsEcho && finalText !== trimmedMarkdown) {
-                logger('Refreshed assistant response via final DOM snapshot');
+                logger("Refreshed assistant response via final DOM snapshot");
                 answerText = finalText;
                 answerMarkdown = finalText;
             }
         }
         // Detect prompt echo using normalized comparison (whitespace-insensitive).
         const alignedEcho = alignPromptEchoPair(answerText, answerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
-            text: 'Aligned assistant response text to copied markdown after prompt echo',
-            markdown: 'Aligned assistant markdown to response text after prompt echo',
+            text: "Aligned assistant response text to copied markdown after prompt echo",
+            markdown: "Aligned assistant markdown to response text after prompt echo",
         });
         answerText = alignedEcho.answerText;
         answerMarkdown = alignedEcho.answerMarkdown;
         const isPromptEcho = alignedEcho.isEcho;
         if (isPromptEcho) {
-            logger('Detected prompt echo in response; waiting for actual assistant response...');
+            logger("Detected prompt echo in response; waiting for actual assistant response...");
             const deadline = Date.now() + 15_000;
             let bestText = null;
             let stableCount = 0;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
                 if (!isStillEcho) {
                     if (!bestText || text.length > bestText.length) {
@@ -670,7 +745,7 @@ export async function runBrowserMode(options) {
                 await new Promise((resolve) => setTimeout(resolve, 300));
             }
             if (bestText) {
-                logger('Recovered assistant response after detecting prompt echo');
+                logger("Recovered assistant response after detecting prompt echo");
                 answerText = bestText;
                 answerMarkdown = bestText;
             }
@@ -681,8 +756,8 @@ export async function runBrowserMode(options) {
             let bestText = answerText.trim();
             let stableCycles = 0;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text && text.length > bestText.length) {
                     bestText = text;
                     stableCycles = 0;
@@ -696,17 +771,17 @@ export async function runBrowserMode(options) {
                 await delay(400);
             }
             if (bestText.length > answerText.trim().length) {
-                logger('Refreshed short assistant response from latest DOM snapshot');
+                logger("Refreshed short assistant response from latest DOM snapshot");
                 answerText = bestText;
                 answerMarkdown = bestText;
             }
         }
         if (connectionClosedUnexpectedly) {
             // Bail out on mid-run disconnects so the session stays reattachable.
-            throw new Error('Chrome disconnected before completion');
+            throw new Error("Chrome disconnected before completion");
         }
         stopThinkingMonitor?.();
-        runStatus = 'complete';
+        runStatus = "complete";
         const durationMs = Date.now() - startedAt;
         const answerChars = answerText.length;
         const answerTokens = estimateTokenCount(answerMarkdown);
@@ -731,20 +806,42 @@ 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) {
+            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
                 logger(normalizedError.stack);
             }
             throw normalizedError;
         }
-        if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+        if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
             logger(`Chrome window closed before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
         await emitRuntimeHint();
-        throw new BrowserAutomationError('Chrome window closed before oracle finished. Please keep it open until completion.', {
-            stage: 'connection-lost',
+        throw new BrowserAutomationError("Chrome window closed before oracle finished. Please keep it open until completion.", {
+            stage: "connection-lost",
             runtime: {
                 chromePid: chrome.pid,
                 chromePort: chrome.port,
@@ -768,12 +865,13 @@ export async function runBrowserMode(options) {
         // Close the isolated tab once the response has been fully captured to prevent
         // tab accumulation across repeated runs. Keep the tab open on incomplete runs
         // so reattach can recover the response.
-        if (runStatus === 'complete' && isolatedTargetId && chrome?.port) {
+        if (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();
@@ -789,7 +887,7 @@ export async function runBrowserMode(options) {
                 });
                 if (shouldCleanup) {
                     // Preserve the persistent manual-login profile, but clear stale reattach hints.
-                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'never' }).catch(() => undefined);
+                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
                 }
             }
             else {
@@ -821,28 +919,28 @@ async function pickAvailableDebugPort(preferredPort, logger) {
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
         const server = net.createServer();
-        server.once('error', () => resolve(false));
-        server.once('listening', () => {
+        server.once("error", () => resolve(false));
+        server.once("listening", () => {
             server.close(() => resolve(true));
         });
-        server.listen(port, '127.0.0.1');
+        server.listen(port, "127.0.0.1");
     });
 }
 async function findEphemeralPort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
-        server.once('error', (error) => {
+        server.once("error", (error) => {
             server.close();
             reject(error);
         });
-        server.listen(0, '127.0.0.1', () => {
+        server.listen(0, "127.0.0.1", () => {
             const address = server.address();
-            if (address && typeof address === 'object') {
+            if (address && typeof address === "object") {
                 const port = address.port;
                 server.close(() => resolve(port));
             }
             else {
-                server.close(() => reject(new Error('Failed to acquire ephemeral port')));
+                server.close(() => reject(new Error("Failed to acquire ephemeral port")));
             }
         });
     });
@@ -861,20 +959,20 @@ async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, time
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const loginDetected = message?.toLowerCase().includes('login button');
-            const sessionMissing = message?.toLowerCase().includes('session not detected');
+            const loginDetected = message?.toLowerCase().includes("login button");
+            const sessionMissing = message?.toLowerCase().includes("session not detected");
             if (!loginDetected && !sessionMissing) {
                 throw error;
             }
             const now = Date.now();
             if (now - lastNotice > 5000) {
-                logger('Manual login mode: please sign into chatgpt.com in the opened Chrome window; waiting for session to appear...');
+                logger("Manual login mode: please sign into chatgpt.com in the opened Chrome window; waiting for session to appear...");
                 lastNotice = now;
             }
             await delay(1000);
         }
     }
-    throw new Error('Manual login mode timed out waiting for ChatGPT session; please sign in and retry.');
+    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
 }
 async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answerText, answerMarkdown, logger, allowMarkdownUpdate, }) {
     // Learned: long streaming responses can still be rendering after initial capture.
@@ -888,7 +986,7 @@ async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answe
     let bestText = answerText;
     for (let i = 0; i < 5; i++) {
         const laterSnapshot = await readAssistantSnapshot(runtime, baselineTurns ?? undefined).catch(() => null);
-        const laterText = typeof laterSnapshot?.text === 'string' ? laterSnapshot.text.trim() : '';
+        const laterText = typeof laterSnapshot?.text === "string" ? laterSnapshot.text.trim() : "";
         if (laterText.length > bestLength) {
             bestLength = laterText.length;
             bestText = laterText;
@@ -909,22 +1007,22 @@ async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answe
 }
 async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
     const deadline = Date.now() + timeoutMs;
-    let lastUrl = '';
+    let lastUrl = "";
     while (Date.now() < deadline) {
         const { result } = await runtime.evaluate({
             expression: 'typeof location === "object" && location.href ? location.href : ""',
             returnByValue: true,
         });
-        const url = typeof result?.value === 'string' ? result.value : '';
+        const url = typeof result?.value === "string" ? result.value : "";
         lastUrl = url;
         if (/^https?:\/\//i.test(url)) {
             return url;
         }
         await delay(250);
     }
-    throw new BrowserAutomationError('ChatGPT session not detected; page never left new tab.', {
-        stage: 'execute-browser',
-        details: { url: lastUrl || '(empty)' },
+    throw new BrowserAutomationError("ChatGPT session not detected; page never left new tab.", {
+        stage: "execute-browser",
+        details: { url: lastUrl || "(empty)" },
     });
 }
 async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
@@ -944,11 +1042,11 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
     if (!probe.ok) {
         logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${probe.error}); launching new Chrome.`);
         // Safe cleanup: remove stale DevToolsActivePort; only remove lock files if this was an Oracle-owned pid that died.
-        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'if_oracle_pid_dead' });
+        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "if_oracle_pid_dead" });
         return null;
     }
     const pid = await readChromePid(userDataDir);
-    logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
+    logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ""})`);
     return {
         port,
         pid: pid ?? undefined,
@@ -959,7 +1057,7 @@ async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
 async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
     const remoteChromeConfig = config.remoteChrome;
     if (!remoteChromeConfig) {
-        throw new Error('Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.');
+        throw new Error("Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.");
     }
     const { host, port } = remoteChromeConfig;
     logger(`Connecting to remote Chrome at ${host}:${port}`);
@@ -985,9 +1083,9 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
     };
     const startedAt = Date.now();
-    let answerText = '';
-    let answerMarkdown = '';
-    let answerHtml = '';
+    let answerText = "";
+    let answerMarkdown = "";
+    let answerHtml = "";
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
@@ -999,16 +1097,16 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         const markConnectionLost = () => {
             connectionClosedUnexpectedly = true;
         };
-        client.on('disconnect', markConnectionLost);
+        client.on("disconnect", markConnectionLost);
         const { Network, Page, Runtime, Input, DOM } = client;
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
-        if (DOM && typeof DOM.enable === 'function') {
+        if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         // Skip cookie sync for remote Chrome - it already has cookies
-        logger('Skipping cookie sync for remote Chrome (using existing session)');
+        logger("Skipping cookie sync for remote Chrome (using existing session)");
         await navigateToChatGPT(Page, Runtime, config.url, logger);
         await ensureNotBlocked(Runtime, config.headless, logger);
         await ensureLoggedIn(Runtime, logger, { remoteSession: true });
@@ -1016,10 +1114,10 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         try {
             const { result } = await Runtime.evaluate({
-                expression: 'location.href',
+                expression: "location.href",
                 returnByValue: true,
             });
-            if (typeof result?.value === 'string') {
+            if (typeof result?.value === "string") {
                 lastUrl = result.value;
             }
             await emitRuntimeHint();
@@ -1028,7 +1126,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             // ignore
         }
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
-        if (config.desiredModel && modelStrategy !== 'ignore') {
+        if (config.desiredModel && modelStrategy !== "ignore") {
             await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
@@ -1041,8 +1139,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        else if (modelStrategy === 'ignore') {
-            logger('Model picker: skipped (strategy=ignore)');
+        else if (modelStrategy === "ignore") {
+            logger("Model picker: skipped (strategy=ignore)");
         }
         // Handle thinking time selection if specified
         const thinkingTime = config.thinkingTime;
@@ -1059,11 +1157,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
-            const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
+            const baselineAssistantText = typeof baselineSnapshot?.text === "string" ? baselineSnapshot.text.trim() : "";
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
-                    throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+                    throw new Error("Chrome DOM domain unavailable while uploading attachments.");
                 }
                 await clearComposerAttachments(Runtime, 5_000, logger);
                 // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
@@ -1077,64 +1175,76 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 const perFileTimeout = 15_000;
                 const waitBudget = Math.max(baseTimeout, 30_000) + (submissionAttachments.length - 1) * perFileTimeout;
                 await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-                logger('All attachments uploaded');
+                logger("All attachments uploaded");
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
-            const 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 };
         };
+        const reloadPromptComposer = async () => {
+            logger("[browser] Composer became unresponsive; reloading page and retrying once.");
+            await Page.reload({ ignoreCache: true });
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        };
         let baselineTurns = null;
         let baselineAssistantText = null;
-        try {
-            const submission = await submitOnce(promptText, attachments);
-            baselineTurns = submission.baselineTurns;
-            baselineAssistantText = submission.baselineAssistantText;
-        }
-        catch (error) {
-            const isPromptTooLarge = error instanceof BrowserAutomationError &&
-                error.details?.code === 'prompt-too-large';
-            if (options.fallbackSubmission && isPromptTooLarge) {
-                logger('[browser] Inline prompt too large; retrying with file uploads.');
+        const submission = await runSubmissionWithRecovery({
+            prompt: promptText,
+            attachments,
+            fallbackSubmission: options.fallbackSubmission,
+            submit: submitOnce,
+            reloadPromptComposer,
+            prepareFallbackSubmission: async () => {
                 await clearPromptComposer(Runtime, logger);
                 await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
-                const submission = await submitOnce(options.fallbackSubmission.prompt, options.fallbackSubmission.attachments);
-                baselineTurns = submission.baselineTurns;
-                baselineAssistantText = submission.baselineAssistantText;
-            }
-            else {
-                throw error;
-            }
-        }
+            },
+            logger,
+        });
+        baselineTurns = submission.baselineTurns;
+        baselineAssistantText = submission.baselineAssistantText;
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
-        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, " ").trim();
+        const expectedConversationId = () => lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
         const waitForFreshAssistantResponse = async (baselineNormalized, timeoutMs) => {
             const baselinePrefix = baselineNormalized.length >= 80
                 ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
+                : "";
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 if (text) {
                     const normalized = normalizeForComparison(text);
-                    const isBaseline = normalized === baselineNormalized || (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
+                    const isBaseline = normalized === baselineNormalized ||
+                        (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
                     if (!isBaseline) {
                         return {
                             text,
                             html: snapshot?.html ?? undefined,
-                            meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+                            meta: {
+                                turnId: snapshot?.turnId ?? undefined,
+                                messageId: snapshot?.messageId ?? undefined,
+                            },
                         };
                     }
                 }
@@ -1164,12 +1274,12 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 // Update session metadata to indicate login is needed
                 await emitRuntimeHint();
                 throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
-                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || "unknown"}. ` +
                     `Please sign in and retry.`, {
-                    stage: 'assistant-recheck',
+                    stage: "assistant-recheck",
                     details: {
                         conversationUrl: conversationUrl || lastUrl || null,
-                        sessionStatus: 'needs_login',
+                        sessionStatus: "needs_login",
                         validationReason: sessionValid.reason,
                     },
                     runtime: {
@@ -1184,12 +1294,17 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             await emitRuntimeHint();
             const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
-            const rechecked = await waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined);
-            logger('Recovered assistant response after delayed recheck');
+            const rechecked = await waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId());
+            logger("Recovered assistant response after delayed recheck");
             return rechecked;
         };
         try {
-            answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
+            const conversationUrl = await readConversationUrl(Runtime).catch(() => null);
+            if (conversationUrl && isConversationUrl(conversationUrl)) {
+                lastUrl = conversationUrl;
+                await emitRuntimeHint();
+            }
+            answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId());
         }
         catch (error) {
             if (isAssistantResponseTimeoutError(error)) {
@@ -1216,23 +1331,25 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                         conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
                         controllerPid: process.pid,
                     };
-                    throw new BrowserAutomationError('Assistant response timed out before completion; reattach later to capture the answer.', { stage: 'assistant-timeout', runtime }, error);
+                    throw 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) : '';
+        const baselineNormalized = baselineAssistantText
+            ? normalizeForComparison(baselineAssistantText)
+            : "";
         if (baselineNormalized) {
-            const normalizedAnswer = normalizeForComparison(answer.text ?? '');
+            const normalizedAnswer = normalizeForComparison(answer.text ?? "");
             const baselinePrefix = baselineNormalized.length >= 80
                 ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
-                : '';
+                : "";
             const isBaseline = normalizedAnswer === baselineNormalized ||
                 (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
             if (isBaseline) {
-                logger('Detected stale assistant response; waiting for new response...');
+                logger("Detected stale assistant response; waiting for new response...");
                 const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
                 if (refreshed) {
                     answer = refreshed;
@@ -1240,11 +1357,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
         }
         answerText = answer.text;
-        answerHtml = answer.html ?? '';
+        answerHtml = answer.html ?? "";
         const copiedMarkdown = await withRetries(async () => {
             const attempt = await captureAssistantMarkdown(Runtime, answer.meta, logger);
             if (!attempt) {
-                throw new Error('copy-missing');
+                throw new Error("copy-missing");
             }
             return attempt;
         }, {
@@ -1266,33 +1383,33 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             allowMarkdownUpdate: !copiedMarkdown,
         }));
         // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
-        const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-        const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
+        const finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+        const finalText = typeof finalSnapshot?.text === "string" ? finalSnapshot.text.trim() : "";
         if (finalText &&
             finalText !== answerMarkdown.trim() &&
             finalText !== promptText.trim() &&
             finalText.length >= answerMarkdown.trim().length) {
-            logger('Refreshed assistant response via final DOM snapshot');
+            logger("Refreshed assistant response via final DOM snapshot");
             answerText = finalText;
             answerMarkdown = finalText;
         }
         // Detect prompt echo using normalized comparison (whitespace-insensitive).
         const promptEchoMatcher = buildPromptEchoMatcher(promptText);
         const alignedEcho = alignPromptEchoPair(answerText, answerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
-            text: 'Aligned assistant response text to copied markdown after prompt echo',
-            markdown: 'Aligned assistant markdown to response text after prompt echo',
+            text: "Aligned assistant response text to copied markdown after prompt echo",
+            markdown: "Aligned assistant markdown to response text after prompt echo",
         });
         answerText = alignedEcho.answerText;
         answerMarkdown = alignedEcho.answerMarkdown;
         const isPromptEcho = alignedEcho.isEcho;
         if (isPromptEcho) {
-            logger('Detected prompt echo in response; waiting for actual assistant response...');
+            logger("Detected prompt echo in response; waiting for actual assistant response...");
             const deadline = Date.now() + 15_000;
             let bestText = null;
             let stableCount = 0;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
-                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined, expectedConversationId()).catch(() => null);
+                const text = typeof snapshot?.text === "string" ? snapshot.text.trim() : "";
                 const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
                 if (!isStillEcho) {
                     if (!bestText || text.length > bestText.length) {
@@ -1309,7 +1426,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 await new Promise((resolve) => setTimeout(resolve, 300));
             }
             if (bestText) {
-                logger('Recovered assistant response after detecting prompt echo');
+                logger("Recovered assistant response after detecting prompt echo");
                 answerText = bestText;
                 answerMarkdown = bestText;
             }
@@ -1341,13 +1458,13 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
         if (!socketClosed) {
             logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
-            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
                 logger(normalizedError.stack);
             }
             throw normalizedError;
         }
-        throw new BrowserAutomationError('Remote Chrome connection lost before Oracle finished.', {
-            stage: 'connection-lost',
+        throw new BrowserAutomationError("Remote Chrome connection lost before Oracle finished.", {
+            stage: "connection-lost",
             runtime: {
                 chromeHost: host,
                 chromePort: port,
@@ -1373,19 +1490,20 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         logger(`Remote session complete • ${totalSeconds.toFixed(1)}s total`);
     }
 }
-export { estimateTokenCount } from './utils.js';
-export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from './config.js';
-export { syncCookies } from './cookies.js';
-export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from './pageActions.js';
+export { estimateTokenCount } from "./utils.js";
+export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from "./config.js";
+export { syncCookies } from "./cookies.js";
+export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from "./pageActions.js";
 export async function maybeReuseRunningChromeForTest(userDataDir, logger, options = {}) {
     return maybeReuseRunningChrome(userDataDir, logger, options);
 }
-function isWebSocketClosureError(error) {
+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('target closed'));
+    return (message.includes("websocket connection closed") ||
+        message.includes("websocket is closed") ||
+        message.includes("websocket error") ||
+        message.includes("inspected target navigated or closed") ||
+        message.includes("target closed"));
 }
 export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
     const elapsedMs = now - startedAt;
@@ -1393,13 +1511,13 @@ export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
     const progress = Math.min(1, elapsedMs / 600_000); // soft target: 10 minutes
     const pct = Math.round(progress * 100)
         .toString()
-        .padStart(3, ' ');
-    const statusLabel = message ? ` — ${message}` : '';
+        .padStart(3, " ");
+    const statusLabel = message ? ` — ${message}` : "";
     return `${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
 }
-async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, minTurnIndex) {
+async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, minTurnIndex, expectedConversationId) {
     try {
-        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
     catch (error) {
         if (!shouldReloadAfterAssistantError(error)) {
@@ -1409,20 +1527,20 @@ async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logg
         if (!conversationUrl || !isConversationUrl(conversationUrl)) {
             throw error;
         }
-        logger('Assistant response stalled; reloading conversation and retrying once');
+        logger("Assistant response stalled; reloading conversation and retrying once");
         await Page.navigate({ url: conversationUrl });
         await delay(1000);
-        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
 }
 function shouldReloadAfterAssistantError(error) {
     if (!(error instanceof Error))
         return false;
     const message = error.message.toLowerCase();
-    return (message.includes('assistant-response') ||
-        message.includes('watchdog') ||
-        message.includes('timeout') ||
-        message.includes('capture assistant response'));
+    return (message.includes("assistant-response") ||
+        message.includes("watchdog") ||
+        message.includes("timeout") ||
+        message.includes("capture assistant response"));
 }
 function isAssistantResponseTimeoutError(error) {
     if (!(error instanceof Error))
@@ -1430,15 +1548,15 @@ function isAssistantResponseTimeoutError(error) {
     const message = error.message.toLowerCase();
     if (!message)
         return false;
-    return (message.includes('assistant-response') ||
-        message.includes('assistant response') ||
-        message.includes('watchdog') ||
-        message.includes('capture assistant response'));
+    return (message.includes("assistant-response") ||
+        message.includes("assistant response") ||
+        message.includes("watchdog") ||
+        message.includes("capture assistant response"));
 }
 async function readConversationUrl(Runtime) {
     try {
-        const currentUrl = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
-        return typeof currentUrl.result?.value === 'string' ? currentUrl.result.value : null;
+        const currentUrl = await Runtime.evaluate({ expression: "location.href", returnByValue: true });
+        return typeof currentUrl.result?.value === "string" ? currentUrl.result.value : null;
     }
     catch {
         return null;
@@ -1461,16 +1579,16 @@ async function validateChatGPTSession(Runtime, logger) {
         });
         const result = outcome.result?.value;
         if (!result) {
-            return { valid: false, reason: 'Failed to evaluate session state' };
+            return { valid: false, reason: "Failed to evaluate session state" };
         }
         if (result.onAuthPage) {
-            return { valid: false, reason: 'Redirected to auth page' };
+            return { valid: false, reason: "Redirected to auth page" };
         }
         if (result.hasLoginCta) {
-            return { valid: false, reason: 'Login button detected on page' };
+            return { valid: false, reason: "Login button detected on page" };
         }
         if (!result.hasTextarea) {
-            return { valid: false, reason: 'Prompt textarea not available' };
+            return { valid: false, reason: "Prompt textarea not available" };
         }
         return { valid: true };
     }
@@ -1557,9 +1675,9 @@ async function readConversationTurnCount(Runtime, logger) {
                 expression: `document.querySelectorAll(${selectorLiteral}).length`,
                 returnByValue: true,
             });
-            const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+            const raw = typeof result?.value === "number" ? result.value : Number(result?.value);
             if (!Number.isFinite(raw)) {
-                throw new Error('Turn count not numeric');
+                throw new Error("Turn count not numeric");
             }
             return Math.max(0, Math.floor(raw));
         }
@@ -1594,14 +1712,14 @@ function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false)
             const nextMessage = await readThinkingStatus(Runtime);
             if (nextMessage && nextMessage !== lastMessage) {
                 lastMessage = nextMessage;
-                let locatorSuffix = '';
+                let locatorSuffix = "";
                 if (includeDiagnostics) {
                     try {
                         const snapshot = await readAssistantSnapshot(Runtime);
-                        locatorSuffix = ` | assistant-turn=${snapshot ? 'present' : 'missing'}`;
+                        locatorSuffix = ` | assistant-turn=${snapshot ? "present" : "missing"}`;
                     }
                     catch {
-                        locatorSuffix = ' | assistant-turn=error';
+                        locatorSuffix = " | assistant-turn=error";
                     }
                 }
                 logger(formatThinkingLog(startedAt, Date.now(), nextMessage, locatorSuffix));
@@ -1628,7 +1746,7 @@ async function readThinkingStatus(Runtime) {
     const expression = buildThinkingStatusExpression();
     try {
         const { result } = await Runtime.evaluate({ expression, returnByValue: true });
-        const value = typeof result.value === 'string' ? result.value.trim() : '';
+        const value = typeof result.value === "string" ? result.value.trim() : "";
         const sanitized = sanitizeThinkingText(value);
         return sanitized || null;
     }
@@ -1638,12 +1756,12 @@ async function readThinkingStatus(Runtime) {
 }
 function sanitizeThinkingText(raw) {
     if (!raw) {
-        return '';
+        return "";
     }
     const trimmed = raw.trim();
     const prefixPattern = /^(pro thinking)\s*[•:\-–—]*\s*/i;
     if (prefixPattern.test(trimmed)) {
-        return trimmed.replace(prefixPattern, '').trim();
+        return trimmed.replace(prefixPattern, "").trim();
     }
     return trimmed;
 }
@@ -1652,20 +1770,20 @@ function describeDevtoolsFirewallHint(host, port) {
         return null;
     return [
         `DevTools port ${host}:${port} is blocked from WSL.`,
-        '',
-        'PowerShell (admin):',
+        "",
+        "PowerShell (admin):",
         `New-NetFirewallRule -DisplayName 'Chrome DevTools ${port}' -Direction Inbound -Action Allow -Protocol TCP -LocalPort ${port}`,
         "New-NetFirewallRule -DisplayName 'Chrome DevTools (chrome.exe)' -Direction Inbound -Action Allow -Program 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' -Protocol TCP",
-        '',
-        'Re-run the same oracle command after adding the rule.',
-    ].join('\n');
+        "",
+        "Re-run the same oracle command after adding the rule.",
+    ].join("\n");
 }
 function isWsl() {
-    if (process.platform !== 'linux')
+    if (process.platform !== "linux")
         return false;
     if (process.env.WSL_DISTRO_NAME)
         return true;
-    return os.release().toLowerCase().includes('microsoft');
+    return os.release().toLowerCase().includes("microsoft");
 }
 function extractConversationIdFromUrl(url) {
     const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
@@ -1675,9 +1793,9 @@ async function resolveUserDataBaseDir() {
     // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
     if (isWsl()) {
         const candidates = [
-            '/mnt/c/Users/Public/AppData/Local/Temp',
-            '/mnt/c/Temp',
-            '/mnt/c/Windows/Temp',
+            "/mnt/c/Users/Public/AppData/Local/Temp",
+            "/mnt/c/Temp",
+            "/mnt/c/Windows/Temp",
         ];
         for (const candidate of candidates) {
             try {
@@ -1689,18 +1807,49 @@ async function resolveUserDataBaseDir() {
             }
         }
     }
-    return os.tmpdir();
+    const tmpDir = os.tmpdir();
+    if (shouldPreferSystemTmpDir(process.platform, tmpDir, os.homedir())) {
+        try {
+            await mkdir("/tmp", { recursive: true });
+            return "/tmp";
+        }
+        catch {
+            // Fall back to the inherited tmpdir if /tmp is unavailable.
+        }
+    }
+    return tmpDir;
+}
+function shouldPreferSystemTmpDir(platform, tmpDir, homeDir) {
+    if (platform !== "linux" || !tmpDir || !homeDir)
+        return false;
+    const relativeToHome = path.relative(homeDir, tmpDir);
+    if (!relativeToHome || relativeToHome.startsWith("..") || path.isAbsolute(relativeToHome)) {
+        return false;
+    }
+    const firstSegment = relativeToHome.split(path.sep, 1)[0];
+    return Boolean(firstSegment?.startsWith("."));
+}
+export function shouldPreferSystemTmpDirForTest(platform, tmpDir, homeDir) {
+    return shouldPreferSystemTmpDir(platform, tmpDir, homeDir);
 }
 function buildThinkingStatusExpression() {
     const selectors = [
-        'span.loading-shimmer',
-        'span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary',
+        "span.loading-shimmer",
+        "span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary",
         '[data-testid*="thinking"]',
         '[data-testid*="reasoning"]',
         '[role="status"]',
         '[aria-live="polite"]',
     ];
-    const keywords = ['pro thinking', 'thinking', 'reasoning', 'clarifying', 'planning', 'drafting', 'summarizing'];
+    const keywords = [
+        "pro thinking",
+        "thinking",
+        "reasoning",
+        "clarifying",
+        "planning",
+        "drafting",
+        "summarizing",
+    ];
     const selectorLiteral = JSON.stringify(selectors);
     const keywordsLiteral = JSON.stringify(keywords);
     return `(() => {