@steipete/oracle 0.5.4 → 0.6.0

package/README.md

@@ -11,7 +11,7 @@
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=for-the-badge" alt="MIT License"></a>
 </p>
 
-Oracle bundles your prompt and files so another AI can answer with real context. It speaks GPT-5.1 Pro (default), GPT-5.1 Codex (API-only), GPT-5.1, Gemini 3 Pro, Claude Sonnet 4.5, Claude Opus 4.1, and more—and it can ask one or multiple models in a single run. Browser automation is available; API remains the most reliable path, and `--copy` is an easy manual fallback.
+Oracle bundles your prompt and files so another AI can answer with real context. It speaks GPT-5.1 Pro (default alias to GPT-5.2 Pro on the API), GPT-5.1 Codex (API-only), GPT-5.1, GPT-5.2, Gemini 3 Pro, Claude Sonnet 4.5, Claude Opus 4.1, and more—and it can ask one or multiple models in a single run. Browser automation is available; API remains the most reliable path, and `--copy` is an easy manual fallback.
 
 ## Quick start
 
@@ -95,7 +95,7 @@ npx -y @steipete/oracle oracle-mcp
 | `-p, --prompt <text>` | Required prompt. |
 | `-f, --file <paths...>` | Attach files/dirs (globs + `!` excludes). |
 | `-e, --engine <api\|browser>` | Choose API or browser (browser is experimental). |
-| `-m, --model <name>` | Built-ins (`gpt-5.1-pro` default, `gpt-5-pro`, `gpt-5.1`, `gpt-5.1-codex`, `gemini-3-pro`, `claude-4.5-sonnet`, `claude-4.1-opus`) plus any OpenRouter id (e.g., `minimax/minimax-m2`, `openai/gpt-4o-mini`). |
+| `-m, --model <name>` | Built-ins (`gpt-5.1-pro` default, `gpt-5-pro`, `gpt-5.1`, `gpt-5.1-codex`, `gpt-5.2`, `gpt-5.2-instant`, `gpt-5.2-pro`, `gemini-3-pro`, `claude-4.5-sonnet`, `claude-4.1-opus`) plus any OpenRouter id (e.g., `minimax/minimax-m2`, `openai/gpt-4o-mini`). |
 | `--models <list>` | Comma-separated API models (mix built-ins and OpenRouter ids) for multi-model runs. |
 | `--base-url <url>` | Point API runs at LiteLLM/Azure/OpenRouter/etc. |
 | `--chatgpt-url <url>` | Target a ChatGPT workspace/folder (browser). |
@@ -131,7 +131,7 @@ Advanced flags
 
 | Area | Flags |
 | --- | --- |
-| Browser | `--browser-timeout`, `--browser-input-timeout`, `--browser-inline-cookies[(-file)]`, `--browser-inline-files`, `--browser-bundle-files`, `--browser-keep-browser`, `--browser-headless`, `--browser-hide-window`, `--browser-no-cookie-sync`, `--browser-allow-cookie-errors`, `--browser-chrome-path`, `--browser-cookie-path`, `--chatgpt-url` |
+| Browser | `--browser-timeout`, `--browser-input-timeout`, `--browser-inline-cookies[(-file)]`, `--browser-attachments`, `--browser-inline-files`, `--browser-bundle-files`, `--browser-keep-browser`, `--browser-headless`, `--browser-hide-window`, `--browser-no-cookie-sync`, `--browser-allow-cookie-errors`, `--browser-chrome-path`, `--browser-cookie-path`, `--chatgpt-url` |
 | Azure/OpenAI | `--azure-endpoint`, `--azure-deployment`, `--azure-api-version`, `--base-url` |
 
 Remote browser example

package/dist/bin/oracle-cli.js

@@ -110,7 +110,7 @@ program
     .addOption(new Option('--copy-markdown', 'Copy the assembled markdown bundle to the clipboard; pair with --render to print it too.').default(false))
     .addOption(new Option('--copy').hideHelp().default(false))
     .option('-s, --slug <words>', 'Custom session slug (3-5 words).')
-    .option('-m, --model <model>', 'Model to target (gpt-5.1-pro default; also gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gemini-3-pro, claude-4.5-sonnet, claude-4.1-opus, or ChatGPT labels like "5.1 Instant" for browser runs).', normalizeModelOption)
+    .option('-m, --model <model>', 'Model to target (gpt-5.1-pro default; aliases to gpt-5.2-pro on API. Also gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gpt-5.2, gpt-5.2-instant, gpt-5.2-pro, gemini-3-pro, claude-4.5-sonnet, claude-4.1-opus, or ChatGPT labels like "5.2 Thinking" for browser runs).', normalizeModelOption)
     .addOption(new Option('--models <models>', 'Comma-separated API model list to query in parallel (e.g., "gpt-5.1-pro,gemini-3-pro").')
     .argParser(collectModelList)
     .default([]))
@@ -172,11 +172,15 @@ 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-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'])
+    .default('auto'))
     .addOption(new Option('--remote-chrome <host:port>', 'Connect to remote Chrome DevTools Protocol (e.g., 192.168.1.10:9222 or [2001:db8::1]:9222 for IPv6).'))
     .addOption(new Option('--remote-host <host:port>', 'Delegate browser runs to a remote `oracle serve` instance.'))
     .addOption(new Option('--remote-token <token>', 'Access token for the remote `oracle serve` instance.'))
-    .addOption(new Option('--browser-inline-files', 'Paste files directly into the ChatGPT composer instead of uploading attachments.').default(false))
+    .addOption(new Option('--browser-inline-files', 'Alias for --browser-attachments never (force pasting file contents inline).').default(false))
     .addOption(new Option('--browser-bundle-files', 'Bundle all attachments into a single archive before uploading.').default(false))
     .option('--retain-hours <hours>', 'Prune stored sessions older than this many hours before running (set 0 to disable).', parseFloatOption)
     .option('--force', 'Force start a new session even if an identical prompt is already running.', false)
