@steipete/oracle 0.5.6 → 0.6.1

package/dist/src/browser/index.js

@@ -1,16 +1,18 @@
-import { mkdtemp, rm, mkdir, readFile } from 'node:fs/promises';
+import { mkdtemp, rm, mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
+import { ensureExtendedThinking } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL } from './constants.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
+import { cleanupStaleProfileState, readChromePid, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
 export { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl } from './utils.js';
 export async function runBrowserMode(options) {
@@ -19,6 +21,7 @@ export async function runBrowserMode(options) {
         throw new Error('Prompt text is required when using browser mode.');
     }
     const attachments = options.attachments ?? [];
+    const fallbackSubmission = options.fallbackSubmission;
     let config = resolveBrowserConfig(options.config);
     const logger = options.log ?? ((_message) => { });
     if (logger.verbose === undefined) {
@@ -96,6 +99,13 @@ export async function runBrowserMode(options) {
             remoteChrome: config.remoteChrome,
         }, userDataDir, logger));
     const chromeHost = chrome.host ?? '127.0.0.1';
+    // Persist profile state so future manual-login runs can reuse this Chrome.
+    if (manualLogin && chrome.port) {
+        await writeDevToolsActivePort(userDataDir, chrome.port);
+        if (!reusedChrome && chrome.pid) {
+            await writeChromePid(userDataDir, chrome.pid);
+        }
+    }
     let removeTerminationHooks = null;
     try {
         removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
@@ -254,20 +264,49 @@ export async function runBrowserMode(options) {
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        const attachmentNames = attachments.map((a) => path.basename(a.path));
-        if (attachments.length > 0) {
-            if (!DOM) {
-                throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+        if (config.extendedThinking) {
+            await raceWithDisconnect(withRetries(() => ensureExtendedThinking(Runtime, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            }));
+        }
+        const submitOnce = async (prompt, submissionAttachments) => {
+            const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            if (submissionAttachments.length > 0) {
+                if (!DOM) {
+                    throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+                }
+                for (const attachment of submissionAttachments) {
+                    logger(`Uploading attachment: ${attachment.displayPath}`);
+                    await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+                }
+                const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                logger('All attachments uploaded');
             }
-            for (const attachment of attachments) {
-                logger(`Uploading attachment: ${attachment.displayPath}`);
-                await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+            await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+        };
+        try {
+            await raceWithDisconnect(submitOnce(promptText, attachments));
+        }
+        catch (error) {
+            const isPromptTooLarge = error instanceof BrowserAutomationError &&
+                error.details?.code === 'prompt-too-large';
+            if (fallbackSubmission && isPromptTooLarge) {
+                logger('[browser] Inline prompt too large; retrying with file uploads.');
+                await raceWithDisconnect(clearPromptComposer(Runtime, logger));
+                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+                await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+            }
+            else {
+                throw error;
             }
-            const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
-            await raceWithDisconnect(waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger));
-            logger('All attachments uploaded');
         }
-        await raceWithDisconnect(submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, promptText, logger));
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         const answer = await raceWithDisconnect(waitForAssistantResponse(Runtime, config.timeoutMs, logger));
         answerText = answer.text;
@@ -502,57 +541,21 @@ async function maybeReuseRunningChrome(userDataDir, logger) {
     const port = await readDevToolsPort(userDataDir);
     if (!port)
         return null;
-    const versionUrl = `http://127.0.0.1:${port}/json/version`;
-    try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 1500);
-        const response = await fetch(versionUrl, { signal: controller.signal });
-        clearTimeout(timeout);
-        if (!response.ok)
-            throw new Error(`HTTP ${response.status}`);
-        const pidPath = path.join(userDataDir, 'chrome.pid');
-        let pid;
-        try {
-            const rawPid = (await readFile(pidPath, 'utf8')).trim();
-            pid = Number.parseInt(rawPid, 10);
-            if (Number.isNaN(pid))
-                pid = undefined;
-        }
-        catch {
-            pid = undefined;
-        }
-        logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
-        return {
-            port,
-            pid,
-            kill: async () => { },
-            process: undefined,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${message}); launching new Chrome.`);
+    const probe = await verifyDevToolsReachable({ port });
+    if (!probe.ok) {
+        logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${probe.error}); launching new Chrome.`);
+        // Safe cleanup: remove stale DevToolsActivePort; only remove lock files if this was an Oracle-owned pid that died.
+        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'if_oracle_pid_dead' });
         return null;
     }
