@steipete/oracle 0.11.0 → 0.12.0

package/dist/src/browser/index.js

@@ -26,6 +26,7 @@ import { resolveAttachRunningConnection } from "./attachRunning.js";
 import { connectToExistingChatGptTab } from "./liveTabs.js";
 import { captureBrowserDiagnostics } from "./domDebug.js";
 import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./actions/archiveConversation.js";
+import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
@@ -70,19 +71,12 @@ export function shouldPreserveBrowserOnErrorForTest(error, headless) {
 export function classifyPreservedBrowserErrorForTest(error, headless) {
     return classifyPreservedBrowserError(error, headless);
 }
-function shouldSkipThinkingTimeSelection(desiredModel, thinkingTime) {
-    if (thinkingTime !== "extended" || !desiredModel) {
-        return false;
-    }
-    const normalized = desiredModel.toLowerCase();
-    return (normalized === "gpt-5.5-pro" ||
-        normalized.includes("gpt-5.5 pro") ||
-        normalized.includes("gpt 5.5 pro") ||
-        normalized.includes("gpt 5 5 pro"));
-}
-export function shouldSkipThinkingTimeSelectionForTest(desiredModel, thinkingTime) {
-    return shouldSkipThinkingTimeSelection(desiredModel, thinkingTime);
-}
+// NOTE: Previously, shouldSkipThinkingTimeSelection() would skip the thinking
+// time UI step when desiredModel was gpt-5.5-pro and thinkingTime was "extended",
+// assuming that selecting "Pro Extended" in the old UI already implied Extended
+// effort. This is wrong for lower-tier plans ($100/mo Pro) where selecting "Pro"
+// defaults to Standard effort. ensureThinkingTime() already handles the
+// "already-selected" case as a no-op, so always attempting it is safe.
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -297,6 +291,17 @@ async function closeRemoteConnectionAfterRun(options) {
 function shouldCloseOwnedRunTargetAfterRun(options) {
     return options.runStatus === "complete" && options.ownsTarget && !options.keepBrowser;
 }
+function buildSkippedModelSelectionEvidence(desiredModel, strategy) {
+    return {
+        requestedModel: desiredModel ?? null,
+        resolvedLabel: null,
+        strategy,
+        status: "skipped",
+        verified: false,
+        source: "config",
+        capturedAt: new Date().toISOString(),
+    };
+}
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
@@ -390,14 +395,19 @@ export async function runBrowserMode(options) {
     const manualLogin = Boolean(config.manualLogin);
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
-        : path.join(os.homedir(), ".oracle", "browser-profile");
+        : defaultManualLoginProfileDir();
     const userDataDir = manualLogin
         ? manualProfileDir
         : await mkdtemp(path.join(await resolveUserDataBaseDir(), "oracle-browser-"));
+    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     if (manualLogin) {
         // Learned: manual login reuses a persistent profile so cookies/SSO survive.
         await mkdir(userDataDir, { recursive: true });
         logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+        await assertManualLoginProfileReadyForRun({
+            userDataDir,
+            keepBrowser: effectiveKeepBrowser,
+        });
     }
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
@@ -410,7 +420,6 @@ export async function runBrowserMode(options) {
             sessionId: options.sessionId,
         });
     }
-    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     let acquiredChrome;
     try {
         acquiredChrome = manualLogin
@@ -458,6 +467,7 @@ export async function runBrowserMode(options) {
     let answerMarkdown = "";
     let answerHtml = "";
     let runStatus = "attempted";
+    let modelSelectionEvidence;
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
@@ -594,6 +604,8 @@ export async function runBrowserMode(options) {
                 appliedCookies,
                 manualLogin,
                 timeoutMs: config.timeoutMs,
+                profileDir: userDataDir,
+                keepBrowser: effectiveKeepBrowser,
             }));
             if (config.url !== baseUrl) {
                 await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
@@ -687,7 +699,7 @@ export async function runBrowserMode(options) {
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore") {
-            await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
+            modelSelectionEvidence = await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -706,26 +718,22 @@ export async function runBrowserMode(options) {
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
         else if (modelStrategy === "ignore") {
+            modelSelectionEvidence = buildSkippedModelSelectionEvidence(config.desiredModel, modelStrategy);
             logger("Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
         // Handle thinking time selection if specified. Deep Research owns its own effort flow.
         const thinkingTime = config.thinkingTime;
         if (thinkingTime && !deepResearch) {
-            if (shouldSkipThinkingTimeSelection(config.desiredModel, thinkingTime)) {
-                logger("Thinking time: Pro Extended (via model selection)");
-            }
-            else {
-                await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
-                    retries: 2,
-                    delayMs: 300,
-                    onRetry: (attempt, error) => {
-                        if (options.verbose) {
-                            logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
-                        }
-                    },
-                }));
-            }
+            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            }));
         }
         if (deepResearch) {
             await raceWithDisconnect(withRetries(() => activateDeepResearch(Runtime, Input, logger), {
@@ -893,6 +901,7 @@ export async function runBrowserMode(options) {
                 answerHtml: researchResult.html,
                 artifacts: savedArtifacts,
                 archive,
+                modelSelection: modelSelectionEvidence,
                 tookMs: durationMs,
                 answerTokens: tokens,
                 answerChars: researchResult.text.length,
@@ -1278,6 +1287,7 @@ export async function runBrowserMode(options) {
             generatedImages: imageArtifacts.generatedImages,
             savedImages: imageArtifacts.savedImages,
             archive,
+            modelSelection: modelSelectionEvidence,
             tookMs: durationMs,
             answerTokens,
             answerChars,
@@ -1503,12 +1513,13 @@ async function findEphemeralPort() {
         });
     });
 }
-async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
+async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, profileDir, keepBrowser, }) {
     if (!manualLogin) {
         await ensureLoggedIn(runtime, logger, { appliedCookies });
         return;
     }
-    const deadline = Date.now() + Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    const waitMs = resolveManualLoginWaitMs(timeoutMs, Boolean(keepBrowser));
+    const deadline = Date.now() + waitMs;
     let lastNotice = 0;
     while (Date.now() < deadline) {
         try {
@@ -1530,7 +1541,10 @@ async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, time
             await delay(1000);
         }
     }
-    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
+    const setupCommand = formatManualLoginSetupCommand(profileDir ?? defaultManualLoginProfileDir());
+    throw new Error("Manual login mode timed out waiting for ChatGPT session. " +
+        `Browser mode is using Oracle's private Chrome profile at ${profileDir ?? "(default profile)"}, not your normal Chrome profile. ` +
+        `Run first-time setup, sign in there, then retry: ${setupCommand}`);
 }
 async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answerText, answerMarkdown, logger, allowMarkdownUpdate, }) {
     // Learned: long streaming responses can still be rendering after initial capture.
@@ -1724,6 +1738,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let answerHtml = "";
     let connectionClosedUnexpectedly = false;
     let runStatus = "attempted";
+    let modelSelectionEvidence;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
     let connection = null;
@@ -1813,7 +1828,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore") {
-            await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
+            modelSelectionEvidence = await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -1826,26 +1841,22 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
         else if (modelStrategy === "ignore") {
+            modelSelectionEvidence = buildSkippedModelSelectionEvidence(config.desiredModel, modelStrategy);
             logger("Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
         // Handle thinking time selection if specified. Deep Research owns its own effort flow.
         const thinkingTime = config.thinkingTime;
         if (thinkingTime && !deepResearch) {
-            if (shouldSkipThinkingTimeSelection(config.desiredModel, thinkingTime)) {
-                logger("Thinking time: Pro Extended (via model selection)");
-            }
-            else {
-                await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
-                    retries: 2,
-                    delayMs: 300,
-                    onRetry: (attempt, error) => {
-                        if (options.verbose) {
-                            logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
-                        }
-                    },
-                });
-            }
+            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Thinking time (${thinkingTime}) attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            });
         }
         if (deepResearch) {
             await withRetries(() => activateDeepResearch(Runtime, Input, logger), {
@@ -1965,6 +1976,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 answerHtml: researchResult.html,
                 artifacts: savedArtifacts,
                 archive,
+                modelSelection: modelSelectionEvidence,
                 tookMs: durationMs,
                 answerTokens: tokens,
                 answerChars: researchResult.text.length,
@@ -2328,6 +2340,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
             artifacts: savedArtifacts,
             archive,
+            modelSelection: modelSelectionEvidence,
             controllerPid: process.pid,
         };
     }
@@ -2389,10 +2402,14 @@ export { estimateTokenCount } from "./utils.js";
 export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from "./config.js";
 // biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
 export const __test__ = {
+    assertManualLoginProfileReadyForRun,
     closeRemoteConnectionAfterRun,
     detachKeptChromeProcess,
+    formatManualLoginSetupCommand,
+    isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
+    resolveManualLoginWaitMs,
     shouldCloseOwnedRunTargetAfterRun,
 };
 export { syncCookies } from "./cookies.js";

package/dist/src/browser/manualLoginProfile.js

@@ -0,0 +1,54 @@
+import { readdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { BrowserAutomationError } from "../oracle/errors.js";
+export function resolveManualLoginWaitMs(timeoutMs, keepBrowser) {
+    const configured = Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    if (keepBrowser) {
+        return configured;
+    }
+    return Math.min(configured, 30_000);
+}
+export async function assertManualLoginProfileReadyForRun({ userDataDir, keepBrowser, }) {
+    if (keepBrowser) {
+        return;
+    }
+    if (await isManualLoginProfileInitialized(userDataDir)) {
+        return;
+    }
+    const setupCommand = formatManualLoginSetupCommand(userDataDir);
+    throw new BrowserAutomationError("ChatGPT browser manual-login profile is not initialized. " +
+        `Browser mode is using Oracle's private Chrome profile at ${userDataDir}, separate from your normal Chrome profile. ` +
+        `Run first-time setup, sign in there, then retry: ${setupCommand}. ` +
+        "If you want to reuse an already signed-in Chrome instead, use --browser-attach-running.", {
+        stage: "browser-login-setup",
+        details: {
+            profileDir: userDataDir,
+            setupCommand,
+            sessionStatus: "needs_login",
+        },
+        reuseProfileHint: setupCommand,
+    });
+}
+export async function isManualLoginProfileInitialized(profileDir) {
+    const entries = await readdir(profileDir, { withFileTypes: true }).catch(() => []);
+    return entries.some((entry) => {
+        if (!entry.name)
+            return false;
+        if (entry.name === "Default" || entry.name === "Local State")
+            return true;
+        if (entry.name.startsWith("Profile "))
+            return true;
+        return false;
+    });
+}
+export function formatManualLoginSetupCommand(profileDir) {
+    return [
+        "oracle --engine browser --browser-manual-login --browser-keep-browser",
+        `--browser-manual-login-profile-dir ${JSON.stringify(profileDir)}`,
+        '-p "HI"',
+    ].join(" ");
+}
+export function defaultManualLoginProfileDir() {
+    return path.join(os.homedir(), ".oracle", "browser-profile");
+}

package/dist/src/browser/projectSourcesRunner.js

@@ -9,6 +9,7 @@ import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLe
 import { acquireProfileRunLock, cleanupStaleProfileState, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
 import { CHATGPT_URL } from "./constants.js";
 import { delay } from "./utils.js";
+import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { openProjectSourcesTab, uploadProjectSources, waitForProjectSourcesReady, waitForProjectSourcesListSettled, } from "./actions/projectSources.js";
 import { normalizeProjectSourcesUrl } from "../projectSources/url.js";
 import { buildProjectSourcesUploadPlan, diffAddedProjectSources } from "../projectSources/plan.js";
@@ -45,13 +46,18 @@ export async function runBrowserProjectSources(request) {
     const manualLogin = Boolean(config.manualLogin);
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
-        : path.join(os.homedir(), ".oracle", "browser-profile");
+        : defaultManualLoginProfileDir();
     const userDataDir = manualLogin
         ? manualProfileDir
         : await mkdtemp(path.join(os.tmpdir(), "oracle-project-sources-"));
+    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     if (manualLogin) {
         await mkdir(userDataDir, { recursive: true });
         logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+        await assertManualLoginProfileReadyForRun({
+            userDataDir,
+            keepBrowser: effectiveKeepBrowser,
+        });
     }
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
@@ -73,7 +79,6 @@ export async function runBrowserProjectSources(request) {
     let removeDialogHandler = null;
     let connectionClosedUnexpectedly = false;
     let completed = false;
-    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     try {
         const acquired = manualLogin
             ? await acquireManualLoginChromeForProjectSources(userDataDir, config, logger)
@@ -140,6 +145,8 @@ export async function runBrowserProjectSources(request) {
             appliedCookies,
             manualLogin,
             timeoutMs: config.timeoutMs,
+            profileDir: userDataDir,
+            keepBrowser: effectiveKeepBrowser,
         }));
         await raceWithDisconnect(navigateToChatGPT(Page, Runtime, projectUrl, logger));
         await raceWithDisconnect(openProjectSourcesTab(Runtime, Input, config.inputTimeoutMs, logger));
@@ -261,12 +268,13 @@ async function applyProjectSourcesCookies({ config, network, manualLogin, logger
         : "No Chrome cookies found; continuing without session reuse");
     return cookieCount;
 }
-async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
+async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, profileDir, keepBrowser, }) {
     if (!manualLogin) {
         await ensureLoggedIn(runtime, logger, { appliedCookies });
         return;
     }
-    const deadline = Date.now() + Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    const waitMs = resolveManualLoginWaitMs(timeoutMs, Boolean(keepBrowser));
+    const deadline = Date.now() + waitMs;
     let lastNotice = 0;
     while (Date.now() < deadline) {
         try {
@@ -288,7 +296,10 @@ async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, man
             await delay(1000);
         }
     }
-    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
+    const setupCommand = formatManualLoginSetupCommand(profileDir ?? defaultManualLoginProfileDir());
+    throw new Error("Manual login mode timed out waiting for ChatGPT session. " +
+        `Browser mode is using Oracle's private Chrome profile at ${profileDir ?? "(default profile)"}, not your normal Chrome profile. ` +
+        `Run first-time setup, sign in there, then retry: ${setupCommand}`);
 }
 async function acquireManualLoginChromeForProjectSources(userDataDir, config, logger) {
     const lockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);

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";
+import { createStoredZip } from "./zipBundle.js";
 const DEFAULT_BROWSER_INLINE_CHAR_BUDGET = 60_000;
 const MEDIA_EXTENSIONS = new Set([
     ".mp4",
@@ -34,6 +35,49 @@ export function isMediaFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return MEDIA_EXTENSIONS.has(ext);
 }
+function formatSectionsForBundle(sections) {
+    const bundleLines = [];
+    sections.forEach((section) => {
+        bundleLines.push(formatFileSection(section.displayPath, section.content).trimEnd());
+        bundleLines.push("");
+    });
+    return `${bundleLines
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd()}\n`;
+}
+async function writeBrowserBundle(sections, format) {
+    const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
+    const tokenEstimateText = formatSectionsForBundle(sections);
+    if (format === "zip") {
+        const bundlePath = path.join(bundleDir, "attachments-bundle.zip");
+        const buffer = createStoredZip(sections.map((section) => ({
+            path: section.displayPath,
+            content: section.content,
+        })));
+        await fs.writeFile(bundlePath, buffer);
+        return {
+            attachment: {
+                path: bundlePath,
+                displayPath: bundlePath,
+                sizeBytes: buffer.length,
+            },
+            metadata: { originalCount: sections.length, bundlePath, format },
+            tokenEstimateText,
+        };
+    }
+    const bundlePath = path.join(bundleDir, "attachments-bundle.txt");
+    await fs.writeFile(bundlePath, tokenEstimateText, "utf8");
+    return {
+        attachment: {
+            path: bundlePath,
+            displayPath: bundlePath,
+            sizeBytes: Buffer.byteLength(tokenEstimateText, "utf8"),
+        },
+        metadata: { originalCount: sections.length, bundlePath, format },
+        tokenEstimateText,
+    };
+}
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
@@ -49,7 +93,10 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             sizeBytes: stats.size,
         };
     }));