@@ -317,6 +321,7 @@ function buildRunOptions(options, overrides = {}) {
         sessionId: overrides.sessionId ?? options.sessionId,
         verbose: overrides.verbose ?? options.verbose,
         heartbeatIntervalMs: overrides.heartbeatIntervalMs ?? resolveHeartbeatIntervalMs(options.heartbeat),
+        browserAttachments: overrides.browserAttachments ?? options.browserAttachments ?? 'auto',
         browserInlineFiles: overrides.browserInlineFiles ?? options.browserInlineFiles ?? false,
         browserBundleFiles: overrides.browserBundleFiles ?? options.browserBundleFiles ?? false,
         background: overrides.background ?? undefined,
@@ -359,6 +364,7 @@ function buildRunOptionsFromMetadata(metadata) {
         sessionId: metadata.id,
         verbose: stored.verbose,
         heartbeatIntervalMs: stored.heartbeatIntervalMs,
+        browserAttachments: stored.browserAttachments,
         browserInlineFiles: stored.browserInlineFiles,
         browserBundleFiles: stored.browserBundleFiles,
         background: stored.background,

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

@@ -135,9 +135,27 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         await runtime.evaluate({ expression: `(function(){${dispatchEvents} return true;})()`, returnByValue: true });
     };
     await tryFileInput();
+    // Snapshot the attachment state immediately after setting files so we can detect silent failures.
+    const snapshotExpr = `(() => {
+    const chips = Array.from(document.querySelectorAll('[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[aria-label="Remove file"]'))
+      .map((node) => (node?.textContent || '').trim())
+      .filter(Boolean);
+    const inputs = Array.from(document.querySelectorAll('input[type="file"]')).map((el) => ({
+      files: Array.from(el.files || []).map((f) => f?.name ?? ''),
+    }));
+    return { chips, inputs };
+  })()`;
+    const snapshot = await runtime
+        .evaluate({ expression: snapshotExpr, returnByValue: true })
+        .then((res) => res?.result?.value)
+        .catch(() => undefined);
+    if (snapshot) {
+        logger?.(`Attachment snapshot after setFileInputFiles: chips=${JSON.stringify(snapshot.chips || [])} inputs=${JSON.stringify(snapshot.inputs || [])}`);
+    }
+    const inputHasFile = snapshot?.inputs?.some((entry) => (entry.files || []).some((name) => name?.toLowerCase?.().includes(expectedName.toLowerCase()))) ?? false;
     if (await waitForAttachmentAnchored(runtime, expectedName, 20_000)) {
         await waitForAttachmentVisible(runtime, expectedName, 20_000, logger);
-        logger('Attachment queued (file input)');
+        logger(inputHasFile ? 'Attachment queued (file input, confirmed present)' : 'Attachment queued (file input)');
         return;
     }
     await logDomFailure(runtime, logger, 'file-upload-missing');
@@ -189,10 +207,6 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
       btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
     );
     attachedNames.push(...cardTexts.filter(Boolean));
-    const filesPills = Array.from(document.querySelectorAll('button,div'))
-      .map((node) => (node?.textContent || '').toLowerCase())
-      .filter((text) => /\bfiles\b/.test(text));
-    attachedNames.push(...filesPills);
     const filesAttached = attachedNames.length > 0;
     return { state: button ? (disabled ? 'disabled' : 'ready') : 'missing', uploading, filesAttached, attachedNames };
   })()`;
@@ -274,13 +288,6 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
       return { found: true, userTurns: userTurns.length, source: 'attachment-cards' };
     }
 
-    const filesPills = Array.from(document.querySelectorAll('button,div')).map((node) =>
-      (node?.textContent || '').toLowerCase(),
-    );
-    if (filesPills.some((text) => /\bfiles\b/.test(text))) {
-      return { found: true, userTurns: userTurns.length, source: 'files-pill' };
-    }
-
     const attrMatch = Array.from(document.querySelectorAll('[aria-label], [title], [data-testid]')).some(matchNode);
     if (attrMatch) {
       return { found: true, userTurns: userTurns.length, source: 'attrs' };
@@ -328,13 +335,6 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
       return { found: true, text: cards.find((t) => t.includes(normalized)) };
     }
 
-    const filesPills = Array.from(document.querySelectorAll('button,div')).map((node) =>
-      (node?.textContent || '').toLowerCase(),
-    );
-    if (filesPills.some((text) => /\bfiles\b/.test(text))) {
-      return { found: true, text: filesPills.find((t) => /\bfiles\b/.test(t)) };
-    }
-
     // As a last resort, treat file inputs that hold the target name as anchored. Some UIs delay chip rendering.
     const inputHit = Array.from(document.querySelectorAll('input[type="file"]')).some((el) =>
       Array.from(el.files || []).some((file) => file?.name?.toLowerCase?.().includes(normalized)),

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

@@ -248,6 +248,23 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens.add('gpt5-0');
         testIdTokens.add('gpt50');
     }
+    // Numeric variations (5.2 ↔ 52 ↔ gpt-5-2)
+    if (base.includes('5.2') || base.includes('5-2') || base.includes('52')) {
+        push('5.2', labelTokens);
+        push('gpt-5.2', labelTokens);
+        push('gpt5.2', labelTokens);
+        push('gpt-5-2', labelTokens);
+        push('gpt5-2', labelTokens);
+        push('gpt52', labelTokens);
+        push('chatgpt 5.2', labelTokens);
+        if (base.includes('thinking'))
+            push('thinking', labelTokens);
+        if (base.includes('instant'))
+            push('instant', labelTokens);
+        testIdTokens.add('gpt-5-2');
+        testIdTokens.add('gpt5-2');
+        testIdTokens.add('gpt52');
+    }
     // Pro / research variants
     if (base.includes('pro')) {
         push('proresearch', labelTokens);
@@ -263,6 +280,11 @@ function buildModelMatchersLiteral(targetModel) {
             testIdTokens.add('gpt-5-0-pro');
             testIdTokens.add('gpt50pro');
         }
+        if (base.includes('5.2') || base.includes('5-2') || base.includes('52')) {
+            testIdTokens.add('gpt-5.2-pro');
+            testIdTokens.add('gpt-5-2-pro');
+            testIdTokens.add('gpt52pro');
+        }
         testIdTokens.add('pro');
         testIdTokens.add('proresearch');
     }

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

@@ -2,6 +2,7 @@ import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEN
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 import { buildClickDispatcher } from './domEvents.js';
+import { BrowserAutomationError } from '../../oracle/errors.js';
 const ENTER_KEY_EVENT = {
     key: 'Enter',
     code: 'Enter',
@@ -70,9 +71,11 @@ export async function submitPrompt(deps, prompt, logger) {
     })()`,
         returnByValue: true,
     });
