@steipete/oracle 1.0.8 → 1.2.0

package/dist/oracle/src/sessionManager.js

@@ -0,0 +1,205 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+const ORACLE_HOME = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+const SESSIONS_DIR = path.join(ORACLE_HOME, 'sessions');
+const MAX_STATUS_LIMIT = 1000;
+const DEFAULT_SLUG = 'session';
+const MAX_SLUG_WORDS = 5;
+const MIN_CUSTOM_SLUG_WORDS = 3;
+async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+export async function ensureSessionStorage() {
+    await ensureDir(SESSIONS_DIR);
+}
+function slugify(text, maxWords = MAX_SLUG_WORDS) {
+    const normalized = text?.toLowerCase() ?? '';
+    const words = normalized.match(/[a-z0-9]+/g) ?? [];
+    const trimmed = words.slice(0, maxWords);
+    return trimmed.length > 0 ? trimmed.join('-') : DEFAULT_SLUG;
+}
+function countSlugWords(slug) {
+    return slug.split('-').filter(Boolean).length;
+}
+function normalizeCustomSlug(candidate) {
+    const slug = slugify(candidate, MAX_SLUG_WORDS);
+    const wordCount = countSlugWords(slug);
+    if (wordCount < MIN_CUSTOM_SLUG_WORDS || wordCount > MAX_SLUG_WORDS) {
+        throw new Error(`Custom slug must include between ${MIN_CUSTOM_SLUG_WORDS} and ${MAX_SLUG_WORDS} words.`);
+    }
+    return slug;
+}
+export function createSessionId(prompt, customSlug) {
+    if (customSlug) {
+        return normalizeCustomSlug(customSlug);
+    }
+    return slugify(prompt);
+}
+function sessionDir(id) {
+    return path.join(SESSIONS_DIR, id);
+}
+function metaPath(id) {
+    return path.join(sessionDir(id), 'session.json');
+}
+function logPath(id) {
+    return path.join(sessionDir(id), 'output.log');
+}
+function requestPath(id) {
+    return path.join(sessionDir(id), 'request.json');
+}
+async function fileExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureUniqueSessionId(baseSlug) {
+    let candidate = baseSlug;
+    let suffix = 2;
+    while (await fileExists(sessionDir(candidate))) {
+        candidate = `${baseSlug}-${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
+export async function initializeSession(options, cwd) {
+    await ensureSessionStorage();
+    const baseSlug = createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
+    const sessionId = await ensureUniqueSessionId(baseSlug);
+    const dir = sessionDir(sessionId);
+    await ensureDir(dir);
+    const mode = options.mode ?? 'api';
+    const browserConfig = options.browserConfig;
+    const metadata = {
+        id: sessionId,
+        createdAt: new Date().toISOString(),
+        status: 'pending',
+        promptPreview: (options.prompt || '').slice(0, 160),
+        model: options.model,
+        cwd,
+        mode,
+        browser: browserConfig ? { config: browserConfig } : undefined,
+        options: {
+            prompt: options.prompt,
+            file: options.file ?? [],
+            model: options.model,
+            maxInput: options.maxInput,
+            system: options.system,
+            maxOutput: options.maxOutput,
+            silent: options.silent,
+            filesReport: options.filesReport,
+            slug: sessionId,
+            mode,
+            browserConfig,
+            verbose: options.verbose,
+            heartbeatIntervalMs: options.heartbeatIntervalMs,
+            browserInlineFiles: options.browserInlineFiles,
+            background: options.background,
+        },
+    };
+    await fs.writeFile(metaPath(sessionId), JSON.stringify(metadata, null, 2), 'utf8');
+    await fs.writeFile(requestPath(sessionId), JSON.stringify(metadata.options, null, 2), 'utf8');
+    await fs.writeFile(logPath(sessionId), '', 'utf8');
+    return metadata;
+}
+export async function readSessionMetadata(sessionId) {
+    try {
+        const raw = await fs.readFile(metaPath(sessionId), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function updateSessionMetadata(sessionId, updates) {
+    const existing = (await readSessionMetadata(sessionId)) ?? { id: sessionId };
+    const next = { ...existing, ...updates };
+    await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), 'utf8');
+    return next;
+}
+export function createSessionLogWriter(sessionId) {
+    const stream = createWriteStream(logPath(sessionId), { flags: 'a' });
+    const logLine = (line = '') => {
+        stream.write(`${line}\n`);
+    };
+    const writeChunk = (chunk) => {
+        stream.write(chunk);
+        return true;
+    };
+    return { stream, logLine, writeChunk, logPath: logPath(sessionId) };
+}
+export async function listSessionsMetadata() {
+    await ensureSessionStorage();
+    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
+    const metas = [];
+    for (const entry of entries) {
+        const meta = await readSessionMetadata(entry);
+        if (meta) {
+            metas.push(meta);
+        }
+    }
+    return metas.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+export function filterSessionsByRange(metas, { hours = 24, includeAll = false, limit = 100 }) {
+    const maxLimit = Math.min(limit, MAX_STATUS_LIMIT);
+    let filtered = metas;
+    if (!includeAll) {
+        const cutoff = Date.now() - hours * 60 * 60 * 1000;
+        filtered = metas.filter((meta) => new Date(meta.createdAt).getTime() >= cutoff);
+    }
+    const limited = filtered.slice(0, maxLimit);
+    const truncated = filtered.length > maxLimit;
+    return { entries: limited, truncated, total: filtered.length };
+}
+export async function readSessionLog(sessionId) {
+    try {
+        return await fs.readFile(logPath(sessionId), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export async function deleteSessionsOlderThan({ hours = 24, includeAll = false, } = {}) {
+    await ensureSessionStorage();
+    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
+    if (!entries.length) {
+        return { deleted: 0, remaining: 0 };
+    }
+    const cutoff = includeAll ? Number.NEGATIVE_INFINITY : Date.now() - hours * 60 * 60 * 1000;
+    let deleted = 0;
+    for (const entry of entries) {
+        const dir = sessionDir(entry);
+        let createdMs;
+        const meta = await readSessionMetadata(entry);
+        if (meta?.createdAt) {
+            const parsed = Date.parse(meta.createdAt);
+            if (!Number.isNaN(parsed)) {
+                createdMs = parsed;
+            }
+        }
+        if (createdMs == null) {
+            try {
+                const stats = await fs.stat(dir);
+                createdMs = stats.birthtimeMs || stats.mtimeMs;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (includeAll || (createdMs != null && createdMs < cutoff)) {
+            await fs.rm(dir, { recursive: true, force: true });
+            deleted += 1;
+        }
+    }
+    const remaining = Math.max(entries.length - deleted, 0);
+    return { deleted, remaining };
+}
+export async function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export { ORACLE_HOME, SESSIONS_DIR, MAX_STATUS_LIMIT };

package/dist/oracle/src/version.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+let cachedVersion = null;
+export function getCliVersion() {
+    if (cachedVersion) {
+        return cachedVersion;
+    }
+    cachedVersion = readVersionFromPackage();
+    return cachedVersion;
+}
+function readVersionFromPackage() {
+    const modulePath = fileURLToPath(import.meta.url);
+    let currentDir = path.dirname(modulePath);
+    const filesystemRoot = path.parse(currentDir).root;
+    // biome-ignore lint/nursery/noUnnecessaryConditions: deliberate sentinel loop to walk up directories
+    while (true) {
+        const candidate = path.join(currentDir, 'package.json');
+        try {
+            const raw = readFileSync(candidate, 'utf8');
+            const parsed = JSON.parse(raw);
+            const version = typeof parsed.version === 'string' && parsed.version.trim().length > 0
+                ? parsed.version.trim()
+                : '0.0.0';
+            return version;
+        }
+        catch (error) {
+            const code = error instanceof Error && 'code' in error ? error.code : undefined;
+            if (code && code !== 'ENOENT') {
+                break;
+            }
+        }
+        if (currentDir === filesystemRoot) {
+            break;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return '0.0.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/cookies.js

@@ -177,7 +177,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,6 +64,7 @@ export async function runBrowserMode(options) {
         await Promise.all(domainEnablers);
         await Network.clearBrowserCookies();
         if (config.cookieSync) {
+            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.');
             const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, config.allowCookieErrors ?? false);
             logger(cookieCount > 0
                 ? `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
@@ -155,7 +156,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,
         });
     }

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

