@steipete/oracle 0.17.0 → 0.17.2

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

@@ -31,7 +31,11 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
     const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
     const targetModelKind = inferThinkingTargetModelKind(desiredModel);
     const observedModelKind = result && "modelKind" in result ? result.modelKind : null;
-    const strictProEffort = (targetModelKind === "pro" || observedModelKind === "pro") && level === "extended";
+    // Pro is expensive and rate-limited, so a Pro request must never degrade quietly
+    // into a cheaper tier. Requesting it explicitly (level "pro") fails closed on its
+    // own, independently of the legacy Pro-model + "extended" combination.
+    const strictProEffort = level === "pro" ||
+        ((targetModelKind === "pro" || observedModelKind === "pro") && level === "extended");
     switch (result?.status) {
         case "already-selected":
             logger(formatBrowserThinkingLog(`${result.label ?? capitalizedLevel} (already selected)`));
@@ -53,16 +57,24 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
                     : "";
             const message = `Thinking time: ${result.status.replaceAll("-", " ")}${kindHint} (requested ${capitalizedLevel})`;
             if (strictProEffort) {
-                throw new Error(`${message}; refusing to submit without confirmed Pro Extended.`);
+                const target = level === "pro" ? "Pro" : "Pro Extended";
+                throw new Error(`${message}; refusing to submit without confirmed ${target}.`);
             }
-            logger(formatBrowserThinkingLog(`${message}; continuing with ChatGPT default.`));
+            // "selection-unverified" is the one status here that already dispatched a
+            // click, so the effort may or may not have moved. Every other status left
+            // the tab on whatever effort it had — which is not necessarily the default.
+            const outcome = result.status === "selection-unverified"
+                ? "the effort in ChatGPT is unconfirmed"
+                : "keeping the effort already selected in ChatGPT";
+            logger(formatBrowserThinkingLog(`${message}; ${outcome}.`));
             return;
         }
         default: {
             await logDomFailure(Runtime, logger, "thinking-time-unknown");
             logPickerDiagnostic(result, logger);
             if (strictProEffort) {
-                throw new Error(`Thinking time: unknown outcome selecting ${capitalizedLevel}; refusing to submit without confirmed Pro Extended.`);
+                const target = level === "pro" ? "Pro" : "Pro Extended";
+                throw new Error(`Thinking time: unknown outcome selecting ${capitalizedLevel}; refusing to submit without confirmed ${target}.`);
             }
             logger(formatBrowserThinkingLog(`unknown outcome selecting ${capitalizedLevel}; continuing with ChatGPT default.`));
             return;
@@ -72,7 +84,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', 'pro', or 'heavy'
  */
 export async function ensureThinkingTimeIfAvailable(Runtime, level, logger, desiredModel) {
     try {
@@ -135,14 +147,20 @@ 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];
+    // Pro is a tier you can request, but it is also a MODEL name, so it must never
+    // be used to decide whether a control or a menu is an effort owner: a model pill
+    // reading "Pro" would be claimed as the effort pill, and a model menu listing
+    // "Instant"/"Pro" would look like a tier list. Keep it to target matching only.
+    const TARGET_LEVEL_TOKENS = { ...LEVEL_TOKENS, pro: ['pro'] };
+    const targetTokens = TARGET_LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
 
     const INITIAL_WAIT_MS = 150;
     const STEP_WAIT_MS = 200;
@@ -155,19 +173,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 +217,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 +377,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,
@@ -356,7 +387,20 @@ function buildThinkingTimeExpression(level, desiredModel) {
       diagnostic: collectPickerDiagnostic(),
     });
     const findOptionInMenu = (menu, modelKindOverride = null) => {
-      const items = Array.from(menu.querySelectorAll(MENU_ITEM_SELECTOR));
+      // Container controls reveal other controls; they are not tiers you can pick.
+      // Two shapes exist and both can collide with a tier label: a submenu opener
+      // ("ModelGPT-5.6 Pro" would satisfy a Pro request) and a disclosure toggle
+      // (German "Erweitert" is literally one of the extended tokens, so the
+      // Advanced toggle would satisfy an extended request and be clicked in place
+      // of the tier). Detect them structurally rather than by label: a real tier row
+      // carries a checked state, while a container carries expansion state.
+      const isContainerControl = (node) =>
+        node?.getAttribute?.('aria-haspopup') === 'menu' ||
+        (node?.getAttribute?.('aria-expanded') !== null &&
+          node?.getAttribute?.('aria-checked') === null);
+      const items = Array.from(menu.querySelectorAll(MENU_ITEM_SELECTOR)).filter(
+        (item) => !isContainerControl(item),
+      );
       const modelKind = modelKindOverride || effectiveTargetModelKind();
       if (modelKind === 'pro') {
         // GPT-5.6's unified Intelligence picker exposes Pro as the highest
@@ -390,29 +434,19 @@ function buildThinkingTimeExpression(level, desiredModel) {
           return null;
         }
       }
-      if (
-        TARGET_IS_GPT56_MODEL &&
-        TARGET_LEVEL === 'heavy' &&
-        isIntelligenceEffortMenu(menu)
-      ) {
-        for (const item of items) {
-          const itemText = normalize(
-            (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
-          );
-          if (
-            hasToken(itemText, 'pro') &&
-            !itemText.includes('gpt') &&
-            !/(?:^|\\s)5[ .-]?6(?:\\s|$)/.test(itemText)
-          ) {
-            return item;
-          }
-        }
-      }
+      // 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') ?? ''),
         );
-        if (modelKind !== 'pro' && hasToken(itemText, 'pro')) {
+        // Pro rows are skipped for non-Pro targets so "High" never resolves to
+        // "Pro". Two things lift this: an explicit TARGET_LEVEL of 'pro', and a
+        // legacy Pro-model menu (modelKind === 'pro'), whose rows are all Pro
+        // variants so excluding them would leave nothing to match.
+        if (TARGET_LEVEL !== 'pro' && modelKind !== 'pro' && hasToken(itemText, 'pro')) {
           continue;
         }
         if (
@@ -422,10 +456,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') ?? '');
@@ -434,11 +468,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;
     };
@@ -449,16 +487,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');
@@ -493,10 +537,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;
     };
@@ -521,10 +565,10 @@ 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;
     };
@@ -534,13 +578,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
       const normalizedLabel = normalize(
         (button?.textContent ?? '') + ' ' + (button?.getAttribute?.('aria-label') ?? ''),
       );
-      if (
-        TARGET_IS_GPT56_MODEL &&
-        TARGET_LEVEL === 'heavy' &&
-        hasToken(normalizedLabel, 'pro')
-      ) {
-        return true;
-      }
+      // 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;
       }