-    const editorText = verification.result?.value?.editorText?.trim?.() ?? '';
-    const fallbackValue = verification.result?.value?.fallbackValue?.trim?.() ?? '';
-    if (!editorText && !fallbackValue) {
+    const editorTextRaw = verification.result?.value?.editorText ?? '';
+    const fallbackValueRaw = verification.result?.value?.fallbackValue ?? '';
+    const editorTextTrimmed = editorTextRaw?.trim?.() ?? '';
+    const fallbackValueTrimmed = fallbackValueRaw?.trim?.() ?? '';
+    if (!editorTextTrimmed && !fallbackValueTrimmed) {
         await runtime.evaluate({
             expression: `(() => {
         const fallback = document.querySelector(${fallbackSelectorLiteral});
@@ -90,6 +93,30 @@ export async function submitPrompt(deps, prompt, logger) {
       })()`,
         });
     }
+    const promptLength = prompt.length;
+    const postVerification = await runtime.evaluate({
+        expression: `(() => {
+      const editor = document.querySelector(${primarySelectorLiteral});
+      const fallback = document.querySelector(${fallbackSelectorLiteral});
+      return {
+        editorText: editor?.innerText ?? '',
+        fallbackValue: fallback?.value ?? '',
+      };
+    })()`,
+        returnByValue: true,
+    });
+    const observedEditor = postVerification.result?.value?.editorText ?? '';
+    const observedFallback = postVerification.result?.value?.fallbackValue ?? '';
+    const observedLength = Math.max(observedEditor.length, observedFallback.length);
+    if (promptLength >= 50_000 && observedLength > 0 && observedLength < promptLength - 2_000) {
+        await logDomFailure(runtime, logger, 'prompt-too-large');
+        throw new BrowserAutomationError('Prompt appears truncated in the composer (likely too large).', {
+            stage: 'submit-prompt',
+            code: 'prompt-too-large',
+            promptLength,
+            observedLength,
+        });
+    }
     const clicked = await attemptSendButton(runtime, logger, deps?.attachmentNames);
     if (!clicked) {
         await input.dispatchKeyEvent({
@@ -110,6 +137,35 @@ export async function submitPrompt(deps, prompt, logger) {
     await verifyPromptCommitted(runtime, prompt, 30_000, logger);
     await clickAnswerNowIfPresent(runtime, logger);
 }
+export async function clearPromptComposer(Runtime, logger) {
+    const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
+    const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const result = await Runtime.evaluate({
+        expression: `(() => {
+      const fallback = document.querySelector(${fallbackSelectorLiteral});
+      const editor = document.querySelector(${primarySelectorLiteral});
+      let cleared = false;
+      if (fallback) {
+        fallback.value = '';
+        fallback.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
+        fallback.dispatchEvent(new Event('change', { bubbles: true }));
+        cleared = true;
+      }
+      if (editor) {
+        editor.textContent = '';
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
+        cleared = true;
+      }
+      return { cleared };
+    })()`,
+        returnByValue: true,
+    });
+    if (!result.result?.value?.cleared) {
+        await logDomFailure(Runtime, logger, 'clear-composer');
+        throw new Error('Failed to clear prompt composer');
+    }
+    await delay(250);
+}
 async function waitForDomReady(Runtime, logger) {
     const deadline = Date.now() + 10_000;
     while (Date.now() < deadline) {
@@ -231,25 +287,46 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
     const fallback = document.querySelector(${fallbackSelectorLiteral});
     const normalize = (value) => value?.toLowerCase?.().replace(/\\s+/g, ' ').trim() ?? '';
     const normalizedPrompt = normalize(${encodedPrompt});
+    const normalizedPromptPrefix = normalizedPrompt.slice(0, 120);
     const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
     const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
-    const userMatched = articles.some((node) => normalize(node?.innerText).includes(normalizedPrompt));
+    const normalizedTurns = articles.map((node) => normalize(node?.innerText));
+    const userMatched = normalizedTurns.some((text) => text.includes(normalizedPrompt));
+    const prefixMatched =
+      normalizedPromptPrefix.length > 30 &&
+      normalizedTurns.some((text) => text.includes(normalizedPromptPrefix));
+    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
     return {
       userMatched,
+      prefixMatched,
       fallbackValue: fallback?.value ?? '',
       editorValue: editor?.innerText ?? '',
+      lastTurn,
+      turnsCount: normalizedTurns.length,
     };
   })()`;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
         const info = result.value;
-        if (info?.userMatched) {
+        if (info?.userMatched || info?.prefixMatched) {
             return;
         }
         await delay(100);
     }
     if (logger) {
+        logger(`Prompt commit check failed; latest state: ${await Runtime.evaluate({
+            expression: script,
+            returnByValue: true,
+        }).then((res) => JSON.stringify(res?.result?.value)).catch(() => 'unavailable')}`);
         await logDomFailure(Runtime, logger, 'prompt-commit');
     }
+    if (prompt.trim().length >= 50_000) {
+        throw new BrowserAutomationError('Prompt did not appear in conversation before timeout (likely too large).', {
+            stage: 'submit-prompt',
+            code: 'prompt-too-large',
+            promptLength: prompt.trim().length,
+            timeoutMs,
+        });
+    }
     throw new Error('Prompt did not appear in conversation before timeout (send may have failed)');
 }

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

@@ -0,0 +1,190 @@
+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);
+    switch (result?.status) {
+        case 'already-extended':
+            logger(`Thinking time: ${result.label ?? 'Extended'} (already selected)`);
+            return;
+        case 'switched':
+            logger(`Thinking time: ${result.label ?? 'Extended'}`);
+            return;
+        case 'chip-not-found': {
+            await logDomFailure(Runtime, logger, 'thinking-chip');
+            throw new Error('Unable to find the Thinking chip button in the composer area.');
+        }
+        case 'menu-not-found': {
+            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.');
+        }
+        default: {
+            await logDomFailure(Runtime, logger, 'thinking-time-unknown');
+            throw new Error('Unknown error selecting Extended thinking time.');
+        }
+    }
+}
+/**
+ * Best-effort selection of the "Extended" thinking-time option in ChatGPT's composer pill menu.
+ * Safe by default: if the pill/menu/option isn't present, we continue without throwing.
+ */
+export async function ensureExtendedThinkingIfAvailable(Runtime, logger) {
+    try {
+        const result = await evaluateThinkingTimeSelection(Runtime);
+        switch (result?.status) {
+            case 'already-extended':
+                logger(`Thinking time: ${result.label ?? 'Extended'} (already selected)`);
+                return true;
+            case 'switched':
+                logger(`Thinking time: ${result.label ?? 'Extended'}`);
+                return true;
+            case 'chip-not-found':
+            case 'menu-not-found':
+            case 'extended-not-found':
+                if (logger.verbose) {
+                    logger(`Thinking time: ${result.status.replaceAll('-', ' ')}; continuing with default.`);
+                }
+                return false;
+            default:
+                if (logger.verbose) {
+                    logger('Thinking time: unknown outcome; continuing with default.');
+                }
+                return false;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (logger.verbose) {
+            logger(`Thinking time selection failed (${message}); continuing with default.`);
+            await logDomFailure(Runtime, logger, 'thinking-time');
+        }
+        return false;
+    }
+}
+async function evaluateThinkingTimeSelection(Runtime) {
+    const outcome = await Runtime.evaluate({
+        expression: buildThinkingTimeExpression(),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    return outcome.result?.value;
+}
+function buildThinkingTimeExpression() {
+    const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
+    const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    return `(async () => {
+    ${buildClickDispatcher()}
+
+    const MENU_CONTAINER_SELECTOR = ${menuContainerLiteral};
+    const MENU_ITEM_SELECTOR = ${menuItemLiteral};
+
+    const CHIP_SELECTORS = [
+      '[data-testid="composer-footer-actions"] button[aria-haspopup="menu"]',
+      'button.__composer-pill[aria-haspopup="menu"]',
+      '.__composer-pill-composite button[aria-haspopup="menu"]',
+    ];
+
+    const INITIAL_WAIT_MS = 150;
+    const MAX_WAIT_MS = 10000;
+
+    const normalize = (value) => (value || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, ' ')
+      .replace(/\\s+/g, ' ')
+      .trim();
+
+    const findThinkingChip = () => {
+      for (const selector of CHIP_SELECTORS) {
+        const buttons = document.querySelectorAll(selector);
+        for (const btn of buttons) {
+          const aria = normalize(btn.getAttribute?.('aria-label') ?? '');
+          const text = normalize(btn.textContent ?? '');
+          if (aria.includes('thinking') || text.includes('thinking')) {
+            return btn;
+          }
+        }
+      }
+      return null;
+    };
+
+    const chip = findThinkingChip();
+    if (!chip) {
+      return { status: 'chip-not-found' };
+    }
+
+    dispatchClickSequence(chip);
+
+    return new Promise((resolve) => {
+      const start = performance.now();
+
+      const findMenu = () => {
+        const menus = document.querySelectorAll(MENU_CONTAINER_SELECTOR + ', [role="group"]');
+        for (const menu of menus) {
+          const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
+          if (normalize(label?.textContent ?? '').includes('thinking time')) {
+            return menu;
+          }
+          const text = normalize(menu.textContent ?? '');
+          if (text.includes('standard') && text.includes('extended')) {
+            return menu;
+          }
+        }
+        return null;
+      };
+
+      const findExtendedOption = (menu) => {
+        const items = menu.querySelectorAll(MENU_ITEM_SELECTOR);
+        for (const item of items) {
+          const text = normalize(item.textContent ?? '');
+          if (text.includes('extended')) {
+            return item;
+          }
+        }
+        return null;
+      };
+
+      const optionIsSelected = (node) => {
+        if (!(node instanceof HTMLElement)) return false;
+        const ariaChecked = node.getAttribute('aria-checked');
+        const dataState = (node.getAttribute('data-state') || '').toLowerCase();
+        if (ariaChecked === 'true') return true;
+        if (dataState === 'checked' || dataState === 'selected' || dataState === 'on') return true;
+        return false;
+      };
+
+      const attempt = () => {
+        const menu = findMenu();
+        if (!menu) {
+          if (performance.now() - start > MAX_WAIT_MS) {
+            resolve({ status: 'menu-not-found' });
+            return;
+          }
+          setTimeout(attempt, 100);
+          return;
+        }
+
+        const extendedOption = findExtendedOption(menu);
+        if (!extendedOption) {
+          resolve({ status: 'extended-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 });
+      };
+
+      setTimeout(attempt, INITIAL_WAIT_MS);
+    });
+  })()`;
+}
+export function buildThinkingTimeExpressionForTest() {
+    return buildThinkingTimeExpression();
+}

package/dist/src/browser/config.js

@@ -24,6 +24,7 @@ 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);

package/dist/src/browser/index.js

@@ -5,8 +5,9 @@ import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
+import { ensureExtendedThinking } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL } from './constants.js';
@@ -19,6 +20,7 @@ export async function runBrowserMode(options) {
         throw new Error('Prompt text is required when using browser mode.');
     }
     const attachments = options.attachments ?? [];
+    const fallbackSubmission = options.fallbackSubmission;
     let config = resolveBrowserConfig(options.config);
     const logger = options.log ?? ((_message) => { });
     if (logger.verbose === undefined) {
@@ -254,20 +256,49 @@ export async function runBrowserMode(options) {
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        const attachmentNames = attachments.map((a) => path.basename(a.path));
-        if (attachments.length > 0) {
-            if (!DOM) {
-                throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+        if (config.extendedThinking) {
+            await raceWithDisconnect(withRetries(() => ensureExtendedThinking(Runtime, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            }));
+        }
+        const submitOnce = async (prompt, submissionAttachments) => {
+            const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            if (submissionAttachments.length > 0) {
+                if (!DOM) {
+                    throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+                }
+                for (const attachment of submissionAttachments) {
+                    logger(`Uploading attachment: ${attachment.displayPath}`);
+                    await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+                }
+                const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                logger('All attachments uploaded');
             }
-            for (const attachment of attachments) {
-                logger(`Uploading attachment: ${attachment.displayPath}`);
-                await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+            await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+        };
+        try {
+            await raceWithDisconnect(submitOnce(promptText, attachments));
+        }
+        catch (error) {
+            const isPromptTooLarge = error instanceof BrowserAutomationError &&
+                error.details?.code === 'prompt-too-large';
+            if (fallbackSubmission && isPromptTooLarge) {
+                logger('[browser] Inline prompt too large; retrying with file uploads.');
+                await raceWithDisconnect(clearPromptComposer(Runtime, logger));
+                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+                await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+            }
+            else {
+                throw error;
             }
-            const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
-            await raceWithDisconnect(waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger));
-            logger('All attachments uploaded');
         }
-        await raceWithDisconnect(submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, promptText, logger));
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         const answer = await raceWithDisconnect(waitForAssistantResponse(Runtime, config.timeoutMs, logger));
         answerText = answer.text;
@@ -636,21 +667,50 @@ 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)`);
         }
-        const attachmentNames = attachments.map((a) => path.basename(a.path));
-        if (attachments.length > 0) {
-            if (!DOM) {
-                throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+        if (config.extendedThinking) {
+            await withRetries(() => ensureExtendedThinking(Runtime, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            });
+        }
+        const submitOnce = async (prompt, submissionAttachments) => {
+            const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            if (submissionAttachments.length > 0) {
+                if (!DOM) {
+                    throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+                }
+                // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
+                for (const attachment of submissionAttachments) {
+                    logger(`Uploading attachment: ${attachment.displayPath}`);
+                    await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+                }
+                const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                logger('All attachments uploaded');
+            }
+            await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+        };
+        try {
+            await submitOnce(promptText, attachments);
+        }
+        catch (error) {
+            const isPromptTooLarge = error instanceof BrowserAutomationError &&
+                error.details?.code === 'prompt-too-large';
+            if (options.fallbackSubmission && isPromptTooLarge) {
+                logger('[browser] Inline prompt too large; retrying with file uploads.');
+                await clearPromptComposer(Runtime, logger);
+                await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                await submitOnce(options.fallbackSubmission.prompt, options.fallbackSubmission.attachments);
             }
-            // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
-            for (const attachment of attachments) {
-                logger(`Uploading attachment: ${attachment.displayPath}`);
-                await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+            else {
+                throw error;
             }
-            const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
-            await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-            logger('All attachments uploaded');
         }
-        await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, promptText, logger);
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         const answer = await waitForAssistantResponse(Runtime, config.timeoutMs, logger);
         answerText = answer.text;

package/dist/src/browser/pageActions.js

@@ -1,5 +1,5 @@
 export { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady } from './actions/navigation.js';
 export { ensureModelSelection } from './actions/modelSelection.js';
-export { submitPrompt } from './actions/promptComposer.js';
+export { submitPrompt, clearPromptComposer } from './actions/promptComposer.js';
 export { uploadAttachmentFile, waitForAttachmentCompletion } from './actions/attachments.js';
 export { waitForAssistantResponse, readAssistantSnapshot, captureAssistantMarkdown, buildAssistantExtractorForTest, buildConversationDebugExpressionForTest, } from './actions/assistantResponse.js';

package/dist/src/browser/prompt.js

@@ -5,6 +5,7 @@ import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS, format
 import { isKnownModel } from '../oracle/modelResolver.js';
 import { buildPromptMarkdown } from '../oracle/promptAssembly.js';
 import { buildAttachmentPlan } from './policies.js';
+const DEFAULT_BROWSER_INLINE_CHAR_BUDGET = 60_000;
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
@@ -14,22 +15,33 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const systemPrompt = runOptions.system?.trim() || '';
     const sections = createFileSections(files, cwd);
     const markdown = buildPromptMarkdown(systemPrompt, userPrompt, sections);
-    const inlineFiles = Boolean(runOptions.browserInlineFiles);
-    const composerSections = [];
+    const attachmentsPolicy = runOptions.browserInlineFiles
+        ? 'never'
+        : runOptions.browserAttachments ?? 'auto';
+    const bundleRequested = Boolean(runOptions.browserBundleFiles);
+    const inlinePlan = buildAttachmentPlan(sections, { inlineFiles: true, bundleRequested });
+    const uploadPlan = buildAttachmentPlan(sections, { inlineFiles: false, bundleRequested });
+    const baseComposerSections = [];
     if (systemPrompt)
-        composerSections.push(systemPrompt);
+        baseComposerSections.push(systemPrompt);
     if (userPrompt)
-        composerSections.push(userPrompt);
-    const attachmentPlan = buildAttachmentPlan(sections, {
-        inlineFiles,
-        bundleRequested: Boolean(runOptions.browserBundleFiles),
-    });
-    if (attachmentPlan.inlineBlock) {
-        composerSections.push(attachmentPlan.inlineBlock);
-    }
-    const composerText = composerSections.join('\n\n').trim();
-    const attachments = attachmentPlan.attachments.slice();
-    const shouldBundle = attachmentPlan.shouldBundle;
+        baseComposerSections.push(userPrompt);
+    const inlineComposerText = [...baseComposerSections, inlinePlan.inlineBlock].filter(Boolean).join('\n\n').trim();
+    const selectedPlan = attachmentsPolicy === 'always'
+        ? uploadPlan
+        : attachmentsPolicy === 'never'
+            ? inlinePlan
+            : inlineComposerText.length <= DEFAULT_BROWSER_INLINE_CHAR_BUDGET || sections.length === 0
+                ? inlinePlan
+                : uploadPlan;
+    const composerText = (selectedPlan.inlineBlock
+        ? [...baseComposerSections, selectedPlan.inlineBlock]
+        : baseComposerSections)
+        .filter(Boolean)
+        .join('\n\n')
+        .trim();
+    const attachments = selectedPlan.attachments.slice();
+    const shouldBundle = selectedPlan.shouldBundle;
     let bundleText = null;
     if (shouldBundle) {
         const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-browser-bundle-'));
@@ -48,11 +60,11 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             sizeBytes: Buffer.byteLength(bundleText, 'utf8'),
         });
     }
-    const inlineFileCount = attachmentPlan.inlineFileCount;
+    const inlineFileCount = selectedPlan.inlineFileCount;
     const modelConfig = isKnownModel(runOptions.model) ? MODEL_CONFIGS[runOptions.model] : MODEL_CONFIGS['gpt-5.1'];
-    const tokenizer = modelConfig.tokenizer;
-    const tokenizerUserContent = inlineFileCount > 0 && attachmentPlan.inlineBlock
-        ? [userPrompt, attachmentPlan.inlineBlock].filter((value) => Boolean(value?.trim())).join('\n\n').trim()
+    const tokenizer = deps.tokenizeImpl ?? modelConfig.tokenizer;
+    const tokenizerUserContent = inlineFileCount > 0 && selectedPlan.inlineBlock
+        ? [userPrompt, selectedPlan.inlineBlock].filter((value) => Boolean(value?.trim())).join('\n\n').trim()
         : userPrompt;
     const tokenizerMessages = [
         systemPrompt ? { role: 'system', content: systemPrompt } : null,
@@ -61,7 +73,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     let estimatedInputTokens = tokenizer(tokenizerMessages.length > 0
         ? tokenizerMessages
         : [{ role: 'user', content: '' }], TOKENIZER_OPTIONS);
-    const tokenEstimateIncludesInlineFiles = inlineFileCount > 0 && Boolean(attachmentPlan.inlineBlock);
+    const tokenEstimateIncludesInlineFiles = inlineFileCount > 0 && Boolean(selectedPlan.inlineBlock);
     if (!tokenEstimateIncludesInlineFiles && sections.length > 0) {
         const attachmentText = bundleText ??
             sections
@@ -70,6 +82,35 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         const attachmentTokens = tokenizer([{ role: 'user', content: attachmentText }], TOKENIZER_OPTIONS);
         estimatedInputTokens += attachmentTokens;
     }
+    let fallback = null;
+    if (attachmentsPolicy === 'auto' && selectedPlan.mode === 'inline' && sections.length > 0) {
+        const fallbackComposerText = baseComposerSections.join('\n\n').trim();
+        const fallbackAttachments = uploadPlan.attachments.slice();
+        let fallbackBundled = null;
+        if (uploadPlan.shouldBundle) {
+            const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-browser-bundle-'));
+            const bundlePath = path.join(bundleDir, 'attachments-bundle.txt');
+            const bundleLines = [];
+            sections.forEach((section) => {
+                bundleLines.push(formatFileSection(section.displayPath, section.content).trimEnd());
+                bundleLines.push('');
+            });
+            const fallbackBundleText = `${bundleLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+            await fs.writeFile(bundlePath, fallbackBundleText, 'utf8');
+            fallbackAttachments.length = 0;
+            fallbackAttachments.push({
+                path: bundlePath,
+                displayPath: bundlePath,
+                sizeBytes: Buffer.byteLength(fallbackBundleText, 'utf8'),
+            });
+            fallbackBundled = { originalCount: sections.length, bundlePath };
+        }
+        fallback = {
+            composerText: fallbackComposerText,
+            attachments: fallbackAttachments,
+            bundled: fallbackBundled,
+        };
+    }
     return {
         markdown,
         composerText,
@@ -77,6 +118,9 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         attachments,
         inlineFileCount,
         tokenEstimateIncludesInlineFiles,
+        attachmentsPolicy,
+        attachmentMode: selectedPlan.mode,
+        fallback,
         bundled: shouldBundle && attachments.length === 1 && attachments[0]?.displayPath
             ? { originalCount: sections.length, bundlePath: attachments[0].displayPath }
             : null,

package/dist/src/browser/sessionRunner.js

@@ -25,8 +25,8 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
                 log(chalk.yellow(`[browser] Bundled ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath}.`));
             }
         }
-        else if (runOptions.file && runOptions.file.length > 0 && runOptions.browserInlineFiles) {
-            log(chalk.dim('[verbose] Browser inline file fallback enabled (pasting file contents).'));
+        else if (runOptions.file && runOptions.file.length > 0 && promptArtifacts.attachmentMode === 'inline') {
+            log(chalk.dim('[verbose] Browser will paste file contents inline (no uploads).'));
         }
     }
     if (promptArtifacts.bundled) {
@@ -34,11 +34,12 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     }
     const headerLine = `Launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
     const automationLogger = ((message) => {
-        if (!runOptions.verbose)
+        if (typeof message !== 'string')
             return;
-        if (typeof message === 'string') {
-            log(message);
-        }
+        const shouldAlwaysPrint = message.startsWith('[browser] ') && /fallback|retry/i.test(message);
+        if (!runOptions.verbose && !shouldAlwaysPrint)
+            return;
+        log(message);
     });
     automationLogger.verbose = Boolean(runOptions.verbose);
     automationLogger.sessionLog = runOptions.verbose ? log : (() => { });
@@ -53,6 +54,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         browserResult = await executeBrowser({
             prompt: promptArtifacts.composerText,
             attachments: promptArtifacts.attachments,
+            fallbackSubmission: promptArtifacts.fallback
+                ? { prompt: promptArtifacts.fallback.composerText, attachments: promptArtifacts.fallback.attachments }
+                : undefined,
             config: browserConfig,
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,

package/dist/src/cli/browserConfig.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import os from 'node:os';
 import { CHATGPT_URL, DEFAULT_MODEL_TARGET, normalizeChatgptUrl, parseDuration } from '../browserMode.js';
+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';
@@ -9,6 +9,9 @@ const BROWSER_MODEL_LABELS = {
     'gpt-5-pro': 'GPT-5 Pro',
     'gpt-5.1-pro': 'GPT-5.1 Pro',
     'gpt-5.1': 'GPT-5.1',
+    'gpt-5.2': 'GPT-5.2 Thinking',
+    'gpt-5.2-instant': 'GPT-5.2 Instant',
+    'gpt-5.2-pro': 'GPT-5.2 Pro',
     'gemini-3-pro': 'Gemini 3 Pro',
 };
 export async function buildBrowserConfig(options) {
@@ -53,6 +56,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,
     };
 }
 function selectBrowserPort(options) {
@@ -155,7 +159,7 @@ async function resolveInlineCookies({ inlineArg, inlineFileArg, envPayload, envF
             return { cookies: parsed, source };
     }
     // fallback: ~/.oracle/cookies.{json,base64}
-    const oracleHome = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+    const oracleHome = getOracleHomeDir();
     const candidates = ['cookies.json', 'cookies.base64'];
     for (const file of candidates) {
         const fullPath = path.join(oracleHome, file);

package/dist/src/cli/sessionRunner.js

@@ -19,7 +19,6 @@ import { formatElapsed } from '../oracle/format.js';
 import { sanitizeOscProgress } from './oscUtils.js';
 import { readFiles } from '../oracle/files.js';
 import { formatUSD } from '../oracle/format.js';
-import { SESSIONS_DIR } from '../sessionManager.js';
 import { cwd as getCwd } from 'node:process';
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
@@ -386,7 +385,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         return;
     }
     const normalizedTarget = path.resolve(targetPath);
-    const normalizedSessionsDir = path.resolve(SESSIONS_DIR);
+    const normalizedSessionsDir = path.resolve(sessionStore.sessionsDir());
     if (normalizedTarget === normalizedSessionsDir ||
         normalizedTarget.startsWith(`${normalizedSessionsDir}${path.sep}`)) {
         log(dim(`write-output skipped: refusing to write inside session storage (${normalizedSessionsDir}).`));
@@ -442,7 +441,7 @@ function buildFallbackPath(original) {
     const dir = getCwd();
     const candidate = ext ? `${stem}.fallback${ext}` : `${stem}.fallback`;
     const fallback = path.join(dir, candidate);
-    const normalizedSessionsDir = path.resolve(SESSIONS_DIR);
+    const normalizedSessionsDir = path.resolve(sessionStore.sessionsDir());
     const normalizedFallback = path.resolve(fallback);
     if (normalizedFallback === normalizedSessionsDir ||
         normalizedFallback.startsWith(`${normalizedSessionsDir}${path.sep}`)) {

package/dist/src/cli/tui/index.js

@@ -388,6 +388,7 @@ async function askOracleFlow(version, userConfig) {
         sessionId: undefined,
         verbose: false,
         heartbeatIntervalMs: undefined,
+        browserAttachments: 'auto',
         browserInlineFiles: false,
         browserBundleFiles: false,
         background: undefined,

package/dist/src/config.js

@@ -1,10 +1,9 @@
 import fs from 'node:fs/promises';
-import os from 'node:os';
 import path from 'node:path';
 import JSON5 from 'json5';
+import { getOracleHomeDir } from './oracleHome.js';
 function resolveConfigPath() {
-    const oracleHome = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
-    return path.join(oracleHome, 'config.json');
+    return path.join(getOracleHomeDir(), 'config.json');
 }
 export async function loadUserConfig() {
     const CONFIG_PATH = resolveConfigPath();

package/dist/src/oracle/config.js

@@ -3,17 +3,18 @@ import { countTokens as countTokensGpt5Pro } from 'gpt-tokenizer/model/gpt-5-pro
 import { countTokens as countTokensAnthropicRaw } from '@anthropic-ai/tokenizer';
 import { stringifyTokenizerInput } from './tokenStringifier.js';
 export const DEFAULT_MODEL = 'gpt-5.1-pro';
-export const PRO_MODELS = new Set(['gpt-5.1-pro', 'gpt-5-pro', 'claude-4.5-sonnet', 'claude-4.1-opus']);
+export const PRO_MODELS = new Set(['gpt-5.1-pro', 'gpt-5-pro', 'gpt-5.2-pro', 'claude-4.5-sonnet', 'claude-4.1-opus']);
 const countTokensAnthropic = (input) => countTokensAnthropicRaw(stringifyTokenizerInput(input));
 export const MODEL_CONFIGS = {
     'gpt-5.1-pro': {
         model: 'gpt-5.1-pro',
+        apiModel: 'gpt-5.2-pro',
         provider: 'openai',
         tokenizer: countTokensGpt5Pro,
         inputLimit: 196000,
         pricing: {
-            inputPerToken: 15 / 1_000_000,
-            outputPerToken: 120 / 1_000_000,
+            inputPerToken: 21 / 1_000_000,
+            outputPerToken: 168 / 1_000_000,
         },
         reasoning: null,
     },
@@ -50,6 +51,40 @@ export const MODEL_CONFIGS = {
         },
         reasoning: { effort: 'high' },
     },
+    'gpt-5.2': {
+        model: 'gpt-5.2',
+        provider: 'openai',
+        tokenizer: countTokensGpt5,
+        inputLimit: 196000,
+        pricing: {
+            inputPerToken: 1.75 / 1_000_000,
+            outputPerToken: 14 / 1_000_000,
+        },
+        reasoning: { effort: 'xhigh' },
+    },
+    'gpt-5.2-instant': {
+        model: 'gpt-5.2-instant',
+        apiModel: 'gpt-5.2-chat-latest',
+        provider: 'openai',
+        tokenizer: countTokensGpt5,
+        inputLimit: 196000,
+        pricing: {
+            inputPerToken: 1.75 / 1_000_000,
+            outputPerToken: 14 / 1_000_000,
+        },
+        reasoning: null,
+    },
+    'gpt-5.2-pro': {
+        model: 'gpt-5.2-pro',
+        provider: 'openai',
+        tokenizer: countTokensGpt5Pro,
+        inputLimit: 196000,
+        pricing: {
+            inputPerToken: 21 / 1_000_000,
+            outputPerToken: 168 / 1_000_000,
+        },
+        reasoning: { effort: 'xhigh' },
+    },
     'gemini-3-pro': {
         model: 'gemini-3-pro',
         provider: 'google',

package/dist/src/oracle/errors.js

@@ -95,13 +95,13 @@ export function toTransportError(error, model) {
         const apiMessage = apiError.error?.message ||
             apiError.message ||
             (apiError.status ? `${apiError.status} OpenAI API error` : 'OpenAI API error');
-        // TODO: Remove once gpt-5.1-pro is available via the Responses API.
-        if (model === 'gpt-5.1-pro' &&
+        // Friendly guidance when a pro-tier model isn't available on this base URL / API key.
+        if (model === 'gpt-5.2-pro' &&
             (code === 'model_not_found' ||
                 messageText.includes('does not exist') ||
                 messageText.includes('unknown model') ||
                 messageText.includes('model_not_found'))) {
-            return new OracleTransportError('model-unavailable', 'gpt-5.1-pro is not yet available on this API base. Using gpt-5-pro until OpenAI enables it. // TODO: Remove once gpt-5.1-pro is available', apiError);
+            return new OracleTransportError('model-unavailable', 'gpt-5.2-pro is not available on this API base/key. Try gpt-5-pro or gpt-5.2, or switch to the browser engine.', apiError);
         }
         if (apiError.status === 404 || apiError.status === 405) {
             return new OracleTransportError('unsupported-endpoint', 'HTTP 404/405 from the Responses API; this base URL or gateway likely does not expose /v1/responses. Set OPENAI_BASE_URL to api.openai.com/v1, update your Azure API version/deployment, or use the browser engine.', apiError);

package/dist/src/oracle/gemini.js

@@ -1,10 +1,13 @@
 import { GoogleGenAI, HarmCategory, HarmBlockThreshold } from '@google/genai';
 const MODEL_ID_MAP = {
     'gemini-3-pro': 'gemini-3-pro-preview',
-    'gpt-5.1-pro': 'gpt-5.1-pro', // unused, normalize TS map
+    'gpt-5.1-pro': 'gpt-5.1-pro',
     'gpt-5-pro': 'gpt-5-pro',
     'gpt-5.1': 'gpt-5.1',
     'gpt-5.1-codex': 'gpt-5.1-codex',
+    'gpt-5.2': 'gpt-5.2',
+    'gpt-5.2-instant': 'gpt-5.2-instant',
+    'gpt-5.2-pro': 'gpt-5.2-pro',
     'claude-4.5-sonnet': 'claude-4.5-sonnet',
     'claude-4.1-opus': 'claude-4.1-opus',
     'grok-4.1': 'grok-4.1',

package/dist/src/oracle/run.js

@@ -186,17 +186,14 @@ export async function runOracle(options, deps = {}) {
             : DEFAULT_TIMEOUT_NON_PRO_MS / 1000
         : options.timeoutSeconds;
     const timeoutMs = timeoutSeconds * 1000;
-    const apiModelFromConfig = modelConfig.apiModel ?? modelConfig.model;
-    const modelDowngraded = apiModelFromConfig === 'gpt-5.1-pro';
-    const resolvedApiModelId = modelDowngraded ? 'gpt-5-pro' : apiModelFromConfig;
     // Track the concrete model id we dispatch to (especially for Gemini preview aliases)
     const effectiveModelId = options.effectiveModelId ??
         (options.model.startsWith('gemini')
             ? resolveGeminiModelId(options.model)
-            : resolvedApiModelId);
+            : (modelConfig.apiModel ?? modelConfig.model));
     const headerModelLabel = richTty ? chalk.cyan(modelConfig.model) : modelConfig.model;
     const requestBody = buildRequestBody({
-        modelConfig: { ...modelConfig, apiModel: resolvedApiModelId },
+        modelConfig,
         systemPrompt,
         userPrompt: promptWithFiles,
         searchEnabled,
@@ -222,8 +219,8 @@ export async function runOracle(options, deps = {}) {
         if (baseUrl) {
             log(dim(`Base URL: ${formatBaseUrlForLog(baseUrl)}`));
         }
-        if (modelDowngraded) {
-            log(dim('gpt-5.1-pro is not yet available via API; sending request with gpt-5-pro instead.'));
+        if (effectiveModelId !== modelConfig.model) {
+            log(dim(`Resolved model: ${modelConfig.model} → ${effectiveModelId}`));
         }
         if (options.background && !supportsBackground) {
             log(dim('Background runs are not supported for this model; streaming in foreground instead.'));

package/dist/src/oracleHome.js

@@ -0,0 +1,13 @@
+import os from 'node:os';
+import path from 'node:path';
+let oracleHomeDirOverride = null;
+/**
+ * Test-only hook: avoid mutating process.env (shared across Vitest worker threads).
+ * This override is scoped to the current Node worker.
+ */
+export function setOracleHomeDirOverrideForTest(dir) {
+    oracleHomeDirOverride = dir;
+}
+export function getOracleHomeDir() {
+    return oracleHomeDirOverride ?? process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+}

package/dist/src/sessionManager.js

@@ -1,11 +1,12 @@
-import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import { createWriteStream } from 'node:fs';
 import { DEFAULT_MODEL } from './oracle.js';
 import { safeModelSlug } from './oracle/modelResolver.js';
-const ORACLE_HOME = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
-const SESSIONS_DIR = path.join(ORACLE_HOME, 'sessions');
+import { getOracleHomeDir } from './oracleHome.js';
+export function getSessionsDir() {
+    return path.join(getOracleHomeDir(), 'sessions');
+}
 const METADATA_FILENAME = 'meta.json';
 const LEGACY_SESSION_FILENAME = 'session.json';
 const LEGACY_REQUEST_FILENAME = 'request.json';
@@ -22,7 +23,7 @@ async function ensureDir(dirPath) {
     await fs.mkdir(dirPath, { recursive: true });
 }
 export async function ensureSessionStorage() {
-    await ensureDir(SESSIONS_DIR);
+    await ensureDir(getSessionsDir());
 }
 function slugify(text, maxWords = MAX_SLUG_WORDS) {
     const normalized = text?.toLowerCase() ?? '';
@@ -50,7 +51,7 @@ export function createSessionId(prompt, customSlug) {
     return slugify(prompt);
 }
 function sessionDir(id) {
-    return path.join(SESSIONS_DIR, id);
+    return path.join(getSessionsDir(), id);
 }
 function metaPath(id) {
     return path.join(sessionDir(id), METADATA_FILENAME);
@@ -191,6 +192,7 @@ export async function initializeSession(options, cwd, notifications) {
             browserConfig,
             verbose: options.verbose,
             heartbeatIntervalMs: options.heartbeatIntervalMs,
+            browserAttachments: options.browserAttachments,
             browserInlineFiles: options.browserInlineFiles,
             browserBundleFiles: options.browserBundleFiles,
             background: options.background,
@@ -287,7 +289,7 @@ export function createSessionLogWriter(sessionId, model) {
 }
 export async function listSessionsMetadata() {
     await ensureSessionStorage();
-    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
+    const entries = await fs.readdir(getSessionsDir()).catch(() => []);
     const metas = [];
     for (const entry of entries) {
         let meta = await readSessionMetadata(entry);
@@ -379,7 +381,7 @@ export async function readSessionRequest(sessionId) {
 }
 export async function deleteSessionsOlderThan({ hours = 24, includeAll = false, } = {}) {
     await ensureSessionStorage();
-    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
+    const entries = await fs.readdir(getSessionsDir()).catch(() => []);
     if (!entries.length) {
         return { deleted: 0, remaining: 0 };
     }
@@ -415,7 +417,7 @@ export async function deleteSessionsOlderThan({ hours = 24, includeAll = false,
 export async function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export { ORACLE_HOME, SESSIONS_DIR, MAX_STATUS_LIMIT };
+export { MAX_STATUS_LIMIT };
 export { ZOMBIE_MAX_AGE_MS };
 export async function getSessionPaths(sessionId) {
     const dir = sessionDir(sessionId);

package/dist/src/sessionStore.js

@@ -1,4 +1,4 @@
-import { ensureSessionStorage, initializeSession, readSessionMetadata, updateSessionMetadata, createSessionLogWriter, readSessionLog, readModelLog, readSessionRequest, listSessionsMetadata, filterSessionsByRange, deleteSessionsOlderThan, updateModelRunMetadata, getSessionPaths, SESSIONS_DIR, } from './sessionManager.js';
+import { ensureSessionStorage, initializeSession, readSessionMetadata, updateSessionMetadata, createSessionLogWriter, readSessionLog, readModelLog, readSessionRequest, listSessionsMetadata, filterSessionsByRange, deleteSessionsOlderThan, updateModelRunMetadata, getSessionPaths, getSessionsDir, } from './sessionManager.js';
 class FileSessionStore {
     ensureStorage() {
         return ensureSessionStorage();
@@ -40,7 +40,7 @@ class FileSessionStore {
         return getSessionPaths(sessionId);
     }
     sessionsDir() {
-        return SESSIONS_DIR;
+        return getSessionsDir();
     }
 }
 export const sessionStore = new FileSessionStore();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.5.4",
-  "description": "CLI wrapper around OpenAI Responses API with GPT-5.1 Pro, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
+  "version": "0.6.0",
+  "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",
   "bin": {
@@ -30,11 +30,7 @@
         "name": "node",
         "version": ">=20"
       }
-    ],
-    "packageManager": {
-      "name": "pnpm",
-      "version": ">=8"
-    }
+    ]
   },
   "keywords": [],
   "author": "",