@steipete/oracle 0.17.1 → 0.17.3

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

@@ -83,19 +83,78 @@ function matchesThinkingStatusLabel(trimmed) {
         return true;
     return trimmed.startsWith("pro thinking") && trimmed.length <= 40;
 }
+// Single source of truth for the "Answer now" placeholder test.
+//
+// This function is ALSO injected verbatim into page expressions via
+// buildAnswerNowPlaceholderPredicateJs (it is stringified with
+// Function.prototype.toString), so it MUST stay closure-free: no imports, no module
+// constants, no helpers. Anything it references must be declared inside its own body
+// or it will throw a ReferenceError inside the renderer.
+//
+// Learned the hard way: ChatGPT's Pro UI keeps the "Answer now" skip-ahead control
+// mounted for the whole reasoning phase, so a bare `text.includes('answer now')` test
+// matched real answers that merely ended with that chrome and discarded them wholesale
+// at every extraction layer. A placeholder is short UI furniture, so this matches the
+// WHOLE trimmed string against known chrome labels behind a length cap, the way the
+// sibling predicates in this file already do.
+//
+// The cap is 60, taken from isActiveLabel in ./thinkingStatus.ts rather than the 40 used
+// by matchesThinkingStatusLabel above: 40 bounds a single status label, while the longest
+// genuine placeholder here is the composite
+// "chatgpt said: file upload request pro thinking answer now" (57 chars), which a 40 cap
+// would wrongly let through.
 export function isAnswerNowPlaceholderText(value) {
-    const text = value.toLowerCase().replace(/\s+/g, " ").trim();
+    let raw = "";
+    if (typeof value === "string") {
+        raw = value;
+    }
+    else if (value && typeof value === "object" && "text" in value) {
+        const candidate = value.text;
+        if (typeof candidate === "string")
+            raw = candidate;
+    }
+    const text = raw.toLowerCase().replace(/\s+/g, " ").trim();
     if (!text)
         return false;
-    // Learned: "Pro thinking" shows a placeholder turn that contains "Answer now".
-    // That is not the final answer and must be ignored in browser automation.
     if (text === "chatgpt said:" || text === "chatgpt said")
         return true;
-    if (text.includes("file upload request") &&
-        (text.includes("pro thinking") || text.includes("chatgpt said"))) {
-        return true;
+    if (text.length > 60)
+        return false;
+    // Whole-string match: consume the text left to right, longest chrome label first.
+    // Any residue means real content is present, so this is an answer, not a placeholder.
+    const chromeLabels = [
+        "chatgpt said:",
+        "chatgpt said",
+        "file upload request",
+        "pro thinking",
+        "answer now",
+    ];
+    let rest = text;
+    let sawOwner = false; // "pro thinking" / "chatgpt said"
+    let sawGate = false; // "answer now" / "file upload request"
+    while (rest.length > 0) {
+        let matched = "";
+        for (const label of chromeLabels) {
+            if (label.length > matched.length && rest.startsWith(label))
+                matched = label;
+        }
+        if (!matched)
+            return false;
+        if (matched === "answer now" || matched === "file upload request")
+            sawGate = true;
+        else
+            sawOwner = true;
+        rest = rest.slice(matched.length).replace(/^[\s:.,;|\u00b7\u2022-]+/, "");
     }
-    return (text.includes("answer now") && (text.includes("pro thinking") || text.includes("chatgpt said")));
+    return sawGate && sawOwner;
+}
+// Exported: the two page expressions below and the tests all consume this one builder,
+// so the predicate cannot drift between the node side and the renderer.
+export function buildAnswerNowPlaceholderPredicateJs(fnName) {
+    // Inject the node-side definition itself so a correction can never land in only one
+    // copy. `const x = function name(){}` is a valid expression, so the exported
+    // declaration stringifies straight into the page expression.
+    return `const ${fnName} = ${isAnswerNowPlaceholderText.toString()};`;
 }
 function buildActiveThinkingStatusPredicateJs(fnName) {
     const labelsLiteral = JSON.stringify(THINKING_STATUS_LABELS);
@@ -288,6 +347,9 @@ export function buildAssistantExtractorForTest(name) {
 export function buildAssistantSnapshotExpressionForTest(minTurnIndex, expectedConversationId) {
     return buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId);
 }
+export function buildResponseObserverExpressionForTest(timeoutMs, minTurnIndex, expectedConversationId) {
+    return buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConversationId);
+}
 export function buildConversationDebugExpressionForTest() {
     return buildConversationDebugExpression();
 }
@@ -629,14 +691,7 @@ function buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId)
     // Learned: the default turn DOM misses project view; keep a fallback extractor.
     ${buildAssistantExtractor("extractAssistantTurn")}
     const extracted = extractAssistantTurn();
