@steipete/oracle 1.2.0 → 1.3.0

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;
+}

package/dist/src/cli/dryRun.js

@@ -2,9 +2,9 @@ import chalk from 'chalk';
 import { MODEL_CONFIGS, TOKENIZER_OPTIONS, DEFAULT_SYSTEM_PROMPT, buildPrompt, readFiles, getFileTokenStats, printFileTokenStats, } from '../oracle.js';
 import { assembleBrowserPrompt } from '../browser/prompt.js';
 import { buildTokenEstimateSuffix, formatAttachmentLabel } from '../browser/promptSummary.js';
-export async function runDryRunSummary({ engine, runOptions, cwd, version, log, }, deps = {}) {
+export async function runDryRunSummary({ engine, runOptions, cwd, version, log, browserConfig, }, deps = {}) {
     if (engine === 'browser') {
-        await runBrowserDryRun({ runOptions, cwd, version, log }, deps);
+        await runBrowserDryRun({ runOptions, cwd, version, log, browserConfig }, deps);
         return;
     }
     await runApiDryRun({ runOptions, cwd, version, log }, deps);
@@ -34,14 +34,30 @@ async function runApiDryRun({ runOptions, cwd, version, log, }, deps) {
     });
     printFileTokenStats(stats, { inputTokenBudget: inputBudget, log });
 }
