@steipete/oracle 0.18.0 → 0.19.0

package/dist/src/browser/prompt.js

@@ -6,6 +6,7 @@ import { isKnownModel } from "../oracle/modelResolver.js";
 import { buildPromptMarkdown } from "../oracle/promptAssembly.js";
 import { buildAttachmentPlan } from "./policies.js";
 import { createStoredZip } from "./zipBundle.js";
+import { buildAttachmentBasenameCollisionDetails, findAttachmentBasenameCollisions, formatAttachmentBasenameCollisionMessage, } from "./attachmentValidation.js";
 const DEFAULT_BROWSER_INLINE_CHAR_BUDGET = 60_000;
 const MAX_BROWSER_ATTACHMENTS = 10;
 const MAX_BROWSER_ZIP_BUNDLE_BYTES = 128 * 1024 * 1024;
@@ -82,70 +83,197 @@ export function isRawUploadFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return MEDIA_EXTENSIONS.has(ext) || ARCHIVE_EXTENSIONS.has(ext);
 }
+const GENERATED_BUNDLE_DIR_PREFIX = "oracle-browser-bundle-";
+const pendingFallbackBundles = new WeakMap();
 function formatSectionsForBundle(sections, options = {}) {
     return formatFileSections(sections, {
         lineNumbers: options.lineNumbers ?? true,
         trailingNewline: true,
     });
 }
