@steipete/oracle 0.8.6 → 0.9.0

package/dist/src/browser/index.js

@@ -5,7 +5,7 @@ import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { INPUT_SELECTORS } from './constants.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
 import { ensureThinkingTime } from './actions/thinkingTime.js';
@@ -15,8 +15,21 @@ import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from
 import { BrowserAutomationError } from '../oracle/errors.js';
 import { alignPromptEchoPair, buildPromptEchoMatcher } from './reattachHelpers.js';
 import { cleanupStaleProfileState, acquireProfileRunLock, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
+import { runProviderSubmissionFlow } from './providerDomFlow.js';
+import { chatgptDomProvider } from './providers/index.js';
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
+function isCloudflareChallengeError(error) {
+    if (!(error instanceof BrowserAutomationError))
+        return false;
+    return error.details?.stage === 'cloudflare-challenge';
+}
+function shouldPreserveBrowserOnError(error, headless) {
+    return !headless && isCloudflareChallengeError(error);
+}
+export function shouldPreserveBrowserOnErrorForTest(error, headless) {
+    return shouldPreserveBrowserOnError(error, headless);
+}
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
@@ -135,6 +148,7 @@ export async function runBrowserMode(options) {
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
     let appliedCookies = 0;
+    let preserveBrowserOnError = false;
     try {
         try {
             const strictTabIsolation = Boolean(manualLogin && reusedChrome);
@@ -413,17 +427,25 @@ export async function runBrowserMode(options) {
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
             // Learned: return baselineTurns so assistant polling can ignore earlier content.
             const sendAttachmentNames = attachmentWaitTimedOut ? [] : attachmentNames;
-            const committedTurns = await submitPrompt({
+            const providerState = {
                 runtime: Runtime,
                 input: Input,
-                attachmentNames: sendAttachmentNames,
-                baselineTurns: baselineTurns ?? undefined,
+                logger,
+                timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
-            }, prompt, logger);
-            if (typeof committedTurns === 'number' && Number.isFinite(committedTurns)) {
-                if (baselineTurns === null || committedTurns > baselineTurns) {
-                    baselineTurns = Math.max(0, committedTurns - 1);
-                }
+                baselineTurns: baselineTurns ?? undefined,
+                attachmentNames: sendAttachmentNames,
+            };
+            await runProviderSubmissionFlow(chatgptDomProvider, {
+                prompt,
+                evaluate: async () => undefined,
+                delay,
+                log: logger,
+                state: providerState,
+            });
+            const providerBaselineTurns = providerState.baselineTurns;
+            if (typeof providerBaselineTurns === 'number' && Number.isFinite(providerBaselineTurns)) {
+                baselineTurns = providerBaselineTurns;
             }
             if (attachmentNames.length > 0) {
                 if (attachmentWaitTimedOut) {
@@ -731,6 +753,28 @@ export async function runBrowserMode(options) {
         stopThinkingMonitor?.();
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
+        if (shouldPreserveBrowserOnError(normalizedError, config.headless)) {
+            preserveBrowserOnError = true;
+            const runtime = {
+                chromePid: chrome.pid,
+                chromePort: chrome.port,
+                chromeHost,
+                userDataDir,
+                chromeTargetId: lastTargetId,
+                tabUrl: lastUrl,
+                controllerPid: process.pid,
+            };
+            const reuseProfileHint = `oracle --engine browser --browser-manual-login ` +
+                `--browser-manual-login-profile-dir ${JSON.stringify(userDataDir)}`;
+            await emitRuntimeHint();
+            logger('Cloudflare challenge detected; leaving browser open so you can complete the check.');
+            logger(`Reuse this browser profile with: ${reuseProfileHint}`);
+            throw new BrowserAutomationError('Cloudflare challenge detected. Complete the “Just a moment…” check in the open browser, then rerun.', {
+                stage: 'cloudflare-challenge',
+                runtime,
+                reuseProfileHint,
+            }, normalizedError);
+        }
         if (!socketClosed) {
             logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
             if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
@@ -773,7 +817,8 @@ export async function runBrowserMode(options) {
         }
         removeDialogHandler?.();
         removeTerminationHooks?.();
-        if (!effectiveKeepBrowser) {
+        const keepBrowserOpen = effectiveKeepBrowser || preserveBrowserOnError;
+        if (!keepBrowserOpen) {
             if (!connectionClosedUnexpectedly) {
                 try {
                     await chrome.kill();
@@ -1080,17 +1125,25 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 logger('All attachments uploaded');
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
-            const committedTurns = await submitPrompt({
+            const providerState = {
                 runtime: Runtime,
                 input: Input,
-                attachmentNames,
-                baselineTurns: baselineTurns ?? undefined,
+                logger,
+                timeoutMs: config.timeoutMs,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
-            }, prompt, logger);
-            if (typeof committedTurns === 'number' && Number.isFinite(committedTurns)) {
-                if (baselineTurns === null || committedTurns > baselineTurns) {
-                    baselineTurns = Math.max(0, committedTurns - 1);
-                }
+                baselineTurns: baselineTurns ?? undefined,
+                attachmentNames,
+            };
+            await runProviderSubmissionFlow(chatgptDomProvider, {
+                prompt,
+                evaluate: async () => undefined,
+                delay,
+                log: logger,
+                state: providerState,
+            });
+            const providerBaselineTurns = providerState.baselineTurns;
+            if (typeof providerBaselineTurns === 'number' && Number.isFinite(providerBaselineTurns)) {
+                baselineTurns = providerBaselineTurns;
             }
             return { baselineTurns, baselineAssistantText };
         };
@@ -1380,11 +1433,12 @@ export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSele
 export async function maybeReuseRunningChromeForTest(userDataDir, logger, options = {}) {
     return maybeReuseRunningChrome(userDataDir, logger, options);
 }
-function isWebSocketClosureError(error) {
+export function isWebSocketClosureError(error) {
     const message = error.message.toLowerCase();
     return (message.includes('websocket connection closed') ||
         message.includes('websocket is closed') ||
         message.includes('websocket error') ||
+        message.includes('inspected target navigated or closed') ||
         message.includes('target closed'));
 }
 export function formatThinkingLog(startedAt, now, message, locatorSuffix) {

package/dist/src/browser/providerDomFlow.js

@@ -0,0 +1,17 @@
+export async function runProviderSubmissionFlow(adapter, ctx) {
+    await adapter.waitForUi(ctx);
+    if (adapter.selectMode) {
+        await adapter.selectMode(ctx);
+    }
+    await adapter.typePrompt(ctx);
+    await adapter.submitPrompt(ctx);
+}
+export async function runProviderDomFlow(adapter, ctx) {
+    await runProviderSubmissionFlow(adapter, ctx);
+    const response = await adapter.waitForResponse(ctx);
+    const thoughts = adapter.extractThoughts ? await adapter.extractThoughts(ctx) : null;
+    return { ...response, thoughts };
+}
+export function joinSelectors(selectors) {
+    return selectors.join(', ');
+}

package/dist/src/browser/providers/chatgptDomProvider.js

@@ -0,0 +1,49 @@
+import { ensurePromptReady } from '../actions/navigation.js';
+import { submitPrompt } from '../actions/promptComposer.js';
+import { waitForAssistantResponse } from '../actions/assistantResponse.js';
+function requireState(ctx) {
+    const state = ctx.state;
+    if (!state?.runtime || !state?.input || !state?.logger) {
+        throw new Error('chatgptDomProvider requires runtime/input/logger in context.state.');
+    }
+    return state;
+}
+async function waitForUi(ctx) {
+    const state = requireState(ctx);
+    await ensurePromptReady(state.runtime, state.inputTimeoutMs ?? 30_000, state.logger);
+}
+async function typePrompt(_ctx) {
+    // submitPrompt() handles typing + send for ChatGPT.
+}
+async function submitPromptViaAdapter(ctx) {
+    const state = requireState(ctx);
+    const committedTurns = await submitPrompt({
+        runtime: state.runtime,
+        input: state.input,
+        attachmentNames: state.attachmentNames ?? [],
+        baselineTurns: state.baselineTurns ?? undefined,
+        inputTimeoutMs: state.inputTimeoutMs ?? undefined,
+    }, ctx.prompt, state.logger);
+    state.committedTurns = typeof committedTurns === 'number' && Number.isFinite(committedTurns)
+        ? committedTurns
+        : null;
+    if (state.committedTurns != null && (state.baselineTurns == null || state.committedTurns > state.baselineTurns)) {
+        state.baselineTurns = Math.max(0, state.committedTurns - 1);
+    }
+}
+async function waitForResponse(ctx) {
+    const state = requireState(ctx);
+    const answer = await waitForAssistantResponse(state.runtime, state.timeoutMs, state.logger, state.baselineTurns ?? undefined);
+    return {
+        text: answer.text,
+        html: answer.html,
+        meta: answer.meta,
+    };
+}
+export const chatgptDomProvider = {
+    providerName: 'chatgpt-web',
+    waitForUi,
+    typePrompt,
+    submitPrompt: submitPromptViaAdapter,
+    waitForResponse,
+};

package/dist/src/browser/providers/geminiDeepThinkDomProvider.js

@@ -0,0 +1,245 @@
+import { joinSelectors } from '../providerDomFlow.js';
+const UI_TIMEOUT_MS = 60_000;
+const RESPONSE_TIMEOUT_MS = 10 * 60_000;
+export const GEMINI_DEEP_THINK_SELECTORS = {
+    input: ['rich-textarea .ql-editor', '[role="textbox"][aria-label*="prompt" i]', 'div[contenteditable="true"]'],
+    sendButton: ['button.send-button', 'button[aria-label="Send message"]'],
+    toolsButton: ['button.toolbox-drawer-button', 'button[aria-label="Tools"]'],
+    toolsMenuItem: ['[role="menuitemcheckbox"]', '.toolbox-drawer-item-list-button'],
+    deepThinkActive: ['.toolbox-drawer-item-deselect-button', 'button[aria-label*="Deselect Deep Think"]'],
+    uploadButton: ['button[aria-label="Open upload file menu"]', '.upload-card-button'],
+    uploadMenuItem: ['[role="menuitem"]'],
+    uploadTrigger: ['.hidden-local-file-upload-button', '.hidden-local-upload-button'],
+    uploaderContainer: ['.uploader-button-container', '.file-uploader'],
+    uploaderElement: ['uploader.upload-button'],
+    userTurnAttachment: ['.file-preview-container'],
+    responseTurn: ['model-response'],
+    responseText: ['message-content', '.model-response-text message-content'],
+    responseComplete: ['.response-footer.complete'],
+    userQuery: ['user-query'],
+    userQueryText: ['user-query-content', '.query-text'],
+    spinner: ['[role="progressbar"]'],
+    thoughtsToggle: ['.thoughts-header-button', '[data-test-id="thoughts-header-button"]'],
+    thoughtsContent: ['model-thoughts', '[data-test-id="model-thoughts"]'],
+    hasThoughts: ['.has-thoughts'],
+};
+function asSelectorLiteral(selectors) {
+    return JSON.stringify(joinSelectors(selectors));
+}
+function readTimeouts(ctx) {
+    const state = ctx.state;
+    const uiTimeoutMs = typeof state?.inputTimeoutMs === 'number' && Number.isFinite(state.inputTimeoutMs)
+        ? Math.max(1_000, state.inputTimeoutMs)
+        : UI_TIMEOUT_MS;
+    const responseTimeoutMs = typeof state?.timeoutMs === 'number' && Number.isFinite(state.timeoutMs)
+        ? Math.max(1_000, state.timeoutMs)
+        : RESPONSE_TIMEOUT_MS;
+    return { uiTimeoutMs, responseTimeoutMs };
+}
+async function waitForUi(ctx) {
+    ctx.log?.('[gemini-web] Waiting for Gemini UI to load...');
+    const inputSelector = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.input);
+    const { uiTimeoutMs } = readTimeouts(ctx);
+    const uiDeadline = Date.now() + uiTimeoutMs;
+    let uiReady = false;
+    let sawLoginRedirect = false;
+    while (Date.now() < uiDeadline) {
+        const state = await ctx.evaluate(`(() => {
+        const editor = document.querySelector(${inputSelector});
+        const href = location.href || '';
+        const bodyText = (document.body?.innerText || '').toLowerCase();
+        const requiresLogin =
+          href.includes('accounts.google.com') ||
+          (bodyText.includes('sign in') && bodyText.includes('google'));
+        return { ready: Boolean(editor), requiresLogin };
+      })()`);
+        if (state?.ready) {
+            uiReady = true;
+            break;
+        }
+        if (state?.requiresLogin) {
+            sawLoginRedirect = true;
+        }
+        await ctx.delay(1_000);
+    }
+    if (!uiReady) {
+        if (sawLoginRedirect) {
+            throw new Error('Gemini is showing a sign-in flow. Please sign in in Chrome and retry.');
+        }
+        throw new Error('Timed out waiting for Gemini UI prompt input to become ready.');
+    }
+}
+async function selectMode(ctx) {
+    const toolsButtonSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.toolsButton);
+    const toolsClickResult = await ctx.evaluate(`(() => {
+      const btn = document.querySelector(${toolsButtonSelectors});
+      if (btn instanceof HTMLElement) {
+        btn.click();
+        return 'clicked';
+      }
+      return 'not-found';
+    })()`);
+    if (toolsClickResult !== 'clicked') {
+        throw new Error('Unable to open Gemini tools menu; Deep Think toggle is not accessible.');
+    }
+    await ctx.delay(1_000);
+    const deepThinkItemSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.toolsMenuItem);
+    const deepThinkClickResult = await ctx.evaluate(`(() => {
+      const items = Array.from(document.querySelectorAll(${deepThinkItemSelectors}));
+      for (const item of items) {
+        const text = item.textContent?.trim().toLowerCase() ?? '';
+        if (!text.includes('deep think')) continue;
+        if (item instanceof HTMLElement) item.click();
+        return 'clicked';
+      }
+      return 'not-found';
+    })()`);
+    if (deepThinkClickResult !== 'clicked') {
+        throw new Error('Unable to select "Deep Think" from Gemini tools menu.');
+    }
+    await ctx.delay(1_500);
+    const deepThinkActiveSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.deepThinkActive);
+    const deepThinkActive = await ctx.evaluate(`(() => {
+      const active = document.querySelector(${deepThinkActiveSelectors});
+      if (!(active instanceof HTMLElement)) return false;
+      const label = active.getAttribute('aria-label')?.toLowerCase() ?? '';
+      const text = active.textContent?.toLowerCase() ?? '';
+      return label.includes('deep think') || text.includes('deep think');
+    })()`);
+    if (!deepThinkActive) {
+        throw new Error('Deep Think did not appear selected after clicking the tools menu item.');
+    }
+}
+async function typePrompt(ctx) {
+    ctx.log?.('[gemini-web] Typing prompt...');
+    const inputSelector = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.input);
+    const typeResult = await ctx.evaluate(`(() => {
+      const editor = document.querySelector(${inputSelector});
+      if (!(editor instanceof HTMLElement)) return 'no-editor';
+      editor.focus();
+      editor.textContent = '';
+      if (typeof document.execCommand === 'function') {
+        document.execCommand('insertText', false, ${JSON.stringify(ctx.prompt)});
+      } else {
+        editor.textContent = ${JSON.stringify(ctx.prompt)};
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(ctx.prompt)} }));
+      }
+      const typed = (editor.textContent || '').trim().length > 0;
+      return typed ? 'typed' : 'empty';
+    })()`);
+    if (typeResult !== 'typed') {
+        throw new Error(`Failed to type Gemini prompt (status=${typeResult ?? 'unknown'}).`);
+    }
+    await ctx.delay(500);
+}
+async function submitPrompt(ctx) {
+    ctx.log?.('[gemini-web] Sending prompt...');
+    const inputSelector = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.input);
+    const sendButtonSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.sendButton);
+    const sendResult = await ctx.evaluate(`(() => {
+      const btn = document.querySelector(${sendButtonSelectors});
+      if (btn instanceof HTMLElement) {
+        btn.click();
+        return 'clicked';
+      }
+      const editor = document.querySelector(${inputSelector});
+      if (editor instanceof HTMLElement) {
+        editor.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', bubbles: true }));
+        editor.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', bubbles: true }));
+        return 'enter';
+      }
+      return 'not-found';
+    })()`);
+    if (sendResult !== 'clicked' && sendResult !== 'enter') {
+        throw new Error('Failed to submit prompt in Gemini Deep Think mode (send control not found).');
+    }
+}
+async function waitForResponse(ctx) {
+    ctx.log?.('[gemini-web] Waiting for Deep Think response (this may take a while)...');
+    const responseTurnSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.responseTurn);
+    const responseTextSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.responseText);
+    const responseCompleteSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.responseComplete);
+    const spinnerSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.spinner);
+    const { responseTimeoutMs } = readTimeouts(ctx);
+    const responseDeadline = Date.now() + responseTimeoutMs;
+    let lastLog = 0;
+    let responseText = '';
+    while (Date.now() < responseDeadline) {
+        const payload = await ctx.evaluate(`(() => {
+        const turns = document.querySelectorAll(${responseTurnSel});
+        if (turns.length === 0) return JSON.stringify({ status: 'waiting' });
+        const lastTurn = turns[turns.length - 1];
+        const footer = lastTurn.querySelector(${responseCompleteSel});
+        const content = lastTurn.querySelector(${responseTextSel});
+        const text = content?.textContent?.trim() ?? '';
+        const lower = text.toLowerCase();
+        if (lower.includes('generating your response') || lower.includes('check back later') || lower.includes("i'm on it")) {
+          return JSON.stringify({ status: 'generating' });
+        }
+        if (footer && text.length > 0) {
+          return JSON.stringify({ status: 'done', text });
+        }
+        const spinners = lastTurn.querySelectorAll(${spinnerSel});
+        const visibleSpinners = Array.from(spinners).filter((s) => s instanceof HTMLElement && s.offsetParent !== null);
+        if (text.length > 0 && visibleSpinners.length === 0 && !footer) {
+          return JSON.stringify({ status: 'streaming' });
+        }
+        return JSON.stringify({ status: 'generating' });
+      })()`);
+        try {
+            const parsed = JSON.parse(payload ?? '{}');
+            if (parsed.status === 'done' && typeof parsed.text === 'string' && parsed.text.length > 0) {
+                responseText = parsed.text;
+                break;
+            }
+            const now = Date.now();
+            if (now - lastLog > 10_000) {
+                ctx.log?.(`[gemini-web] Deep Think still generating... (${parsed.status ?? 'unknown'})`);
+                lastLog = now;
+            }
+        }
+        catch {
+            // ignore parse errors while polling
+        }
+        await ctx.delay(3_000);
+    }
+    if (!responseText) {
+        throw new Error(`Deep Think timed out waiting for response (${Math.ceil(responseTimeoutMs / 1000)} seconds).`);
+    }
+    return { text: responseText };
+}
+async function extractThoughts(ctx) {
+    const thoughtsToggleSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.thoughtsToggle);
+    const thoughtsContentSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.thoughtsContent);
+    const thinkResult = await ctx.evaluate(`(() => {
+      const toggle = document.querySelector(${thoughtsToggleSel});
+      if (!(toggle instanceof HTMLElement)) return 'no-toggle';
+      toggle.click();
+      return 'clicked';
+    })()`);
+    if (thinkResult !== 'clicked') {
+        return null;
+    }
+    await ctx.delay(1_500);
+    const extractedThoughts = await ctx.evaluate(`(() => {
+      const el = document.querySelector(${thoughtsContentSel});
+      if (!el) return '';
+      const full = el.textContent?.trim() ?? '';
+      const btn = el.querySelector('.thoughts-header-button, [data-test-id="thoughts-header-button"]');
+      const btnText = btn?.textContent?.trim() ?? '';
+      if (btnText && full.startsWith(btnText)) {
+        return full.slice(btnText.length).trim();
+      }
+      return full;
+    })()`);
+    return typeof extractedThoughts === 'string' && extractedThoughts.length > 0 ? extractedThoughts : null;
+}
+export const geminiDeepThinkDomProvider = {
+    providerName: 'gemini-web',
+    waitForUi,
+    selectMode,
+    typePrompt,
+    submitPrompt,
+    waitForResponse,
+    extractThoughts,
+};

package/dist/src/browser/providers/index.js

@@ -0,0 +1,2 @@
+export { chatgptDomProvider } from './chatgptDomProvider.js';
+export { geminiDeepThinkDomProvider, GEMINI_DEEP_THINK_SELECTORS, } from './geminiDeepThinkDomProvider.js';

package/dist/src/cli/browserConfig.js

@@ -12,24 +12,30 @@ const DEFAULT_CHROME_PROFILE = 'Default';
 // The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
 const BROWSER_MODEL_LABELS = [
     // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
+    ['gpt-5.4-pro', 'GPT-5.4 Pro'],
     ['gpt-5.2-thinking', 'GPT-5.2 Thinking'],
     ['gpt-5.2-instant', 'GPT-5.2 Instant'],
-    ['gpt-5.2-pro', 'GPT-5.2 Pro'],
-    ['gpt-5.1-pro', 'GPT-5.2 Pro'],
-    ['gpt-5-pro', 'GPT-5.2 Pro'],
+    ['gpt-5.2-pro', 'GPT-5.4 Pro'],
+    ['gpt-5.1-pro', 'GPT-5.4 Pro'],
+    ['gpt-5-pro', 'GPT-5.4 Pro'],
     // Base models last (least specific)
+    ['gpt-5.4', 'Thinking 5.4'],
     ['gpt-5.2', 'GPT-5.2'], // Selects "Auto" in ChatGPT UI
     ['gpt-5.1', 'GPT-5.2'], // Legacy alias → Auto
     ['gemini-3-pro', 'Gemini 3 Pro'],
+    ['gemini-3-pro-deep-think', 'gemini-3-deep-think'],
 ];
 export function normalizeChatGptModelForBrowser(model) {
     const normalized = model.toLowerCase();
     if (!normalized.startsWith('gpt-') || normalized.includes('codex')) {
         return model;
     }
-    // Pro variants: always resolve to the latest Pro model in ChatGPT.
-    if (normalized === 'gpt-5-pro' || normalized === 'gpt-5.1-pro' || normalized.endsWith('-pro')) {
-        return 'gpt-5.2-pro';
+    if (normalized === 'gpt-5.4-pro' || normalized === 'gpt-5.4') {
+        return normalized;
+    }
+    // Pro variants: resolve to the latest Pro model in ChatGPT.
+    if (normalized === 'gpt-5-pro' || normalized === 'gpt-5.1-pro' || normalized === 'gpt-5.2-pro') {
+        return 'gpt-5.4-pro';
     }
     // Explicit model variants: keep as-is (they have their own browser labels)
     if (normalized === 'gpt-5.2-thinking' || normalized === 'gpt-5.2-instant') {

package/dist/src/cli/detach.js

@@ -1,9 +1,12 @@
 import { isProModel } from '../oracle/modelResolver.js';
 export function shouldDetachSession({ 
-// Params kept for future policy tweaks; currently only model/disableDetachEnv matter.
-engine, model, waitPreference: _waitPreference, disableDetachEnv, }) {
+// Params kept for policy tweaks.
+engine, model, waitPreference, disableDetachEnv, }) {
     if (disableDetachEnv)
         return false;
+    // Explicit --wait means "stay attached", regardless of model defaults.
+    if (waitPreference)
+        return false;
     // Only Pro-tier API runs should start detached by default; browser runs stay inline so failures surface.
     if (isProModel(model) && engine === 'api')
         return true;

package/dist/src/cli/fileSize.js

@@ -0,0 +1,11 @@
+import { normalizeMaxFileSizeBytes } from '../oracle/files.js';
+export function resolveConfiguredMaxFileSizeBytes(userConfig, env = process.env) {
+    const envValue = env.ORACLE_MAX_FILE_SIZE_BYTES?.trim();
+    if (envValue) {
+        return normalizeMaxFileSizeBytes(envValue, 'ORACLE_MAX_FILE_SIZE_BYTES');
+    }
+    if (userConfig?.maxFileSizeBytes !== undefined) {
+        return normalizeMaxFileSizeBytes(userConfig.maxFileSizeBytes, 'config.maxFileSizeBytes');
+    }
+    return undefined;
+}

package/dist/src/cli/help.js

@@ -38,7 +38,7 @@ export function applyHelpStyling(program, version, isTty) {
     program.addHelpText('after', () => renderHelpFooter(program, colors));
 }
 function renderHelpBanner(version, colors) {
-    const subtitle = 'Prompt + files required — GPT-5.2 Pro/GPT-5.2 for tough questions with code/file context.';
+    const subtitle = 'Prompt + files required — GPT-5.4 Pro/GPT-5.4 for tough questions with code/file context.';
     return `${colors.banner(`Oracle CLI v${version}`)} ${colors.subtitle(`— ${subtitle}`)}\n`;
 }
 function renderHelpFooter(program, colors) {
@@ -49,9 +49,9 @@ function renderHelpFooter(program, colors) {
         `${colors.bullet('•')} Spell out the project + platform + version requirements (repo name, target OS/toolchain versions, API dependencies) so Oracle doesn’t guess defaults.`,
         `${colors.bullet('•')} When comparing multiple repos/files, spell out each repo + path + role (e.g., “Project A SettingsView → apps/project-a/Sources/SettingsView.swift; Project B SettingsView → ../project-b/mac/...”) so the model knows exactly which file is which.`,
         `${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('•')} Oracle is one-shot by default. For OpenAI/Azure API runs, you can chain follow-ups by passing ${colors.accent('--followup <sessionId|responseId>')} (continues via Responses API previous_response_id).`,
         `${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.2-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent('oracle session <slug>')} to resume/inspect the existing run.`,
+        `${colors.bullet('•')} Non-preview runs spawn detached sessions (especially gpt-5.4-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent('oracle session <slug>')} to resume/inspect the existing run.`,
         `${colors.bullet('•')} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,
         `${colors.bullet('•')} Finished sessions auto-hide preamble logs when reattached; raw timestamps remain in the saved log file.`,
         `${colors.bullet('•')} Need hidden flags? Run ${colors.accent(`${program.name()} --help --verbose`)} to list search/token/browser overrides.`,

package/dist/src/cli/markdownBundle.js

@@ -7,7 +7,11 @@ import { buildPromptMarkdown } from '../oracle/promptAssembly.js';
 export async function buildMarkdownBundle(options, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const fsModule = deps.fs ?? createFsAdapter(fs);
-    const files = await readFiles(options.file ?? [], { cwd, fsModule });
+    const files = await readFiles(options.file ?? [], {
+        cwd,
+        fsModule,
+        maxFileSizeBytes: options.maxFileSizeBytes,
+    });
     const sections = createFileSections(files, cwd);
     const systemPrompt = options.system?.trim() || DEFAULT_SYSTEM_PROMPT;
     const userPrompt = (options.prompt ?? '').trim();