@steipete/oracle 0.11.1 → 0.12.1

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

@@ -1,6 +1,8 @@
 import { COMPOSER_MODEL_SIGNAL_SELECTOR, MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from "../constants.js";
 import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
+const LEGACY_PRO_VERSION_WORD_TOKENS = ["5 4", "5 2", "5 1", "5 0", "gpt 5 pro"];
+const LEGACY_PRO_VERSION_COMPACT_TOKENS = ["gpt54", "gpt52", "gpt51", "gpt50"];
 export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = "select") {
     const outcome = await Runtime.evaluate({
         expression: buildModelSelectionExpression(desiredModel, strategy),
@@ -17,7 +19,15 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
                 assertResolvedModelSelection(desiredModel, label);
             }
             logger(`Model picker: ${label}`);
-            return;
+            return {
+                requestedModel: desiredModel,
+                resolvedLabel: label,
+                strategy,
+                status: result.status,
+                verified: strategy !== "current",
+                source: "chatgpt-model-picker",
+                capturedAt: new Date().toISOString(),
+            };
         }
         case "option-not-found": {
             await logDomFailure(Runtime, logger, "model-switcher-option");
@@ -38,23 +48,35 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
 function assertResolvedModelSelection(desiredModel, resolvedLabel) {
     const desired = desiredModel.toLowerCase();
     const resolved = resolvedLabel.toLowerCase();
-    const wantsGpt55Pro = desired === "gpt-5.5-pro" ||
+    const wantsGpt55Pro = desired === "pro" ||
+        desired === "chatgpt pro" ||
+        desired === "gpt-5.5-pro" ||
         desired.includes("5.5 pro") ||
         desired.includes("5-5 pro") ||
         (desired.includes("pro") && desired.includes("extended"));
     if (!wantsGpt55Pro || !resolved) {
         return;
     }
-    const hasProSignal = resolved.includes(" pro") ||
-        resolved.endsWith("pro") ||
-        resolved.includes("pro ") ||
-        resolved.includes("extended") ||
-        resolved.includes("gpt-5.5-pro") ||
-        resolved.includes("gpt 5 5 pro");
-    if (!hasProSignal || (resolved.includes("thinking") && !resolved.includes("pro"))) {
+    if (!hasCurrentProSignal(resolved) ||
+        hasLegacyProVersionLabel(resolved) ||
+        resolved.includes("thinking")) {
         throw new Error(`Model picker selected "${resolvedLabel}" while "${desiredModel}" requires GPT-5.5 Pro. Use model "gpt-5.5" with browser thinking time for the Thinking variant.`);
     }
 }
+function normalizeResolvedModelLabel(value) {
+    return value
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function hasCurrentProSignal(resolved) {
+    return normalizeResolvedModelLabel(resolved).split(" ").includes("pro");
+}
+function hasLegacyProVersionLabel(resolved) {
+    const normalized = normalizeResolvedModelLabel(resolved);
+    return (LEGACY_PRO_VERSION_WORD_TOKENS.some((token) => normalized.includes(token)) ||
+        LEGACY_PRO_VERSION_COMPACT_TOKENS.some((token) => resolved.includes(token)));
+}
 export function assertResolvedModelSelectionForTest(desiredModel, resolvedLabel) {
     assertResolvedModelSelection(desiredModel, resolvedLabel);
 }
@@ -101,6 +123,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
         .replace(/\\s+/g, ' ')
         .trim();
     };
+    const hasToken = (value, token) => normalizeText(value).split(' ').includes(token);
     // Normalize every candidate token to keep fuzzy matching deterministic.
     const normalizedTarget = normalizeText(PRIMARY_LABEL);
     const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
@@ -121,8 +144,16 @@ function buildModelSelectionExpression(targetModel, strategy) {
     const wantsPro = normalizedTarget.includes(' pro') || normalizedTarget.endsWith(' pro') || normalizedTokens.includes('pro');
     const wantsInstant = normalizedTarget.includes('instant');
     const wantsThinking = normalizedTarget.includes('thinking');
+    const targetUsesCurrentGpt55Alias =
+      desiredVersion === '5-5' || normalizedTarget === 'pro' || normalizedTarget === 'chatgpt pro';
+    const labelHasProWord = (label) => label === 'pro' || label.startsWith('pro ') || label.includes(' pro ') || label.endsWith(' pro');
+    const legacyProVersionTokens = ['5 4', '5 2', '5 1', '5 0', 'gpt54', 'gpt52', 'gpt51', 'gpt50', 'gpt 5 pro'];
+    const labelHasLegacyProVersion = (value) => {
+      const label = normalizeText(value);
+      return legacyProVersionTokens.some((token) => label.includes(token));
+    };
     const isTargetGpt55VisibleAlias = (value) => {
-      if (desiredVersion !== '5-5') return false;
+      if (!targetUsesCurrentGpt55Alias) return false;
       const label = normalizeText(value);
       if (wantsPro) {
         // ChatGPT UI as of 2026-05: the picker shows just "Pro" (no longer "Pro Extended").
@@ -138,7 +169,17 @@ function buildModelSelectionExpression(targetModel, strategy) {
       return false;
     };
     const hasProComposerPill = () => Boolean(
-      document.querySelector('button.__composer-pill, button[aria-label="Pro, click to remove"]')
+      Array.from(document.querySelectorAll('button.__composer-pill, button[aria-label]'))
+        .filter((node) => {
+          const label = normalizeText(node.getAttribute?.('aria-label') ?? '');
+          return node.matches?.('button.__composer-pill') || label.includes('click to remove');
+        })
+        .some((node) => {
+          const label = normalizeText(
+            (node.getAttribute?.('aria-label') ?? '') + ' ' + (node.textContent ?? '')
+          );
+          return hasToken(label, 'pro') && !hasToken(label, 'thinking');
+        })
     );
 
     const button = document.querySelector(BUTTON_SELECTOR);
@@ -174,7 +215,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const resolved = label || '';
       if (!wantsPro || !hasProComposerPill()) return resolved;
       const normalized = normalizeText(resolved);
-      if (!normalized || normalized.includes('pro')) return resolved;
+      if (!normalized) return resolved;
+      if (normalized.includes('thinking')) return 'Pro';
+      if (normalized.includes('pro')) return resolved;
       return resolved + ' + Pro';
     };
     const getResolvedLabel = (fallback) =>
@@ -190,7 +233,15 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const normalizedLabel = normalizeText(getButtonLabel());
       if (!normalizedLabel) return false;
       if (isTargetGpt55VisibleAlias(normalizedLabel)) return true;
-      if (wantsPro && normalizedLabel === 'chatgpt' && hasProComposerPill()) {
+      if (
+        wantsPro &&
+        hasProComposerPill() &&
+        (normalizedLabel === 'chatgpt' ||
+          normalizedLabel === 'extended' ||
+          normalizedLabel === 'standard' ||
+          normalizedLabel === 'heavy' ||
+          normalizedLabel === 'light')
+      ) {
         return true;
       }
       if (desiredVersion) {
@@ -200,7 +251,8 @@ function buildModelSelectionExpression(targetModel, strategy) {
         if (desiredVersion === '5-1' && !normalizedLabel.includes('5 1')) return false;
         if (desiredVersion === '5-0' && !normalizedLabel.includes('5 0')) return false;
       }
-      if (wantsPro && !normalizedLabel.includes(' pro')) return false;
+      if (wantsPro && labelHasLegacyProVersion(normalizedLabel)) return false;
+      if (wantsPro && !labelHasProWord(normalizedLabel)) return false;
       if (wantsInstant && !normalizedLabel.includes('instant')) return false;
       if (wantsThinking && !normalizedLabel.includes('thinking')) return false;
       // Also reject if button has variants we DON'T want
@@ -218,6 +270,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       if (!signal) {
         return COMPOSER_SIGNAL_ALLOW_BLANK;
       }
+      if (wantsPro && labelHasLegacyProVersion(signal)) {
+        return false;
+      }
       if (COMPOSER_SIGNAL_EXCLUDES.some((token) => token && signal.includes(token))) {
         return false;
       }
@@ -356,15 +411,14 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const candidateGpt55VisibleAlias = isTargetGpt55VisibleAlias(normalizedText);
       const candidateHasThinking =
         normalizedText.includes('thinking') || normalizedTestId.includes('thinking');
+      const candidateHasLegacyProVersion = labelHasLegacyProVersion(normalizedText);
       const candidateHasPro =
         candidateGpt55VisibleAlias ||
-        normalizedText === 'pro' ||
-        normalizedText.startsWith('pro ') ||
-        normalizedText.includes(' pro ') ||
-        normalizedText.endsWith(' pro') ||
+        labelHasProWord(normalizedText) ||
         normalizedText.includes('proresearch') ||
         normalizedTestId.includes('pro');
       if (wantsPro && candidateHasThinking) return 0;
+      if (wantsPro && candidateHasLegacyProVersion) return 0;
       if (wantsPro && !candidateHasPro) return 0;
       if (wantsThinking && candidateHasPro) return 0;
       if (desiredVersion === '5-5' && normalizedText && !candidateGpt55VisibleAlias) {
@@ -407,10 +461,10 @@ function buildModelSelectionExpression(targetModel, strategy) {
       }
       // If the caller didn't explicitly ask for Pro, prefer non-Pro options when both exist.
       if (wantsPro) {
-        if (!normalizedText.includes(' pro')) {
+        if (!labelHasProWord(normalizedText)) {
           score -= 80;
         }
-      } else if (normalizedText.includes(' pro')) {
+      } else if (labelHasProWord(normalizedText)) {
         score -= 40;
       }
       // Similarly for Thinking variant

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

@@ -388,9 +388,8 @@ function buildLoginProbeExpression(timeoutMs) {
         if (!text) return false;
         const normalized = text.toLowerCase().trim();
         return (
-          ['log in', 'login', 'sign in', 'signin', 'continue with', 'sign up for free'].some(
-            (needle) => normalized.startsWith(needle),
-          ) ||
+          ['log in', 'login', 'sign in', 'signin', 'sign up for free'].includes(normalized) ||
+          normalized.startsWith('continue with') ||
           normalized.includes('get responses tailored to you') ||
           normalized.includes('log in to get answers')
         );
@@ -490,3 +489,6 @@ function normalizeLoginProbe(raw) {
         onAuthPage: Boolean(value.onAuthPage),
     };
 }
+export function buildLoginProbeExpressionForTest(timeoutMs = LOGIN_CHECK_TIMEOUT_MS) {
+    return buildLoginProbeExpression(timeoutMs);
+}

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

@@ -183,6 +183,7 @@ export async function submitPrompt(deps, prompt, logger) {
     else {
         logger("Clicked send button");
     }
+    await deps.onPromptSubmitted?.();
     const commitTimeoutMs = Math.max(60_000, deps.inputTimeoutMs ?? 0);
     // Learned: the send button can succeed but the turn doesn't appear immediately; verify commit via turns/stop button.
     return await verifyPromptCommitted(runtime, prompt, commitTimeoutMs, logger, deps.baselineTurns ?? undefined);
@@ -290,17 +291,35 @@ function buildAttachmentReadyExpression(attachmentNames) {
       document.querySelector('form') ||
       document.body ||
       document;
-    const labelText = (node) =>
-      [
-        node?.textContent,
-        node?.getAttribute?.('aria-label'),
-        node?.getAttribute?.('title'),
-        node?.getAttribute?.('data-testid'),
-      ]
-        .filter(Boolean)
-        .join(' ')
-        .toLowerCase();
-    const match = (node, name) => labelText(node).includes(name);
+    // Walk node + ancestors (up to grandparent) + descendants to gather every textual hint.
+    // ChatGPT's current chip DOM nests the filename inside truncated child spans, so checking
+    // only the node's own textContent/aria/title misses the match.
+    const collectLabelHaystack = (node) => {
+      if (!node) return '';
+      const pieces = [];
+      const pushAttrs = (el) => {
+        if (!el || typeof el.getAttribute !== 'function') return;
+        for (const attr of ['aria-label', 'title', 'data-testid', 'data-tooltip', 'data-tooltip-content']) {
+          const v = el.getAttribute(attr);
+          if (v) pieces.push(v);
+        }
+      };
+      const pushText = (el) => {
+        if (!el) return;
+        const text = (el.innerText ?? el.textContent ?? '').trim();
+        if (text) pieces.push(text);
+      };
+      pushAttrs(node);
+      pushText(node);
+      const parent = node.parentElement;
+      pushAttrs(parent);
+      pushText(parent);
+      const grandparent = parent?.parentElement;
+      pushAttrs(grandparent);
+      pushText(grandparent);
+      return pieces.join(' ').toLowerCase();
+    };
+    const match = (node, name) => collectLabelHaystack(node).includes(name);
 
     // Restrict to attachment affordances; never scan generic div/span nodes (prompt text can contain the file name).
     const attachmentSelectors = [
@@ -312,13 +331,32 @@ function buildAttachmentReadyExpression(attachmentNames) {
       'button[aria-label*="Remove file"]',
       '[aria-label*="remove file"]',
       'button[aria-label*="remove file"]',
+      '[aria-label*="Remove attachment"]',
+      'button[aria-label*="Remove attachment"]',
+      '[aria-label*="remove attachment"]',
+      'button[aria-label*="remove attachment"]',
     ];
-    const attachmentRoots = Array.from(new Set([composer, document])).filter(Boolean);
+    const attachmentRoots = Array.from(new Set([composer])).filter(Boolean);
+    const collectChipNodes = () => {
+      const seen = new Set();
+      const collected = [];
+      for (const root of attachmentRoots) {
+        for (const node of Array.from(root.querySelectorAll(attachmentSelectors.join(',')))) {
+          if (!(node instanceof HTMLElement)) continue;
+          // Skip elements clearly inside the editable input (composer textarea may contain
+          // filename text in the user's prompt — avoid mistaking that for a chip).
+          if (node.closest('textarea,[contenteditable="true"]')) continue;
+          if (seen.has(node)) continue;
+          seen.add(node);
+          collected.push(node);
+        }
+      }
+      return collected;
+    };
+    const chipNodes = collectChipNodes();
 
     const chipsReady = names.every((name) =>
-      attachmentRoots.some((root) =>
-        Array.from(root.querySelectorAll(attachmentSelectors.join(','))).some((node) => match(node, name)),
-      ),
+      chipNodes.some((node) => match(node, name)),
     );
     const inputsReady = names.every((name) =>
       attachmentRoots.some((root) =>
@@ -329,14 +367,28 @@ function buildAttachmentReadyExpression(attachmentNames) {
         ),
       ),
     );
+    // Count-based fallback: if we cannot match names individually (ChatGPT may strip
+    // the filename out of attribute-readable text into a deeply nested span), but we
+    // do see at least as many distinct chip-shaped nodes as attachments we uploaded,
+    // and a sibling "Remove" affordance exists per chip, trust the upload.
+    const removeAffordanceCount = chipNodes.filter((node) => {
+      const aria = (node.getAttribute?.('aria-label') ?? '').toLowerCase();
+      if (aria.includes('remove')) return true;
+      const removeSibling = node.querySelector?.(
+        '[aria-label*="Remove" i], [aria-label*="remove" i], button[aria-label*="Remove" i], button[aria-label*="remove" i]',
+      );
+      return Boolean(removeSibling);
+    }).length;
+    const countReady = chipNodes.length >= names.length && removeAffordanceCount >= names.length;
 
-    return chipsReady || inputsReady;
+    return chipsReady || inputsReady || countReady;
   })()`;
 }
 export function buildAttachmentReadyExpressionForTest(attachmentNames) {
     return buildAttachmentReadyExpression(attachmentNames);
 }
 async function attemptSendButton(Runtime, _logger, attachmentNames) {
+    const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
     const script = `(() => {
     ${buildClickDispatcher()}
     const selectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
@@ -369,9 +421,11 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
     dispatchClickSequence(button);
     return 'clicked';
   })()`;
-    const deadline = Date.now() + 20_000;
+    // Give attachment-bearing submissions more headroom. ChatGPT's chip render can
+    // settle slowly for multi-file uploads, but plain text sends should keep the
+    // shorter historical deadline.
+    const deadline = Date.now() + sendButtonTimeoutMs(attachmentNames);
     while (Date.now() < deadline) {
-        const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
         if (needAttachment) {
             const ready = await Runtime.evaluate({
                 expression: buildAttachmentReadyExpression(attachmentNames),
@@ -400,6 +454,9 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
     }
     return false;
 }
+function sendButtonTimeoutMs(attachmentNames) {
+    return Array.isArray(attachmentNames) && attachmentNames.length > 0 ? 45_000 : 20_000;
+}
 async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselineTurns) {
     const deadline = Date.now() + timeoutMs;
     const encodedPrompt = JSON.stringify(prompt.trim());
@@ -542,5 +599,6 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
 // biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
 export const __test__ = {
     attemptSendButton,
+    sendButtonTimeoutMs,
     verifyPromptCommitted,
 };

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

@@ -11,9 +11,11 @@ import { buildClickDispatcher } from "./domEvents.js";
  *
  * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
  */
-export async function ensureThinkingTime(Runtime, level, logger) {
-    const result = await evaluateThinkingTimeSelection(Runtime, level);
+export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
+    const result = await evaluateThinkingTimeSelection(Runtime, level, desiredModel);
     const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
+    const targetModelKind = inferThinkingTargetModelKind(desiredModel);
+    const strictProEffort = targetModelKind === "pro" && level === "extended";
     switch (result?.status) {
         case "already-selected":
             logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
@@ -23,13 +25,26 @@ export async function ensureThinkingTime(Runtime, level, logger) {
             return;
         case "chip-not-found":
         case "menu-not-found":
-        case "option-not-found": {
+        case "option-not-found":
+        case "model-kind-not-found": {
             await logDomFailure(Runtime, logger, `thinking-${result.status}`);
-            logger(`Thinking time: ${result.status.replaceAll("-", " ")} (requested ${capitalizedLevel}); continuing with ChatGPT default.`);
+            const kindHint = result.status === "model-kind-not-found" && result.modelKind
+                ? ` for ${result.modelKind}`
+                : targetModelKind
+                    ? ` for ${targetModelKind}`
+                    : "";
+            const message = `Thinking time: ${result.status.replaceAll("-", " ")}${kindHint} (requested ${capitalizedLevel})`;
+            if (strictProEffort) {
+                throw new Error(`${message}; refusing to submit without confirmed Pro Extended.`);
+            }
+            logger(`${message}; continuing with ChatGPT default.`);
             return;
         }
         default: {
             await logDomFailure(Runtime, logger, "thinking-time-unknown");
+            if (strictProEffort) {
+                throw new Error(`Thinking time: unknown outcome selecting ${capitalizedLevel}; refusing to submit without confirmed Pro Extended.`);
+            }
             logger(`Thinking time: unknown outcome selecting ${capitalizedLevel}; continuing with ChatGPT default.`);
             return;
         }
@@ -40,9 +55,9 @@ export async function ensureThinkingTime(Runtime, level, logger) {
  * 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'
  */
-export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
+export async function ensureThinkingTimeIfAvailable(Runtime, level, logger, desiredModel) {
     try {
-        const result = await evaluateThinkingTimeSelection(Runtime, level);
+        const result = await evaluateThinkingTimeSelection(Runtime, level, desiredModel);
         const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
         switch (result?.status) {
             case "already-selected":
@@ -54,6 +69,7 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
             case "chip-not-found":
             case "menu-not-found":
             case "option-not-found":
+            case "model-kind-not-found":
                 if (logger.verbose) {
                     logger(`Thinking time: ${result.status.replaceAll("-", " ")}; continuing with default.`);
                 }
@@ -74,19 +90,20 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
         return false;
     }
 }
-async function evaluateThinkingTimeSelection(Runtime, level) {
+async function evaluateThinkingTimeSelection(Runtime, level, desiredModel) {
     const outcome = await Runtime.evaluate({
-        expression: buildThinkingTimeExpression(level),
+        expression: buildThinkingTimeExpression(level, desiredModel),
         awaitPromise: true,
         returnByValue: true,
     });
     return outcome.result?.value;
 }
-function buildThinkingTimeExpression(level) {
+function buildThinkingTimeExpression(level, desiredModel) {
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
     const modelButtonLiteral = JSON.stringify(MODEL_BUTTON_SELECTOR);
     const targetLevelLiteral = JSON.stringify(level.toLowerCase());
+    const targetModelKindLiteral = JSON.stringify(inferThinkingTargetModelKind(desiredModel));
     return `(async () => {
     ${buildClickDispatcher()}
 
@@ -94,6 +111,7 @@ function buildThinkingTimeExpression(level) {
     const MENU_ITEM_SELECTOR = ${menuItemLiteral};
     const MODEL_BUTTON_SELECTOR = ${modelButtonLiteral};
     const TARGET_LEVEL = ${targetLevelLiteral};
+    const TARGET_MODEL_KIND = ${targetModelKindLiteral};
 
     // Bilingual matchers: English level token + observed Chinese variants.
     const LEVEL_TOKENS = {
@@ -119,6 +137,7 @@ function buildThinkingTimeExpression(level) {
       const t = normalize(text);
       return targetTokens.some((tok) => t.includes(String(tok).toLowerCase()));
     };
+    const hasToken = (text, token) => normalize(text).split(' ').includes(token);
     const optionIsSelected = (node) => {
       if (!(node instanceof HTMLElement)) return false;
       const ariaChecked = node.getAttribute('aria-checked');
@@ -207,28 +226,99 @@ function buildThinkingTimeExpression(level) {
 
     const findModelButton = () => document.querySelector(MODEL_BUTTON_SELECTOR);
     const findTrailingButtons = () => Array.from(document.querySelectorAll(TRAILING_SELECTOR));
+    const KIND_NOT_FOUND = { kindNotFound: true };
+    const findEffortRow = (node) => {
+      let current = node instanceof HTMLElement ? node.parentElement : null;
+      while (current && current !== document.body) {
+        if (current.getAttribute?.('data-model-picker-thinking-effort-row') === 'true') {
+          return current;
+        }
+        current = current.parentElement;
+      }
+      return null;
+    };
+    const rowIsSelected = (row) => {
+      if (!(row instanceof HTMLElement)) return false;
+      const modelItem = row.querySelector('[data-model-picker-thinking-effort-menu-item="true"], [role="menuitemradio"]');
+      if (optionIsSelected(modelItem)) return true;
+      return Boolean(
+        row.querySelector(
+          '[aria-checked="true"], [aria-selected="true"], [aria-current="true"], [data-selected="true"], [data-state="checked"], [data-state="selected"], [data-state="on"]',
+        ),
+      );
+    };
+    const rowForTrailing = (trailing) =>
+      trailing.closest('[role="menuitem"], [role="menuitemradio"], [data-radix-collection-item]');
+    const rowTextForTrailing = (trailing) => {
+      const row = rowForTrailing(trailing) || findEffortRow(trailing);
+      return normalize(
+        (row?.getAttribute?.('aria-label') ?? '') + ' ' +
+        (row?.getAttribute?.('data-testid') ?? '') + ' ' +
+        (row?.textContent ?? '') + ' ' +
+        (trailing.getAttribute?.('aria-label') ?? '') + ' ' +
+        (trailing.getAttribute?.('data-testid') ?? '')
+      );
+    };
+    const testIdTextForTrailing = (trailing) => {
+      const row = rowForTrailing(trailing) || findEffortRow(trailing);
+      return normalize(
+        (row?.getAttribute?.('data-testid') ?? '') + ' ' +
+        (trailing.getAttribute?.('data-testid') ?? '')
+      );
+    };
+    const modelKindFromTrailing = (trailing) => {
+      const idText = testIdTextForTrailing(trailing);
+      if (!idText.includes('model switcher')) return null;
+      const modelPart = normalize(idText.replace(/\\bthinking effort\\b.*$/, ''));
+      if (hasToken(modelPart, 'pro')) return 'pro';
+      if (hasToken(modelPart, 'thinking')) return 'thinking';
+      if (hasToken(modelPart, 'instant')) return 'instant';
+      return null;
+    };
+    const trailingMatchesTargetModelKind = (trailing) => {
+      if (!TARGET_MODEL_KIND) return false;
+      const idKind = modelKindFromTrailing(trailing);
+      if (idKind) return idKind === TARGET_MODEL_KIND;
+      const text = rowTextForTrailing(trailing);
+      if (TARGET_MODEL_KIND === 'pro') {
+        return hasToken(text, 'pro') && !hasToken(text, 'thinking');
+      }
+      if (TARGET_MODEL_KIND === 'thinking') {
+        return hasToken(text, 'thinking') && !hasToken(text, 'pro');
+      }
+      if (TARGET_MODEL_KIND === 'instant') {
+        return hasToken(text, 'instant') && !hasToken(text, 'thinking') && !hasToken(text, 'pro');
+      }
+      return false;
+    };
+    const hasStableBox = (node) => {
+      const r = node.getBoundingClientRect?.();
+      return Boolean(r && r.width > 0 && r.height > 0 && node.getAttribute?.('aria-hidden') !== 'true');
+    };
+    const pickSingleStableTrailing = (trailings) => {
+      const visible = trailings.filter((t) => hasStableBox(t));
+      return visible.length === 1 ? visible[0] : null;
+    };
     const pickTrailingForCurrentModel = () => {
       const trailings = findTrailingButtons();
       if (trailings.length === 0) return null;
       if (trailings.length === 1) return trailings[0];
       // Prefer the trailing button whose model row is currently selected.
       for (const t of trailings) {
-        const row = t.closest('[role="menuitem"], [role="menuitemradio"], [data-radix-collection-item]');
-        if (row && (optionIsSelected(row) || row.querySelector('[aria-checked="true"]'))) return t;
+        const row = findEffortRow(t);
+        if (rowIsSelected(row)) return t;
       }
-      // Fallback: first one with non-zero box.
-      for (const t of trailings) {
-        const r = t.getBoundingClientRect?.();
-        if (r && r.width > 0 && r.height > 0) return t;
+      if (TARGET_MODEL_KIND) {
+        const targetTrailings = trailings.filter((t) => trailingMatchesTargetModelKind(t));
+        return pickSingleStableTrailing(targetTrailings) || KIND_NOT_FOUND;
       }
-      return trailings[0];
+      return null;
     };
 
     const modelBtn = findModelButton();
     if (!modelBtn) {
       return { status: 'chip-not-found' };
     }
-
     // Open model menu (idempotent — leaves it open if already open).
     if (modelBtn.getAttribute('aria-expanded') !== 'true') {
       dispatchClickSequence(modelBtn);
@@ -246,6 +336,10 @@ function buildThinkingTimeExpression(level) {
       closeOpenMenus();
       return { status: 'chip-not-found' };
     }
+    if (trailing.kindNotFound) {
+      closeOpenMenus();
+      return { status: 'model-kind-not-found', modelKind: TARGET_MODEL_KIND };
+    }
 
     dispatchClickSequence(trailing);
     await sleep(STEP_WAIT_MS);
@@ -298,6 +392,26 @@ function buildThinkingTimeExpression(level) {
     return { status: already ? 'already-selected' : 'switched', label };
   })()`;
 }
-export function buildThinkingTimeExpressionForTest(level = "extended") {
-    return buildThinkingTimeExpression(level);
+export function buildThinkingTimeExpressionForTest(level = "extended", desiredModel) {
+    return buildThinkingTimeExpression(level, desiredModel);
+}
+function inferThinkingTargetModelKind(desiredModel) {
+    const normalized = (desiredModel ?? "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized)
+        return null;
+    const tokens = normalized.split(" ");
+    if (tokens.includes("pro"))
+        return "pro";
+    if (tokens.includes("thinking"))
+        return "thinking";
+    if (tokens.includes("instant"))
+        return "instant";
+    return null;
+}
+export function inferThinkingTargetModelKindForTest(desiredModel) {
+    return inferThinkingTargetModelKind(desiredModel);
 }

package/dist/src/browser/constants.js

@@ -1,5 +1,5 @@
 export const CHATGPT_URL = "https://chatgpt.com/";
-export const DEFAULT_MODEL_TARGET = "GPT-5.5 Pro";
+export const DEFAULT_MODEL_TARGET = "Pro";
 export const DEFAULT_MODEL_STRATEGY = "select";
 export const COOKIE_URLS = [
     "https://chatgpt.com",