-    const files = await readFilesFn(textFilePaths, { cwd });
+    const files = await readFilesFn(textFilePaths, {
+        cwd,
+        maxFileSizeBytes: runOptions.maxFileSizeBytes,
+    });
     const basePrompt = (runOptions.prompt ?? "").trim();
     const userPrompt = basePrompt;
     const systemPrompt = runOptions.system?.trim() || "";
@@ -59,6 +106,7 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         ? "never"
         : (runOptions.browserAttachments ?? "auto");
     const bundleRequested = Boolean(runOptions.browserBundleFiles);
+    const bundleFormat = runOptions.browserBundleFormat ?? "text";
     const inlinePlan = buildAttachmentPlan(sections, { inlineFiles: true, bundleRequested });
     const uploadPlan = buildAttachmentPlan(sections, { inlineFiles: false, bundleRequested });
     const baseComposerSections = [];
@@ -88,26 +136,12 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     let bundleText = null;
     let bundled = null;
     if (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("");
-        });
-        bundleText = `${bundleLines
-            .join("\n")
-            .replace(/\n{3,}/g, "\n\n")
-            .trimEnd()}\n`;
-        await fs.writeFile(bundlePath, bundleText, "utf8");
+        const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
+        bundleText = writtenBundle.tokenEstimateText;
         attachments.length = 0;