@@ -553,14 +593,21 @@ function buildThinkingTimeExpression(level, desiredModel) {
         modelKindFromNode(trigger) ||
         effectiveTargetModelKind();
       const option = findOption();
-      if (
-        !option &&
-        TARGET_IS_GPT56_MODEL &&
-        TARGET_LEVEL === 'heavy' &&
-        currentEffortPillMatchesTarget(trigger, triggerModelKind)
-      ) {
-        closeOpenMenus();
-        return { status: 'already-selected', label: trigger.textContent?.trim?.() || null };
+      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;
@@ -629,6 +676,119 @@ function buildThinkingTimeExpression(level, desiredModel) {
       return null;
     };
 
+    // ---------- Unified Intelligence picker: Advanced -> Effort submenu ----------
+    // A newer ChatGPT layout replaces the flat effort rows with a "power" slider
+    // (simple view) plus an "Advanced" view holding two submenu openers: Model and
+    // Effort. The tier rows only exist inside the Effort submenu, so the flat scan
+    // of the top-level menu finds nothing and we must expand and descend.
+    const ADVANCED_VIEW_SELECTOR = '[data-testid="composer-model-picker-slider-advanced-view"]';
+    const SUBMENU_OPENER_SELECTOR = '[role="menuitem"][aria-haspopup="menu"]';
+    const nodeLabel = (node) =>
+      normalize((node?.getAttribute?.('aria-label') ?? '') + ' ' + (node?.textContent ?? ''));
+    // Row labels in this menu concatenate without separators ("EffortHigh"), so
+    // token matching cannot be used here — substring is deliberate, as in
+    // countEffortLevels above.
+    const ADVANCED_WORDS = ['advanced', 'erweitert', '高级', 'avanzado', 'avancado', 'avance'];
+    const EFFORT_WORDS = [
+      'effort', 'aufwand', '强度', '努力',
+      'esfuerzo', 'esforco', 'sforzo', 'inspanning', 'wysilek',
+    ];
+    const containsAny = (label, words) => words.some((word) => label.includes(word));
+    const findAdvancedToggle = (menu) => {
+      for (const item of (menu || document).querySelectorAll('[role="menuitem"]')) {
+        if (!isVisible(item)) continue;
+        if (containsAny(nodeLabel(item), ADVANCED_WORDS)) return item;
+      }
+      return null;
+    };
+    // Verify the shape rather than trusting the selector: a tier row must never be
+    // mistaken for the opener, or hovering it would silently change the effort.
+    const isSubmenuOpener = (node) =>
+      node?.getAttribute?.('aria-haspopup') === 'menu' &&
+      (node?.getAttribute?.('role') ?? '') === 'menuitem';
+    // The Effort opener's label is the word "Effort" plus the tier it currently sits
+    // on ("EffortHigh"). Positive identification only: the sibling Model opener has
+    // the identical shape and can read "ModelGPT-5.6 Pro", so guessing from tier
+    // words would pick it and then click model rows as if they were efforts. An
+    // unrecognised language yields no opener, and the caller fails instead of
+    // gambling on the wrong control.
+    const findEffortSubmenuOpener = (menu) => {
+      const scope = menu?.querySelector?.(ADVANCED_VIEW_SELECTOR) || menu || document;
+      for (const item of scope.querySelectorAll(SUBMENU_OPENER_SELECTOR)) {
+        if (!isVisible(item) || !isSubmenuOpener(item)) continue;
+        if (containsAny(nodeLabel(item), EFFORT_WORDS)) return item;
+      }
+      return null;
+    };
+    // countEffortLevels reads aggregate menu text, where one "Extra High" row scores
+    // twice (once as "high", once as "extra high"). Count distinct levels across
+    // distinct rows instead, so ">= 2" really means two selectable tiers.
+    const countDistinctTierRows = (menu) => {
+      if (!menu) return 0;
+      const matched = new Set();
+      for (const row of menu.querySelectorAll(MENU_ITEM_SELECTOR)) {
+        if (isSubmenuOpener(row)) continue;
+        const text = nodeLabel(row);
+        for (const [level, tokens] of Object.entries(LEVEL_TOKENS)) {
+          if (matchesTokens(text, tokens)) matched.add(level);
+        }
+      }
+      return matched.size;
+    };
+    const resolveSubmenuFor = (opener, parentMenu) => {
+      const id = opener?.getAttribute?.('aria-controls');
+      if (id) {
+        const node = document.getElementById?.(id);
+        if (isVisible(node) && countDistinctTierRows(node) >= 2) return node;
+      }
+      let best = null;
+      for (const menu of document.querySelectorAll(MENU_CONTAINER_SELECTOR)) {
+        if (menu === parentMenu || menu.contains?.(opener) || !isVisible(menu)) continue;
+        const hits = countDistinctTierRows(menu);
+        if (hits >= 2 && (!best || hits > best.hits)) best = { menu, hits };
+      }
+      return best?.menu ?? null;
+    };
+    const selectEffortFromAdvancedSubmenu = async (parentMenu, modelKindOverride = null) => {
+      if (!parentMenu) return null;
+      // React can mount the advanced view well after the click under load, so poll
+      // for the opener to the same deadline the submenu gets instead of assuming it
+      // rendered within one STEP_WAIT_MS. Re-expand if the toggle collapses again.
+      let opener = null;
+      const openerDeadline = performance.now() + MAX_WAIT_MS;
+      while (!opener && performance.now() < openerDeadline) {
+        const toggle = findAdvancedToggle(parentMenu);
+        if (toggle && toggle.getAttribute?.('aria-expanded') === 'false') {
+          dispatchClickSequence(toggle);
+          await sleep(STEP_WAIT_MS);
+        }
+        opener = findEffortSubmenuOpener(parentMenu);
+        if (opener) break;
+        await sleep(100);
+      }
+      if (!opener) return null;
+      dispatchHoverSequence(opener);
+      if (opener.getAttribute?.('aria-expanded') !== 'true') {
+        dispatchClickSequence(opener);
+      }
+      const deadline = performance.now() + MAX_WAIT_MS;
+      while (performance.now() < deadline) {
+        const submenu = resolveSubmenuFor(opener, parentMenu);
+        if (submenu) {
+          return selectAndVerify(
+            opener,
+            () => {
+              const current = resolveSubmenuFor(opener, parentMenu);
+              return current ? findOptionInMenu(current, modelKindOverride) : null;
+            },
+            modelKindOverride,
+          );
+        }
+        await sleep(100);
+      }
+      return null;
+    };
+
     // Current ChatGPT exposes a standalone Pro or Thinking composer pill whose
     // controlled menu contains the effort levels. Prefer this ownership boundary
     // before probing older model-picker layouts.
@@ -725,9 +885,26 @@ function buildThinkingTimeExpression(level, desiredModel) {
     }
     if (composerEffortPill) {
       if (attemptedModelButton && attemptedModelButton !== composerEffortPill) closeOpenMenus();
+      // In the unified Intelligence picker the composer pill shows the current
+      // EFFORT ("Pro", "High"), not the model. Reading a Pro *model* out of it would
+      // lift the Pro-row exclusion in findOptionInMenu and let a lower-tier request
+      // settle on Pro. Only a pill naming a tier and nothing else qualifies: legacy
+      // pills read "Pro Extended" (model + effort) and must keep naming their model,
+      // or a Pro Extended user asking for extended would be moved down to High.
+      const pillLabel = normalize(
+        (composerEffortPill.getAttribute?.('aria-label') ?? '') +
+          ' ' +
+          (composerEffortPill.textContent ?? ''),
+      );
+      const pillIsBareEffortTier = Object.values(TARGET_LEVEL_TOKENS).some((tokens) =>
+        tokens.some((token) => normalize(token) === pillLabel),
+      );
+      const pillNamesEffortNotModel =
+        TARGET_IS_GPT56_MODEL ||
+        (pillIsBareEffortTier && Boolean(document.querySelector(INTELLIGENCE_MENU_SELECTOR)));
       const composerModelKind =
         TARGET_MODEL_KIND ||
-        (TARGET_IS_GPT56_MODEL ? 'versioned' : modelKindFromNode(composerEffortPill));
+        (pillNamesEffortNotModel ? 'versioned' : modelKindFromNode(composerEffortPill));
       if (composerEffortPill.getAttribute?.('aria-expanded') !== 'true') {
         dispatchClickSequence(composerEffortPill);
         await sleep(INITIAL_WAIT_MS);
@@ -740,6 +917,14 @@ function buildThinkingTimeExpression(level, desiredModel) {
           if (proEffortResult) {
             return proEffortResult;
           }
+          // Flat rows win when present; only descend into Advanced -> Effort when
+          // this menu has no matching tier of its own (the slider layout).
+          if (!findOptionInMenu(menu, composerModelKind)) {
+            const advancedResult = await selectEffortFromAdvancedSubmenu(menu, composerModelKind);
+            if (advancedResult) {
+              return advancedResult;
+            }
+          }
           return selectAndVerify(
             composerEffortPill,
             () => {
@@ -857,7 +1042,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

@@ -542,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",
     ];

package/dist/src/cli/browserConfig.js

@@ -19,7 +19,7 @@ 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-pro", "GPT-5.5"],
     ["gpt-5.5-instant", "GPT-5.5 Instant"],
     ["gpt-5.5", "Thinking 5.5"],
     ["gpt-5.4-pro", "Pro"],
@@ -85,8 +85,11 @@ export async function buildBrowserConfig(options) {
     const normalizedOverride = desiredModelOverride?.toLowerCase() ?? "";
     const baseModel = options.model.toLowerCase();
     const isChatGptModel = baseModel.startsWith("gpt-") && !baseModel.includes("codex");
+    const normalizedBrowserModel = normalizeChatGptModelForBrowser(options.model);
     const shouldUseOverride = !isChatGptModel && normalizedOverride.length > 0 && normalizedOverride !== baseModel;
     const modelStrategy = normalizeBrowserModelStrategy(options.browserModelStrategy) ?? DEFAULT_MODEL_STRATEGY;
+    const thinkingTime = normalizeThinkingTimeLevel(options.browserThinkingTime) ??
+        (modelStrategy === "select" && normalizedBrowserModel === "gpt-5.5-pro" ? "pro" : undefined);
     assertBrowserModelAvailable(options.model, modelStrategy);
     const cookieNames = parseCookieNames(options.browserCookieNames ?? process.env.ORACLE_BROWSER_COOKIE_NAMES);
     let inline = await resolveInlineCookies({
@@ -175,7 +178,7 @@ export async function buildBrowserConfig(options) {
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
         browserTabRef: options.browserTab ?? undefined,
-        thinkingTime: normalizeThinkingTimeLevel(options.browserThinkingTime) ?? undefined,
+        thinkingTime,
         researchMode: options.browserResearch === "deep" ? "deep" : "off",
         archiveConversations: options.browserArchive,
     };

package/dist/src/cli/options.js

@@ -133,7 +133,7 @@ export function parseThinkingTimeOption(value) {
     if (normalized) {
         return normalized;
     }
-    throw new InvalidArgumentError('Thinking time must be one of "light", "standard", "extended", "heavy", or a ChatGPT UI alias like "instant", "medium", "high", or "extra-high".');
+    throw new InvalidArgumentError('Thinking time must be one of "light", "standard", "extended", "extra-high", "pro", "heavy", or a ChatGPT UI alias like "instant", "medium", "high", or "xhigh".');
 }
 export function normalizeModelOption(value) {
     return (value ?? "").trim();

package/dist/src/oracle/thinkingTime.js

@@ -1,10 +1,19 @@
-export const THINKING_TIME_LEVELS = ["light", "standard", "extended", "heavy"];
+export const THINKING_TIME_LEVELS = [
+    "light",
+    "standard",
+    "extended",
+    "extra-high",
+    // ChatGPT's unified Intelligence picker exposes Pro as the top effort tier of
+    // the active model rather than a separate model row, so it is a level here.
+    // Kept distinct from "heavy": requesting Pro must be deliberate.
+    "pro",
+    "heavy",
+];
 export const THINKING_TIME_ALIASES = [
     "instant",
     "low",
     "medium",
     "high",
-    "extra-high",
     "extra high",
     "extrahigh",
     "xhigh",
@@ -29,10 +38,13 @@ export function normalizeThinkingTimeLevel(value) {
         case "extended":
         case "high":
             return "extended";
-        case "heavy":
         case "extra-high":
         case "extrahigh":
         case "xhigh":
+            return "extra-high";
+        case "pro":
+            return "pro";
+        case "heavy":
             return "heavy";
         default:
             return null;