@@ -16,14 +16,14 @@ 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`;
     const automationLogger = ((message) => {
         if (typeof message === 'string') {
             log(message);
@@ -56,6 +56,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,
@@ -76,5 +77,6 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             chromePort: browserResult.chromePort,
             userDataDir: browserResult.userDataDir,
         },
+        answerText,
     };
 }

package/dist/src/cli/dryRun.js

@@ -40,20 +40,56 @@ async function runBrowserDryRun({ runOptions, cwd, version, log, }, deps) {
     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));
-    logBrowserFileSummary(artifacts, log);
+    logBrowserFileSummary(artifacts, log, 'dry-run');
 }
-function logBrowserFileSummary(artifacts, log) {
+function logBrowserFileSummary(artifacts, log, label) {
     if (artifacts.attachments.length > 0) {
-        log(chalk.bold('[dry-run] Attachments to upload:'));
+        const prefix = artifacts.bundled ? `[${label}] Bundled upload:` : `[${label}] Attachments to upload:`;
+        log(chalk.bold(prefix));
         artifacts.attachments.forEach((attachment) => {
             log(`  • ${formatAttachmentLabel(attachment)}`);
         });
+        if (artifacts.bundled) {
+            log(chalk.dim(`  (bundled ${artifacts.bundled.originalCount} files into ${artifacts.bundled.bundlePath})`));
+        }
         return;
     }
     if (artifacts.inlineFileCount > 0) {
-        log(chalk.bold('[dry-run] Inline file content:'));
+        log(chalk.bold(`[${label}] Inline file content:`));
         log(`  • ${artifacts.inlineFileCount} file${artifacts.inlineFileCount === 1 ? '' : 's'} pasted directly into the composer.`);
         return;
     }
-    log(chalk.dim('[dry-run] No files attached.'));
+    log(chalk.dim(`[${label}] No files attached.`));
+}
+export async function runBrowserPreview({ runOptions, cwd, version, previewMode, log, }, deps = {}) {
+    const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
+    const artifacts = await assemblePromptImpl(runOptions, { cwd });
+    const suffix = buildTokenEstimateSuffix(artifacts);
+    const headerLine = `[preview] Oracle (${version}) browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+    log(chalk.cyan(headerLine));
+    logBrowserFileSummary(artifacts, log, 'preview');
+    if (previewMode === 'json' || previewMode === 'full') {
+        const attachmentSummary = artifacts.attachments.map((attachment) => ({
+            path: attachment.path,
+            displayPath: attachment.displayPath,
+            sizeBytes: attachment.sizeBytes,
+        }));
+        const previewPayload = {
+            model: runOptions.model,
+            engine: 'browser',
+            composerText: artifacts.composerText,
+            attachments: attachmentSummary,
+            inlineFileCount: artifacts.inlineFileCount,
+            bundled: artifacts.bundled,
+            tokenEstimate: artifacts.estimatedInputTokens,
+        };
+        log('');
+        log(chalk.bold('Preview JSON'));
+        log(JSON.stringify(previewPayload, null, 2));
+    }
+    if (previewMode === 'full') {
+        log('');
+        log(chalk.bold('Composer Text'));
+        log(artifacts.composerText || chalk.dim('(empty prompt)'));
+    }
 }

package/dist/src/cli/engine.js

@@ -1,3 +1,10 @@
+export function defaultWaitPreference(model, engine) {
+    // gpt-5-pro (API) can take up to 10 minutes; default to non-blocking
+    if (engine === 'api' && model === 'gpt-5-pro') {
+        return false;
+    }
+    return true; // browser or gpt-5.1 are fast enough to block by default
+}
 /**
  * Determine which engine to use based on CLI flags and the environment.
  *