-    const isPlaceholder = (snapshot) => {
-      const normalized = String(snapshot?.text ?? '').toLowerCase().trim();
-      if (normalized === 'chatgpt said:' || normalized === 'chatgpt said') return true;
-      if (normalized.includes('file upload request') && (normalized.includes('pro thinking') || normalized.includes('chatgpt said'))) {
-        return true;
-      }
-      return normalized.includes('answer now') && (normalized.includes('pro thinking') || normalized.includes('chatgpt said'));
-    };
+    ${buildAnswerNowPlaceholderPredicateJs("isPlaceholder")}
     ${buildActiveThinkingStatusPredicateJs("isActiveThinkingStatus")}
     if (
       extracted &&
@@ -682,14 +737,7 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
       const currentId = currentConversationId();
       return !currentId || currentId === EXPECTED_CONVERSATION_ID;
     };
-    const isAnswerNowPlaceholder = (snapshot) => {
-      const normalized = String(snapshot?.text ?? '').toLowerCase().trim();
-      if (normalized === 'chatgpt said:' || normalized === 'chatgpt said') return true;
-      if (normalized.includes('file upload request') && (normalized.includes('pro thinking') || normalized.includes('chatgpt said'))) {
-        return true;
-      }
-      return normalized.includes('answer now') && (normalized.includes('pro thinking') || normalized.includes('chatgpt said'));
-    };
+    ${buildAnswerNowPlaceholderPredicateJs("isAnswerNowPlaceholder")}
     ${buildActiveThinkingStatusPredicateJs("isActiveThinkingStatus")}
     ${buildThinkingActivePredicateJs("isThinkingActiveNow")}
 

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

@@ -224,10 +224,24 @@ function buildModelSelectionExpression(targetModel, strategy) {
     );
 
     const isVisibleElement = (node) => {
+      if (typeof HTMLElement === 'undefined') return false;
       if (!(node instanceof HTMLElement)) return false;
-      const rect = node.getBoundingClientRect();
-      const style = window.getComputedStyle(node);
-      return rect.width > 0 && rect.height > 0 && style.display !== 'none' && style.visibility !== 'hidden';
+      try {
+        const rect = node.getBoundingClientRect?.();
+        const style = window.getComputedStyle?.(node);
+        if (!rect) return true;
+        return (
+          rect.width > 0 &&
+          rect.height > 0 &&
+          style?.display !== 'none' &&
+          style?.visibility !== 'hidden'
+        );
+      } catch {
+        // DOM test doubles and older Chromium nodes can omit one of these APIs.
+        // Treat them as visible; real hidden picker rows still report a zero rect
+        // or display:none and are filtered above.
+        return true;
+      }
     };
     const looksLikeModelPill = (node) => {
       if (!(node instanceof HTMLElement) || !node.matches('button.__composer-pill')) return false;
@@ -383,6 +397,103 @@ function buildModelSelectionExpression(targetModel, strategy) {
       }
       return true;
     };
