@steipete/oracle 1.1.0 → 1.3.0

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

@@ -9,7 +9,8 @@ export async function ensureModelSelection(Runtime, desiredModel, logger) {
     const result = outcome.result?.value;
     switch (result?.status) {
         case 'already-selected':
-        case 'switched': {
+        case 'switched':
+        case 'switched-best-effort': {
             const label = result.label ?? desiredModel;
             logger(`Model picker: ${label}`);
             return;
@@ -24,18 +25,26 @@ export async function ensureModelSelection(Runtime, desiredModel, logger) {
         }
     }
 }
+/**
+ * Builds the DOM expression that runs inside the ChatGPT tab to select a model.
+ * The string is evaluated inside Chrome, so keep it self-contained and well-commented.
+ */
 function buildModelSelectionExpression(targetModel) {
     const matchers = buildModelMatchersLiteral(targetModel);
     const labelLiteral = JSON.stringify(matchers.labelTokens);
     const idLiteral = JSON.stringify(matchers.testIdTokens);
+    const primaryLabelLiteral = JSON.stringify(targetModel);
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
     return `(() => {
+    // Capture the selectors and matcher literals up front so the browser expression stays pure.
     const BUTTON_SELECTOR = '${MODEL_BUTTON_SELECTOR}';
     const LABEL_TOKENS = ${labelLiteral};
     const TEST_IDS = ${idLiteral};
-    const CLICK_INTERVAL_MS = 50;
-    const MAX_WAIT_MS = 12000;
+    const PRIMARY_LABEL = ${primaryLabelLiteral};
+    const INITIAL_WAIT_MS = 150;
+    const REOPEN_INTERVAL_MS = 400;
+    const MAX_WAIT_MS = 20000;
     const normalizeText = (value) => {
       if (!value) {
         return '';
@@ -46,6 +55,12 @@ function buildModelSelectionExpression(targetModel) {
         .replace(/\\s+/g, ' ')
         .trim();
     };
+    // Normalize every candidate token to keep fuzzy matching deterministic.
+    const normalizedTarget = normalizeText(PRIMARY_LABEL);
+    const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
+      .map((token) => normalizeText(token))
+      .filter(Boolean);
+    const targetWords = normalizedTarget.split(' ').filter(Boolean);
 
     const button = document.querySelector(BUTTON_SELECTOR);
     if (!button) {
@@ -54,6 +69,7 @@ function buildModelSelectionExpression(targetModel) {
 
     let lastPointerClick = 0;
     const pointerClick = () => {
+      // Some menus ignore synthetic click events.
       const down = new PointerEvent('pointerdown', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
       const up = new PointerEvent('pointerup', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
       const click = new MouseEvent('click', { bubbles: true });
@@ -86,64 +102,109 @@ function buildModelSelectionExpression(targetModel) {
       return false;
     };
 
-    const findOption = () => {
+    const scoreOption = (normalizedText, testid) => {
+      // Assign a score to every node so we can pick the most likely match without brittle equality checks.
+      if (!normalizedText && !testid) {
+        return 0;
+      }
+      let score = 0;
+      const normalizedTestId = (testid ?? '').toLowerCase();
+      if (normalizedTestId && TEST_IDS.some((id) => normalizedTestId.includes(id))) {
+        score += 1000;
+      }
+      if (normalizedText && normalizedTarget) {
+        if (normalizedText === normalizedTarget) {
+          score += 500;
+        } else if (normalizedText.startsWith(normalizedTarget)) {
+          score += 420;
+        } else if (normalizedText.includes(normalizedTarget)) {
+          score += 380;
+        }
+      }
+      for (const token of normalizedTokens) {
+        // Reward partial matches to the expanded label/token set.
+        if (token && normalizedText.includes(token)) {
+          const tokenWeight = Math.min(120, Math.max(10, token.length * 4));
+          score += tokenWeight;
+        }
+      }
+      if (targetWords.length > 1) {
+        let missing = 0;
+        for (const word of targetWords) {
+          if (!normalizedText.includes(word)) {
+            missing += 1;
+          }
+        }
+        score -= missing * 12;
+      }
+      return Math.max(score, 0);
+    };
+
+    const findBestOption = () => {
+      // Walk through every menu item and keep whichever earns the highest score.
+      let bestMatch = null;
       const menus = Array.from(document.querySelectorAll(${menuContainerLiteral}));
       for (const menu of menus) {
         const buttons = Array.from(menu.querySelectorAll(${menuItemLiteral}));
         for (const option of buttons) {
-          const testid = (option.getAttribute('data-testid') ?? '').toLowerCase();
           const text = option.textContent ?? '';
           const normalizedText = normalizeText(text);
-          const matchesTestId = testid && TEST_IDS.some((id) => testid.includes(id));
-          const matchesText = LABEL_TOKENS.some((token) => {
-            const normalizedToken = normalizeText(token);
-            if (!normalizedToken) {
-              return false;
-            }
-            return normalizedText.includes(normalizedToken);
-          });
-          if (matchesTestId || matchesText) {
-            return option;
+          const testid = option.getAttribute('data-testid') ?? '';
+          const score = scoreOption(normalizedText, testid);
+          if (score <= 0) {
+            continue;
+          }
+          const label = getOptionLabel(option);
+          if (!bestMatch || score > bestMatch.score) {
+            bestMatch = { node: option, label, score };
           }
         }
       }
-      return null;
+      return bestMatch;
     };
 
-    pointerClick();
     return new Promise((resolve) => {
       const start = performance.now();
       const ensureMenuOpen = () => {
         const menuOpen = document.querySelector('[role="menu"], [data-radix-collection-root]');
-        if (!menuOpen && performance.now() - lastPointerClick > 300) {
+        if (!menuOpen && performance.now() - lastPointerClick > REOPEN_INTERVAL_MS) {
           pointerClick();
         }
       };
-      const attempt = () => {
+
+      // Open once and wait a tick before first scan.
+      pointerClick();
+      const openDelay = () => new Promise((r) => setTimeout(r, INITIAL_WAIT_MS));
+      let initialized = false;
+      const attempt = async () => {
+        if (!initialized) {
+          initialized = true;
+          await openDelay();
+        }
         ensureMenuOpen();
-        const option = findOption();
-        if (option) {
-          if (optionIsSelected(option)) {
-            resolve({ status: 'already-selected', label: getOptionLabel(option) });
+        const match = findBestOption();
+        if (match) {
+          if (optionIsSelected(match.node)) {
+            resolve({ status: 'already-selected', label: match.label });
             return;
           }
-          option.click();
-          resolve({ status: 'switched', label: getOptionLabel(option) });
+          match.node.click();
+          resolve({ status: 'switched', label: match.label });
           return;
         }
         if (performance.now() - start > MAX_WAIT_MS) {
           resolve({ status: 'option-not-found' });
           return;
         }
-        if (performance.now() - lastPointerClick > 500) {
-          pointerClick();
-        }
-        setTimeout(attempt, CLICK_INTERVAL_MS);
+        setTimeout(attempt, REOPEN_INTERVAL_MS / 2);
       };
       attempt();
     });
   })()`;
 }
+export function buildModelMatchersLiteralForTest(targetModel) {
+    return buildModelMatchersLiteral(targetModel);
+}
 function buildModelMatchersLiteral(targetModel) {
     const base = targetModel.trim().toLowerCase();
     const labelTokens = new Set();
@@ -164,6 +225,28 @@ function buildModelMatchersLiteral(targetModel) {
     push(`chatgpt ${dotless}`, labelTokens);
     push(`gpt ${base}`, labelTokens);
     push(`gpt ${dotless}`, labelTokens);
+    // Numeric variations (5.1 ↔ 51 ↔ gpt-5-1)
+    if (base.includes('5.1') || base.includes('5-1') || base.includes('51')) {
+        push('5.1', labelTokens);
+        push('gpt-5.1', labelTokens);
+        push('gpt5.1', labelTokens);
+        push('gpt-5-1', labelTokens);
+        push('gpt5-1', labelTokens);
+        push('gpt51', labelTokens);
+        push('chatgpt 5.1', labelTokens);
+        testIdTokens.add('gpt-5-1');
+        testIdTokens.add('gpt5-1');
+        testIdTokens.add('gpt51');
+    }
+    // Pro / research variants
+    if (base.includes('pro')) {
+        push('proresearch', labelTokens);
+        push('research grade', labelTokens);
+        push('advanced reasoning', labelTokens);
+        testIdTokens.add('gpt-5-pro');
+        testIdTokens.add('pro');
+        testIdTokens.add('proresearch');
+    }
     base
         .split(/\s+/)
         .map((token) => token.trim())
@@ -175,8 +258,10 @@ function buildModelMatchersLiteral(targetModel) {
     push(hyphenated, testIdTokens);
     push(collapsed, testIdTokens);
     push(dotless, testIdTokens);
+    // data-testid values observed in the ChatGPT picker (e.g., model-switcher-gpt-5-pro)
     push(`model-switcher-${hyphenated}`, testIdTokens);
     push(`model-switcher-${collapsed}`, testIdTokens);
+    push(`model-switcher-${dotless}`, testIdTokens);
     if (!labelTokens.size) {
         labelTokens.add(base);
     }
@@ -188,3 +273,6 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens: Array.from(testIdTokens).filter(Boolean),
     };
 }
+export function buildModelSelectionExpressionForTest(targetModel) {
+    return buildModelSelectionExpression(targetModel);
+}

package/dist/src/browser/config.js

@@ -6,6 +6,9 @@ export const DEFAULT_BROWSER_CONFIG = {
     timeoutMs: 900_000,
     inputTimeoutMs: 30_000,
     cookieSync: true,
+    cookieNames: null,
+    inlineCookies: null,
+    inlineCookiesSource: null,
     headless: false,
     keepBrowser: false,
     hideWindow: false,
@@ -21,6 +24,9 @@ export function resolveBrowserConfig(config) {
         timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
         inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
         cookieSync: config?.cookieSync ?? DEFAULT_BROWSER_CONFIG.cookieSync,
+        cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
+        inlineCookies: config?.inlineCookies ?? DEFAULT_BROWSER_CONFIG.inlineCookies,
+        inlineCookiesSource: config?.inlineCookiesSource ?? DEFAULT_BROWSER_CONFIG.inlineCookiesSource,
         headless: config?.headless ?? DEFAULT_BROWSER_CONFIG.headless,
         keepBrowser: config?.keepBrowser ?? DEFAULT_BROWSER_CONFIG.keepBrowser,
         hideWindow: config?.hideWindow ?? DEFAULT_BROWSER_CONFIG.hideWindow,

package/dist/src/browser/cookies.js

@@ -4,21 +4,18 @@ import { fileURLToPath } from 'node:url';
 import { COOKIE_URLS } from './constants.js';
 export class ChromeCookieSyncError extends Error {
 }
-export async function syncCookies(Network, url, profile, logger, allowErrors = false) {
+export async function syncCookies(Network, url, profile, logger, options = {}) {
+    const { allowErrors = false, filterNames, inlineCookies } = options;
     try {
-        const cookies = await readChromeCookies(url, profile);
+        const cookies = inlineCookies?.length
+            ? normalizeInlineCookies(inlineCookies, new URL(url).hostname)
+            : await readChromeCookies(url, profile, filterNames ?? undefined);
         if (!cookies.length) {
             return 0;
         }
         let applied = 0;
         for (const cookie of cookies) {
-            const cookieWithUrl = { ...cookie };
-            if (!cookieWithUrl.domain || cookieWithUrl.domain === 'localhost') {
-                cookieWithUrl.url = url;
-            }
-            else if (!cookieWithUrl.domain.startsWith('.')) {
-                cookieWithUrl.url = `https://${cookieWithUrl.domain}`;
-            }
+            const cookieWithUrl = attachUrl(cookie, url);
             try {
                 const result = await Network.setCookie(cookieWithUrl);
                 if (result?.success) {
@@ -41,10 +38,11 @@ export async function syncCookies(Network, url, profile, logger, allowErrors = f
         throw error instanceof ChromeCookieSyncError ? error : new ChromeCookieSyncError(message);
     }
 }
-async function readChromeCookies(url, profile) {
+async function readChromeCookies(url, profile, filterNames) {
     const chromeModule = await loadChromeCookiesModule();
     const urlsToCheck = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
     const merged = new Map();
+    const allowlist = normalizeCookieNames(filterNames);
     for (const candidateUrl of urlsToCheck) {
         let rawCookies;
         rawCookies = await chromeModule.getCookiesPromised(candidateUrl, 'puppeteer', profile ?? undefined);
@@ -54,7 +52,7 @@ async function readChromeCookies(url, profile) {
         const fallbackHostname = new URL(candidateUrl).hostname;
         for (const cookie of rawCookies) {
             const normalized = normalizeCookie(cookie, fallbackHostname);
-            if (!normalized) {
+            if (!normalized || (allowlist && !allowlist.has(normalized.name))) {
                 continue;
             }
             const key = `${normalized.domain ?? fallbackHostname}:${normalized.name}`;
@@ -83,6 +81,46 @@ function normalizeCookie(cookie, fallbackHost) {
         httpOnly,
     };
 }
+function normalizeInlineCookies(rawCookies, fallbackHost) {
+    const merged = new Map();
+    for (const cookie of rawCookies) {
+        if (!cookie?.name)
+            continue;
+        const normalized = {
+            ...cookie,
+            name: cookie.name,
+            value: cookie.value ?? '',
+            domain: cookie.domain ?? fallbackHost,
+            path: cookie.path ?? '/',
+            expires: normalizeExpiration(cookie.expires),
+            secure: cookie.secure ?? true,
+            httpOnly: cookie.httpOnly ?? false,
+        };
+        const key = `${normalized.domain ?? fallbackHost}:${normalized.name}`;
+        if (!merged.has(key)) {
+            merged.set(key, normalized);
+        }
+    }
+    return Array.from(merged.values());
+}
+function normalizeCookieNames(names) {
+    if (!names || names.length === 0) {
+        return null;
+    }
+    return new Set(names.map((name) => name.trim()).filter(Boolean));
+}
+function attachUrl(cookie, fallbackUrl) {
+    const cookieWithUrl = { ...cookie };
+    if (!cookieWithUrl.url) {
+        if (!cookieWithUrl.domain || cookieWithUrl.domain === 'localhost') {
+            cookieWithUrl.url = fallbackUrl;
+        }
+        else if (!cookieWithUrl.domain.startsWith('.')) {
+            cookieWithUrl.url = `https://${cookieWithUrl.domain}`;
+        }
+    }
+    return cookieWithUrl;
+}
 function stripQuery(url) {
     try {
         const parsed = new URL(url);
@@ -177,7 +215,7 @@ async function attemptSqliteRebuild() {
     }
     attemptedSqliteRebuild = true;
     if (process.env.ORACLE_ALLOW_SQLITE_REBUILD !== '1') {
-        console.warn('[oracle] sqlite3 bindings missing. Set ORACLE_ALLOW_SQLITE_REBUILD=1 if you want Oracle to attempt an automatic rebuild, or run `pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root` manually.');
+        console.warn('[oracle] sqlite3 bindings missing. Set ORACLE_ALLOW_SQLITE_REBUILD=1 if you want oracle to attempt an automatic rebuild, or run `pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root` manually.');
         return false;
     }
     const pnpmCommand = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';

package/dist/src/browser/index.js

@@ -64,10 +64,24 @@ export async function runBrowserMode(options) {
         await Promise.all(domainEnablers);
         await Network.clearBrowserCookies();
         if (config.cookieSync) {
-            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, config.allowCookieErrors ?? false);
+            if (!config.inlineCookies) {
+                logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; approve it to stay signed in or rerun with --browser-no-cookie-sync / --browser-allow-cookie-errors / --browser-inline-cookies[(-file)]. Inline cookies skip Chrome + Keychain entirely.');
+            }
+            else {
+                logger('Applying inline cookies (skipping Chrome profile read and Keychain prompt)');
+            }
+            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
+                allowErrors: config.allowCookieErrors ?? false,
+                filterNames: config.cookieNames ?? undefined,
+                inlineCookies: config.inlineCookies ?? undefined,
+            });
             logger(cookieCount > 0
-                ? `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
-                : 'No Chrome cookies found; continuing without session reuse');
+                ? config.inlineCookies
+                    ? `Applied ${cookieCount} inline cookies`
+                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
+                : config.inlineCookies
+                    ? 'No inline cookies applied; continuing without session reuse'
+                    : 'No Chrome cookies found; continuing without session reuse');
         }
         else {
             logger('Skipping Chrome cookie sync (--browser-no-cookie-sync)');
@@ -155,7 +169,7 @@ export async function runBrowserMode(options) {
             logger(`Chrome window closed before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
-        throw new Error('Chrome window closed before Oracle finished. Please keep it open until completion.', {
+        throw new Error('Chrome window closed before oracle finished. Please keep it open until completion.', {
             cause: normalizedError,
         });
     }
@@ -211,7 +225,7 @@ export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
         .toString()
         .padStart(3, ' ');
     const statusLabel = message ? ` — ${message}` : '';
-    return `[${elapsedText} / ~10m] ${bar} ${pct}%${statusLabel}${locatorSuffix}`;
+    return `${bar} ${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
 }
 function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false) {
     let stopped = false;

package/dist/src/browser/prompt.js

@@ -1,14 +1,14 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { readFiles, createFileSections, DEFAULT_SYSTEM_PROMPT, MODEL_CONFIGS, TOKENIZER_OPTIONS } from '../oracle.js';
+import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS } from '../oracle.js';
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
     const files = await readFilesFn(runOptions.file ?? [], { cwd });
     const basePrompt = (runOptions.prompt ?? '').trim();
     const userPrompt = basePrompt;
-    const systemPrompt = runOptions.system?.trim() || DEFAULT_SYSTEM_PROMPT;
+    const systemPrompt = runOptions.system?.trim() || '';
     const sections = createFileSections(files, cwd);
     const lines = ['[SYSTEM]', systemPrompt, '', '[USER]', userPrompt, ''];
     sections.forEach((section) => {
@@ -43,7 +43,8 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             sizeBytes: Buffer.byteLength(section.content, 'utf8'),
         }));
     const MAX_BROWSER_ATTACHMENTS = 10;
-    if (!inlineFiles && attachments.length > MAX_BROWSER_ATTACHMENTS) {
+    const shouldBundle = !inlineFiles && (runOptions.browserBundleFiles || attachments.length > MAX_BROWSER_ATTACHMENTS);
+    if (shouldBundle) {
         const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-browser-bundle-'));
         const bundlePath = path.join(bundleDir, 'attachments-bundle.txt');
         const bundleLines = [];
@@ -57,7 +58,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         attachments.length = 0;
         attachments.push({
             path: bundlePath,
-            displayPath: 'attachments-bundle.txt',
+            displayPath: bundlePath,
             sizeBytes: Buffer.byteLength(bundleText, 'utf8'),
         });
     }
@@ -81,7 +82,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         attachments,
         inlineFileCount,
         tokenEstimateIncludesInlineFiles,
-        bundled: !inlineFiles && attachments.length === 1 && sections.length > MAX_BROWSER_ATTACHMENTS && attachments[0]?.displayPath
+        bundled: shouldBundle && attachments.length === 1 && attachments[0]?.displayPath
             ? { originalCount: sections.length, bundlePath: attachments[0].displayPath }
             : null,
     };

package/dist/src/browser/sessionRunner.js

@@ -4,6 +4,11 @@ import { runBrowserMode } from '../browserMode.js';
 import { assembleBrowserPrompt } from './prompt.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log, cliVersion }, deps = {}) {
+    if (runOptions.model.startsWith('gemini')) {
+        throw new BrowserAutomationError('Gemini models are not available in browser mode. Re-run with --engine api.', {
+            stage: 'preflight',
+        });
+    }
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
     const promptArtifacts = await assemblePrompt(runOptions, { cwd });
@@ -16,14 +21,17 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             const attachmentList = promptArtifacts.attachments.map((attachment) => attachment.displayPath).join(', ');
             log(chalk.dim(`[verbose] Browser attachments: ${attachmentList}`));
             if (promptArtifacts.bundled) {
-                log(chalk.yellow(`[browser] More than 10 files provided; bundled ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath} to satisfy ChatGPT upload limits.`));
+                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).'));
         }
     }
-    const headerLine = `Oracle (${cliVersion}) launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens`;
+    const headerLine = `oracle (${cliVersion}) launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens`;
+    if (promptArtifacts.bundled) {
+        log(chalk.yellow(`[browser] Packed ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath}. If automation fails, you can drag this file into ChatGPT manually.`));
+    }
     const automationLogger = ((message) => {
         if (typeof message === 'string') {
             log(message);
@@ -56,6 +64,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         log(browserResult.answerMarkdown || browserResult.answerText || chalk.dim('(no text output)'));
         log('');
     }
+    const answerText = browserResult.answerMarkdown || browserResult.answerText || '';
     const usage = {
         inputTokens: promptArtifacts.estimatedInputTokens,
         outputTokens: browserResult.answerTokens,
@@ -63,7 +72,8 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         totalTokens: promptArtifacts.estimatedInputTokens + browserResult.answerTokens,
     };
     const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
-    const statsParts = [`${runOptions.model}[browser]`, `tok(i/o/r/t)=${tokensDisplay}`];
+    const tokensLabel = runOptions.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
+    const statsParts = [`${runOptions.model}[browser]`, `${tokensLabel}=${tokensDisplay}`];
     if (runOptions.file && runOptions.file.length > 0) {
         statsParts.push(`files=${runOptions.file.length}`);
     }
@@ -76,5 +86,6 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             chromePort: browserResult.chromePort,
             userDataDir: browserResult.userDataDir,
         },
+        answerText,
     };
 }

package/dist/src/cli/browserConfig.js

@@ -1,16 +1,28 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
 import { DEFAULT_MODEL_TARGET, parseDuration } from '../browserMode.js';
 const DEFAULT_BROWSER_TIMEOUT_MS = 900_000;
 const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 30_000;
 const DEFAULT_CHROME_PROFILE = 'Default';
 const BROWSER_MODEL_LABELS = {
     'gpt-5-pro': 'GPT-5 Pro',
-    'gpt-5.1': 'ChatGPT 5.1',
+    'gpt-5.1': 'GPT-5.1',
+    'gemini-3-pro': 'Gemini 3 Pro',
 };
-export function buildBrowserConfig(options) {
+export async function buildBrowserConfig(options) {
     const desiredModelOverride = options.browserModelLabel?.trim();
     const normalizedOverride = desiredModelOverride?.toLowerCase() ?? '';
     const baseModel = options.model.toLowerCase();
     const shouldUseOverride = normalizedOverride.length > 0 && normalizedOverride !== baseModel;
+    const cookieNames = parseCookieNames(options.browserCookieNames ?? process.env.ORACLE_BROWSER_COOKIE_NAMES);
+    const inline = await resolveInlineCookies({
+        inlineArg: options.browserInlineCookies,
+        inlineFileArg: options.browserInlineCookiesFile,
+        envPayload: process.env.ORACLE_BROWSER_COOKIES_JSON,
+        envFile: process.env.ORACLE_BROWSER_COOKIES_FILE,
+        cwd: process.cwd(),
+    });
     return {
         chromeProfile: options.browserChromeProfile ?? DEFAULT_CHROME_PROFILE,
         chromePath: options.browserChromePath ?? null,
@@ -20,6 +32,9 @@ export function buildBrowserConfig(options) {
             ? parseDuration(options.browserInputTimeout, DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
             : undefined,
         cookieSync: options.browserNoCookieSync ? false : undefined,
+        cookieNames,
+        inlineCookies: inline?.cookies,
+        inlineCookiesSource: inline?.source ?? null,
         headless: options.browserHeadless ? true : undefined,
         keepBrowser: options.browserKeepBrowser ? true : undefined,
         hideWindow: options.browserHideWindow ? true : undefined,
@@ -42,3 +57,95 @@ export function resolveBrowserModelLabel(input, model) {
     }
     return trimmed;
 }
+function parseCookieNames(raw) {
+    if (!raw)
+        return undefined;
+    const names = raw
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    return names.length ? names : undefined;
+}
+async function resolveInlineCookies({ inlineArg, inlineFileArg, envPayload, envFile, cwd, }) {
+    const tryLoad = async (source, allowPathResolution) => {
+        if (!source)
+            return undefined;
+        const trimmed = source.trim();
+        if (!trimmed)
+            return undefined;
+        if (allowPathResolution) {
+            const resolved = path.isAbsolute(trimmed) ? trimmed : path.join(cwd, trimmed);
+            try {
+                const stat = await fs.stat(resolved);
+                if (stat.isFile()) {
+                    const fileContent = await fs.readFile(resolved, 'utf8');
+                    const parsed = parseInlineCookiesPayload(fileContent);
+                    if (parsed)
+                        return parsed;
+                }
+            }
+            catch {
+                // not a file; treat as payload below
+            }
+        }
+        return parseInlineCookiesPayload(trimmed);
+    };
+    const sources = [
+        { value: inlineFileArg, allowPath: true, source: 'inline-file' },
+        { value: inlineArg, allowPath: true, source: 'inline-arg' },
+        { value: envFile, allowPath: true, source: 'env-file' },
+        { value: envPayload, allowPath: false, source: 'env-payload' },
+    ];
+    for (const { value, allowPath, source } of sources) {
+        const parsed = await tryLoad(value, allowPath);
+        if (parsed)
+            return { cookies: parsed, source };
+    }
+    // fallback: ~/.oracle/cookies.{json,base64}
+    const oracleHome = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+    const candidates = ['cookies.json', 'cookies.base64'];
+    for (const file of candidates) {
+        const fullPath = path.join(oracleHome, file);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (!stat.isFile())
+                continue;
+            const content = await fs.readFile(fullPath, 'utf8');
+            const parsed = parseInlineCookiesPayload(content);
+            if (parsed)
+                return { cookies: parsed, source: `home:${file}` };
+        }
+        catch {
+            // ignore missing/invalid
+        }
+    }
+    return undefined;
+}
+function parseInlineCookiesPayload(raw) {
+    if (!raw)
+        return undefined;
+    const text = raw.trim();
+    if (!text)
+        return undefined;
+    let jsonPayload = text;
+    // Attempt base64 decode first; fall back to raw text on failure.
+    try {
+        const decoded = Buffer.from(text, 'base64').toString('utf8');
+        if (decoded.trim().startsWith('[')) {
+            jsonPayload = decoded;
+        }
+    }
+    catch {
+        // not base64; continue with raw text
+    }
+    try {
+        const parsed = JSON.parse(jsonPayload);
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // invalid json; skip silently to keep this hidden flag non-fatal
+    }
+    return undefined;
+}

package/dist/src/cli/detach.js

@@ -0,0 +1,12 @@
+export function shouldDetachSession({ 
+// Params kept for future policy tweaks; currently only model/disableDetachEnv matter.
+engine: _engine, model, waitPreference: _waitPreference, disableDetachEnv, }) {
+    if (disableDetachEnv)
+        return false;
+    // Gemini runs must stay inline: forcing detachment can launch the background session runner,
+    // which previously led to silent hangs when Gemini picked the browser path. Keep it simple: no detach.
+    if (model.startsWith('gemini'))
+        return false;
+    // For other models, keep legacy behavior (detach if allowed, then reattach when waitPreference=true).
+    return true;
+}