-async function runBrowserDryRun({ runOptions, cwd, version, log, }, deps) {
+async function runBrowserDryRun({ runOptions, cwd, version, log, browserConfig, }, deps) {
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
     const suffix = buildTokenEstimateSuffix(artifacts);
     const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
     log(chalk.cyan(headerLine));
+    logBrowserCookieStrategy(browserConfig, log, 'dry-run');
     logBrowserFileSummary(artifacts, log, 'dry-run');
 }
+function logBrowserCookieStrategy(browserConfig, log, label) {
+    if (!browserConfig)
+        return;
+    if (browserConfig.inlineCookies && browserConfig.inlineCookies.length > 0) {
+        const source = browserConfig.inlineCookiesSource ?? 'inline';
+        log(chalk.bold(`[${label}] Cookies: inline payload (${browserConfig.inlineCookies.length}) via ${source}.`));
+        return;
+    }
+    if (browserConfig.cookieSync === false) {
+        log(chalk.bold(`[${label}] Cookies: sync disabled (--browser-no-cookie-sync).`));
+        return;
+    }
+    const allowlist = browserConfig.cookieNames?.length ? browserConfig.cookieNames.join(', ') : 'all from Chrome profile';
+    log(chalk.bold(`[${label}] Cookies: copy from Chrome (${allowlist}).`));
+}
 function logBrowserFileSummary(artifacts, log, label) {
     if (artifacts.attachments.length > 0) {
         const prefix = artifacts.bundled ? `[${label}] Bundled upload:` : `[${label}] Attachments to upload:`;

package/dist/src/cli/help.js

@@ -43,8 +43,10 @@ function renderHelpBanner(version, colors) {
 }
 function renderHelpFooter(program, colors) {
     const tips = [
+        `${colors.bullet('•')} Oracle cannot see your project unless you pass ${colors.accent('--file …')} — attach the files/dirs you want it to read.`,
         `${colors.bullet('•')} Attach lots of source (whole directories beat single files) and keep total input under ~196k tokens.`,
         `${colors.bullet('•')} Oracle starts empty—open with a short project briefing (stack, services, build steps), spell out the question and prior attempts, and why it matters; the more explanation and context you provide, the better the response will be.`,
+        `${colors.bullet('•')} Best results: 6–30 sentences plus key source files; very short prompts often yield generic answers.`,
         `${colors.bullet('•')} Oracle is one-shot: it does not remember prior runs, so start fresh each time with full context.`,
         `${colors.bullet('•')} Run ${colors.accent('--files-report')} to inspect token spend before hitting the API.`,
         `${colors.bullet('•')} Non-preview runs spawn detached sessions (especially gpt-5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent('oracle session <slug>')} to resume/inspect the existing run.`,

package/dist/src/cli/options.js

@@ -75,11 +75,30 @@ export function parseSearchOption(value) {
 export function normalizeModelOption(value) {
     return (value ?? '').trim();
 }
+export function normalizeBaseUrl(value) {
+    const trimmed = value?.trim();
+    return trimmed?.length ? trimmed : undefined;
+}
+export function parseTimeoutOption(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'auto')
+        return 'auto';
+    const parsed = Number.parseFloat(normalized);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError('Timeout must be a positive number of seconds or "auto".');
+    }
+    return parsed;
+}
 export function resolveApiModel(modelValue) {
     const normalized = normalizeModelOption(modelValue).toLowerCase();
     if (normalized in MODEL_CONFIGS) {
         return normalized;
     }
+    if (normalized.includes('gemini')) {
+        return 'gemini-3-pro';
+    }
     throw new InvalidArgumentError(`Unsupported model "${modelValue}". Choose one of: ${Object.keys(MODEL_CONFIGS).join(', ')}`);
 }
 export function inferModelFromLabel(modelValue) {
@@ -90,6 +109,9 @@ export function inferModelFromLabel(modelValue) {
     if (normalized in MODEL_CONFIGS) {
         return normalized;
     }
+    if (normalized.includes('gemini')) {
+        return 'gemini-3-pro';
+    }
     if (normalized.includes('pro')) {
         return 'gpt-5-pro';
     }

package/dist/src/cli/runOptions.js

@@ -1,14 +1,26 @@
 import { resolveEngine } from './engine.js';
-import { normalizeModelOption, inferModelFromLabel, resolveApiModel } from './options.js';
+import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBaseUrl } from './options.js';
+import { resolveGeminiModelId } from '../oracle/gemini.js';
 export function resolveRunOptionsFromConfig({ prompt, files = [], model, engine, userConfig, env = process.env, }) {
     const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
+    const browserRequested = engine === 'browser';
     const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || 'gpt-5-pro';
     const resolvedModel = resolvedEngine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const isGemini = resolvedModel.startsWith('gemini');
+    // Keep the resolved model id alongside the canonical model name so we can log
+    // and dispatch the exact identifier (useful for Gemini preview aliases).
+    const effectiveModelId = isGemini ? resolveGeminiModelId(resolvedModel) : resolvedModel;
+    if (isGemini && browserRequested) {
+        throw new Error('Gemini is only supported via API. Use --engine api.');
+    }
+    // When Gemini is selected, always force API engine (overrides config/env auto browser).
+    const fixedEngine = isGemini ? 'api' : resolvedEngine;
     const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0
         ? `${prompt.trim()}\n${userConfig.promptSuffix}`
         : prompt;
     const search = userConfig?.search !== 'off';
     const heartbeatIntervalMs = userConfig?.heartbeatSeconds !== undefined ? userConfig.heartbeatSeconds * 1000 : 30_000;
+    const baseUrl = normalizeBaseUrl(userConfig?.apiBaseUrl ?? env.OPENAI_BASE_URL);
     const runOptions = {
         prompt: promptWithSuffix,
         model: resolvedModel,
@@ -17,8 +29,10 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, engine,
         heartbeatIntervalMs,
         filesReport: userConfig?.filesReport,
         background: userConfig?.background,
+        baseUrl,
+        effectiveModelId,
     };
-    return { runOptions, resolvedEngine };
+    return { runOptions, resolvedEngine: fixedEngine };
 }
 function resolveEngineWithConfig({ engine, configEngine, env, }) {
     if (engine)

package/dist/src/cli/sessionRunner.js

@@ -17,6 +17,12 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
     const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     try {
         if (mode === 'browser') {
+            if (runOptions.model.startsWith('gemini')) {
+                throw new Error('Gemini models are not available in browser mode. Re-run with --engine api.');
+            }
+            if (process.platform !== 'darwin') {
+                throw new Error('Browser engine is only supported on macOS today. Use --engine api instead, or run on macOS.');
+            }
             if (!browserConfig) {
                 throw new Error('Missing browser configuration for session.');
             }
@@ -105,6 +111,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 }
                 : undefined,
         });
+        if (mode === 'browser') {
+            log(dim('Browser fallback:')); // guides users when automation breaks
+            log(dim('- Use --engine api to run the same prompt without Chrome.'));
+            log(dim('- Add --browser-bundle-files to bundle attachments into a single text file you can drag into ChatGPT.'));
+        }
         throw error;
     }
 }

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

@@ -16,79 +16,98 @@ const isTty = () => Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 const RECENT_WINDOW_HOURS = 24;
 const PAGE_SIZE = 10;
+const STATUS_PAD = 9;
+const MODEL_PAD = 13;
+const MODE_PAD = 7;
+const TIMESTAMP_PAD = 19;
+const CHARS_PAD = 5;
+const COST_PAD = 7;
 export async function launchTui({ version }) {
     const userConfig = (await loadUserConfig()).config;
     console.log(chalk.bold(`🧿 oracle v${version}`), dim('— Whispering your tokens to the silicon sage'));
     console.log('');
-    let olderOffset = 0;
+    let showingOlder = false;
     for (;;) {
-        const { recent, older, hasMoreOlder } = await fetchSessionBuckets(olderOffset);
+        const { recent, older, olderTotal } = await fetchSessionBuckets();
         const choices = [];
-        if (recent.length > 0) {
-            choices.push(new inquirer.Separator());
-            choices.push(new inquirer.Separator('Status  Model      Mode    Timestamp           Chars  Cost  Slug'));
-            choices.push(...recent.map(toSessionChoice));
-        }
-        else if (older.length > 0 && olderOffset === 0) {
-            choices.push(new inquirer.Separator());
-            choices.push(new inquirer.Separator('Status  Model      Mode    Timestamp           Chars  Cost  Slug'));
-            choices.push(...older.slice(0, PAGE_SIZE).map(toSessionChoice));
+        const headerLabel = dim(`${'Status'.padEnd(STATUS_PAD)} ${'Model'.padEnd(MODEL_PAD)} ${'Mode'.padEnd(MODE_PAD)} ${'Timestamp'.padEnd(TIMESTAMP_PAD)} ${'Chars'.padStart(CHARS_PAD)} ${'Cost'.padStart(COST_PAD)}  Slug`);
+        // Start with a selectable row so focus never lands on a separator
+        choices.push({ name: chalk.bold.green('ask oracle'), value: '__ask__' });
+        choices.push(new inquirer.Separator());
+        if (!showingOlder) {
+            if (recent.length > 0) {
+                choices.push(new inquirer.Separator(headerLabel));
+                choices.push(...recent.map(toSessionChoice));
+            }
+            else if (older.length > 0) {
+                // No recent entries; show first page of older.
+                choices.push(new inquirer.Separator(headerLabel));
+                choices.push(...older.slice(0, PAGE_SIZE).map(toSessionChoice));
+            }
         }
-        if (older.length > 0 && olderOffset > 0) {
-            choices.push(new inquirer.Separator());
-            choices.push(new inquirer.Separator('Status  Model      Mode    Timestamp           Chars  Cost  Slug'));
-            choices.push(...older.slice(0, PAGE_SIZE).map(toSessionChoice));
+        else if (older.length > 0) {
+            choices.push(new inquirer.Separator(headerLabel));
+            choices.push(...older.map(toSessionChoice));
         }
         choices.push(new inquirer.Separator());
         choices.push(new inquirer.Separator('Actions'));
         choices.push({ name: chalk.bold.green('ask oracle'), value: '__ask__' });
-        if (hasMoreOlder) {
-            choices.push({ name: 'Load older', value: '__more__' });
+        if (!showingOlder && olderTotal > 0) {
+            choices.push({ name: 'Older page', value: '__older__' });
         }
-        if (olderOffset > 0) {
-            choices.push({ name: 'Back to recent', value: '__reset__' });
+        else {
+            choices.push({ name: 'Newer (recent)', value: '__reset__' });
         }
         choices.push({ name: 'Exit', value: '__exit__' });
-        const { selection } = await inquirer.prompt([
-            {
-                name: 'selection',
-                type: 'list',
-                message: 'Select a session or action',
-                choices,
-                pageSize: 16,
-            },
-        ]);
+        const selection = await new Promise((resolve) => {
+            const prompt = inquirer.prompt([
+                {
+                    name: 'selection',
+                    type: 'list',
+                    message: 'Select a session or action',
+                    choices,
+                    pageSize: 16,
+                    loop: false,
+                },
+            ]);
+            prompt
+                .then(({ selection: answer }) => resolve(answer))
+                .catch((error) => {
+                console.error(chalk.red('Paging failed; returning to recent list.'), error instanceof Error ? error.message : error);
+                resolve('__reset__');
+            });
+        });
         if (selection === '__exit__') {
             console.log(chalk.green('🧿 Closing the book. See you next prompt.'));
             return;
         }
-        if (selection === '__more__') {
-            olderOffset += PAGE_SIZE;
+        if (selection === '__ask__') {
+            await askOracleFlow(version, userConfig);
             continue;
         }
-        if (selection === '__reset__') {
-            olderOffset = 0;
+        if (selection === '__older__') {
+            showingOlder = true;
             continue;
         }
-        if (selection === '__ask__') {
-            await askOracleFlow(version, userConfig);
+        if (selection === '__reset__') {
+            showingOlder = false;
             continue;
         }
         await showSessionDetail(selection);
     }
 }
-async function fetchSessionBuckets(olderOffset) {
+async function fetchSessionBuckets() {
     const all = await listSessionsMetadata();
     const cutoff = Date.now() - RECENT_WINDOW_HOURS * 60 * 60 * 1000;
     const recent = all.filter((meta) => new Date(meta.createdAt).getTime() >= cutoff).slice(0, PAGE_SIZE);
     const olderAll = all.filter((meta) => new Date(meta.createdAt).getTime() < cutoff);
-    const older = olderAll.slice(olderOffset, olderOffset + PAGE_SIZE);
-    const hasMoreOlder = olderAll.length > olderOffset + PAGE_SIZE;
+    const older = olderAll.slice(0, PAGE_SIZE);
+    const hasMoreOlder = olderAll.length > PAGE_SIZE;
     if (recent.length === 0 && older.length === 0 && olderAll.length > 0) {
         // No recent entries; fall back to top 10 overall.
-        return { recent: olderAll.slice(0, PAGE_SIZE), older: [], hasMoreOlder: olderAll.length > PAGE_SIZE };
+        return { recent: olderAll.slice(0, PAGE_SIZE), older: [], hasMoreOlder: olderAll.length > PAGE_SIZE, olderTotal: olderAll.length };
     }
-    return { recent, older, hasMoreOlder };
+    return { recent, older, hasMoreOlder, olderTotal: olderAll.length };
 }
 function toSessionChoice(meta) {
     return {
@@ -103,10 +122,10 @@ function formatSessionLabel(meta) {
     const mode = meta.mode ?? meta.options?.mode ?? 'api';
     const slug = meta.id;
     const chars = meta.options?.prompt?.length ?? meta.promptPreview?.length ?? 0;
-    const charLabel = chars > 0 ? chalk.gray(String(chars).padStart(5)) : chalk.gray('    -');
+    const charLabel = chars > 0 ? chalk.gray(String(chars).padStart(CHARS_PAD)) : chalk.gray(`${''.padStart(CHARS_PAD - 1)}-`);
     const cost = mode === 'browser' ? null : resolveCost(meta);
-    const costLabel = cost != null ? chalk.gray(formatCostTable(cost)) : chalk.gray('      -');
-    return `${status} ${chalk.white(model.padEnd(10))} ${chalk.gray(mode.padEnd(7))} ${chalk.gray(created)} ${charLabel} ${costLabel}  ${chalk.cyan(slug)}`;
+    const costLabel = cost != null ? chalk.gray(formatCostTable(cost)) : chalk.gray(`${''.padStart(COST_PAD - 1)}-`);
+    return `${status} ${chalk.white(model.padEnd(MODEL_PAD))} ${chalk.gray(mode.padEnd(MODE_PAD))} ${chalk.gray(created.padEnd(TIMESTAMP_PAD))} ${charLabel} ${costLabel}  ${chalk.cyan(slug)}`;
 }
 function resolveCost(meta) {
     if (meta.usage?.cost != null) {
@@ -124,7 +143,7 @@ function resolveCost(meta) {
     return cost > 0 ? cost : null;
 }
 function formatCostTable(cost) {
-    return `$${cost.toFixed(3)}`.padStart(7);
+    return `$${cost.toFixed(3)}`.padStart(COST_PAD);
 }
 function formatTimestampAligned(iso) {
     const date = new Date(iso);
@@ -138,10 +157,12 @@ function formatTimestampAligned(iso) {
         second: undefined,
         hour12: true,
     };
-    const formatted = date.toLocaleString(locale, opts);
+    let formatted = date.toLocaleString(locale, opts);
+    // Drop the comma and use double-space between date and time for alignment.
+    formatted = formatted.replace(', ', '  ');
     // Insert a leading space when hour is a single digit to align AM/PM column.
-    // Example: "11/18/2025, 1:07:05 AM" -> "11/18/2025,  1:07:05 AM"
-    return formatted.replace(/(, )(\d:)/, '$1 $2');
+    // Example: "11/18/2025  1:07 AM" -> "11/18/2025   1:07 AM"
+    return formatted.replace(/(\s)(\d:)/, '$1 $2');
 }
 function colorStatus(status) {
     const padded = status.padEnd(9);
@@ -346,7 +367,7 @@ async function askOracleFlow(version, userConfig) {
         background: undefined,
     };
     const browserConfig = mode === 'browser'
-        ? buildBrowserConfig({
+        ? await buildBrowserConfig({
             browserChromeProfile: answers.chromeProfile,
             browserHeadless: answers.headless,
             browserHideWindow: answers.hideWindow,

package/dist/src/oracle/client.js

@@ -1,16 +1,34 @@
-import OpenAI from 'openai';
+import OpenAI, { AzureOpenAI } from 'openai';
 import path from 'node:path';
 import { createRequire } from 'node:module';
+import { createGeminiClient } from './gemini.js';
 const CUSTOM_CLIENT_FACTORY = loadCustomClientFactory();
 export function createDefaultClientFactory() {
     if (CUSTOM_CLIENT_FACTORY) {
         return CUSTOM_CLIENT_FACTORY;
     }
-    return (key) => {
-        const instance = new OpenAI({
-            apiKey: key,
-            timeout: 20 * 60 * 1000,
-        });
+    return (key, options) => {
+        if (options?.model?.startsWith('gemini')) {
+            // Gemini client uses its own SDK; allow passing the already-resolved id for transparency/logging.
+            return createGeminiClient(key, options.model, options.resolvedModelId);
+        }
+        let instance;
+        if (options?.azure?.endpoint) {
+            instance = new AzureOpenAI({
+                apiKey: key,
+                endpoint: options.azure.endpoint,
+                apiVersion: options.azure.apiVersion,
+                deployment: options.azure.deployment,
+                timeout: 20 * 60 * 1000,
+            });
+        }
+        else {
+            instance = new OpenAI({
+                apiKey: key,
+                timeout: 20 * 60 * 1000,
+                baseURL: options?.baseUrl,
+            });
+        }
         return {
             responses: {
                 stream: (body) => instance.responses.stream(body),

package/dist/src/oracle/config.js

@@ -21,6 +21,16 @@ export const MODEL_CONFIGS = {
         },
         reasoning: { effort: 'high' },
     },
+    'gemini-3-pro': {
+        model: 'gemini-3-pro',
+        tokenizer: countTokensGpt5Pro,
+        inputLimit: 200000,
+        pricing: {
+            inputPerToken: 2 / 1_000_000,
+            outputPerToken: 12 / 1_000_000,
+        },
+        reasoning: null,
+    },
 };
 export const DEFAULT_SYSTEM_PROMPT = [
     'You are Oracle, a focused one-shot problem solver.',

package/dist/src/oracle/files.js

@@ -10,7 +10,7 @@ export async function readFiles(filePaths, { cwd = process.cwd(), fsModule = DEF
         return [];
     }
     const partitioned = await partitionFileInputs(filePaths, cwd, fsModule);
-    const useNativeFilesystem = fsModule === DEFAULT_FS;
+    const useNativeFilesystem = fsModule === DEFAULT_FS || isNativeFsModule(fsModule);
     let candidatePaths = [];
     if (useNativeFilesystem) {
         candidatePaths = await expandWithNativeGlob(partitioned, cwd);
@@ -292,6 +292,12 @@ function makeDirectoryPattern(relative) {
     }
     return `${stripTrailingSlashes(relative)}/**/*`;
 }
+function isNativeFsModule(fsModule) {
+    return ((fsModule.__nativeFs === true ||
+        (fsModule.readFile === DEFAULT_FS.readFile &&
+            fsModule.stat === DEFAULT_FS.stat &&
+            fsModule.readdir === DEFAULT_FS.readdir)));
+}
 function normalizeGlob(pattern, cwd) {
     if (!pattern) {
         return '';
@@ -339,7 +345,7 @@ function relativePath(targetPath, cwd) {
 }
 export function createFileSections(files, cwd = process.cwd()) {
     return files.map((file, index) => {
-        const relative = path.relative(cwd, file.path) || file.path;
+        const relative = toPosix(path.relative(cwd, file.path) || file.path);
         const sectionText = [
             `### File ${index + 1}: ${relative}`,
             '```',

package/dist/src/oracle/format.js

@@ -2,13 +2,8 @@ export function formatUSD(value) {
     if (!Number.isFinite(value)) {
         return 'n/a';
     }
-    if (value >= 0.1) {
-        return `$${value.toFixed(2)}`;
-    }
-    if (value >= 0.01) {
-        return `$${value.toFixed(3)}`;
-    }
-    return `$${value.toFixed(6)}`;
+    // Display with 4 decimal places, rounding to $0.0001 minimum granularity.
+    return `$${value.toFixed(4)}`;
 }
 export function formatNumber(value, { estimated = false } = {}) {
     if (value == null) {

package/dist/src/oracle/fsAdapter.js

@@ -1,7 +1,10 @@
 export function createFsAdapter(fsModule) {
-    return {
+    const adapter = {
         stat: (targetPath) => fsModule.stat(targetPath),
         readdir: (targetPath) => fsModule.readdir(targetPath),
         readFile: (targetPath, encoding) => fsModule.readFile(targetPath, encoding),
     };
+    // Mark adapters so downstream callers can treat them as native filesystem access.
+    adapter.__nativeFs = true;
+    return adapter;
 }