+
+    // ---------- Unified Intelligence picker: Advanced -> Model submenu ----------
+    // The slider picker exposes only the current effort in the composer pill. Its
+    // model versions live behind Advanced -> Model, next to an identically-shaped
+    // Effort submenu. Identify the Model opener positively so a Pro effort label can
+    // never be mistaken for a model target.
+    const ADVANCED_VIEW_SELECTOR = '[data-testid="composer-model-picker-slider-advanced-view"]';
+    const INTELLIGENCE_PICKER_SELECTOR = '[data-testid="composer-intelligence-picker-content"]';
+    const SUBMENU_OPENER_SELECTOR = '[role="menuitem"][aria-haspopup="menu"]';
+    const ADVANCED_WORDS = ['advanced', 'erweitert', '高级', 'avanzado', 'avancado', 'avance'];
+    const MODEL_WORDS = ['model', 'modell', '模型', 'modelo', 'modello', 'modele'];
+    const EFFORT_WORDS = [
+      'effort', 'aufwand', '强度', '努力',
+      'esfuerzo', 'esforco', 'sforzo', 'inspanning', 'wysilek',
+    ];
+    const pickerNodeLabel = (node) => {
+      const value =
+        (node?.getAttribute?.('aria-label') ?? '') + ' ' + (node?.textContent ?? '');
+      try {
+        return value
+          .toLowerCase()
+          .normalize('NFD')
+          .replace(/[\u0300-\u036f]/g, '')
+          .replace(/\\s+/g, ' ')
+          .trim();
+      } catch {
+        return value.toLowerCase().replace(/\\s+/g, ' ').trim();
+      }
+    };
+    const containsPickerWord = (label, words) =>
+      words.some((word) => label.includes(word));
+    const isSubmenuOpener = (node) =>
+      node?.getAttribute?.('role') === 'menuitem' &&
+      node?.getAttribute?.('aria-haspopup') === 'menu';
+    const isUnifiedPickerMenu = (menu) =>
+      Boolean(
+        menu?.getAttribute?.('data-testid') === 'composer-intelligence-picker-content' ||
+          menu?.querySelector?.(INTELLIGENCE_PICKER_SELECTOR) ||
+          menu?.querySelector?.(ADVANCED_VIEW_SELECTOR),
+      );
+    const findUnifiedPickerMenu = () =>
+      Array.from(document.querySelectorAll(${menuContainerLiteral})).find(isUnifiedPickerMenu) ??
+      null;
+    const findAdvancedToggle = (menu) => {
+      for (const item of (menu || document).querySelectorAll('[role="menuitem"]')) {
+        if (!isVisibleElement(item)) continue;
+        if (containsPickerWord(pickerNodeLabel(item), ADVANCED_WORDS)) return item;
+      }
+      return null;
+    };
+    const findModelSubmenuOpener = (menu) => {
+      const scope = menu?.querySelector?.(ADVANCED_VIEW_SELECTOR) || menu || document;
+      for (const item of scope.querySelectorAll(SUBMENU_OPENER_SELECTOR)) {
+        if (!isVisibleElement(item) || !isSubmenuOpener(item)) continue;
+        const label = pickerNodeLabel(item);
+        if (
+          containsPickerWord(label, MODEL_WORDS) &&
+          !containsPickerWord(label, EFFORT_WORDS)
+        ) {
+          return item;
+        }
+      }
+      return null;
+    };
+    const advancedModelSignalMatchesTarget = (menu = null) => {
+      const parentMenu = menu || findUnifiedPickerMenu();
+      const opener = findModelSubmenuOpener(parentMenu);
+      if (!opener) return false;
+      const label = normalizeText(pickerNodeLabel(opener));
+      const version = versionFromLabel(label);
+      if (desiredVersion && version !== desiredVersion) return false;
+      if (desiredModelVariant && !label.split(' ').includes(desiredModelVariant)) return false;
+      if (wantsPro) return labelHasProWord(label) && !labelHasLegacyProVersion(label);
+      if (wantsInstant) return label.includes('instant');
+      if (wantsThinking) return Boolean(desiredVersion) && !labelHasProWord(label);
+      if (desiredVersion) return true;
+      return normalizedTokens.some((token) => token && label.includes(token));
+    };
+    const getAdvancedModelLabel = () => {
+      const opener = findModelSubmenuOpener(findUnifiedPickerMenu());
+      if (!opener) return '';
+      const raw = (opener.textContent ?? '').trim();
+      const normalized = normalizeText(pickerNodeLabel(opener));
+      const version = versionFromLabel(normalized);
+      if (!version) return raw;
+      const [major, minor] = version.split('-');
+      const suffix = normalized.split(' ').includes('sol') ? ' Sol' : '';
+      return 'GPT-' + major + '.' + minor + suffix;
+    };
+    const isLegacyFlatIntelligencePickerOpen = () => {
+      const menu = findUnifiedPickerMenu();
+      return Boolean(
+        menu &&
+          !menu.querySelector?.(ADVANCED_VIEW_SELECTOR) &&
+          !findAdvancedToggle(menu),
+      );
+    };
     const getResolvedLabel = (observedOptionLabel = '') => {
       if (configuredSelectionMatchesTarget()) {
         const variant = getConfiguredVariantLabel();
@@ -390,6 +501,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
         if (desiredModelVariant === 'sol' && labelHasProWord(normalizeText(variant))) return version;
         return [variant, version].filter(Boolean).join(' ');
       }
+      if (advancedModelSignalMatchesTarget()) {
+        return getAdvancedModelLabel();
+      }
       const composerLabel = getComposerModelLabel();
       const normalizedComposerLabel = normalizeText(composerLabel);
       if (
@@ -448,8 +562,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
         desiredVersion === '5-5' &&
         !hasProComposerPill() &&
         isThinkingEffortLabel(normalizedLabel) &&
-        (isNonProIntelligenceThinkingLabel(normalizedLabel) ||
-          isTargetGpt55VisibleAlias(readComposerModelSignal()))
+        (isTargetGpt55VisibleAlias(readComposerModelSignal()) ||
+          (isNonProIntelligenceThinkingLabel(normalizedLabel) &&
+            isLegacyFlatIntelligencePickerOpen()))
       ) {
         return true;
       }
@@ -521,6 +636,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       return COMPOSER_SIGNAL_INCLUDES.some((token) => token && signal.includes(token));
     };
     const activeSelectionMatchesTarget = () => {
+      if (advancedModelSignalMatchesTarget()) {
+        return true;
+      }
       if (buttonMatchesTarget()) {
         return true;
       }
@@ -952,6 +1070,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       for (const menu of menus) {
         const buttons = Array.from(menu.querySelectorAll(${menuItemLiteral}));
         for (const option of buttons) {
+          if (!isVisibleElement(option)) {
+            continue;
+          }
           if (isNestedEffortControl(option, menu)) {
             continue;
           }
@@ -1038,6 +1159,33 @@ function buildModelSelectionExpression(targetModel, strategy) {
       dispatchHoverSequence(node);
       dispatchClickSequence(node);
     };
+    const descendIntoAdvancedModelPicker = () => {
+      const parentMenu = findUnifiedPickerMenu();
+      if (!parentMenu) return 'unavailable';
+
+      const opener = findModelSubmenuOpener(parentMenu);
+      if (opener) {
+        if (advancedModelSignalMatchesTarget(parentMenu)) {
+          return 'already-selected';
+        }
+        const key = submenuKey(
+          normalizeText(opener.textContent ?? ''),
+          opener.getAttribute?.('data-testid') ?? '',
+        );
+        openedSubmenuKeys.add(key);
+        if (opener.getAttribute?.('aria-expanded') !== 'true') {
+          openSubmenuOption(opener);
+        }
+        return 'opened';
+      }
+
+      const advancedToggle = findAdvancedToggle(parentMenu);
+      if (!advancedToggle) return 'unavailable';
+      if (advancedToggle.getAttribute?.('aria-expanded') !== 'true') {
+        dispatchClickSequence(advancedToggle);
+      }
+      return 'expanded';
+    };
 
     return new Promise((resolve) => {
       const start = performance.now();
@@ -1124,6 +1272,17 @@ function buildModelSelectionExpression(targetModel, strategy) {
           });
           return;
         }
+        const advancedState = descendIntoAdvancedModelPicker();
+        if (advancedState === 'already-selected') {
+          const resolvedLabel = getResolvedLabel();
+          closeMenu();
+          resolve({ status: 'already-selected', label: resolvedLabel });
+          return;
+        }
+        if (advancedState === 'expanded' || advancedState === 'opened') {
+          setTimeout(attempt, REOPEN_INTERVAL_MS / 2);
+          return;
+        }
         if (performance.now() - start > MAX_WAIT_MS) {
           resolve({
             status: 'option-not-found',

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,18 +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}.`);
             }
-            // 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.`));
+            // "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;
@@ -74,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', 'extra-high', 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 {
@@ -137,15 +147,20 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
     const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
 
-    // Multilingual matchers: English level token + observed German/Chinese variants.
+    // Multilingual matchers: English level token + observed German/Japanese/Chinese variants.
     const LEVEL_TOKENS = {
-      light: ['light', 'instant', 'sofort', 'leicht', '轻', '极速'],
-      standard: ['standard', 'medium', 'mittel', '标准', '中'],
-      extended: ['extended', 'high', 'hoch', 'erweitert', '扩展', '深度', '加强', '高'],
-      'extra-high': ['extra high', 'sehr hoch', '极高'],
+      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;
@@ -156,7 +171,8 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const INTELLIGENCE_WAIT_MS = 2500;
 
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-    // Keep CJK characters so we can match Chinese labels against LEVEL_TOKENS.
+    // Keep CJK characters, including Japanese kana, so localized labels survive
+    // normalization before being matched against LEVEL_TOKENS and picker controls.
     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).
@@ -166,7 +182,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
       .replace(/ö/g, 'o')
       .replace(/ü/g, 'u')
       .replace(/ß/g, 'ss')
-      .replace(/[^a-z0-9\\u4e00-\\u9fa5]+/g, ' ')
+      .replace(/[^a-z0-9\\u3040-\\u30ff\\u4e00-\\u9fff]+/g, ' ')
       .replace(/\\s+/g, ' ')
       .trim();
     const hasToken = (text, token) => normalize(text).split(' ').includes(token);
@@ -195,6 +211,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
         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 === '高い' || token === '非常に高い') {
+          return t === token || hasToken(t, token);
+        }
         if (token === '极速') {
           const suffix = t.slice(token.length);
           return t === token || hasToken(t, token) || /^[0-9]/.test(suffix);
@@ -372,7 +391,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
@@ -414,7 +446,11 @@ function buildThinkingTimeExpression(level, desiredModel) {
         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 (
@@ -644,6 +680,122 @@ 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.
@@ -740,9 +892,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);
@@ -755,6 +924,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,
             () => {