@steipete/oracle 0.15.1 → 0.16.0

package/dist/src/browser/config.js

@@ -61,6 +61,7 @@ export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
     const envAllowCookieErrors = (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim().toLowerCase() === "true" ||
         (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim() === "1";
+    const envMaxConcurrentTabs = parseMaxConcurrentTabs(process.env.ORACLE_BROWSER_MAX_CONCURRENT_TABS);
     const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
     const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
     const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
@@ -87,7 +88,7 @@ export function resolveBrowserConfig(config) {
         assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
         reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
         profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
-        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
+        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? envMaxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
         autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
         autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
         autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
@@ -134,6 +135,18 @@ function parseDebugPort(raw) {
     }
     return value;
 }
+function parseMaxConcurrentTabs(raw) {
+    if (!raw)
+        return null;
+    const trimmed = raw.trim();
+    if (!/^\d+$/.test(trimmed))
+        return null;
+    const value = Number(trimmed);
+    if (!Number.isInteger(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
 function resolveManualLoginProfileDir(...candidates) {
     for (const candidate of candidates) {
         const profileDir = candidate?.trim();

package/dist/src/browser/constants.js

@@ -32,6 +32,7 @@ export const ANSWER_SELECTORS = [
 export const CONVERSATION_TURN_SELECTOR = 'article[data-testid^="conversation-turn"], div[data-testid^="conversation-turn"], section[data-testid^="conversation-turn"], ' +
     "article[data-message-author-role], div[data-message-author-role], section[data-message-author-role], " +
     "article[data-turn], div[data-turn], section[data-turn]";
+export const CONVERSATION_TURN_CONTAINER_SELECTOR = '[data-testid^="conversation-turn"]';
 export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"], [data-turn="assistant"]';
 export const CLOUDFLARE_SCRIPT_SELECTOR = 'script[src*="/challenge-platform/"]';
 export const CLOUDFLARE_TITLE = "just a moment";
@@ -63,10 +64,14 @@ export const UPLOAD_STATUS_SELECTORS = [
     '[aria-live="assertive"]',
 ];
 export const STOP_BUTTON_SELECTOR = '[data-testid="stop-button"]';
+// The aria-label fallback exists for data-testid drift, but a document-wide match makes ANY
+// visible "stop" control (read-aloud, voice/dictation) read as "still generating", which blocks
+// completion until the response timeout. Scope it to the composer form and exclude the known
+// non-generation stop controls that legitimately live there.
 export const STOP_BUTTON_SELECTORS = [
     STOP_BUTTON_SELECTOR,
     '[data-testid="composer-stop-button"]',
-    'button[aria-label*="stop" i]',
+    'form button[aria-label*="stop" i]:not([aria-label*="dictat" i]):not([aria-label*="voice" i]):not([aria-label*="read" i])',
 ];
 export const SEND_BUTTON_SELECTORS = [
     'button[data-testid="send-button"]',

package/dist/src/browser/controlPlan.js

@@ -45,13 +45,13 @@ export function describeBrowserControlPlan(config = {}) {
         };
     }
     if (config.hideWindow) {
-        guidance.push("Chrome may briefly focus while launching before Oracle hides it.");
+        guidance.push("On macOS, Oracle launches Chrome off-screen while keeping the page rendered.");
         guidance.push("For the calmest shared-desktop flow, prefer --browser-attach-running or --remote-chrome.");
         return {
             mode: "hidden-window",
             launchesChrome: true,
             mayFocusWindow: true,
-            summary: "launch Chrome and hide the window after startup",
+            summary: "launch Chrome in hidden-window mode",
             guidance,
         };
     }

package/dist/src/browser/conversationTurns.js

@@ -0,0 +1,16 @@
+import { CONVERSATION_TURN_CONTAINER_SELECTOR, CONVERSATION_TURN_SELECTOR } from "./constants.js";
+/** Build a browser-context expression that returns one DOM node per conversation turn. */
+export function buildConversationTurnListExpression(rootExpression = "document") {
+    const containerSelector = JSON.stringify(CONVERSATION_TURN_CONTAINER_SELECTOR);
+    const fallbackSelector = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    return `(() => {
+    const root = ${rootExpression};
+    const containers = Array.from(root.querySelectorAll(${containerSelector}));
+    return containers.length > 0
+      ? containers
+      : Array.from(root.querySelectorAll(${fallbackSelector}));
+  })()`;
+}
+export function buildConversationTurnCountExpression(rootExpression = "document") {
+    return `(${buildConversationTurnListExpression(rootExpression)}).length`;
+}

package/dist/src/browser/conversationUrlMonitor.js

@@ -0,0 +1,64 @@
+import { delay } from "./utils.js";
+export function createConversationUrlMonitor(options) {
+    const pollIntervalMs = options.pollIntervalMs ?? 250;
+    const wait = options.wait ?? delay;
+    const now = options.now ?? Date.now;
+    let inFlight = null;
+    let stopped = false;
+    const activePersists = new Set();
+    const update = async (label, timeoutMs = 10_000) => {
+        const startedAt = now();
+        while (!stopped && now() - startedAt < timeoutMs) {
+            try {
+                const url = await options.readUrl();
+                if (stopped) {
+                    return false;
+                }
+                if (url && isConversationUrl(url)) {
+                    options.logger(`[browser] conversation url (${label}) = ${url}`);
+                    const persist = options.persistUrl(url);
+                    activePersists.add(persist);
+                    try {
+                        await persist;
+                    }
+                    finally {
+                        activePersists.delete(persist);
+                    }
+                    return true;
+                }
+            }
+            catch {
+                // The page can navigate or disconnect between polls; keep trying until timeout.
+            }
+            await wait(pollIntervalMs);
+        }
+        return false;
+    };
+    const schedule = (label, timeoutMs) => {
+        if (stopped) {
+            return Promise.resolve(false);
+        }
+        if (inFlight) {
+            return inFlight;
+        }
+        // The /c/ URL can appear after submit. Persist it without blocking response capture.
+        inFlight = update(label, timeoutMs)
+            .catch(() => false)
+            .finally(() => {
+            inFlight = null;
+        });
+        return inFlight;
+    };
+    return {
+        update,
+        schedule,
+        isInFlight: () => inFlight !== null,
+        stop: async () => {
+            stopped = true;
+            await Promise.allSettled(activePersists);
+        },
+    };
+}
+function isConversationUrl(url) {
+    return /\/c\/[a-z0-9-]+/i.test(url);
+}

package/dist/src/browser/cookies.js

@@ -3,6 +3,56 @@ import { delay } from "./utils.js";
 import { getCookies } from "@steipete/sweet-cookie";
 export class ChromeCookieSyncError extends Error {
 }
+export async function clearStaleChatGptConversationCookies(Network, Target, logger, options = {}) {
+    try {
+        const preservedNames = new Set((options.preserveConversationIds ?? [])
+            .filter((id) => Boolean(id))
+            .map((id) => `conv_key_${id}`));
+        try {
+            const { targetInfos = [] } = await Target.getTargets();
+            for (const target of targetInfos) {
+                const conversationId = extractChatGptConversationId(target.url ?? "");
+                if (conversationId) {
+                    preservedNames.add(`conv_key_${conversationId}`);
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(`[cookies] Failed to inspect active ChatGPT conversations; skipping stale cookie cleanup: ${message}`);
+            return 0;
+        }
+        const { cookies = [] } = await Network.getAllCookies();
+        const targets = cookies.filter((cookie) => isChatGptConversationCookie(cookie) && !preservedNames.has(String(cookie.name ?? "")));
+        if (targets.length === 0) {
+            return 0;
+        }
+        let deleted = 0;
+        for (const cookie of targets) {
+            try {
+                await Network.deleteCookies({
+                    name: cookie.name,
+                    domain: cookie.domain,
+                    path: cookie.path ?? "/",
+                });
+                deleted += 1;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger(`[cookies] Failed to clear a stale ChatGPT conversation cookie: ${message}`);
+            }
+        }
+        if (deleted > 0) {
+            logger(`[cookies] Cleared ${deleted} stale ChatGPT conversation cookie${deleted === 1 ? "" : "s"}.`);
+        }
+        return deleted;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[cookies] Failed to inspect ChatGPT conversation cookies: ${message}`);
+        return 0;
+    }
+}
 export async function syncCookies(Network, url, profile, logger, options = {}) {
     const { allowErrors = false, filterNames, inlineCookies, cookiePath, waitMs = 0 } = options;
     try {
@@ -94,6 +144,28 @@ async function readChromeCookies(url, profile, filterNames, cookiePath) {
     }
     return Array.from(merged.values());
 }
+function isChatGptConversationCookie(cookie) {
+    if (!cookie.name?.startsWith("conv_key_")) {
+        return false;
+    }
+    const domain = String(cookie.domain ?? "")
+        .replace(/^\./, "")
+        .toLowerCase();
+    return domain === "chatgpt.com" || domain === "chat.openai.com";
+}
+function extractChatGptConversationId(url) {
+    try {
+        const parsed = new URL(url);
+        const domain = parsed.hostname.toLowerCase();
+        if (domain !== "chatgpt.com" && domain !== "chat.openai.com") {
+            return undefined;
+        }
+        return parsed.pathname.match(/\/c\/([a-zA-Z0-9-]+)/)?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
 function normalizeInlineCookies(rawCookies, fallbackHost) {
     const merged = new Map();
     for (const cookie of rawCookies) {

package/dist/src/browser/index.js

@@ -4,9 +4,9 @@ import os from "node:os";
 import net from "node:net";
 import { resolveBrowserConfig } from "./config.js";
 import { copyChromeProfile } from "./profileCopy.js";
-import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
-import { syncCookies } from "./cookies.js";
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
+import { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
+import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
 import { INPUT_SELECTORS } from "./constants.js";
 import { uploadAttachmentViaDataTransfer } from "./actions/remoteFileTransfer.js";
 import { ensureThinkingTime } from "./actions/thinkingTime.js";
@@ -14,9 +14,10 @@ import { startThinkingStatusMonitor } from "./actions/thinkingStatus.js";
 import { activateDeepResearch, captureDeepResearchTargetKeys, waitForDeepResearchCompletion, waitForResearchPlanAutoConfirm, } from "./actions/deepResearch.js";
 import { estimateTokenCount, withRetries, delay } from "./utils.js";
 import { formatElapsed } from "../oracle/format.js";
-import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from "./constants.js";
+import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY } from "./constants.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { alignPromptEchoPair, buildPromptEchoMatcher } from "./reattachHelpers.js";
+import { buildConversationTurnCountExpression } from "./conversationTurns.js";
 import { cleanupStaleProfileState, acquireProfileRunLock, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, terminateRecordedChromeForProfile, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
 import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
@@ -30,6 +31,7 @@ import { captureBrowserDiagnostics } from "./domDebug.js";
 import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./actions/archiveConversation.js";
 import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
+import { createConversationUrlMonitor, } from "./conversationUrlMonitor.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
 export { formatThinkingLog, formatThinkingWaitingLog, buildThinkingStatusExpressionForTest, readThinkingStatusForTest, sanitizeThinkingText, startThinkingStatusMonitorForTest, } from "./actions/thinkingStatus.js";
@@ -279,6 +281,25 @@ async function createAssistantTimeoutError(params) {
     }
     return warningError;
 }
+/**
+ * Make the page behave like a focused foreground tab.
+ *
+ * The send button is activated with trusted CDP input events dispatched at
+ * viewport coordinates. Chrome delivers those only to a window that is being
+ * composited, so a hidden (`--browser-hide-window`), minimized, or occluded
+ * window swallows the click while the automation still believes it clicked.
+ * Soft-fails: focus emulation is an optimization, never a hard requirement.
+ */
+async function enableFocusEmulation(client, logger, label) {
+    try {
+        await client.Emulation.setFocusEmulationEnabled({ enabled: true });
+        logger(`[browser] Focus emulation enabled for ${label}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[browser] Focus emulation unavailable: ${message}`);
+    }
+}
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -354,13 +375,13 @@ async function pollGeneratedImageOrTextAssistantResponse(Runtime, timeoutMs, min
     }
     return null;
 }
-function isImageOnlyUiChromeText(text) {
+export function isImageOnlyUiChromeText(text) {
     const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
     return (normalized.length === 0 ||
         normalized === "edit" ||
         normalized === "stopped thinking" ||
         normalized === "stopped thinking edit" ||
-        /^thought for \d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s+edit$/.test(normalized));
+        /^(?:reasoning\s+|pro thinking\s+)?thought for \d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s+edit$/.test(normalized));
 }
 function normalizeBrowserFollowUpPrompts(values) {
     return (values ?? []).map((entry) => entry.trim()).filter(Boolean);
@@ -560,6 +581,7 @@ export async function runBrowserMode(options) {
     let promptSubmitted = false;
     let modelSelectionEvidence;
     let tabLease = null;
+    let conversationUrlMonitor = null;
     const emitRuntimeHint = async () => {
         if (!chrome?.port) {
             return;
@@ -596,6 +618,7 @@ export async function runBrowserMode(options) {
         }
         promptSubmitted = true;
         await emitRuntimeHint();
+        void conversationUrlMonitor?.schedule("post-submit", config.timeoutMs ?? 120_000);
     };
     if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") {
         logger(`[browser-mode] config: ${JSON.stringify({
@@ -746,7 +769,7 @@ export async function runBrowserMode(options) {
             else {
                 const strictTabIsolation = Boolean(manualLogin && reusedChrome);
                 const devtoolsRetries = manualLogin ? 6 : 0;
-                const connection = await connectWithNewTab(chrome.port, logger, config.url, chromeHost, {
+                const connection = await connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
                     fallbackToDefault: !strictTabIsolation,
                     retries: devtoolsRetries,
                     retryDelayMs: 500,
@@ -778,15 +801,19 @@ export async function runBrowserMode(options) {
             });
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
-        const { Network, Page, Runtime, Input, DOM } = client;
-        if (!config.headless && config.hideWindow) {
-            await hideChromeWindow(chrome, logger);
-        }
+        const { Network, Page, Runtime, Input, DOM, Target } = client;
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
         if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
+        if (!config.headless && config.hideWindow) {
+            await positionChromeWindowOffscreen(client, logger);
+        }
+        // The send button is clicked with trusted CDP input events at viewport
+        // coordinates, which ChatGPT silently drops when the window is hidden or
+        // occluded. Emulate focus so the page behaves like a foreground tab.
+        await enableFocusEmulation(client, logger, "local target");
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         if (!profileIsPreSigned) {
             await Network.clearBrowserCookies();
@@ -828,6 +855,12 @@ export async function runBrowserMode(options) {
                 ? "Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in."
                 : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
         }
+        await clearStaleChatGptConversationCookies(Network, Target, logger, {
+            preserveConversationIds: [
+                extractConversationIdFromUrl(config.resumeConversationUrl ?? ""),
+                extractConversationIdFromUrl(lastUrl ?? ""),
+            ],
+        });
         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.
@@ -901,6 +934,18 @@ export async function runBrowserMode(options) {
                 }));
             }
         }
+        const chatMode = await raceWithDisconnect(ensureChatMode(Runtime, Input, config.inputTimeoutMs, logger, {
+            resetWorkConversation: config.browserTabRef && !isResumingConversation
+                ? async () => {
+                    await navigateToChatGPT(Page, Runtime, config.url, logger);
+                    await ensureNotBlocked(Runtime, config.headless, logger);
+                    await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                }
+                : undefined,
+        }));
+        if (chatMode === "switched") {
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+        }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         const captureRuntimeSnapshot = async () => {
             try {
@@ -939,44 +984,22 @@ export async function runBrowserMode(options) {
                 await emitRuntimeHint();
             }
         };
-        let conversationHintInFlight = null;
-        const updateConversationHint = async (label, timeoutMs = 10_000) => {
-            if (!chrome?.port) {
-                return false;
-            }
-            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/")) {
-                        lastUrl = result.value;
-                        logger(`[browser] conversation url (${label}) = ${lastUrl}`);
-                        await emitRuntimeHint();
-                        return true;
-                    }
-                }
-                catch {
-                    // ignore; keep polling until timeout
-                }
-                await delay(250);
-            }
-            return false;
-        };
-        const scheduleConversationHint = (label, timeoutMs) => {
-            if (conversationHintInFlight) {
-                return;
-            }
-            // Learned: the /c/ URL can update after the answer; emit hints in the background.
-            // Run in the background so prompt submission/streaming isn't blocked by slow URL updates.
-            conversationHintInFlight = updateConversationHint(label, timeoutMs)
-                .catch(() => false)
-                .finally(() => {
-                conversationHintInFlight = null;
-            });
-        };
+        const activeConversationUrlMonitor = createConversationUrlMonitor({
+            readUrl: async () => {
+                const { result } = await Runtime.evaluate({
+                    expression: "location.href",
+                    returnByValue: true,
+                });
+                return typeof result?.value === "string" ? result.value : null;
+            },
+            persistUrl: async (url) => {
+                lastUrl = url;
+                await emitRuntimeHint();
+            },
+            logger,
+        });
+        conversationUrlMonitor = activeConversationUrlMonitor;
+        const updateConversationHint = conversationUrlMonitor.update;
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore" && !isResumingConversation) {
@@ -1128,8 +1151,6 @@ export async function runBrowserMode(options) {
                     }
                 }
             }
-            // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
-            scheduleConversationHint("post-submit", config.timeoutMs ?? 120_000);
             return {
                 baselineTurns,
                 baselineAssistantText,
@@ -1725,6 +1746,7 @@ export async function runBrowserMode(options) {
         }, normalizedError);
     }
     finally {
+        await conversationUrlMonitor?.stop();
         try {
             if (!connectionClosedUnexpectedly) {
                 await client?.close();
@@ -1974,7 +1996,7 @@ function detachKeptChromeProcess(chrome) {
         // Best-effort only; cleanup should not mask the original browser result.
     }
 }
-async function acquireManualLoginChromeForRun(userDataDir, config, logger, sessionId, deps = {}) {
+export async function acquireManualLoginChromeForRun(userDataDir, config, logger, sessionId, deps = {}) {
     const maybeReuse = deps.maybeReuse ?? maybeReuseRunningChrome;
     const launch = deps.launch ?? launchChrome;
     const lockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
@@ -2086,6 +2108,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let modelSelectionEvidence;
     let attachedExistingTab = false;
     let ownsTarget = true;
+    let conversationUrlMonitor = null;
     const runtimeHintCb = options.runtimeHintCb;
     const emitRuntimeHint = async () => {
         if (!runtimeHintCb)
@@ -2120,6 +2143,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         promptSubmitted = true;
         await emitRuntimeHint();
+        void conversationUrlMonitor?.schedule("post-submit", config.timeoutMs ?? 120_000);
     };
     const startedAt = Date.now();
     let answerText = "";
@@ -2161,7 +2185,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             logger(`Attached to existing remote ChatGPT tab ${attached.targetId}${attached.tab.url ? ` (${attached.tab.url})` : ""}`);
         }
         else {
-            connection = await connectToRemoteChrome(host, port, logger, config.url, browserWSEndpoint, {
+            connection = await connectToRemoteChrome(host, port, logger, "about:blank", browserWSEndpoint, {
                 approvalWaitMs: config.attachRunning && browserWSEndpoint ? 20_000 : undefined,
             });
             client = connection.client;
@@ -2180,15 +2204,37 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             connectionClosedUnexpectedly = true;
         };
         client.on("disconnect", markConnectionLost);
-        const { Network, Page, Runtime, Input, DOM } = client;
+        const { Network, Page, Runtime, Input, DOM, Target } = client;
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
         if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
+        await enableFocusEmulation(client, logger, "remote target");
+        const activeConversationUrlMonitor = createConversationUrlMonitor({
+            readUrl: async () => {
+                const { result } = await Runtime.evaluate({
+                    expression: "location.href",
+                    returnByValue: true,
+                });
+                return typeof result?.value === "string" ? result.value : null;
+            },
+            persistUrl: async (url) => {
+                lastUrl = url;
+                await emitRuntimeHint();
+            },
+            logger,
+        });
+        conversationUrlMonitor = activeConversationUrlMonitor;
         // Skip cookie sync for remote Chrome - it already has cookies
         logger("Skipping cookie sync for remote Chrome (using existing session)");
+        await clearStaleChatGptConversationCookies(Network, Target, logger, {
+            preserveConversationIds: [
+                extractConversationIdFromUrl(config.resumeConversationUrl ?? ""),
+                extractConversationIdFromUrl(lastUrl ?? ""),
+            ],
+        });
         if (config.resumeConversationUrl) {
             await navigateToChatGPT(Page, Runtime, config.resumeConversationUrl, logger);
         }
@@ -2204,6 +2250,18 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 expectedConversationUrl: config.resumeConversationUrl,
             });
         }
+        const chatMode = await ensureChatMode(Runtime, Input, config.inputTimeoutMs, logger, {
+            resetWorkConversation: attachedExistingTab && !config.resumeConversationUrl
+                ? async () => {
+                    await navigateToChatGPT(Page, Runtime, config.url, logger);
+                    await ensureNotBlocked(Runtime, config.headless, logger);
+                    await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                }
+                : undefined,
+        });
+        if (chatMode === "switched") {
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         try {
             const { result } = await Runtime.evaluate({
@@ -2361,7 +2419,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 ignoredTargetKeys: deepResearchTargetKeys,
                 targetBaselineCaptured: deepResearchTargetBaselineCaptured,
             });
-            await emitRuntimeHint();
+            await activeConversationUrlMonitor.update("post-deep-research", 15_000).catch(() => false);
             const durationMs = Date.now() - startedAt;
             const tokens = estimateTokenCount(researchResult.text);
             const reportArtifact = await saveOptionalArtifact(() => saveDeepResearchReportArtifact({
@@ -2512,11 +2570,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         const captureAssistantTurn = async (turnPrompt, label) => {
             let turnAnswer;
             try {
-                const conversationUrl = await readConversationUrl(Runtime).catch(() => null);
-                if (conversationUrl && isConversationUrl(conversationUrl)) {
-                    lastUrl = conversationUrl;
-                    await emitRuntimeHint();
-                }
+                await activeConversationUrlMonitor.update("assistant-wait", 15_000).catch(() => false);
                 turnAnswer = await waitWithThinkingMonitor(() => waitForAssistantOrGeneratedImageResponse({
                     Runtime,
                     waitForText: () => waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined, expectedConversationId()),
@@ -2534,16 +2588,9 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                         turnAnswer = rechecked;
                     }
                     else {
-                        try {
-                            const conversationUrl = await readConversationUrl(Runtime);
-                            if (conversationUrl) {
-                                lastUrl = conversationUrl;
-                            }
-                        }
-                        catch {
-                            // ignore
-                        }
-                        await emitRuntimeHint();
+                        await activeConversationUrlMonitor
+                            .update("assistant-timeout", 15_000)
+                            .catch(() => false);
                         const diagnostics = await captureBrowserDiagnostics(Runtime, logger, "assistant-timeout", {
                             Page,
                             sessionId: options.sessionId,
@@ -2572,6 +2619,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                     throw error;
                 }
             }
+            await activeConversationUrlMonitor.update("post-response", 15_000).catch(() => false);
             const baselineNormalized = baselineAssistantText
                 ? normalizeForComparison(baselineAssistantText)
                 : "";
@@ -2836,6 +2884,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         });
     }
     finally {
+        await conversationUrlMonitor?.stop();
         try {
             await closeRemoteConnectionAfterRun({
                 connectionClosedUnexpectedly,
@@ -3053,12 +3102,12 @@ function buildSessionValidationExpression() {
   })()`;
 }
 async function readConversationTurnCount(Runtime, logger) {
-    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const expression = buildConversationTurnCountExpression();
     const attempts = 4;
     for (let attempt = 0; attempt < attempts; attempt += 1) {
         try {
             const { result } = await Runtime.evaluate({
-                expression: `document.querySelectorAll(${selectorLiteral}).length`,
+                expression,
                 returnByValue: true,
             });
             const raw = typeof result?.value === "number" ? result.value : Number(result?.value);