@steipete/oracle 0.16.1 → 0.17.1

package/dist/src/browser/actions/thinkingTime.js

@@ -55,7 +55,9 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
             if (strictProEffort) {
                 throw new Error(`${message}; refusing to submit without confirmed Pro Extended.`);
             }
-            logger(formatBrowserThinkingLog(`${message}; continuing with ChatGPT default.`));
+            // Nothing was clicked, so the tab keeps whatever effort it already had —
+            // which is not necessarily ChatGPT's default.
+            logger(formatBrowserThinkingLog(`${message}; keeping the effort already selected in ChatGPT.`));
             return;
         }
         default: {
@@ -72,7 +74,7 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
 /**
  * Best-effort selection of a thinking time level in ChatGPT's composer pill menu.
  * Safe by default: if the pill/menu/option isn't present, we continue without throwing.
- * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
+ * @param level - The thinking time intensity: 'light', 'standard', 'extended', 'extra-high', or 'heavy'
  */
 export async function ensureThinkingTimeIfAvailable(Runtime, level, logger, desiredModel) {
     try {
@@ -135,12 +137,13 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
     const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
 
-    // Bilingual matchers: English level token + observed Chinese variants.
+    // Multilingual matchers: English level token + observed German/Chinese variants.
     const LEVEL_TOKENS = {
-      light: ['light', 'instant', '轻', '极速'],
-      standard: ['standard', 'medium', '标准', '中'],
-      extended: ['extended', 'high', '扩展', '深度', '加强', '高'],
-      heavy: ['heavy', 'extra high', '重度', '加重', '极高'],
+      light: ['light', 'instant', 'sofort', 'leicht', '轻', '极速'],
+      standard: ['standard', 'medium', 'mittel', '标准', '中'],
+      extended: ['extended', 'high', 'hoch', 'erweitert', '扩展', '深度', '加强', '高'],
+      'extra-high': ['extra high', 'sehr hoch', '极高'],
+      heavy: ['heavy', 'schwer', '重度', '加重'],
     };
     const targetTokens = LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
 
@@ -155,19 +158,43 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
     // Keep CJK characters so we can match Chinese labels against LEVEL_TOKENS.
     const normalize = (value) => (value || '')
+      // Compose first so NFD umlauts fold too, then map them onto ASCII before
+      // the strip below would drop them (and split the token in half).
+      .normalize('NFC')
       .toLowerCase()
+      .replace(/ä/g, 'a')
+      .replace(/ö/g, 'o')
+      .replace(/ü/g, 'u')
+      .replace(/ß/g, 'ss')
       .replace(/[^a-z0-9\\u4e00-\\u9fa5]+/g, ' ')
       .replace(/\\s+/g, ' ')
       .trim();
     const hasToken = (text, token) => normalize(text).split(' ').includes(token);
-    const matchesLevel = (text) => {
+    // Whole-word/phrase containment. Latin effort labels are short words that also
+    // occur inside unrelated UI text ("Hochladen", "Ermitteln") and inside their own
+    // row descriptions ("Hoch – für sehr komplexe Aufgaben"), so plain substring
+    // matching misclassifies rows. CJK labels have no word separators, so they keep
+    // substring semantics.
+    const hasPhrase = (text, phrase) => {
+      const haystack = ' ' + normalize(text) + ' ';
+      const needle = normalize(phrase);
+      if (!needle) return false;
+      return /^[a-z0-9 ]+$/.test(needle)
+        ? haystack.includes(' ' + needle + ' ')
+        : haystack.includes(needle);
+    };
+    // ChatGPT's Pro effort tiers are "Pro Extended"/"Pro Erweitert" per UI language.
+    const hasExtendedWord = (text) => hasPhrase(text, 'extended') || hasPhrase(text, 'erweitert');
+    const matchesTokens = (text, tokens) => {
       const t = normalize(text);
       if (!t) return false;
-      return targetTokens.some((tok) => {
+      return tokens.some((tok) => {
         const token = normalize(tok);
         if (!token) return false;
-        if (token === 'high') return hasToken(t, 'high') && !hasToken(t, 'extra');
-        if (token === 'extra high') return hasToken(t, 'extra') && hasToken(t, 'high');
+        if (token === 'high') return hasPhrase(t, 'high') && !hasPhrase(t, 'extra high');
+        if (token === 'extra high') return hasPhrase(t, 'extra high');
+        if (token === 'hoch') return hasPhrase(t, 'hoch') && !hasPhrase(t, 'sehr hoch');
+        if (token === 'sehr hoch') return hasPhrase(t, 'sehr hoch');
         if (token === '极速') {
           const suffix = t.slice(token.length);
           return t === token || hasToken(t, token) || /^[0-9]/.test(suffix);
@@ -175,27 +202,15 @@ function buildThinkingTimeExpression(level, desiredModel) {
         if (['中', '高', '极高'].includes(token)) {
           return t === token || hasToken(t, token);
         }
+        if (/^[a-z0-9 ]+$/.test(token)) {
+          return hasPhrase(t, token);
+        }
         return t === token || hasToken(t, token) || t.includes(token);
       });
     };
-    const matchesAnyEffortLevel = (text) => {
-      const normalizedText = normalize(text);
-      if (!normalizedText) return false;
-      for (const tokens of Object.values(LEVEL_TOKENS)) {
-        for (const rawToken of tokens) {
-          const token = normalize(rawToken);
-          if (!token) continue;
-          if (token.includes(' ')) {
-            if (token.split(' ').every((part) => hasToken(normalizedText, part))) return true;
-          } else if (/^[a-z0-9]+$/.test(token)) {
-            if (hasToken(normalizedText, token)) return true;
-          } else if (normalizedText.includes(token)) {
-            return true;
-          }
-        }
-      }
-      return false;
-    };
+    const matchesLevel = (text) => matchesTokens(text, targetTokens);
+    const matchesAnyEffortLevel = (text) =>
+      Object.values(LEVEL_TOKENS).some((tokens) => matchesTokens(text, tokens));
     const optionIsSelected = (node) => {
       if (!(node instanceof HTMLElement)) return false;
       const ariaChecked = node.getAttribute('aria-checked');
@@ -347,7 +362,8 @@ function buildThinkingTimeExpression(level, desiredModel) {
         return true;
       }
       const label = menu?.querySelector?.('.__menu-label, [class*="menu-label"]');
-      return normalize(label?.textContent ?? '').includes('intelligence');
+      // 'intelligen' matches both "Intelligence" and German "Intelligenz".
+      return normalize(label?.textContent ?? '').includes('intelligen');
     };
     const failure = (status, extra = {}) => ({
       status,
@@ -390,6 +406,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
           return null;
         }
       }
+      // Generic effort-label match for every model/level. GPT-5.6 heavy used to
+      // short-circuit to the Pro row before reaching here; it no longer does, so
+      // a UI without a matching tier (e.g. German, which has no "heavy") falls
+      // through to null and the caller keeps the current selection.
       for (const item of items) {
         const itemText = normalize(
           (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
@@ -404,10 +424,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
           return item;
         }
       }
-      if (TARGET_LEVEL === 'heavy') {
-        // Older Chinese layouts used bare 高 for the highest effort. Keep it
-        // only as a second-pass exact fallback so a current 高 row can never
-        // win before the primary 极高 row.
+      if (TARGET_LEVEL === 'extra-high') {
+        // Older Chinese layouts used bare 高 for the highest non-Pro effort.
+        // Keep it only as a second-pass exact fallback so a current 高 row can
+        // never win before the primary 极高 row.
         for (const item of items) {
           const itemText = normalize(item.textContent ?? '');
           const ariaLabel = normalize(item.getAttribute?.('aria-label') ?? '');
@@ -416,11 +436,15 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       return null;
     };
+    // Menu-shape heuristic only. This reads the whole menu's textContent, where
+    // adjacent row labels concatenate without a separator ("Pro StandardPro
+    // Extended"), so word-boundary matching does not apply here — substring is
+    // deliberate. Row-level classification uses matchesLevel/matchesTokens.
     const countEffortLevels = (menu) => {
       const text = normalize(menu?.textContent ?? '');
       let hits = 0;
       for (const tokens of Object.values(LEVEL_TOKENS)) {
-        if (tokens.some((token) => text.includes(String(token).toLowerCase()))) hits += 1;
+        if (tokens.some((token) => text.includes(normalize(token)))) hits += 1;
       }
       return hits;
     };
@@ -431,16 +455,22 @@ function buildThinkingTimeExpression(level, desiredModel) {
       const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
       const labelText = normalize(label?.textContent ?? '');
       return (
-        labelText.includes('intelligence') ||
+        labelText.includes('intelligen') ||
         labelText.includes('thinking time') ||
         labelText.includes('thinking effort') ||
+        labelText.includes('denkdauer') ||
+        labelText.includes('denkzeit') ||
         countEffortLevels(menu) >= 2
       );
     };
     const isProEffortMenu = (menu) => {
       if (!isVisible(menu)) return false;
       const text = normalize(menu?.textContent ?? '');
-      return text.includes('pro standard') && text.includes('pro extended');
+      // Aggregate menu text, so plain substring only (see countEffortLevels).
+      return (
+        text.includes('pro standard') &&
+        (text.includes('pro extended') || text.includes('pro erweitert'))
+      );
     };
     const controlledMenu = (trigger) => {
       const id = trigger?.getAttribute?.('aria-controls');
@@ -475,10 +505,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
         (node?.textContent ?? '') + ' ' + (node?.getAttribute?.('aria-label') ?? ''),
       );
       if (TARGET_LEVEL === 'standard') {
-        return text.includes('pro') && text.includes('standard');
+        return hasPhrase(text, 'pro') && hasPhrase(text, 'standard');
       }
       if (TARGET_LEVEL === 'extended') {
-        return text.includes('pro') && text.includes('extended');
+        return hasPhrase(text, 'pro') && hasExtendedWord(text);
       }
       return false;
     };
@@ -503,29 +533,50 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       const label = normalize(button?.textContent ?? '');
       if (TARGET_LEVEL === 'standard') {
-        return hasToken(label, 'pro') && !hasToken(label, 'extended');
+        return hasToken(label, 'pro') && !hasExtendedWord(label);
       }
       if (TARGET_LEVEL === 'extended') {
-        return hasToken(label, 'pro') && hasToken(label, 'extended');
+        return hasToken(label, 'pro') && hasExtendedWord(label);
       }
       return false;
     };
     const currentEffortPillMatchesTarget = (trigger, modelKindOverride = null) => {
       if (currentProEffortPillMatchesTarget(trigger, modelKindOverride)) return true;
       const button = freshComposerTrigger(trigger) || findModelButton();
+      const normalizedLabel = normalize(
+        (button?.textContent ?? '') + ' ' + (button?.getAttribute?.('aria-label') ?? ''),
+      );
+      // No 5.6-heavy "a Pro pill counts as heavy" shortcut here: that would also
+      // make post-click verification pass on an unchanged Pro pill. selectAndVerify
+      // handles the already-on-Pro case explicitly before any click.
       if ((modelKindOverride || TARGET_MODEL_KIND || modelKindFromNode(button)) === 'pro') {
         return false;
       }
-      const label = (button?.textContent ?? '') + ' ' + (button?.getAttribute?.('aria-label') ?? '');
-      return matchesLevel(label);
+      return matchesLevel(normalizedLabel);
     };
     const selectAndVerify = async (trigger, findOption, modelKindOverride = null) => {
-      const option = findOption();
       const triggerModelKind =
         modelKindOverride ||
         TARGET_MODEL_KIND ||
         modelKindFromNode(trigger) ||
         effectiveTargetModelKind();
+      const option = findOption();
+      if (!option && TARGET_IS_GPT56_MODEL && TARGET_LEVEL === 'heavy') {
+        // GPT-5.6 has no "heavy" tier: Pro is the closest thing. Accept a pill that
+        // is already on Pro as satisfying the request, but never click Pro to get
+        // there, and never let this stand in for post-click verification.
+        const pill = freshComposerTrigger(trigger) || findModelButton();
+        const pillLabel = normalize(
+          (pill?.textContent ?? '') + ' ' + (pill?.getAttribute?.('aria-label') ?? ''),
+        );
+        if (
+          hasToken(pillLabel, 'pro') ||
+          currentEffortPillMatchesTarget(trigger, triggerModelKind)
+        ) {
+          closeOpenMenus();
+          return { status: 'already-selected', label: trigger.textContent?.trim?.() || null };
+        }
+      }
       if (!option) return failure('option-not-found', { modelKind: triggerModelKind });
       const label = option.textContent?.trim?.() || null;
       if (optionIsSelected(option)) {
@@ -821,7 +872,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
         const text = normalize(
           (node?.textContent ?? '') + ' ' + (node?.getAttribute?.('aria-label') ?? ''),
         );
-        return text.includes('pro') && text.includes('extended');
+        return hasPhrase(text, 'pro') && hasExtendedWord(text);
       };
       const findProExtendedOption = () => {
         const menu = document.querySelector(INTELLIGENCE_MENU_SELECTOR);

package/dist/src/browser/chromeLifecycle.js

@@ -1,17 +1,14 @@
 import { rm } from "node:fs/promises";
-import { readFileSync } from "node:fs";
-import os from "node:os";
 import net from "node:net";
 import CDP from "chrome-remote-interface";
 import { launch, Launcher } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
+import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
 export async function launchChrome(config, userDataDir, logger) {
-    const connectHost = resolveRemoteDebugHost();
-    const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
+    const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
     const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress, config.hideWindow ?? false);
-    const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
     // copy-profile reuses a copied signed-in profile whose cookies are
     // Keychain-encrypted, so it must launch with the real Keychain (not mocked):
     // strip the keychain-mocking flags from both chrome-launcher's defaults and
@@ -545,6 +542,12 @@ function buildChromeFlags(headless, debugBindAddress, hideWindow = false) {
         "--disable-features=TranslateUI,AutomationControlled",
         "--mute-audio",
         "--window-size=1280,720",
+        // Chrome that *we* launch is pinned to English, so ChatGPT renders the labels
+        // our selectors were written against. This does not make English the only case
+        // to handle: --browser-attach-running and --remote-chrome never build these
+        // flags (see controlPlan.ts), so those runs inherit the user's own Chrome
+        // locale, and a ChatGPT account language setting can localize the UI even here.
+        // That is why the model/effort matchers must stay language-tolerant.
         "--lang=en-US",
         "--accept-lang=en-US,en",
     ];
@@ -595,38 +598,6 @@ function parseDebugPortEnv() {
     }
     return value;
 }
-function resolveRemoteDebugHost() {
-    const override = process.env.ORACLE_BROWSER_REMOTE_DEBUG_HOST?.trim() || process.env.WSL_HOST_IP?.trim();
-    if (override) {
-        return override;
-    }
-    if (!isWsl()) {
-        return null;
-    }
-    try {
-        const resolv = readFileSync("/etc/resolv.conf", "utf8");
-        for (const line of resolv.split("\n")) {
-            const match = line.match(/^nameserver\s+([0-9.]+)/);
-            if (match?.[1]) {
-                return match[1];
-            }
-        }
-    }
-    catch {
-        // ignore; fall back to localhost
-    }
-    return null;
-}
-function isWsl() {
-    if (process.platform !== "linux") {
-        return false;
-    }
-    if (process.env.WSL_DISTRO_NAME) {
-        return true;
-    }
-    const release = os.release();
-    return release.toLowerCase().includes("microsoft");
-}
 async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, ignoreDefaultFlags, }) {
     const launcher = new Launcher({
         chromePath: chromePath ?? undefined,

package/dist/src/browser/index.js

@@ -71,6 +71,9 @@ function classifyPreservedBrowserError(error, headless) {
 function shouldPreserveBrowserOnError(error, headless) {
     return classifyPreservedBrowserError(error, headless) !== null;
 }
+function normalizeAuthenticatedModelSelectionError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
 function shouldKeepLocalBrowserOpen(options) {
     if (options.usingCopiedProfile)
         return false;
@@ -1054,11 +1057,9 @@ 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)."
-                    : "";
-                throw new Error(`${base}${hint}`);
+                // Login has already been verified above. Preserve the picker failure instead of
+                // misdiagnosing an unavailable model as missing cookies.
+                throw normalizeAuthenticatedModelSelectionError(error);
             });
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
@@ -1342,7 +1343,11 @@ export async function runBrowserMode(options) {
             if (conversationUrl && isConversationUrl(conversationUrl)) {
                 logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
                 await raceWithDisconnect(Page.navigate({ url: conversationUrl }));
-                await raceWithDisconnect(delay(1000));
+                await raceWithDisconnect(waitForResumedConversationHydration(Runtime, recheckTimeoutMs || 30_000, logger, {
+                    requirePriorTurns: true,
+                    requirePromptReady: false,
+                    expectedConversationUrl: conversationUrl,
+                }));
             }
             // Validate session before attempting recheck - sessions can expire during the delay
             const sessionValid = await validateChatGPTSession(Runtime, logger);
@@ -2607,7 +2612,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 lastUrl = conversationUrl;
                 logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
                 await Page.navigate({ url: conversationUrl });
-                await delay(1000);
+                await waitForResumedConversationHydration(Runtime, recheckTimeoutMs || 30_000, logger, {
+                    requirePriorTurns: true,
+                    requirePromptReady: false,
+                    expectedConversationUrl: conversationUrl,
+                });
             }
             // Validate session before attempting recheck - sessions can expire during the delay
             const sessionValid = await validateChatGPTSession(Runtime, logger);
@@ -3051,10 +3060,12 @@ export const __test__ = {
     isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
+    normalizeAuthenticatedModelSelectionError,
     resolveManualLoginWaitMs,
     shouldCleanupBlankTabsAfterLastLease,
     shouldCloseOwnedRunTargetAfterRun,
     shouldKeepLocalBrowserOpen,
+    waitForAssistantResponseWithReload,
 };
 export { syncCookies } from "./cookies.js";
 export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from "./pageActions.js";
@@ -3086,7 +3097,11 @@ async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logg
         }
         logger("Assistant response stalled; reloading conversation and retrying once");
         await Page.navigate({ url: conversationUrl });
-        await delay(1000);
+        await waitForResumedConversationHydration(Runtime, timeoutMs, logger, {
+            requirePriorTurns: true,
+            requirePromptReady: false,
+            expectedConversationUrl: conversationUrl,
+        });
         return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
 }

package/dist/src/browser/modelDisplay.js

@@ -0,0 +1,67 @@
+function cleanLabel(value) {
+    const label = value?.trim();
+    return label ? label : null;
+}
+function sameLabel(left, right) {
+    return left.localeCompare(right, undefined, { sensitivity: "accent" }) === 0;
+}
+/**
+ * Describe what a browser run will try to select without presenting the target as observed fact.
+ */
+export function formatBrowserModelTarget({ model, desiredModel, modelStrategy, }) {
+    const requested = cleanLabel(model) ?? "n/a";
+    if (modelStrategy === "current" || modelStrategy === "ignore") {
+        return `picker=${modelStrategy}; requested=${requested}`;
+    }
+    const target = cleanLabel(desiredModel);
+    if (!target) {
+        return requested;
+    }
+    return `target=${target}; requested=${requested}`;
+}
+/**
+ * Prefer picker evidence only when Oracle verified it. Otherwise retain the requested CLI key.
+ * In particular, a bare `Pro` picker label must not be expanded to a server-side model version.
+ */
+export function resolveBrowserModelDisplayName({ model, evidence, }) {
+    const verifiedLabel = evidence?.verified ? cleanLabel(evidence.resolvedLabel) : null;
+    return verifiedLabel ?? cleanLabel(model) ?? "n/a";
+}
+export function formatBrowserModelWithRequestedKey(input) {
+    const displayName = resolveBrowserModelDisplayName(input);
+    const requested = cleanLabel(input.model);
+    if (!requested || sameLabel(displayName, requested)) {
+        return displayName;
+    }
+    return `${displayName} (requested ${requested})`;
+}
+export function resolveSessionBrowserModelDisplayName(metadata, model = metadata.model) {
+    const sessionModel = cleanLabel(metadata.model);
+    const requestedModel = cleanLabel(model);
+    const evidenceApplies = requestedModel === null
+        ? sessionModel === null
+        : sessionModel !== null && sameLabel(requestedModel, sessionModel);
+    return resolveBrowserModelDisplayName({
+        model,
+        evidence: evidenceApplies ? metadata.browser?.modelSelection : undefined,
+    });
+}
+export function formatSessionBrowserModelWithRequestedKey(metadata, model = metadata.model) {
+    const sessionModel = cleanLabel(metadata.model);
+    const requestedModel = cleanLabel(model);
+    const evidenceApplies = requestedModel === null
+        ? sessionModel === null
+        : sessionModel !== null && sameLabel(requestedModel, sessionModel);
+    return formatBrowserModelWithRequestedKey({
+        model,
+        evidence: evidenceApplies ? metadata.browser?.modelSelection : undefined,
+    });
+}
+export function formatBrowserModelSelectionEvidence(evidence, model) {
+    const requestedKey = cleanLabel(model) ?? "(none)";
+    const target = cleanLabel(evidence.requestedModel) ?? "(none)";
+    const resolvedLabel = cleanLabel(evidence.resolvedLabel) ?? "(unavailable)";
+    const strategy = evidence.strategy ?? "(default)";
+    const verified = evidence.verified ? "yes" : "no";
+    return `requestedKey=${requestedKey}; target=${target}; resolvedLabel=${resolvedLabel}; status=${evidence.status}; strategy=${strategy}; verified=${verified}; source=${evidence.source}; capturedAt=${evidence.capturedAt}`;
+}

package/dist/src/browser/reattach.js

@@ -2,7 +2,7 @@ import CDP from "chrome-remote-interface";
 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 { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, } from "./pageActions.js";
 import { launchChrome, connectToChrome, positionChromeWindowOffscreen, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
@@ -98,6 +98,13 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const pingTimeoutMs = Math.min(5_000, Math.max(1_500, Math.floor(timeoutMs * 0.05)));
         await withTimeout(Runtime.evaluate({ expression: "1+1", returnByValue: true }), pingTimeoutMs, "Reattach target did not respond");
         await ensureConversationOpen();
+        const waitForHydration = deps.waitForConversationHydration ?? waitForResumedConversationHydration;
+        const expectedConversationUrl = buildConversationUrl(runtime, resolveBrowserConfig(config ?? {}).url);
+        await waitForHydration(Runtime, timeoutMs, logger, {
+            requirePriorTurns: true,
+            requirePromptReady: false,
+            expectedConversationUrl: expectedConversationUrl ?? undefined,
+        });
         const minTurnIndex = (await readPromptPreviewTurnIndex(Runtime, deps.promptPreview)) ??
             (deps.promptPreview ? null : await readConversationTurnIndex(Runtime, logger));
         if (config?.researchMode === "deep") {
@@ -226,6 +233,12 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         }
         await waitForLocationChange(Runtime, 15_000);
     }
+    const waitForHydration = deps.waitForConversationHydration ?? waitForResumedConversationHydration;
+    await waitForHydration(Runtime, resolved.inputTimeoutMs, logger, {
+        requirePriorTurns: true,
+        requirePromptReady: false,
+        expectedConversationUrl: conversationUrl ?? undefined,
+    });
     const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
     const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
     const timeoutMs = resolved.timeoutMs ?? 120_000;

package/dist/src/browser/recoverConversation.js

@@ -67,7 +67,8 @@ export function isRecoveredConversationHarvestReady(harvested) {
         (typeof harvested.lastAssistantTurnIndex === "number" &&
             typeof harvested.lastUserTurnIndex === "number" &&
             harvested.lastAssistantTurnIndex > harvested.lastUserTurnIndex);
-    return (harvested.stopExists === true ||
+    const hasHydratedUserTurn = typeof harvested.lastUserTurnIndex === "number" && harvested.lastUserTurnIndex >= 0;
+    return ((harvested.stopExists === true && hasHydratedUserTurn) ||
         ((harvested.assistantCount ?? 0) > 0 &&
             assistantFollowsLatestUser &&
             latestAssistant.trim().length > 0 &&

package/dist/src/browser/sessionRunner.js

@@ -5,6 +5,7 @@ import { runBrowserMode } from "../browserMode.js";
 import { assembleBrowserPrompt } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
 const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
 const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
 function buildUnavailableModelSelectionEvidence(browserConfig) {
@@ -21,13 +22,6 @@ function buildUnavailableModelSelectionEvidence(browserConfig) {
         capturedAt: new Date().toISOString(),
     };
 }
-function formatModelSelectionEvidence(evidence) {
-    const requested = evidence.requestedModel ?? "(none)";
-    const resolved = evidence.resolvedLabel ?? "(unavailable)";
-    const strategy = evidence.strategy ?? "(default)";
-    const verified = evidence.verified ? "yes" : "no";
-    return `[browser] Model selection evidence: requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}.`;
-}
 function isRequestedProBrowserRun(runOptions, browserConfig, evidence) {
     const candidates = [
         runOptions.model,
@@ -87,7 +81,12 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (promptArtifacts.bundled) {
         log(chalk.dim(`Packed ${promptArtifacts.bundled.originalCount} files into 1 bundle (contents counted in token estimate).`));
     }
-    const headerLine = `Launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
+    const launchModel = formatBrowserModelTarget({
+        model: runOptions.model,
+        desiredModel: browserConfig.desiredModel,
+        modelStrategy: browserConfig.modelStrategy,
+    });
+    const headerLine = `Launching browser mode (${launchModel}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
     const automationLogger = ((message) => {
         if (typeof message !== "string")
             return;
@@ -150,7 +149,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     }
     const modelSelection = browserResult.modelSelection ?? buildUnavailableModelSelectionEvidence(browserConfig);
     if (modelSelection) {
-        log(formatModelSelectionEvidence(modelSelection));
+        log(`[browser] Model selection evidence: ${formatBrowserModelSelectionEvidence(modelSelection, runOptions.model)}`);
     }
     const warnings = buildBrowserRunWarnings({
         runOptions,
@@ -199,7 +198,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     })();
     const { line1, line2 } = formatFinishLine({
         elapsedMs: browserResult.tookMs,
-        model: `${runOptions.model}[browser]`,
+        model: `${resolveBrowserModelDisplayName({ model: runOptions.model, evidence: modelSelection })}[browser]`,
         tokensPart,
         detailParts: [
             runOptions.file && runOptions.file.length > 0 ? `files=${runOptions.file.length}` : null,

package/dist/src/browser/wslHost.js

@@ -0,0 +1,50 @@
+import { readFileSync } from "node:fs";
+import os from "node:os";
+export function isWsl() {
+    if (process.platform !== "linux")
+        return false;
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    return os.release().toLowerCase().includes("microsoft");
+}
+export function parseWslResolverHost(resolvConf) {
+    for (const line of resolvConf.split("\n")) {
+        const match = line.match(/^nameserver\s+([0-9.]+)/);
+        if (match?.[1]) {
+            return match[1].startsWith("127.") ? "127.0.0.1" : match[1];
+        }
+    }
+    return null;
+}
+export function resolveWslHost() {
+    if (!isWsl())
+        return null;
+    try {
+        return parseWslResolverHost(readFileSync("/etc/resolv.conf", "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveWslChromeHost(options = {}) {
+    const remoteDebugHost = options.remoteDebugHost === undefined
+        ? process.env.ORACLE_BROWSER_REMOTE_DEBUG_HOST
+        : options.remoteDebugHost;
+    const wslHostIp = options.wslHostIp === undefined ? process.env.WSL_HOST_IP : options.wslHostIp;
+    const override = remoteDebugHost?.trim() || wslHostIp?.trim();
+    if (override)
+        return override;
+    if (options.resolvConf !== undefined) {
+        return options.resolvConf === null ? null : parseWslResolverHost(options.resolvConf);
+    }
+    return resolveWslHost();
+}
+export function resolveWslChromeLaunchRoute(options = {}) {
+    const connectHost = resolveWslChromeHost(options);
+    const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
+    return {
+        connectHost,
+        debugBindAddress: usePatchedLauncher ? "0.0.0.0" : connectHost,
+        usePatchedLauncher,
+    };
+}