@steipete/oracle 0.15.2 → 0.16.0

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 { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
 import { clearStaleChatGptConversationCookies, 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 { 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";
@@ -281,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,
@@ -356,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);
@@ -783,14 +802,18 @@ export async function runBrowserMode(options) {
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
         const { Network, Page, Runtime, Input, DOM, Target } = client;
-        if (!config.headless && config.hideWindow) {
-            await hideChromeWindow(chrome, logger);
-        }
         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();
@@ -911,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 {
@@ -1961,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);
@@ -2176,14 +2211,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
-        try {
-            await client.Emulation.setFocusEmulationEnabled({ enabled: true });
-            logger("[browser] Focus emulation enabled for remote target");
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger(`[browser] Focus emulation unavailable: ${message}`);
-        }
+        await enableFocusEmulation(client, logger, "remote target");
         const activeConversationUrlMonitor = createConversationUrlMonitor({
             readUrl: async () => {
                 const { result } = await Runtime.evaluate({
@@ -2222,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({

package/dist/src/browser/liveTabs.js

@@ -1,7 +1,8 @@
 import CDP from "chrome-remote-interface";
 import { createHash } from "node:crypto";
-import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, INPUT_SELECTORS, MODEL_BUTTON_SELECTOR, SEND_BUTTON_SELECTORS, STOP_BUTTON_SELECTOR, } from "./constants.js";
+import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, INPUT_SELECTORS, MODEL_BUTTON_SELECTOR, SEND_BUTTON_SELECTORS, STOP_BUTTON_SELECTOR, } from "./constants.js";
 import { captureAssistantMarkdown, readAssistantSnapshot } from "./actions/assistantResponse.js";
+import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { delay } from "./utils.js";
 export const DEFAULT_REMOTE_CHROME_HOST = "127.0.0.1";
 export const DEFAULT_REMOTE_CHROME_PORT = 9222;
@@ -58,7 +59,6 @@ function buildTabInspectionExpression() {
     const inputSelectorsLiteral = JSON.stringify(INPUT_SELECTORS);
     const sendSelectorsLiteral = JSON.stringify(SEND_BUTTON_SELECTORS);
     const answerSelectorsLiteral = JSON.stringify(ANSWER_SELECTORS);
-    const turnSelectorLiteral = escapeLiteral(CONVERSATION_TURN_SELECTOR);
     const assistantRoleLiteral = escapeLiteral(ASSISTANT_ROLE_SELECTOR);
     const modelButtonSelectorLiteral = escapeLiteral(MODEL_BUTTON_SELECTOR);
     const stopSelectorLiteral = escapeLiteral(STOP_BUTTON_SELECTOR);
@@ -66,7 +66,6 @@ function buildTabInspectionExpression() {
       const INPUT_SELECTORS = ${inputSelectorsLiteral};
       const SEND_SELECTORS = ${sendSelectorsLiteral};
       const ANSWER_SELECTORS = ${answerSelectorsLiteral};
-      const TURN_SELECTOR = ${turnSelectorLiteral};
       const ASSISTANT_ROLE_SELECTOR = ${assistantRoleLiteral};
       const MODEL_BUTTON_SELECTOR = ${modelButtonSelectorLiteral};
       const STOP_BUTTON_SELECTOR = ${stopSelectorLiteral};
@@ -97,15 +96,21 @@ function buildTabInspectionExpression() {
       const sendExists = Boolean(sendButton);
       const promptNode = firstVisible(INPUT_SELECTORS);
       const promptReady = Boolean(promptNode);
-      const turns = Array.from(document.querySelectorAll(TURN_SELECTOR));
+      const turns = ${buildConversationTurnListExpression()};
       const assistantTurns = turns.filter((turn) => {
         const role = normalize(turn.getAttribute('data-message-author-role') || turn.getAttribute('data-turn')).toLowerCase();
         if (role === 'assistant') return true;
         return Boolean(turn.querySelector(ASSISTANT_ROLE_SELECTOR));
       });
+      const fallbackUserTurns = Array.from(
+        document.querySelectorAll('[data-message-author-role="user"], [data-turn="user"]'),
+      );
       const userTurns = turns.filter((turn) => {
         const role = normalize(turn.getAttribute('data-message-author-role') || turn.getAttribute('data-turn')).toLowerCase();
-        return role === 'user';
+        if (role === 'user') return true;
+        return Boolean(
+          turn.querySelector('[data-message-author-role="user"], [data-turn="user"]'),
+        );
       });
       const answerNode = ANSWER_SELECTORS
         .map((selector) => document.querySelectorAll(selector))
@@ -116,16 +121,47 @@ function buildTabInspectionExpression() {
       if (currentModelLabel === 'ChatGPT' && hasProPill) {
         currentModelLabel = 'ChatGPT + Pro';
       }
-      const assistantTexts = assistantTurns
-        .map((node) => normalize(node.textContent))
-        .filter(Boolean);
-      const userTexts = userTurns
-        .map((node) => normalize(node.textContent))
-        .filter(Boolean);
-      const answerTexts = Array.from(answerNode || []).map((node) => normalize(node.textContent)).filter(Boolean);
-      const assistantCount = assistantTurns.length > 0 ? assistantTurns.length : answerTexts.length;
-      const lastAssistantText = assistantTexts[assistantTexts.length - 1] || answerTexts[answerTexts.length - 1] || '';
-      const lastUserText = userTexts[userTexts.length - 1] || '';
+      const rawAnswerNodes = Array.from(answerNode || []);
+      const userCandidates = Array.from(new Set([...userTurns, ...fallbackUserTurns]));
+      const lastUserTurn = userCandidates.reduce((latest, candidate) => {
+        if (!latest) return candidate;
+        return latest.compareDocumentPosition(candidate) & 4 ? candidate : latest;
+      }, null);
+      const lastUserContainer = lastUserTurn
+        ? turns.find((turn) => turn === lastUserTurn || turn.contains?.(lastUserTurn))
+        : null;
+      const answerNodes = rawAnswerNodes.filter(
+        (node) =>
+          !lastUserTurn ||
+          (node !== lastUserTurn &&
+            !lastUserTurn.contains?.(node) &&
+            !node.contains?.(lastUserTurn)),
+      );
+      const answerTexts = answerNodes.map((node) => normalize(node.textContent)).filter(Boolean);
+      const assistantCandidates = Array.from(new Set([...assistantTurns, ...answerNodes]));
+      const lastAssistantNode = assistantCandidates.reduce((latest, candidate) => {
+        if (!latest) return candidate;
+        return latest.compareDocumentPosition(candidate) & 4 ? candidate : latest;
+      }, null);
+      const lastAssistantContainer = lastAssistantNode
+        ? turns.find((turn) => turn === lastAssistantNode || turn.contains?.(lastAssistantNode))
+        : null;
+      const assistantFollowsLatestUser = Boolean(
+        lastAssistantNode &&
+        lastUserTurn &&
+        lastAssistantNode !== lastUserTurn &&
+        (lastUserTurn.compareDocumentPosition(lastAssistantNode) & 4),
+      );
+      const lastAssistantTurnIndex = lastAssistantContainer
+        ? turns.indexOf(lastAssistantContainer)
+        : -1;
+      const lastUserTurnIndex = lastUserContainer ? turns.indexOf(lastUserContainer) : -1;
+      const assistantOwners = assistantCandidates.map(
+        (node) => turns.find((turn) => turn === node || turn.contains?.(node)) || node,
+      );
+      const assistantCount = new Set(assistantOwners).size;
+      const lastAssistantText = normalize(lastAssistantNode?.textContent);
+      const lastUserText = normalize(lastUserTurn?.textContent);
       const authenticated = !loginButtonExists && (promptReady || sendExists || stopExists || assistantCount > 0);
       return {
         title: normalize(document.title),
@@ -138,12 +174,18 @@ function buildTabInspectionExpression() {
         authenticated,
         assistantCount,
         lastAssistantText,
+        assistantFollowsLatestUser,
+        lastAssistantTurnIndex,
+        lastUserTurnIndex,
         lastUserText,
         visibilityState: document.visibilityState,
         focused: Boolean(document.hasFocus?.()),
       };
     })()`;
 }
+export function buildTabInspectionExpressionForTest() {
+    return buildTabInspectionExpression();
+}
 export async function listChatGptTargets(options = {}) {
     const { host, port } = normalizeHostPort(options);
     const targets = (await CDP.List({ host, port }));
@@ -183,7 +225,20 @@ export async function inspectChatGptTab(options) {
         });
         const info = (evaluation.result?.value ?? {});
         const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
-        const lastAssistantText = typeof snapshot?.text === "string" && snapshot.text.trim().length > 0
+        const inspectedAssistantTurnIndex = typeof info.lastAssistantTurnIndex === "number" && info.lastAssistantTurnIndex >= 0
+            ? info.lastAssistantTurnIndex
+            : undefined;
+        const normalizedSnapshotText = normalizeTitle(snapshot?.text ?? "").toLowerCase();
+        const normalizedInspectedText = normalizeTitle(info.lastAssistantText ?? "").toLowerCase();
+        const snapshotMatchesInspectedTurn = (typeof snapshot?.turnIndex === "number" &&
+            snapshot.turnIndex === inspectedAssistantTurnIndex) ||
+            (snapshot?.turnIndex == null &&
+                inspectedAssistantTurnIndex === undefined &&
+                normalizedSnapshotText.length > 0 &&
+                normalizedSnapshotText === normalizedInspectedText);
+        const lastAssistantText = snapshotMatchesInspectedTurn &&
+            typeof snapshot?.text === "string" &&
+            snapshot.text.trim().length > 0
             ? snapshot.text.trim()
             : String(info.lastAssistantText ?? "").trim();
         const lastUserText = String(info.lastUserText ?? "").trim();
@@ -201,6 +256,11 @@ export async function inspectChatGptTab(options) {
             authenticated: Boolean(info.authenticated),
             assistantCount: Number.isFinite(info.assistantCount) ? Number(info.assistantCount) : 0,
             lastAssistantText,
+            assistantFollowsLatestUser: Boolean(info.assistantFollowsLatestUser),
+            lastAssistantTurnIndex: inspectedAssistantTurnIndex,
+            lastUserTurnIndex: typeof info.lastUserTurnIndex === "number" && info.lastUserTurnIndex >= 0
+                ? info.lastUserTurnIndex
+                : undefined,
             lastAssistantSnippet: trimToSnippet(lastAssistantText),
             lastUserText,
             lastUserSnippet: trimToSnippet(lastUserText),
@@ -210,8 +270,12 @@ export async function inspectChatGptTab(options) {
             fingerprint: "",
             state: "detached",
             lastAssistantMarkdown: null,
-            lastAssistantMessageId: typeof snapshot?.messageId === "string" ? snapshot.messageId : undefined,
-            lastAssistantTurnId: typeof snapshot?.turnId === "string" ? snapshot.turnId : undefined,
+            lastAssistantMessageId: snapshotMatchesInspectedTurn && typeof snapshot?.messageId === "string"
+                ? snapshot.messageId
+                : undefined,
+            lastAssistantTurnId: snapshotMatchesInspectedTurn && typeof snapshot?.turnId === "string"
+                ? snapshot.turnId
+                : undefined,
         };
         summary.state = classifyTabState(summary);
         summary.fingerprint = buildTargetFingerprint(summary);
@@ -292,6 +356,10 @@ function resolveChatGptTabFromSummaries(summaries, ref) {
     if (exactUrl) {
         return exactUrl;
     }
+    const exactConversationId = summaries.find((tab) => tab.conversationId === trimmedRef);
+    if (exactConversationId) {
+        return exactConversationId;
+    }
     const lower = trimmedRef.toLowerCase();
     const titleMatches = summaries.filter((tab) => tab.title.toLowerCase().includes(lower));
     if (titleMatches.length === 1) {
@@ -328,17 +396,6 @@ export async function harvestChatGptTab(options = {}) {
     try {
         const { Runtime } = client;
         const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
-        let assistantMarkdown = null;
-        if (snapshot?.messageId || snapshot?.turnId) {
-            assistantMarkdown = await captureAssistantMarkdown(Runtime, {
-                messageId: snapshot.messageId,
-                turnId: snapshot.turnId,
-            }, noopLogger).catch(() => null);
-        }
-        const latestText = typeof snapshot?.text === "string" && snapshot.text.trim().length > 0
-            ? snapshot.text.trim()
-            : resolved.lastAssistantText;
-        const lastAssistantText = latestText ?? "";
         const nowSummary = await inspectChatGptTab({
             host,
             port,
@@ -349,15 +406,37 @@ export async function harvestChatGptTab(options = {}) {
                 type: "page",
             },
         });
+        const normalizedSnapshotText = normalizeTitle(snapshot?.text ?? "").toLowerCase();
+        const normalizedInspectedText = normalizeTitle(nowSummary.lastAssistantText).toLowerCase();
+        const snapshotMatchesLatestTurn = (typeof snapshot?.turnIndex === "number" &&
+            snapshot.turnIndex === nowSummary.lastAssistantTurnIndex) ||
+            (snapshot?.turnIndex == null &&
+                nowSummary.lastAssistantTurnIndex === undefined &&
+                normalizedSnapshotText.length > 0 &&
+                normalizedSnapshotText === normalizedInspectedText);
+        let assistantMarkdown = null;
+        if (snapshotMatchesLatestTurn && (snapshot?.messageId || snapshot?.turnId)) {
+            assistantMarkdown = await captureAssistantMarkdown(Runtime, {
+                messageId: snapshot.messageId,
+                turnId: snapshot.turnId,
+            }, noopLogger).catch(() => null);
+        }
+        const lastAssistantText = snapshotMatchesLatestTurn &&
+            typeof snapshot?.text === "string" &&
+            snapshot.text.trim().length > 0
+            ? snapshot.text.trim()
+            : nowSummary.lastAssistantText;
         const harvested = {
             ...nowSummary,
             lastAssistantText,
             lastAssistantSnippet: trimToSnippet(lastAssistantText),
             lastAssistantMarkdown: assistantMarkdown ?? (lastAssistantText || null),
-            lastAssistantMessageId: typeof snapshot?.messageId === "string"
+            lastAssistantMessageId: snapshotMatchesLatestTurn && typeof snapshot?.messageId === "string"
                 ? snapshot.messageId
                 : nowSummary.lastAssistantMessageId,
-            lastAssistantTurnId: typeof snapshot?.turnId === "string" ? snapshot.turnId : nowSummary.lastAssistantTurnId,
+            lastAssistantTurnId: snapshotMatchesLatestTurn && typeof snapshot?.turnId === "string"
+                ? snapshot.turnId
+                : nowSummary.lastAssistantTurnId,
         };
         if (harvested.stopExists && options.stallWindowMs && options.stallWindowMs > 0) {
             const firstFingerprint = harvested.fingerprint;
@@ -383,6 +462,9 @@ export async function harvestChatGptTab(options = {}) {
             harvested.loginButtonExists = followup.loginButtonExists;
             harvested.lastUserText = followup.lastUserText;
             harvested.lastUserSnippet = followup.lastUserSnippet;
+            harvested.assistantFollowsLatestUser = followup.assistantFollowsLatestUser;
+            harvested.lastAssistantTurnIndex = followup.lastAssistantTurnIndex;
+            harvested.lastUserTurnIndex = followup.lastUserTurnIndex;
             harvested.fingerprint = followup.fingerprint;
             harvested.state =
                 harvested.stopExists && firstFingerprint === followup.fingerprint

package/dist/src/browser/pageActions.js

@@ -1,4 +1,4 @@
-export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, } from "./actions/navigation.js";
+export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, } from "./actions/navigation.js";
 export { ensureModelSelection } from "./actions/modelSelection.js";
 export { submitPrompt, clearPromptComposer } from "./actions/promptComposer.js";
 export { clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, buildUserTurnAttachmentExpressionForTest, } from "./actions/attachments.js";

package/dist/src/browser/projectSourcesRunner.js

@@ -1,7 +1,7 @@
 import { mkdtemp, mkdir, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { closeTab, connectWithNewTab, hideChromeWindow, launchChrome, registerTerminationHooks, } from "./chromeLifecycle.js";
+import { closeTab, connectWithNewTab, launchChrome, positionChromeWindowOffscreen, registerTerminationHooks, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
 import { installJavaScriptDialogAutoDismissal, navigateToChatGPT, ensureLoggedIn, } from "./pageActions.js";
@@ -121,14 +121,14 @@ export async function runBrowserProjectSources(request) {
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
         const { Network, Page, Runtime, Input, DOM, Target } = client;
-        if (!config.headless && config.hideWindow) {
-            await hideChromeWindow(chrome, logger);
-        }
         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);
+        }
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         if (!manualLogin) {
             await Network.clearBrowserCookies();

package/dist/src/browser/reattach.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { mkdtemp, mkdir, rm } from "node:fs/promises";
 import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from "./pageActions.js";
-import { launchChrome, connectToChrome, hideChromeWindow, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
+import { launchChrome, connectToChrome, positionChromeWindowOffscreen, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
 import { CHATGPT_URL } from "./constants.js";
@@ -180,7 +180,7 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         await DOM.enable();
     }
     if (!resolved.headless && resolved.hideWindow) {
-        await hideChromeWindow(chrome, logger);
+        await positionChromeWindowOffscreen(client, logger);
     }
     let appliedCookies = 0;
     if (!manualLogin && resolved.cookieSync) {

package/dist/src/browser/recoverConversation.js

@@ -1,7 +1,10 @@
-import { launch } from "chrome-launcher";
-import { defaultManualLoginProfileDir } from "./manualLoginProfile.js";
+import { isAnswerNowPlaceholderText } from "./actions/assistantResponse.js";
+import { resolveBrowserConfig } from "./config.js";
+import { acquireManualLoginChromeForRun, isImageOnlyUiChromeText } from "./index.js";
 import { isRecoverableChatGptConversationUrl } from "./reattachability.js";
-const DEFAULT_HYDRATION_DELAY_MS = 3_000;
+import { harvestChatGptTab, openChatGptTarget } from "./liveTabs.js";
+const DEFAULT_READY_TIMEOUT_MS = 30_000;
+const READY_POLL_MS = 1_000;
 /**
  * Picks the URL to navigate the recovered Chrome tab to.
  *
@@ -23,12 +26,54 @@ export function resolveRecoveryUrl(meta) {
     }
     return null;
 }
-function resolveProfileDir(meta) {
-    const fromMeta = meta?.browser?.config?.manualLoginProfileDir;
-    if (typeof fromMeta === "string" && fromMeta.length > 0) {
-        return fromMeta;
+export function resolveRecoveryProfileDir(meta) {
+    const config = meta?.browser?.config;
+    const resolved = resolveBrowserConfig(config);
+    if (!resolved.manualLogin) {
+        throw new Error("Cannot recover conversation: session was not run with a manual-login browser profile.");
     }
-    return defaultManualLoginProfileDir();
+    const runtime = meta?.browser?.runtime;
+    const profileDir = runtime?.userDataDir ?? resolved.manualLoginProfileDir;
+    if (typeof profileDir !== "string" || profileDir.trim().length === 0) {
+        throw new Error("Cannot recover conversation: session metadata has no recorded manual-login profile directory.");
+    }
+    return profileDir;
+}
+async function waitForRecoveredConversationReady(endpoint, ref, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError = null;
+    while (Date.now() < deadline) {
+        try {
+            const harvested = await harvestChatGptTab({ ...endpoint, ref });
+            if (isRecoveredConversationHarvestReady(harvested)) {
+                return;
+            }
+            lastError = new Error(`recovered tab is still ${harvested.state}`);
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
+    }
+    const suffix = lastError instanceof Error ? ` Last error: ${lastError.message}` : "";
+    throw new Error(`Recovered ChatGPT conversation did not become ready in time.${suffix}`);
+}
+export function isRecoveredConversationHarvestReady(harvested) {
+    const latestAssistant = harvested.lastAssistantText ??
+        harvested.lastAssistantMarkdown ??
+        harvested.lastAssistantSnippet ??
+        "";
+    const assistantFollowsLatestUser = harvested.assistantFollowsLatestUser === true ||
+        (typeof harvested.lastAssistantTurnIndex === "number" &&
+            typeof harvested.lastUserTurnIndex === "number" &&
+            harvested.lastAssistantTurnIndex > harvested.lastUserTurnIndex);
+    return (harvested.stopExists === true ||
+        ((harvested.assistantCount ?? 0) > 0 &&
+            assistantFollowsLatestUser &&
+            latestAssistant.trim().length > 0 &&
+            !isImageOnlyUiChromeText(latestAssistant) &&
+            !isAnswerNowPlaceholderText(latestAssistant) &&
+            !/^answer now$/i.test(latestAssistant.trim())));
 }
 /**
  * Re-open a previously-harvested ChatGPT conversation by relaunching Chrome
@@ -46,28 +91,44 @@ export async function recoverConversationTab(meta, logger, options = {}) {
         throw new Error("Cannot recover conversation: session metadata has no recoverable ChatGPT conversation URL " +
             "(expected browser.harvest.url or browser.runtime.tabUrl to be a chatgpt.com/c/<id> URL).");
     }
-    const userDataDir = resolveProfileDir(meta);
+    const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+    const waitForReady = options.waitForReady !== false;
+    if (options.existingEndpoint) {
+        try {
+            logger(`[browser] Recovery: opening saved conversation in existing Chrome at ` +
+                `${options.existingEndpoint.host}:${options.existingEndpoint.port}`);
+            const targetId = await openChatGptTarget({ ...options.existingEndpoint, url });
+            if (waitForReady) {
+                await waitForRecoveredConversationReady(options.existingEndpoint, targetId, readyTimeoutMs);
+            }
+            return { ...options.existingEndpoint, url, ref: targetId, chrome: null };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(`[browser] Recovery: existing Chrome could not reopen the conversation (${message}).`);
+        }
+    }
+    const userDataDir = resolveRecoveryProfileDir(meta);
+    const config = resolveBrowserConfig(meta.browser?.config);
     logger(`[browser] Recovery: relaunching Chrome with profile ${userDataDir} and navigating to ${url}`);
-    const chrome = await launch({
-        chromeFlags: [
-            "--no-first-run",
-            "--no-default-browser-check",
-            "--disable-features=AutomationControlled,TranslateUI",
-            "--disable-sync",
-            "--password-store=basic",
-            "--use-mock-keychain",
-            "--lang=en-US",
-            url,
-        ],
-        userDataDir,
-        handleSIGINT: false,
-    });
-    const host = "127.0.0.1";
+    const { chrome } = await acquireManualLoginChromeForRun(userDataDir, config, logger, meta.id, {});
+    const host = chrome.host ?? "127.0.0.1";
     const port = chrome.port;
-    const hydrationDelayMs = options.hydrationDelayMs ?? DEFAULT_HYDRATION_DELAY_MS;
-    if (hydrationDelayMs > 0) {
-        await new Promise((resolve) => setTimeout(resolve, hydrationDelayMs));
+    try {
+        const targetId = await openChatGptTarget({ host, port, url });
+        if (waitForReady) {
+            await waitForRecoveredConversationReady({ host, port }, targetId, readyTimeoutMs);
+        }
+        logger(`[browser] Recovery: Chrome listening on ${host}:${port}; tab loaded.`);
+        return { host, port, url, ref: targetId, chrome };
+    }
+    catch (error) {
+        try {
+            chrome.kill();
+        }
+        catch {
+            // best-effort cleanup
+        }
+        throw error;
     }
-    logger(`[browser] Recovery: Chrome listening on ${host}:${port}; tab loaded.`);
-    return { host, port, url, chrome };
 }

package/dist/src/cli/browserConfig.js

@@ -16,6 +16,8 @@ const DEFAULT_CHROME_PROFILE = "Default";
 // The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
 const BROWSER_MODEL_LABELS = [
     // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
+    ["gpt-5.6-sol", "GPT-5.6 Sol"],
+    ["gpt-5.6", "GPT-5.6 Sol"],
     ["gpt-5.5-pro", "Pro"],
     ["gpt-5.5-instant", "GPT-5.5 Instant"],
     ["gpt-5.5", "Thinking 5.5"],
@@ -40,7 +42,9 @@ export function normalizeChatGptModelForBrowser(model) {
     if (!normalized.startsWith("gpt-") || normalized.includes("codex")) {
         return model;
     }
-    if (normalized === "gpt-5.5-pro" ||
+    if (normalized === "gpt-5.6-sol" ||
+        normalized === "gpt-5.6" ||
+        normalized === "gpt-5.5-pro" ||
         normalized === "gpt-5.5-instant" ||
         normalized === "gpt-5.5" ||
         normalized === "gpt-5.4") {