@steipete/oracle 0.7.3 → 0.7.5

package/README.md

@@ -64,6 +64,12 @@ Engine auto-picks API when `OPENAI_API_KEY` is set, otherwise browser; browser i
   ```
 - Tip: set `browser.chatgptUrl` in config (or `--chatgpt-url`) to a dedicated ChatGPT project folder so browser runs don’t clutter your main history.
 
+**Codex skill**
+- Copy the bundled skill from this repo to your Codex skills folder:
+  - `mkdir -p ~/.codex/skills`
+  - `cp -R skills/oracle ~/.codex/skills/oracle`
+- Then reference it in your `AGENTS.md`/`CLAUDE.md` so Codex loads it.
+
 **MCP**
 - Run the stdio server via `oracle-mcp`.
 - Configure clients via [steipete/mcporter](https://github.com/steipete/mcporter) or `.mcp.json`; see [docs/mcp.md](docs/mcp.md) for connection examples.

package/dist/bin/oracle-cli.js

@@ -174,7 +174,9 @@ program
     .addOption(new Option('--browser-headless', 'Launch Chrome in headless mode.').hideHelp())
     .addOption(new Option('--browser-hide-window', 'Hide the Chrome window after launch (macOS headful only).').hideHelp())
     .addOption(new Option('--browser-keep-browser', 'Keep Chrome running after completion.').hideHelp())
-    .addOption(new Option('--browser-extended-thinking', 'Select Extended thinking time for GPT-5.2 Thinking model.').hideHelp())
+    .addOption(new Option('--browser-thinking-time <level>', 'Thinking time intensity for Thinking/Pro models: light, standard, extended, heavy.')
+    .choices(['light', 'standard', 'extended', 'heavy'])
+    .hideHelp())
     .addOption(new Option('--browser-allow-cookie-errors', 'Continue even if Chrome cookies cannot be copied.').hideHelp())
     .addOption(new Option('--browser-attachments <mode>', 'How to deliver --file inputs in browser mode: auto (default) pastes inline up to ~60k chars then uploads; never always paste inline; always always upload.')
     .choices(['auto', 'never', 'always'])

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

@@ -177,12 +177,15 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         }
         await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [attachment.path] });
         await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
-        const probeDeadline = Date.now() + 4000;
+        await delay(350);
+        const probeDeadline = Date.now() + 6500;
+        const pokeIntervalMs = 1200;
         let lastPoke = 0;
+        let seenInputHasFile = false;
         while (Date.now() < probeDeadline) {
             // ChatGPT's composer can take a moment to hydrate the file-input onChange handler after navigation/model switches.
             // If the UI hasn't reacted yet, poke the input a few times to ensure the handler fires once it's mounted.
-            if (Date.now() - lastPoke > 650) {
+            if (!seenInputHasFile && Date.now() - lastPoke > pokeIntervalMs) {
                 lastPoke = Date.now();
                 await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
             }
@@ -198,6 +201,7 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
                     composerText: typeof snapshot.composerText === 'string' ? snapshot.composerText : '',
                 };
                 const inputHasFile = finalSnapshot.inputNames.some((name) => name.toLowerCase().includes(expectedName.toLowerCase()));
+                seenInputHasFile = seenInputHasFile || inputHasFile;
                 const expectedLower = expectedName.toLowerCase();
                 const expectedNoExt = expectedLower.replace(/\.[a-z0-9]{1,10}$/i, '');
                 const uiAcknowledged = finalSnapshot.chipCount > baselineChipCount ||
@@ -209,7 +213,7 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
                     break;
                 }
             }
-            await delay(200);
+            await delay(250);
         }
         const inputHasFile = finalSnapshot?.inputNames?.some((name) => name.toLowerCase().includes(expectedName.toLowerCase())) ?? false;
         const uiAcknowledged = (finalSnapshot?.chipCount ?? 0) > baselineChipCount;

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

@@ -97,6 +97,10 @@ function buildModelSelectionExpression(targetModel) {
       if (wantsPro && !normalizedLabel.includes(' pro')) 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
+      if (!wantsPro && normalizedLabel.includes(' pro')) return false;
+      if (!wantsInstant && normalizedLabel.includes('instant')) return false;
+      if (!wantsThinking && normalizedLabel.includes('thinking')) return false;
       return true;
     };
 
@@ -172,14 +176,21 @@ function buildModelSelectionExpression(targetModel) {
             return 0;
           }
         }
-        const matches = TEST_IDS.filter((id) => id && normalizedTestId.includes(id));
-        if (matches.length > 0) {
-          // Prefer the most specific match (longest token) instead of treating any hit as equal.
-          // This prevents generic tokens (e.g. "pro") from outweighing version-specific targets.
-          const best = matches.reduce((acc, token) => (token.length > acc.length ? token : acc), '');
-          score += 200 + Math.min(900, best.length * 25);
-          if (best.startsWith('model-switcher-')) score += 120;
-          if (best.includes('gpt-')) score += 60;
+        // Exact testid matches take priority over substring matches
+        const exactMatch = TEST_IDS.find((id) => id && normalizedTestId === id);
+        if (exactMatch) {
+          score += 1500;
+          if (exactMatch.startsWith('model-switcher-')) score += 200;
+        } else {
+          const matches = TEST_IDS.filter((id) => id && normalizedTestId.includes(id));
+          if (matches.length > 0) {
+            // Prefer the most specific match (longest token) instead of treating any hit as equal.
+            // This prevents generic tokens (e.g. "pro") from outweighing version-specific targets.
+            const best = matches.reduce((acc, token) => (token.length > acc.length ? token : acc), '');
+            score += 200 + Math.min(900, best.length * 25);
+            if (best.startsWith('model-switcher-')) score += 120;
+            if (best.includes('gpt-')) score += 60;
+          }
         }
       }
       if (normalizedText && normalizedTarget) {
@@ -215,6 +226,22 @@ function buildModelSelectionExpression(targetModel) {
       } else if (normalizedText.includes(' pro')) {
         score -= 40;
       }
+      // Similarly for Thinking variant
+      if (wantsThinking) {
+        if (!normalizedText.includes('thinking') && !normalizedTestId.includes('thinking')) {
+          score -= 80;
+        }
+      } else if (normalizedText.includes('thinking') || normalizedTestId.includes('thinking')) {
+        score -= 40;
+      }
+      // Similarly for Instant variant
+      if (wantsInstant) {
+        if (!normalizedText.includes('instant') && !normalizedTestId.includes('instant')) {
+          score -= 80;
+        }
+      } else if (normalizedText.includes('instant') || normalizedTestId.includes('instant')) {
+        score -= 40;
+      }
       return Math.max(score, 0);
     };
 
@@ -377,10 +404,24 @@ function buildModelMatchersLiteral(targetModel) {
         push('gpt5-2', labelTokens);
         push('gpt52', labelTokens);
         push('chatgpt 5.2', labelTokens);
-        if (base.includes('thinking'))
+        // Thinking variant: explicit testid for "Thinking" picker option
+        if (base.includes('thinking')) {
             push('thinking', labelTokens);
-        if (base.includes('instant'))
+            testIdTokens.add('model-switcher-gpt-5-2-thinking');
+            testIdTokens.add('gpt-5-2-thinking');
+            testIdTokens.add('gpt-5.2-thinking');
+        }
+        // Instant variant: explicit testid for "Instant" picker option
+        if (base.includes('instant')) {
             push('instant', labelTokens);
+            testIdTokens.add('model-switcher-gpt-5-2-instant');
+            testIdTokens.add('gpt-5-2-instant');
+            testIdTokens.add('gpt-5.2-instant');
+        }
+        // Base 5.2 testids (for "Auto" mode when no suffix specified)
+        if (!base.includes('thinking') && !base.includes('instant') && !base.includes('pro')) {
+            testIdTokens.add('model-switcher-gpt-5-2');
+        }
         testIdTokens.add('gpt-5-2');
         testIdTokens.add('gpt5-2');
         testIdTokens.add('gpt52');

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

@@ -1,14 +1,19 @@
 import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR } from '../constants.js';
 import { logDomFailure } from '../domDebug.js';
 import { buildClickDispatcher } from './domEvents.js';
-export async function ensureExtendedThinking(Runtime, logger) {
-    const result = await evaluateThinkingTimeSelection(Runtime);
+/**
+ * Selects a specific thinking time level in ChatGPT's composer pill menu.
+ * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
+ */
+export async function ensureThinkingTime(Runtime, level, logger) {
+    const result = await evaluateThinkingTimeSelection(Runtime, level);
+    const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
     switch (result?.status) {
-        case 'already-extended':
-            logger(`Thinking time: ${result.label ?? 'Extended'} (already selected)`);
+        case 'already-selected':
+            logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
             return;
         case 'switched':
-            logger(`Thinking time: ${result.label ?? 'Extended'}`);
+            logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
             return;
         case 'chip-not-found': {
             await logDomFailure(Runtime, logger, 'thinking-chip');
@@ -18,33 +23,35 @@ export async function ensureExtendedThinking(Runtime, logger) {
             await logDomFailure(Runtime, logger, 'thinking-time-menu');
             throw new Error('Unable to find the Thinking time dropdown menu.');
         }
-        case 'extended-not-found': {
-            await logDomFailure(Runtime, logger, 'extended-option');
-            throw new Error('Unable to find the Extended option in the Thinking time menu.');
+        case 'option-not-found': {
+            await logDomFailure(Runtime, logger, `${level}-option`);
+            throw new Error(`Unable to find the ${capitalizedLevel} option in the Thinking time menu.`);
         }
         default: {
             await logDomFailure(Runtime, logger, 'thinking-time-unknown');
-            throw new Error('Unknown error selecting Extended thinking time.');
+            throw new Error(`Unknown error selecting ${capitalizedLevel} thinking time.`);
         }
     }
 }
 /**
- * Best-effort selection of the "Extended" thinking-time option in ChatGPT's composer pill menu.
+ * 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'
  */
-export async function ensureExtendedThinkingIfAvailable(Runtime, logger) {
+export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
     try {
-        const result = await evaluateThinkingTimeSelection(Runtime);
+        const result = await evaluateThinkingTimeSelection(Runtime, level);
+        const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
         switch (result?.status) {
-            case 'already-extended':
-                logger(`Thinking time: ${result.label ?? 'Extended'} (already selected)`);
+            case 'already-selected':
+                logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
                 return true;
             case 'switched':
-                logger(`Thinking time: ${result.label ?? 'Extended'}`);
+                logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
                 return true;
             case 'chip-not-found':
             case 'menu-not-found':
-            case 'extended-not-found':
+            case 'option-not-found':
                 if (logger.verbose) {
                     logger(`Thinking time: ${result.status.replaceAll('-', ' ')}; continuing with default.`);
                 }
@@ -65,22 +72,24 @@ export async function ensureExtendedThinkingIfAvailable(Runtime, logger) {
         return false;
     }
 }
-async function evaluateThinkingTimeSelection(Runtime) {
+async function evaluateThinkingTimeSelection(Runtime, level) {
     const outcome = await Runtime.evaluate({
-        expression: buildThinkingTimeExpression(),
+        expression: buildThinkingTimeExpression(level),
         awaitPromise: true,
         returnByValue: true,
     });
     return outcome.result?.value;
 }
-function buildThinkingTimeExpression() {
+function buildThinkingTimeExpression(level) {
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    const targetLevelLiteral = JSON.stringify(level.toLowerCase());
     return `(async () => {
     ${buildClickDispatcher()}
 
     const MENU_CONTAINER_SELECTOR = ${menuContainerLiteral};
     const MENU_ITEM_SELECTOR = ${menuItemLiteral};
+    const TARGET_LEVEL = ${targetLevelLiteral};
 
     const CHIP_SELECTORS = [
       '[data-testid="composer-footer-actions"] button[aria-haspopup="menu"]',
@@ -136,11 +145,11 @@ function buildThinkingTimeExpression() {
         return null;
       };
 
-      const findExtendedOption = (menu) => {
+      const findTargetOption = (menu) => {
         const items = menu.querySelectorAll(MENU_ITEM_SELECTOR);
         for (const item of items) {
           const text = normalize(item.textContent ?? '');
-          if (text.includes('extended')) {
+          if (text.includes(TARGET_LEVEL)) {
             return item;
           }
         }
@@ -167,24 +176,24 @@ function buildThinkingTimeExpression() {
           return;
         }
 
-        const extendedOption = findExtendedOption(menu);
-        if (!extendedOption) {
-          resolve({ status: 'extended-not-found' });
+        const targetOption = findTargetOption(menu);
+        if (!targetOption) {
+          resolve({ status: 'option-not-found' });
           return;
         }
 
         const alreadySelected =
-          optionIsSelected(extendedOption) ||
-          optionIsSelected(extendedOption.querySelector?.('[aria-checked="true"], [data-state="checked"], [data-state="selected"]'));
-        const label = extendedOption.textContent?.trim?.() || null;
-        dispatchClickSequence(extendedOption);
-        resolve({ status: alreadySelected ? 'already-extended' : 'switched', label });
+          optionIsSelected(targetOption) ||
+          optionIsSelected(targetOption.querySelector?.('[aria-checked="true"], [data-state="checked"], [data-state="selected"]'));
+        const label = targetOption.textContent?.trim?.() || null;
+        dispatchClickSequence(targetOption);
+        resolve({ status: alreadySelected ? 'already-selected' : 'switched', label });
       };
 
       setTimeout(attempt, INITIAL_WAIT_MS);
     });
   })()`;
 }
-export function buildThinkingTimeExpressionForTest() {
-    return buildThinkingTimeExpression();
+export function buildThinkingTimeExpressionForTest(level = 'extended') {
+    return buildThinkingTimeExpression(level);
 }

package/dist/src/browser/config.js

@@ -24,7 +24,6 @@ export const DEFAULT_BROWSER_CONFIG = {
     remoteChrome: null,
     manualLogin: false,
     manualLoginProfileDir: null,
-    extendedThinking: false,
 };
 export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
@@ -64,6 +63,7 @@ export function resolveBrowserConfig(config) {
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,
         debug: config?.debug ?? DEFAULT_BROWSER_CONFIG.debug,
         allowCookieErrors: config?.allowCookieErrors ?? envAllowCookieErrors ?? DEFAULT_BROWSER_CONFIG.allowCookieErrors,
+        thinkingTime: config?.thinkingTime,
         manualLogin,
         manualLoginProfileDir: manualLogin ? resolvedProfileDir : null,
     };

package/dist/src/browser/index.js

@@ -7,7 +7,7 @@ import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChro
 import { syncCookies } from './cookies.js';
 import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
-import { ensureExtendedThinking } from './actions/thinkingTime.js';
+import { ensureThinkingTime } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL } from './constants.js';
@@ -266,13 +266,15 @@ export async function runBrowserMode(options) {
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        if (config.extendedThinking) {
-            await raceWithDisconnect(withRetries(() => ensureExtendedThinking(Runtime, logger), {
+        // Handle thinking time selection if specified
+        const thinkingTime = config.thinkingTime;
+        if (thinkingTime) {
+            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             }));
@@ -286,6 +288,7 @@ export async function runBrowserMode(options) {
                 for (const attachment of submissionAttachments) {
                     logger(`Uploading attachment: ${attachment.displayPath}`);
                     await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+                    await delay(500);
                 }
                 // Scale timeout based on number of files: base 30s + 15s per additional file
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
@@ -317,7 +320,7 @@ export async function runBrowserMode(options) {
             }
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
-        const answer = await raceWithDisconnect(waitForAssistantResponse(Runtime, config.timeoutMs, logger));
+        const answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger));
         answerText = answer.text;
         answerHtml = answer.html ?? '';
         const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
@@ -663,13 +666,15 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        if (config.extendedThinking) {
-            await withRetries(() => ensureExtendedThinking(Runtime, logger), {
+        // Handle thinking time selection if specified
+        const thinkingTime = config.thinkingTime;
+        if (thinkingTime) {
+            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
                     if (options.verbose) {
-                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
                     }
                 },
             });
@@ -684,6 +689,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 for (const attachment of submissionAttachments) {
                     logger(`Uploading attachment: ${attachment.displayPath}`);
                     await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+                    await delay(500);
                 }
                 // Scale timeout based on number of files: base 30s + 15s per additional file
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
@@ -711,7 +717,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
-        const answer = await waitForAssistantResponse(Runtime, config.timeoutMs, logger);
+        const answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger);
         answerText = answer.text;
         answerHtml = answer.html ?? '';
         const copiedMarkdown = await withRetries(async () => {
@@ -861,6 +867,42 @@ export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
     const statusLabel = message ? ` — ${message}` : '';
     return `${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
 }
+async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger) {
+    try {
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger);
+    }
+    catch (error) {
+        if (!shouldReloadAfterAssistantError(error)) {
+            throw error;
+        }
+        const conversationUrl = await readConversationUrl(Runtime);
+        if (!conversationUrl || !isConversationUrl(conversationUrl)) {
+            throw error;
+        }
+        logger('Assistant response stalled; reloading conversation and retrying once');
+        await Page.navigate({ url: conversationUrl });
+        await delay(1000);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger);
+    }
+}
+function shouldReloadAfterAssistantError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return message.includes('assistant-response') || message.includes('watchdog') || message.includes('timeout');
+}
+async function readConversationUrl(Runtime) {
+    try {
+        const currentUrl = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+        return typeof currentUrl.result?.value === 'string' ? currentUrl.result.value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isConversationUrl(url) {
+    return /\/c\/[a-z0-9-]+/i.test(url);
+}
 function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false) {
     let stopped = false;
     let pending = false;

package/dist/src/cli/browserConfig.js

@@ -5,17 +5,20 @@ import { getOracleHomeDir } from '../oracleHome.js';
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
 const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 30_000;
 const DEFAULT_CHROME_PROFILE = 'Default';
-const BROWSER_MODEL_LABELS = {
-    // Browser engine supports GPT-5.2 and GPT-5.2 Pro (legacy/Pro aliases normalize to those targets).
-    'gpt-5-pro': 'GPT-5.2 Pro',
-    'gpt-5.1-pro': 'GPT-5.2 Pro',
-    'gpt-5.1': 'GPT-5.2',
-    'gpt-5.2': 'GPT-5.2',
-    // ChatGPT UI doesn't expose "instant" as a separate picker option; treat it as GPT-5.2 for browser automation.
-    'gpt-5.2-instant': 'GPT-5.2',
-    'gpt-5.2-pro': 'GPT-5.2 Pro',
-    'gemini-3-pro': 'Gemini 3 Pro',
-};
+// Ordered array: most specific models first to ensure correct selection.
+// The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
+const BROWSER_MODEL_LABELS = [
+    // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
+    ['gpt-5.2-thinking', 'GPT-5.2 Thinking'],
+    ['gpt-5.2-instant', 'GPT-5.2 Instant'],
+    ['gpt-5.2-pro', 'GPT-5.2 Pro'],
+    ['gpt-5.1-pro', 'GPT-5.2 Pro'],
+    ['gpt-5-pro', 'GPT-5.2 Pro'],
+    // Base models last (least specific)
+    ['gpt-5.2', 'GPT-5.2'], // Selects "Auto" in ChatGPT UI
+    ['gpt-5.1', 'GPT-5.2'], // Legacy alias → Auto
+    ['gemini-3-pro', 'Gemini 3 Pro'],
+];
 export function normalizeChatGptModelForBrowser(model) {
     const normalized = model.toLowerCase();
     if (!normalized.startsWith('gpt-') || normalized.includes('codex')) {
@@ -25,10 +28,11 @@ export function normalizeChatGptModelForBrowser(model) {
     if (normalized === 'gpt-5-pro' || normalized === 'gpt-5.1-pro' || normalized.endsWith('-pro')) {
         return 'gpt-5.2-pro';
     }
-    // Legacy / UI-mismatch variants: map to the closest ChatGPT picker target.
-    if (normalized === 'gpt-5.2-instant') {
-        return 'gpt-5.2';
+    // Explicit model variants: keep as-is (they have their own browser labels)
+    if (normalized === 'gpt-5.2-thinking' || normalized === 'gpt-5.2-instant') {
+        return normalized;
     }
+    // Legacy aliases: map to base GPT-5.2 (Auto)
     if (normalized === 'gpt-5.1') {
         return 'gpt-5.2';
     }
@@ -86,7 +90,7 @@ export async function buildBrowserConfig(options) {
         // Allow cookie failures by default so runs can continue without Chrome/Keychain secrets.
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
-        extendedThinking: options.browserExtendedThinking ? true : undefined,
+        thinkingTime: options.browserThinkingTime,
     };
 }
 function selectBrowserPort(options) {
@@ -100,7 +104,13 @@ function selectBrowserPort(options) {
 }
 export function mapModelToBrowserLabel(model) {
     const normalized = normalizeChatGptModelForBrowser(model);
-    return BROWSER_MODEL_LABELS[normalized] ?? DEFAULT_MODEL_TARGET;
+    // Iterate ordered array to find first match (most specific first)
+    for (const [key, label] of BROWSER_MODEL_LABELS) {
+        if (key === normalized) {
+            return label;
+        }
+    }
+    return DEFAULT_MODEL_TARGET;
 }
 export function resolveBrowserModelLabel(input, model) {
     const trimmed = input?.trim?.() ?? '';

package/dist/src/cli/options.js

@@ -187,6 +187,13 @@ export function inferModelFromLabel(modelValue) {
     if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('pro')) {
         return 'gpt-5.2-pro';
     }
+    // Browser-only: pass through 5.2 thinking/instant variants for browser label mapping
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('thinking')) {
+        return 'gpt-5.2-thinking';
+    }
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('instant')) {
+        return 'gpt-5.2-instant';
+    }
     if (normalized.includes('5.0') || normalized.includes('5-pro')) {
         return 'gpt-5-pro';
     }
@@ -205,8 +212,11 @@ export function inferModelFromLabel(modelValue) {
     if (normalized.includes('5.1') || normalized.includes('5_1')) {
         return 'gpt-5.1';
     }
-    if (normalized.includes('instant') || normalized.includes('thinking') || normalized.includes('fast')) {
-        return 'gpt-5.1';
+    if (normalized.includes('thinking')) {
+        return 'gpt-5.2-thinking';
+    }
+    if (normalized.includes('instant') || normalized.includes('fast')) {
+        return 'gpt-5.2-instant';
     }
-    return 'gpt-5.1';
+    return 'gpt-5.2';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.2 Pro (via gpt-5.1-pro alias), GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -83,7 +83,7 @@
     "shiki": "^3.20.0",
     "sqlite3": "^5.1.7",
     "toasted-notifier": "^10.1.0",
-    "tokentally": "github:steipete/tokentally#v0.1.0",
+    "tokentally": "^0.1.1",
     "zod": "^4.2.1"
   },
   "devDependencies": {