-        attachments.push({
-            path: bundlePath,
-            displayPath: bundlePath,
-            sizeBytes: Buffer.byteLength(bundleText, "utf8"),
-        });
+        attachments.push(writtenBundle.attachment);
         attachments.push(...mediaAttachments);
-        bundled = { originalCount: sections.length, bundlePath };
+        bundled = writtenBundle.metadata;
     }
     const inlineFileCount = selectedPlan.inlineFileCount;
     const modelConfig = isKnownModel(runOptions.model)
@@ -140,26 +174,11 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         const fallbackAttachments = [...uploadPlan.attachments, ...mediaAttachments];
         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");
+            const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
             fallbackAttachments.length = 0;
-            fallbackAttachments.push({
-                path: bundlePath,
-                displayPath: bundlePath,
-                sizeBytes: Buffer.byteLength(fallbackBundleText, "utf8"),
-            });
+            fallbackAttachments.push(writtenBundle.attachment);
             fallbackAttachments.push(...mediaAttachments);
-            fallbackBundled = { originalCount: sections.length, bundlePath };
+            fallbackBundled = writtenBundle.metadata;
         }
         fallback = {
             composerText: fallbackComposerText,

package/dist/src/browser/sessionRunner.js

@@ -5,6 +5,61 @@ import { runBrowserMode } from "../browserMode.js";
 import { assembleBrowserPrompt } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
+const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
+const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
+function buildUnavailableModelSelectionEvidence(browserConfig) {
+    if (!browserConfig.desiredModel) {
+        return undefined;
+    }
+    return {
+        requestedModel: browserConfig.desiredModel,
+        resolvedLabel: null,
+        strategy: browserConfig.modelStrategy,
+        status: "unavailable",
+        verified: false,
+        source: "config",
+        capturedAt: new Date().toISOString(),
+    };
+}
+function formatModelSelectionEvidence(evidence) {
+    const requested = evidence.requestedModel ?? "(none)";
+    const resolved = evidence.resolvedLabel ?? "(unavailable)";
+    const strategy = evidence.strategy ?? "(default)";
+    const verified = evidence.verified ? "yes" : "no";
+    return `[browser] Model selection evidence: requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}.`;
+}
+function isRequestedProBrowserRun(runOptions, browserConfig, evidence) {
+    const candidates = [
+        runOptions.model,
+        browserConfig.desiredModel,
+        evidence?.requestedModel,
+        evidence?.resolvedLabel,
+    ];
+    return candidates.some((value) => typeof value === "string" && /\bpro\b/i.test(value));
+}
+export function buildBrowserRunWarningsForTest(args) {
+    return buildBrowserRunWarnings(args);
+}
+function buildBrowserRunWarnings(args) {
+    if (!isRequestedProBrowserRun(args.runOptions, args.browserConfig, args.modelSelection) ||
+        args.inputTokens < LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD ||
+        args.elapsedMs >= LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD) {
+        return [];
+    }
+    return [
+        {
+            code: "browser-pro-fast-large-run",
+            severity: "warning",
+            message: `Large browser Pro run completed quickly (${(args.elapsedMs / 1000).toFixed(0)}s for ~${args.inputTokens.toLocaleString()} input tokens); verify the stored model selection evidence before claiming Pro Extended output.`,
+            details: {
+                inputTokens: args.inputTokens,
+                elapsedMs: args.elapsedMs,
+                requestedModel: args.modelSelection?.requestedModel ?? args.browserConfig.desiredModel,
+                resolvedLabel: args.modelSelection?.resolvedLabel ?? null,
+            },
+        },
+    ];
+}
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, deps = {}) {
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
@@ -37,7 +92,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         if (typeof message !== "string")
             return;
         const shouldAlwaysPrint = message.startsWith("[browser] ") &&
-            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|browser slot|browser control|browser guidance/i.test(message);
+            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
         if (!runOptions.verbose && !shouldAlwaysPrint)
             return;
         log(message);
@@ -84,6 +139,20 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         const message = error instanceof Error ? error.message : "Browser automation failed.";
         throw new BrowserAutomationError(message, { stage: "execute-browser" }, error);
     }
+    const modelSelection = browserResult.modelSelection ?? buildUnavailableModelSelectionEvidence(browserConfig);
+    if (modelSelection) {
+        log(formatModelSelectionEvidence(modelSelection));
+    }
+    const warnings = buildBrowserRunWarnings({
+        runOptions,
+        browserConfig,
+        inputTokens: promptArtifacts.estimatedInputTokens,
+        elapsedMs: browserResult.tookMs,
+        modelSelection,
+    });
+    for (const warning of warnings) {
+        log(chalk.yellow(`[browser] ${warning.message}`));
+    }
     if (!runOptions.silent) {
         log(chalk.bold("Answer:"));
         log(browserResult.answerMarkdown || browserResult.answerText || chalk.dim("(no text output)"));
@@ -148,6 +217,8 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             controllerPid: browserResult.controllerPid ?? process.pid,
         },
         archive: browserResult.archive,
+        modelSelection,
+        warnings,
         answerText,
         artifacts: savedArtifacts,
     };