@steipete/oracle 0.18.0 → 0.20.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,11 +20,14 @@ 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,
         onPromptSubmitted: state.onPromptSubmitted,
+        webSearch: state.webSearch,
     }, ctx.prompt, state.logger);
     state.committedTurns =
         typeof committedTurns === "number" && Number.isFinite(committedTurns) ? committedTurns : null;

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
@@ -62,6 +66,19 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         closeAttachedConnection = () => connection.close();
         const client = connection.client;
         const { Runtime, DOM, Page } = client;
+        const captureIdentity = async () => {
+            const targetId = target?.targetId ?? target?.id;
+            if (!targetId || !port)
+                return undefined;
+            const { result } = await withTimeout(Runtime.evaluate({ expression: "location.href", returnByValue: true }), 2_000, "Recovery target identity unavailable");
+            return {
+                host,
+                port,
+                targetId,
+                browserWSEndpoint,
+                conversationId: extractConversationIdFromUrl(typeof result?.value === "string" ? result.value : ""),
+            };
+        };
         if (Runtime?.enable) {
             await Runtime.enable();
         }
@@ -113,10 +130,12 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
             const researchResult = await withTimeout(waitForDeepResearch(Runtime, logger, timeoutMs, minTurnIndex ?? undefined, Page, client, {
                 requireScopedTargetOwner: true,
             }), timeoutMs + 5_000, "Reattach Deep Research response timed out");
+            const captureTarget = await captureIdentity().catch(() => undefined);
             await closeAttached();
             return {
                 answerText: researchResult.text,
                 answerMarkdown: researchResult.text,
+                captureTarget,
             };
         }
         const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
@@ -124,8 +143,13 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
         const markdown = (await withTimeout(captureMarkdown(Runtime, recovered.meta, logger), 15_000, "Reattach markdown capture timed out")) ?? recovered.text;
         const aligned = alignPromptEchoMarkdown(recovered.text, markdown, promptEcho, logger);
+        const captureTarget = await captureIdentity().catch(() => undefined);
         await closeAttached();
-        return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+        return {
+            answerText: aligned.answerText,
+            answerMarkdown: aligned.answerMarkdown,
+            captureTarget,
+        };
     }
     catch (error) {
         await closeAttached();
@@ -216,7 +240,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 })) {