-function resolveBrowserBundleFormat(format, sources) {
+function resolveBrowserBundleFormat(format, { hasRawUploadFiles }) {
     if (format !== "auto") {
         return format;
     }
-    return sources.hasRawUploadFiles ? "zip" : "text";
+    return hasRawUploadFiles ? "zip" : "text";
 }
-function shouldWriteBrowserBundle(format, { attachmentCount, bundleRequested, textSourceCount, textPlanShouldBundle, }) {
-    if (format === "zip") {
-        return (textPlanShouldBundle ||
-            (bundleRequested && attachmentCount > 0) ||
-            attachmentCount > MAX_BROWSER_ATTACHMENTS);
+function resolveBrowserBundleScope(format, { bundleRequested, rawAttachmentCount, textAttachmentCount, }) {
+    const attachmentCount = textAttachmentCount + rawAttachmentCount;
+    if (attachmentCount === 0) {
+        return "none";
+    }
+    if (format === "text") {
+        if (textAttachmentCount === 0) {
+            return "none";
+        }
+        const shouldBundleText = bundleRequested || textAttachmentCount > 1 || attachmentCount > MAX_BROWSER_ATTACHMENTS;
+        return shouldBundleText ? "text-only" : "none";
+    }
+    if (bundleRequested) {
+        return "all";
     }
-    return textSourceCount > 0 && (textPlanShouldBundle || attachmentCount > MAX_BROWSER_ATTACHMENTS);
+    // Preserve native uploads for images, PDFs, archives, and other raw inputs.
+    // Multiple text/source files benefit from a real filesystem tree, so bundle
+    // those into one ZIP while leaving any native attachments alongside it.
+    if (textAttachmentCount > 1) {
+        return rawAttachmentCount + 1 <= MAX_BROWSER_ATTACHMENTS ? "text-only" : "all";
+    }
+    return attachmentCount > MAX_BROWSER_ATTACHMENTS ? "all" : "none";
+}
+function appendZipBundleInstruction(composerText, originalCount, bundlePath) {
+    const fileLabel = originalCount === 1 ? "file" : "files";
+    const instruction = [
+        `The attached \`${path.basename(bundlePath)}\` contains ${originalCount} selected ${fileLabel} with relative paths preserved.`,
+        "Extract it into a temporary directory, then inspect the resulting file tree with filesystem and search tools before answering.",
+    ].join(" ");
+    return [composerText, instruction].filter(Boolean).join("\n\n").trim();
+}
+function assertAttachmentCount(attachmentCount, format) {
+    if (attachmentCount <= MAX_BROWSER_ATTACHMENTS)
+        return;
+    throw new Error(`Browser upload has ${attachmentCount} attachments after applying bundle format "${format}". Use --browser-bundle-format auto or zip to stay within the ${MAX_BROWSER_ATTACHMENTS}-attachment limit.`);
 }
-function assertAttachmentCount(attachments, format) {
-    if (attachments.length <= MAX_BROWSER_ATTACHMENTS)
+function assertUniqueAttachmentBasenames(attachments, cwd) {
+    const collisions = findAttachmentBasenameCollisions(attachments);
+    if (collisions.length === 0)
         return;
-    throw new Error(`Browser upload has ${attachments.length} attachments after applying bundle format "${format}". Use --browser-bundle-format auto or zip to stay within the ${MAX_BROWSER_ATTACHMENTS}-attachment limit.`);
+    const details = buildAttachmentBasenameCollisionDetails(collisions, (attachment) => path.isAbsolute(attachment.path) ? attachment.path : path.resolve(cwd, attachment.path));
+    throw new FileValidationError(formatAttachmentBasenameCollisionMessage("Browser upload", details.collisions), { ...details });
+}
+async function applyWrittenBundle({ sections, sources, format, scope, rawUploadAttachments, composerText, bundleParentDir, }) {
+    const nativeAttachments = scope === "text-only" ? rawUploadAttachments : [];
+    assertAttachmentCount(1 + nativeAttachments.length, format);
+    assertUniqueAttachmentBasenames(nativeAttachments, process.cwd());
+    const reservedNames = new Set(nativeAttachments.map((a) => path.basename(a.path).toLowerCase()));
+    let bundleName = `attachments-bundle.${format === "zip" ? "zip" : "txt"}`;
+    for (let suffix = 2; reservedNames.has(bundleName.toLowerCase()); suffix += 1) {
+        bundleName = `attachments-bundle-${suffix}.${format === "zip" ? "zip" : "txt"}`;
+    }
+    const writtenBundle = await writeBrowserBundle(sections, sources, format, bundleName, bundleParentDir);
+    const attachments = [writtenBundle.attachment];
+    if (scope === "text-only") {
+        attachments.push(...rawUploadAttachments);
+    }
+    assertAttachmentCount(attachments.length, format);
+    return {
+        attachments,
+        bundled: writtenBundle.metadata,
+        composerText: format === "zip"
+            ? appendZipBundleInstruction(composerText, writtenBundle.metadata.originalCount, writtenBundle.metadata.bundlePath)
+            : composerText,
+        tokenEstimateText: writtenBundle.tokenEstimateText,
+    };
 }
-async function writeBrowserBundle(sections, sources, format) {
-    const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
-    const tokenEstimateText = formatSectionsForBundle(sections, {
-        lineNumbers: format === "text",
+function generatedBundleDirectory(attachment) {
+    if (!attachment.generatedBundle)
+        return null;
+    const dir = path.dirname(attachment.path);
+    return path.basename(dir).startsWith(GENERATED_BUNDLE_DIR_PREFIX) ? dir : null;
+}
+export function listGeneratedBrowserBundleDirs(artifacts) {
+    const dirs = new Set();
+    for (const attachment of [...artifacts.attachments, ...(artifacts.fallback?.attachments ?? [])]) {
+        const dir = generatedBundleDirectory(attachment);
+        if (dir)
+            dirs.add(dir);
+    }
+    return [...dirs];
+}
+export async function cleanupGeneratedBrowserBundles(artifacts) {
+    await Promise.all(listGeneratedBrowserBundleDirs(artifacts).map((dir) => fs.rm(dir, { recursive: true, force: true })));
+}
+export async function materializeBrowserFallback(artifacts) {
+    const pending = pendingFallbackBundles.get(artifacts);
+    if (!pending || !artifacts.fallback) {
+        return artifacts.fallback ?? null;
+    }
+    pendingFallbackBundles.delete(artifacts);
+    const applied = await applyWrittenBundle({
+        sections: pending.sections,
+        sources: pending.scope === "all" ? pending.allSources : pending.textSources,
+        format: pending.format,
+        scope: pending.scope,
+        rawUploadAttachments: pending.rawUploadAttachments,
+        composerText: artifacts.fallback.composerText,
     });
+    artifacts.fallback.composerText = applied.composerText;
+    artifacts.fallback.attachments = applied.attachments;
+    artifacts.fallback.bundled = applied.bundled;
+    artifacts.fallback.pendingBundle = null;
+    return artifacts.fallback;
+}
+export async function materializeStagedFallbackBundle({ composerText, attachments, format, scope, bundleParentDir, }) {
+    const textAttachments = attachments.filter((attachment) => !isRawUploadFile(attachment.path));
+    const rawAttachments = attachments.filter((attachment) => isRawUploadFile(attachment.path));
+    const textSources = textAttachments.map((attachment) => ({
+        absolutePath: attachment.path,
+        displayPath: attachment.displayPath,
+        sizeBytes: attachment.sizeBytes ?? 0,
+    }));
+    const allSources = [
+        ...textSources,
+        ...rawAttachments.map((attachment) => ({
+            absolutePath: attachment.path,
+            displayPath: attachment.displayPath,
+            sizeBytes: attachment.sizeBytes ?? 0,
+        })),
+    ];
+    const sections = await Promise.all(textAttachments.map(async (attachment, index) => {
+        const content = await fs.readFile(attachment.path, "utf8");
+        return {
+            index: index + 1,
+            absolutePath: attachment.path,
+            displayPath: attachment.displayPath,
+            content,
+            sectionText: "",
+        };
+    }));
+    return applyWrittenBundle({
+        sections,
+        sources: scope === "all" ? allSources : textSources,
+        format,
+        scope,
+        rawUploadAttachments: rawAttachments,
+        composerText,
+        bundleParentDir,
+    });
+}
+async function writeBrowserBundle(sections, sources, format, bundleName, bundleParentDir = os.tmpdir()) {
+    const tokenEstimateText = formatSectionsForBundle(sections, { lineNumbers: format === "text" });
+    let content = tokenEstimateText;
     if (format === "zip") {
         const totalSourceBytes = sources.reduce((total, source) => total + source.sizeBytes, 0);
         if (totalSourceBytes > MAX_BROWSER_ZIP_BUNDLE_BYTES) {
             throw new Error(`Browser ZIP bundle inputs exceed the ${MAX_BROWSER_ZIP_BUNDLE_BYTES}-byte in-memory limit.`);
         }
-        const bundlePath = path.join(bundleDir, "attachments-bundle.zip");
-        const buffer = createStoredZip(await Promise.all(sources.map(async (source) => ({
+        content = createStoredZip(await Promise.all(sources.map(async (source) => ({
             path: source.displayPath,
             content: await fs.readFile(source.absolutePath),
         }))));
-        await fs.writeFile(bundlePath, buffer);
+    }
+    const bundleDir = await fs.mkdtemp(path.join(bundleParentDir, GENERATED_BUNDLE_DIR_PREFIX));
+    const bundlePath = path.join(bundleDir, bundleName);
+    try {
+        await fs.writeFile(bundlePath, content);
         return {
             attachment: {
                 path: bundlePath,
                 displayPath: bundlePath,
-                sizeBytes: buffer.length,
+                sizeBytes: Buffer.byteLength(content),
                 generatedBundle: true,
             },
-            metadata: { originalCount: sources.length, bundlePath, format },
+            metadata: {
+                originalCount: format === "zip" ? sources.length : 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"),
-            generatedBundle: true,
-        },
-        metadata: { originalCount: sections.length, bundlePath, format },
-        tokenEstimateText,
-    };
+    catch (error) {
+        await fs.rm(bundleDir, { recursive: true, force: true });
+        throw error;
+    }
 }
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
@@ -206,10 +334,10 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         .filter(Boolean)
         .join("\n\n")
         .trim();
-    const selectedPlan = attachmentsPolicy === "always"
-        ? uploadPlan
-        : attachmentsPolicy === "never"
-            ? inlinePlan
+    const selectedPlan = attachmentsPolicy === "never"
+        ? inlinePlan
+        : attachmentsPolicy === "always" || bundleRequested
+            ? uploadPlan
             : inlineComposerText.length <= DEFAULT_BROWSER_INLINE_CHAR_BUDGET || sections.length === 0
                 ? inlinePlan
                 : uploadPlan;
@@ -228,13 +356,13 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const resolvedBundleFormat = resolveBrowserBundleFormat(bundleFormat, {
         hasRawUploadFiles: rawUploadAttachments.length > 0,
     });
-    const shouldBundle = shouldWriteBrowserBundle(resolvedBundleFormat, {
-        attachmentCount: attachments.length,
+    const bundleScope = resolveBrowserBundleScope(resolvedBundleFormat, {
         bundleRequested,
-        textSourceCount: textBundleSources.length,
-        textPlanShouldBundle: selectedPlan.shouldBundle,
+        rawAttachmentCount: rawUploadAttachments.length,
+        textAttachmentCount: selectedPlan.attachments.length,
     });
-    const composerText = (!shouldBundle && selectedPlan.inlineBlock
+    const shouldBundle = bundleScope !== "none";
+    let composerText = (!shouldBundle && selectedPlan.inlineBlock
         ? [...baseComposerSections, selectedPlan.inlineBlock]
         : baseComposerSections)
         .filter(Boolean)
@@ -242,85 +370,116 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         .trim();
     let bundleText = null;
     let bundled = null;
-    if (shouldBundle) {
-        const writtenBundle = await writeBrowserBundle(sections, resolvedBundleFormat === "zip" ? allBundleSources : textBundleSources, resolvedBundleFormat);
+    if (bundleScope !== "none") {
+        const writtenBundle = await applyWrittenBundle({
+            sections,
+            sources: bundleScope === "all" ? allBundleSources : textBundleSources,
+            format: resolvedBundleFormat,
+            scope: bundleScope,
+            rawUploadAttachments,
+            composerText,
+        });
         bundleText = writtenBundle.tokenEstimateText;
         attachments.length = 0;
-        attachments.push(writtenBundle.attachment);
-        if (resolvedBundleFormat === "text") {
-            attachments.push(...rawUploadAttachments);
-        }
-        bundled = writtenBundle.metadata;
+        attachments.push(...writtenBundle.attachments);
+        bundled = writtenBundle.bundled;
+        composerText = writtenBundle.composerText;
     }
-    assertAttachmentCount(attachments, resolvedBundleFormat);
-    const inlineFileCount = shouldBundle ? 0 : selectedPlan.inlineFileCount;
-    const modelConfig = isKnownModel(runOptions.model)
-        ? MODEL_CONFIGS[runOptions.model]
-        : MODEL_CONFIGS["gpt-5.1"];
-    const tokenizer = deps.tokenizeImpl ?? modelConfig.tokenizer;
-    const tokenizerUserContent = inlineFileCount > 0 && selectedPlan.inlineBlock
-        ? [userPrompt, selectedPlan.inlineBlock]
+    else {
+        assertAttachmentCount(attachments.length, resolvedBundleFormat);
+    }
+    try {
+        assertUniqueAttachmentBasenames(attachments, cwd);
+        const inlineFileCount = shouldBundle ? 0 : selectedPlan.inlineFileCount;
+        const modelConfig = isKnownModel(runOptions.model)
+            ? MODEL_CONFIGS[runOptions.model]
+            : MODEL_CONFIGS["gpt-5.1"];
+        const tokenizer = deps.tokenizeImpl ?? modelConfig.tokenizer;
+        const tokenizerUserSections = [userPrompt];
+        if (inlineFileCount > 0 && selectedPlan.inlineBlock) {
+            tokenizerUserSections.push(selectedPlan.inlineBlock);
+        }
+        if (shouldBundle && resolvedBundleFormat === "zip" && bundled) {
+            tokenizerUserSections.push(appendZipBundleInstruction("", bundled.originalCount, bundled.bundlePath));
+        }
+        const tokenizerUserContent = tokenizerUserSections
             .filter((value) => Boolean(value?.trim()))
             .join("\n\n")
-            .trim()
-        : userPrompt;
-    const tokenizerMessages = [
-        systemPrompt ? { role: "system", content: systemPrompt } : null,
-        tokenizerUserContent ? { role: "user", content: tokenizerUserContent } : null,
-    ].filter(Boolean);
-    let estimatedInputTokens = tokenizer(tokenizerMessages.length > 0 ? tokenizerMessages : [{ role: "user", content: "" }], TOKENIZER_OPTIONS);
-    const tokenEstimateIncludesInlineFiles = inlineFileCount > 0 && Boolean(selectedPlan.inlineBlock);
-    if (!tokenEstimateIncludesInlineFiles && sections.length > 0) {
-        const attachmentText = bundleText ?? formatFileSections(sections, { lineNumbers: false });
-        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, ...rawUploadAttachments];
-        let fallbackBundled = null;
-        const fallbackBundleFormat = resolveBrowserBundleFormat(bundleFormat, {
-            hasRawUploadFiles: rawUploadAttachments.length > 0,
-        });
-        const fallbackShouldBundle = shouldWriteBrowserBundle(fallbackBundleFormat, {
-            attachmentCount: fallbackAttachments.length,
-            bundleRequested,
-            textSourceCount: textBundleSources.length,
-            textPlanShouldBundle: uploadPlan.shouldBundle,
-        });
-        if (fallbackShouldBundle) {
-            const writtenBundle = await writeBrowserBundle(sections, fallbackBundleFormat === "zip" ? allBundleSources : textBundleSources, fallbackBundleFormat);
-            fallbackAttachments.length = 0;
-            fallbackAttachments.push(writtenBundle.attachment);
-            if (fallbackBundleFormat === "text") {
-                fallbackAttachments.push(...rawUploadAttachments);
+            .trim();
+        const tokenizerMessages = [
+            systemPrompt ? { role: "system", content: systemPrompt } : null,
+            tokenizerUserContent ? { role: "user", content: tokenizerUserContent } : null,
+        ].filter(Boolean);
+        let estimatedInputTokens = tokenizer(tokenizerMessages.length > 0 ? tokenizerMessages : [{ role: "user", content: "" }], TOKENIZER_OPTIONS);
+        const tokenEstimateIncludesInlineFiles = inlineFileCount > 0 && Boolean(selectedPlan.inlineBlock);
+        if (!tokenEstimateIncludesInlineFiles && sections.length > 0) {
+            const attachmentText = bundleText ?? formatFileSections(sections, { lineNumbers: false });
+            const attachmentTokens = tokenizer([{ role: "user", content: attachmentText }], TOKENIZER_OPTIONS);
+            estimatedInputTokens += attachmentTokens;
+        }
+        let fallback = null;
+        let pendingFallback;
+        if (attachmentsPolicy === "auto" && selectedPlan.mode === "inline" && sections.length > 0) {
+            const fallbackComposerText = baseComposerSections.join("\n\n").trim();
+            const fallbackAttachments = [...uploadPlan.attachments, ...rawUploadAttachments];
+            const fallbackBundleFormat = resolveBrowserBundleFormat(bundleFormat, {
+                hasRawUploadFiles: rawUploadAttachments.length > 0,
+            });
+            const fallbackBundleScope = resolveBrowserBundleScope(fallbackBundleFormat, {
+                bundleRequested,
+                rawAttachmentCount: rawUploadAttachments.length,
+                textAttachmentCount: uploadPlan.attachments.length,
+            });
+            fallback = {
+                composerText: fallbackComposerText,
+                attachments: fallbackAttachments,
+                bundled: null,
+                pendingBundle: fallbackBundleScope === "none"
+                    ? null
+                    : { format: fallbackBundleFormat, scope: fallbackBundleScope },
+            };
+            if (fallbackBundleScope !== "none") {
+                pendingFallback = {
+                    format: fallbackBundleFormat,
+                    scope: fallbackBundleScope,
+                    sections,
+                    textSources: textBundleSources,
+                    allSources: allBundleSources,
+                    rawUploadAttachments,
+                };
+            }
+            else {
+                assertAttachmentCount(fallbackAttachments.length, fallbackBundleFormat);
             }
-            fallbackBundled = writtenBundle.metadata;
         }
-        assertAttachmentCount(fallbackAttachments, fallbackBundleFormat);
-        fallback = {
-            composerText: fallbackComposerText,
-            attachments: fallbackAttachments,
-            bundled: fallbackBundled,
+        const artifacts = {
+            markdown,
+            composerText,
+            estimatedInputTokens,
+            attachments,
+            inlineFileCount,
+            tokenEstimateIncludesInlineFiles,
+            attachmentsPolicy,
+            attachmentMode: shouldBundle
+                ? "bundle"
+                : attachments.length > 0
+                    ? "upload"
+                    : selectedPlan.mode === "bundle"
+                        ? "inline"
+                        : selectedPlan.mode,
+            fallback,
+            bundled,
         };
+        if (pendingFallback) {
+            pendingFallbackBundles.set(artifacts, pendingFallback);
+        }
+        return artifacts;
+    }
+    catch (error) {
+        await Promise.all(attachments
+            .map(generatedBundleDirectory)
+            .filter((dir) => dir !== null)
+            .map((dir) => fs.rm(dir, { recursive: true, force: true })));
+        throw error;
     }
-    return {
-        markdown,
-        composerText,
-        estimatedInputTokens,
-        attachments,
-        inlineFileCount,
-        tokenEstimateIncludesInlineFiles,
-        attachmentsPolicy,
-        attachmentMode: shouldBundle
-            ? "bundle"
-            : attachments.length > 0
-                ? "upload"
-                : selectedPlan.mode === "bundle"
-                    ? "inline"
-                    : selectedPlan.mode,
-        fallback,
-        bundled,
-    };
 }

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

@@ -20,7 +20,9 @@ async function submitPromptViaAdapter(ctx) {
     const committedTurns = await submitPrompt({
         runtime: state.runtime,
         input: state.input,
+        page: state.page,
         attachmentNames: state.attachmentNames ?? [],
+        attachmentNavigationUrl: state.attachmentNavigationUrl,
         baselineTurns: state.baselineTurns ?? undefined,
         inputTimeoutMs: state.inputTimeoutMs ?? undefined,
         attachmentTimeoutMs: state.attachmentTimeoutMs ?? undefined,

package/dist/src/browser/reattach.js

@@ -3,8 +3,8 @@ import os from "node:os";
 import path from "node:path";
 import { mkdtemp, mkdir, rm } from "node:fs/promises";
 import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, } from "./pageActions.js";
-import { launchChrome, connectToChrome, positionChromeWindowOffscreen, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
-import { resolveBrowserConfig } from "./config.js";
+import { launchChrome, connectToChrome, positionChromeWindowOffscreen, positionChromeWindowOnscreen, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
+import { resolveBrowserApprovalWait, resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
 import { CHATGPT_URL } from "./constants.js";
 import { buildConversationTurnListExpression } from "./conversationTurns.js";
@@ -31,11 +31,14 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const host = liveRuntime.chromeHost ?? "127.0.0.1";
         const port = liveRuntime.chromePort ?? inferPortFromBrowserWSEndpoint(liveRuntime.chromeBrowserWSEndpoint);
         const browserWSEndpoint = liveRuntime.chromeBrowserWSEndpoint ?? undefined;
+        const approvalWaitMs = resolveBrowserApprovalWait(config?.approvalWaitMs);
         const listTargets = deps.listTargets ??
             (async () => (await listRemoteChromeTargets({
                 host,
                 port: port ?? 9222,
                 browserWSEndpoint,
+                approvalWaitMs,
+                logger,
             })));
         const targetList = (await listTargets());
         const target = pickTarget(targetList, liveRuntime);
@@ -44,6 +47,7 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
                 browserWSEndpoint,
                 targetId: target?.targetId ?? target?.id,
                 closeTargetOnDispose: false,
+                approvalWaitMs,
             })
             : await (async () => {
                 const client = (await (deps.connect ?? ((options) => CDP(options)))(browserWSEndpoint
@@ -216,7 +220,10 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         await DOM.enable();
     }
     if (!resolved.headless && resolved.hideWindow) {
-        await positionChromeWindowOffscreen(client, logger);
+        await positionChromeWindowOffscreen(client, userDataDir, logger);
+    }
+    else if (!resolved.headless) {
+        await positionChromeWindowOnscreen(client, userDataDir, logger);
     }
     let appliedCookies = 0;
     if (shouldSyncBrowserCookies(resolved, { manualLogin })) {

package/dist/src/browser/sessionRunner.js

@@ -2,10 +2,11 @@ import chalk from "chalk";
 import { formatTokenCount } from "../oracle/runUtils.js";
 import { formatFinishLine } from "../oracle/finishLine.js";
 import { runBrowserMode } from "../browserMode.js";
-import { assembleBrowserPrompt } from "./prompt.js";
+import { DEFAULT_BROWSER_CONFIG } from "./config.js";
+import { assembleBrowserPrompt, cleanupGeneratedBrowserBundles, materializeBrowserFallback, } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
-import { formatBrowserModelSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserThinkingSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
 const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
 const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
 function buildUnavailableModelSelectionEvidence(browserConfig) {
@@ -57,7 +58,50 @@ function buildBrowserRunWarnings(args) {
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, deps = {}) {
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
-    const promptArtifacts = await assemblePrompt(runOptions, { cwd });
+    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    const inputTimeoutMs = browserConfig.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs;
+    let preparationTimedOut = false;
+    let preparationTimeout;
+    let promptArtifacts;
+    try {
+        promptArtifacts = await Promise.race([
+            assemblePrompt(runOptions, { cwd }).then(async (artifacts) => {
+                if (preparationTimedOut)
+                    await cleanupGeneratedBrowserBundles(artifacts);
+                return artifacts;
+            }),
+            new Promise((_, reject) => {
+                preparationTimeout = setTimeout(() => {
+                    preparationTimedOut = true;
+                    reject(new BrowserAutomationError(`Browser prompt preparation timed out after ${inputTimeoutMs}ms; increase --browser-input-timeout if local files need more time.`, {
+                        stage: "prepare-prompt",
+                        code: "prompt-preparation-timeout",
+                        timeoutMs: inputTimeoutMs,
+                    }));
+                }, inputTimeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (preparationTimeout) {
+            clearTimeout(preparationTimeout);
+        }
+    }
+    try {
+        return await executeAssembledBrowserSession({
+            runOptions,
+            browserConfig,
+            log,
+            promptArtifacts,
+            executeBrowser,
+            persistRuntimeHint,
+        });
+    }
+    finally {
+        await cleanupGeneratedBrowserBundles(promptArtifacts);
+    }
+}
+async function executeAssembledBrowserSession({ runOptions, browserConfig, log, promptArtifacts, executeBrowser, persistRuntimeHint, }) {
     if (runOptions.verbose) {
         log(chalk.dim(`[verbose] Browser config: ${JSON.stringify({
             ...browserConfig,
@@ -91,7 +135,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|model selection|model picker/i.test(message);
+            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|remote debugging approval|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
         if (!runOptions.verbose && !shouldAlwaysPrint)
             return;
         log(message);
@@ -103,7 +147,22 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (runOptions.verbose) {
         log(chalk.dim("Chrome automation does not stream output; this may take a minute..."));
     }
-    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    let fallbackSubmission = undefined;
+    if (promptArtifacts.fallback) {
+        fallbackSubmission = {
+            prompt: promptArtifacts.fallback.composerText,
+            attachments: promptArtifacts.fallback.attachments,
+            pendingBundle: promptArtifacts.fallback.pendingBundle ?? undefined,
+            prepare: async () => {
+                const prepared = await materializeBrowserFallback(promptArtifacts);
+                if (!prepared || !fallbackSubmission)
+                    return;
+                fallbackSubmission.prompt = prepared.composerText;
+                fallbackSubmission.attachments = prepared.attachments;
+                fallbackSubmission.pendingBundle = undefined;
+            },
+        };
+    }
     const executionBrowserConfig = runOptions.browserResumeConversationUrl
         ? { ...browserConfig, resumeConversationUrl: runOptions.browserResumeConversationUrl }
         : browserConfig;
@@ -112,12 +171,7 @@ 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,
+            fallbackSubmission,
             config: executionBrowserConfig,
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
@@ -151,6 +205,10 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (modelSelection) {
         log(`[browser] Model selection evidence: ${formatBrowserModelSelectionEvidence(modelSelection, runOptions.model)}`);
     }
+    const thinkingSelection = browserResult.thinkingSelection;
+    if (thinkingSelection) {
+        log(`[browser] Thinking effort evidence: ${formatBrowserThinkingSelectionEvidence(thinkingSelection)}`);
+    }
     const warnings = buildBrowserRunWarnings({
         runOptions,
         browserConfig,
@@ -227,9 +285,11 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         },
         archive: browserResult.archive,
         modelSelection,
+        thinkingSelection,
         warnings,
         answerText,
         artifacts: savedArtifacts,
+        savedFiles: browserResult.savedFiles,
     };
 }
 export async function ensureSessionArtifacts(params) {