-}
-async function readDevToolsPort(userDataDir) {
-    const candidates = [
-        path.join(userDataDir, 'DevToolsActivePort'),
-        path.join(userDataDir, 'Default', 'DevToolsActivePort'),
-    ];
-    for (const candidate of candidates) {
-        try {
-            const raw = await readFile(candidate, 'utf8');
-            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
-            const port = Number.parseInt(firstLine ?? '', 10);
-            if (Number.isFinite(port)) {
-                return port;
-            }
-        }
-        catch {
-        }
-    }
-    return null;
+    const pid = await readChromePid(userDataDir);
+    logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
+    return {
+        port,
+        pid: pid ?? undefined,
+        kill: async () => { },
+        process: undefined,
+    };
 }
 async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
     const remoteChromeConfig = config.remoteChrome;
@@ -636,21 +639,50 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
-        const attachmentNames = attachments.map((a) => path.basename(a.path));
-        if (attachments.length > 0) {
-            if (!DOM) {
-                throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+        if (config.extendedThinking) {
+            await withRetries(() => ensureExtendedThinking(Runtime, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Extended thinking attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            });
+        }
+        const submitOnce = async (prompt, submissionAttachments) => {
+            const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            if (submissionAttachments.length > 0) {
+                if (!DOM) {
+                    throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+                }
+                // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
+                for (const attachment of submissionAttachments) {
+                    logger(`Uploading attachment: ${attachment.displayPath}`);
+                    await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+                }
+                const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                logger('All attachments uploaded');
             }
-            // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
-            for (const attachment of attachments) {
-                logger(`Uploading attachment: ${attachment.displayPath}`);
-                await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+            await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+        };
+        try {
+            await submitOnce(promptText, attachments);
+        }
+        catch (error) {
+            const isPromptTooLarge = error instanceof BrowserAutomationError &&
+                error.details?.code === 'prompt-too-large';
+            if (options.fallbackSubmission && isPromptTooLarge) {
+                logger('[browser] Inline prompt too large; retrying with file uploads.');
+                await clearPromptComposer(Runtime, logger);
+                await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                await submitOnce(options.fallbackSubmission.prompt, options.fallbackSubmission.attachments);
+            }
+            else {
+                throw error;
             }
-            const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
-            await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-            logger('All attachments uploaded');
         }
-        await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, promptText, logger);
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         const answer = await waitForAssistantResponse(Runtime, config.timeoutMs, logger);
         answerText = answer.text;

package/dist/src/browser/pageActions.js

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

package/dist/src/browser/profileState.js

@@ -0,0 +1,171 @@
+import path from 'node:path';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const DEVTOOLS_ACTIVE_PORT_FILENAME = 'DevToolsActivePort';
+const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
+    DEVTOOLS_ACTIVE_PORT_FILENAME,
+    path.join('Default', DEVTOOLS_ACTIVE_PORT_FILENAME),
+];
+const CHROME_PID_FILENAME = 'chrome.pid';
+const execFileAsync = promisify(execFile);
+export function getDevToolsActivePortPaths(userDataDir) {
+    return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
+}
+export async function readDevToolsPort(userDataDir) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            const raw = await readFile(candidate, 'utf8');
+            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
+            const port = Number.parseInt(firstLine ?? '', 10);
+            if (Number.isFinite(port)) {
+                return port;
+            }
+        }
+        catch {
+            // ignore missing/unreadable candidates
+        }
+    }
+    return null;
+}
+export async function writeDevToolsActivePort(userDataDir, port) {
+    const contents = `${port}\n/devtools/browser`;
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await mkdir(path.dirname(candidate), { recursive: true });
+            await writeFile(candidate, contents, 'utf8');
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+export async function readChromePid(userDataDir) {
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        const raw = (await readFile(pidPath, 'utf8')).trim();
+        const pid = Number.parseInt(raw, 10);
+        if (!Number.isFinite(pid) || pid <= 0) {
+            return null;
+        }
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeChromePid(userDataDir, pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return;
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        await mkdir(path.dirname(pidPath), { recursive: true });
+        await writeFile(pidPath, `${Math.trunc(pid)}\n`, 'utf8');
+    }
+    catch {
+        // best effort
+    }
+}
+export function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means "exists but no permission"; treat as alive.
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+export async function verifyDevToolsReachable({ port, host = '127.0.0.1', attempts = 3, timeoutMs = 3000, }) {
+    const versionUrl = `http://${host}:${port}/json/version`;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            const response = await fetch(versionUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            if (attempt < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    return { ok: false, error: 'unreachable' };
+}
+export async function cleanupStaleProfileState(userDataDir, logger, options = {}) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await rm(candidate, { force: true });
+            logger?.(`Removed stale DevToolsActivePort: ${candidate}`);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+    const lockRemovalMode = options.lockRemovalMode ?? 'never';
+    if (lockRemovalMode === 'never') {
+        return;
+    }
+    const pid = await readChromePid(userDataDir);
+    if (!pid) {
+        return;
+    }
+    if (isProcessAlive(pid)) {
+        logger?.(`Chrome pid ${pid} still alive; skipping profile lock cleanup`);
+        return;
+    }
+    // Extra safety: if Chrome is running with this profile (but with a different PID, e.g. user relaunched
+    // without remote debugging), never delete lock files.
+    if (await isChromeUsingUserDataDir(userDataDir)) {
+        logger?.('Detected running Chrome using this profile; skipping profile lock cleanup');
+        return;
+    }
+    const lockFiles = [
+        path.join(userDataDir, 'lockfile'),
+        path.join(userDataDir, 'SingletonLock'),
+        path.join(userDataDir, 'SingletonSocket'),
+        path.join(userDataDir, 'SingletonCookie'),
+    ];
+    for (const lock of lockFiles) {
+        await rm(lock, { force: true }).catch(() => undefined);
+    }
+    logger?.('Cleaned up stale Chrome profile locks');
+}
+async function isChromeUsingUserDataDir(userDataDir) {
+    if (process.platform === 'win32') {
+        // On Windows, lockfiles are typically held open and removal should fail anyway; avoid expensive process scans.
+        return false;
+    }
+    try {
+        const { stdout } = await execFileAsync('ps', ['-ax', '-o', 'command='], { maxBuffer: 10 * 1024 * 1024 });
+        const lines = String(stdout ?? '').split('\n');
+        const needle = userDataDir;
+        for (const line of lines) {
+            if (!line)
+                continue;
+            const lower = line.toLowerCase();
+            if (!lower.includes('chrome') && !lower.includes('chromium'))
+                continue;
+            if (line.includes(needle) && lower.includes('user-data-dir')) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // best effort
+    }
+    return false;
+}

package/dist/src/browser/prompt.js

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

package/dist/src/browser/sessionRunner.js

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

package/dist/src/cli/browserConfig.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import os from 'node:os';
 import { CHATGPT_URL, DEFAULT_MODEL_TARGET, normalizeChatgptUrl, parseDuration } from '../browserMode.js';
+import { getOracleHomeDir } from '../oracleHome.js';
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
 const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 30_000;
 const DEFAULT_CHROME_PROFILE = 'Default';
@@ -9,6 +9,9 @@ const BROWSER_MODEL_LABELS = {
     'gpt-5-pro': 'GPT-5 Pro',
     'gpt-5.1-pro': 'GPT-5.1 Pro',
     'gpt-5.1': 'GPT-5.1',
+    'gpt-5.2': 'GPT-5.2 Thinking',
+    'gpt-5.2-instant': 'GPT-5.2 Instant',
+    'gpt-5.2-pro': 'GPT-5.2 Pro',
     'gemini-3-pro': 'Gemini 3 Pro',
 };
 export async function buildBrowserConfig(options) {
@@ -53,6 +56,7 @@ export async function buildBrowserConfig(options) {
         // Allow cookie failures by default so runs can continue without Chrome/Keychain secrets.
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
+        extendedThinking: options.browserExtendedThinking ? true : undefined,
     };
 }
 function selectBrowserPort(options) {
@@ -155,7 +159,7 @@ async function resolveInlineCookies({ inlineArg, inlineFileArg, envPayload, envF
             return { cookies: parsed, source };
     }
     // fallback: ~/.oracle/cookies.{json,base64}
-    const oracleHome = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+    const oracleHome = getOracleHomeDir();
     const candidates = ['cookies.json', 'cookies.base64'];
     for (const file of candidates) {
         const fullPath = path.join(oracleHome, file);

package/dist/src/cli/sessionDisplay.js

@@ -18,7 +18,14 @@ function isProcessAlive(pid) {
         return true;
     }
     catch (error) {
-        return !(error instanceof Error && error.code === 'ESRCH');
+        const code = error instanceof Error ? error.code : undefined;
+        if (code === 'ESRCH' || code === 'EINVAL') {
+            return false;
+        }
+        if (code === 'EPERM') {
+            return true;
+        }
+        return true;
     }
 }
 const CLEANUP_TIP = 'Tip: Run "oracle session --clear --hours 24" to prune cached runs (add --all to wipe everything).';