@steipete/oracle 0.13.0 → 0.14.1

package/dist/src/browser/pageActions.js

@@ -1,4 +1,4 @@
-export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, } from "./actions/navigation.js";
+export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, } from "./actions/navigation.js";
 export { ensureModelSelection } from "./actions/modelSelection.js";
 export { submitPrompt, clearPromptComposer } from "./actions/promptComposer.js";
 export { clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, buildUserTurnAttachmentExpressionForTest, } from "./actions/attachments.js";

package/dist/src/browser/policies.js

@@ -1,11 +1,7 @@
-import { formatFileSection } from "../oracle/markdown.js";
+import { formatFileSections } from "../oracle/markdown.js";
 export function buildAttachmentPlan(sections, { inlineFiles, bundleRequested, maxAttachments = 10, }) {
     if (inlineFiles) {
-        const inlineLines = [];
-        sections.forEach((section) => {
-            inlineLines.push(formatFileSection(section.displayPath, section.content).trimEnd(), "");
-        });
-        const inlineBlock = inlineLines.join("\n").trim();
+        const inlineBlock = formatFileSections(sections);
         return {
             mode: "inline",
             inlineBlock,

package/dist/src/browser/projectSourcesRunner.js

@@ -97,9 +97,10 @@ export async function runBrowserProjectSources(request) {
             preserveUserDataDir: manualLogin,
         });
         const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+        const devtoolsRetries = manualLogin ? 6 : 0;
         const connection = await connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
             fallbackToDefault: !strictTabIsolation,
-            retries: strictTabIsolation ? 3 : 0,
+            retries: devtoolsRetries,
             retryDelayMs: 500,
         });
         client = connection.client;
@@ -347,11 +348,20 @@ async function maybeReuseProjectSourcesChrome(userDataDir, logger, options = {})
     if (!port) {
         const discovered = await findRunningChromeDebugTargetForProfile(userDataDir);
         if (!discovered) {
+            if (pid) {
+                logger(`No reachable Chrome DevTools target found for ${userDataDir}; clearing stale profile state before launching new Chrome.`);
+                await cleanupStaleProfileState(userDataDir, logger, {
+                    lockRemovalMode: "if_oracle_pid_dead",
+                });
+            }
             return null;
         }
-        const probe = await verifyDevToolsReachable({ port: discovered.port });
+        const probe = await (options.probe ?? verifyDevToolsReachable)({ port: discovered.port });
         if (!probe.ok) {
             logger(`Discovered Chrome for ${userDataDir} on port ${discovered.port} but it was unreachable (${probe.error}); launching new Chrome.`);
+            await cleanupStaleProfileState(userDataDir, logger, {
+                lockRemovalMode: "if_oracle_pid_dead",
+            });
             return null;
         }
         await writeDevToolsActivePort(userDataDir, discovered.port);
@@ -361,7 +371,7 @@ async function maybeReuseProjectSourcesChrome(userDataDir, logger, options = {})
         logger(`Discovered running Chrome for ${userDataDir}; reusing (DevTools port ${port}, pid ${pid})`);
         return { port, pid, kill: async () => { }, process: undefined };
     }
-    const probe = await verifyDevToolsReachable({ port });
+    const probe = await (options.probe ?? verifyDevToolsReachable)({ port });
     if (!probe.ok) {
         logger(`Recorded Chrome DevTools port ${port} is stale (${probe.error}); launching new Chrome.`);
         await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "if_oracle_pid_dead" });
@@ -375,3 +385,6 @@ async function maybeReuseProjectSourcesChrome(userDataDir, logger, options = {})
         process: undefined,
     };
 }
+export async function maybeReuseProjectSourcesChromeForTest(userDataDir, logger, options = {}) {
+    return maybeReuseProjectSourcesChrome(userDataDir, logger, options);
+}

package/dist/src/browser/prompt.js

@@ -1,12 +1,14 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS, formatFileSection, } from "../oracle.js";
+import { readFiles, createFileSections, FileValidationError, MODEL_CONFIGS, TOKENIZER_OPTIONS, formatFileSections, } from "../oracle.js";
 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 MAX_BROWSER_ATTACHMENTS = 10;
+const MAX_BROWSER_ZIP_BUNDLE_BYTES = 128 * 1024 * 1024;
 const MEDIA_EXTENSIONS = new Set([
     ".mp4",
     ".mov",
@@ -31,38 +33,104 @@ const MEDIA_EXTENSIONS = new Set([
     ".heif",
     ".pdf",
 ]);
+const ARCHIVE_EXTENSIONS = new Set([
+    ".7z",
+    ".aab",
+    ".apk",
+    ".br",
+    ".bz2",
+    ".cab",
+    ".crx",
+    ".deb",
+    ".dmg",
+    ".doc",
+    ".docx",
+    ".ear",
+    ".epub",
+    ".gz",
+    ".ipa",
+    ".iso",
+    ".jar",
+    ".lz",
+    ".lz4",
+    ".msi",
+    ".odp",
+    ".ods",
+    ".odt",
+    ".pkg",
+    ".ppt",
+    ".pptx",
+    ".rar",
+    ".rpm",
+    ".tar",
+    ".tgz",
+    ".war",
+    ".whl",
+    ".xls",
+    ".xlsx",
+    ".xz",
+    ".xpi",
+    ".zip",
+    ".zipx",
+    ".zst",
+]);
 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("");
+export function isRawUploadFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MEDIA_EXTENSIONS.has(ext) || ARCHIVE_EXTENSIONS.has(ext);
+}
+function formatSectionsForBundle(sections, options = {}) {
+    return formatFileSections(sections, {
+        lineNumbers: options.lineNumbers ?? true,
+        trailingNewline: true,
     });
-    return `${bundleLines
-        .join("\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trimEnd()}\n`;
 }
-async function writeBrowserBundle(sections, format) {
+function resolveBrowserBundleFormat(format, sources) {
+    if (format !== "auto") {
+        return format;
+    }
+    return sources.hasRawUploadFiles ? "zip" : "text";
+}
+function shouldWriteBrowserBundle(format, { attachmentCount, bundleRequested, textSourceCount, textPlanShouldBundle, }) {
+    if (format === "zip") {
+        return (textPlanShouldBundle ||
+            (bundleRequested && attachmentCount > 0) ||
+            attachmentCount > MAX_BROWSER_ATTACHMENTS);
+    }
+    return textSourceCount > 0 && (textPlanShouldBundle || attachmentCount > MAX_BROWSER_ATTACHMENTS);
+}
+function assertAttachmentCount(attachments, format) {
+    if (attachments.length <= MAX_BROWSER_ATTACHMENTS)
+        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.`);
+}
+async function writeBrowserBundle(sections, sources, format) {
     const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
-    const tokenEstimateText = formatSectionsForBundle(sections);
+    const tokenEstimateText = formatSectionsForBundle(sections, {
+        lineNumbers: format === "text",
+    });
     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(sections.map((section) => ({
-            path: section.displayPath,
-            content: section.content,
-        })));
+        const buffer = createStoredZip(await Promise.all(sources.map(async (source) => ({
+            path: source.displayPath,
+            content: await fs.readFile(source.absolutePath),
+        }))));
         await fs.writeFile(bundlePath, buffer);
         return {
             attachment: {
                 path: bundlePath,
                 displayPath: bundlePath,
                 sizeBytes: buffer.length,
+                generatedBundle: true,
             },
-            metadata: { originalCount: sections.length, bundlePath, format },
+            metadata: { originalCount: sources.length, bundlePath, format },
             tokenEstimateText,
         };
     }
@@ -73,6 +141,7 @@ async function writeBrowserBundle(sections, format) {
             path: bundlePath,
             displayPath: bundlePath,
             sizeBytes: Buffer.byteLength(tokenEstimateText, "utf8"),
+            generatedBundle: true,
         },
         metadata: { originalCount: sections.length, bundlePath, format },
         tokenEstimateText,
@@ -82,11 +151,27 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
     const allFilePaths = runOptions.file ?? [];
-    const textFilePaths = allFilePaths.filter((f) => !isMediaFile(f));
-    const mediaFilePaths = allFilePaths.filter((f) => isMediaFile(f));
-    const mediaAttachments = await Promise.all(mediaFilePaths.map(async (filePath) => {
+    const discoveredFiles = allFilePaths.length > 0
+        ? await readFilesFn(allFilePaths, {
+            cwd,
+            maxFileSizeBytes: 0,
+            readContents: false,
+        })
+        : [];
+    const textFilePaths = discoveredFiles
+        .filter((file) => !isRawUploadFile(file.path))
+        .map((file) => file.path);
+    const rawUploadFiles = discoveredFiles.filter((file) => isRawUploadFile(file.path));
+    const maxFileSizeBytes = runOptions.maxFileSizeBytes;
+    const rawUploadAttachments = await Promise.all(rawUploadFiles.map(async ({ path: filePath }) => {
         const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
         const stats = await fs.stat(resolvedPath);
+        if (maxFileSizeBytes && stats.size > maxFileSizeBytes) {
+            throw new FileValidationError(`The following file exceeds the ${maxFileSizeBytes}-byte limit:\n- ${path.relative(cwd, resolvedPath) || resolvedPath} (${stats.size} bytes)`, {
+                files: [resolvedPath],
+                limitBytes: maxFileSizeBytes,
+            });
+        }
         return {
             path: resolvedPath,
             displayPath: path.relative(cwd, resolvedPath) || path.basename(resolvedPath),
@@ -106,7 +191,10 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         ? "never"
         : (runOptions.browserAttachments ?? "auto");
     const bundleRequested = Boolean(runOptions.browserBundleFiles);
-    const bundleFormat = runOptions.browserBundleFormat ?? "text";
+    const bundleFormat = runOptions.browserBundleFormat ?? "auto";
+    if (attachmentsPolicy === "never" && rawUploadAttachments.length > 0) {
+        throw new FileValidationError("Raw or binary files cannot be pasted inline when browser attachments are disabled. Use --browser-attachments auto or always.", { files: rawUploadAttachments.map((attachment) => attachment.displayPath) });
+    }
     const inlinePlan = buildAttachmentPlan(sections, { inlineFiles: true, bundleRequested });
     const uploadPlan = buildAttachmentPlan(sections, { inlineFiles: false, bundleRequested });
     const baseComposerSections = [];
@@ -125,25 +213,47 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             : inlineComposerText.length <= DEFAULT_BROWSER_INLINE_CHAR_BUDGET || sections.length === 0
                 ? inlinePlan
                 : uploadPlan;
-    const composerText = (selectedPlan.inlineBlock
+    const textBundleSources = sections.map((section) => ({
+        absolutePath: section.absolutePath,
+        displayPath: section.displayPath,
+        sizeBytes: Buffer.byteLength(section.content, "utf8"),
+    }));
+    const rawUploadBundleSources = rawUploadAttachments.map((attachment) => ({
+        absolutePath: attachment.path,
+        displayPath: attachment.displayPath,
+        sizeBytes: attachment.sizeBytes ?? 0,
+    }));
+    const allBundleSources = [...textBundleSources, ...rawUploadBundleSources];
+    const attachments = [...selectedPlan.attachments, ...rawUploadAttachments];
+    const resolvedBundleFormat = resolveBrowserBundleFormat(bundleFormat, {
+        hasRawUploadFiles: rawUploadAttachments.length > 0,
+    });
+    const shouldBundle = shouldWriteBrowserBundle(resolvedBundleFormat, {
+        attachmentCount: attachments.length,
+        bundleRequested,
+        textSourceCount: textBundleSources.length,
+        textPlanShouldBundle: selectedPlan.shouldBundle,
+    });
+    const composerText = (!shouldBundle && selectedPlan.inlineBlock
         ? [...baseComposerSections, selectedPlan.inlineBlock]
         : baseComposerSections)
         .filter(Boolean)
         .join("\n\n")
         .trim();
-    const attachments = [...selectedPlan.attachments, ...mediaAttachments];
-    const shouldBundle = selectedPlan.shouldBundle;
     let bundleText = null;
     let bundled = null;
     if (shouldBundle) {
-        const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
+        const writtenBundle = await writeBrowserBundle(sections, resolvedBundleFormat === "zip" ? allBundleSources : textBundleSources, resolvedBundleFormat);
         bundleText = writtenBundle.tokenEstimateText;
         attachments.length = 0;
         attachments.push(writtenBundle.attachment);
-        attachments.push(...mediaAttachments);
+        if (resolvedBundleFormat === "text") {
+            attachments.push(...rawUploadAttachments);
+        }
         bundled = writtenBundle.metadata;
     }
-    const inlineFileCount = selectedPlan.inlineFileCount;
+    assertAttachmentCount(attachments, resolvedBundleFormat);
+    const inlineFileCount = shouldBundle ? 0 : selectedPlan.inlineFileCount;
     const modelConfig = isKnownModel(runOptions.model)
         ? MODEL_CONFIGS[runOptions.model]
         : MODEL_CONFIGS["gpt-5.1"];
@@ -161,25 +271,34 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     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 ??
-            sections
-                .map((section) => formatFileSection(section.displayPath, section.content).trimEnd())
-                .join("\n\n");
+        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, ...mediaAttachments];
+        const fallbackAttachments = [...uploadPlan.attachments, ...rawUploadAttachments];
         let fallbackBundled = null;
-        if (uploadPlan.shouldBundle) {
-            const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
+        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);
-            fallbackAttachments.push(...mediaAttachments);
+            if (fallbackBundleFormat === "text") {
+                fallbackAttachments.push(...rawUploadAttachments);
+            }
             fallbackBundled = writtenBundle.metadata;
         }
+        assertAttachmentCount(fallbackAttachments, fallbackBundleFormat);
         fallback = {
             composerText: fallbackComposerText,
             attachments: fallbackAttachments,
@@ -194,7 +313,13 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         inlineFileCount,
         tokenEstimateIncludesInlineFiles,
         attachmentsPolicy,
-        attachmentMode: selectedPlan.mode,
+        attachmentMode: shouldBundle
+            ? "bundle"
+            : attachments.length > 0
+                ? "upload"
+                : selectedPlan.mode === "bundle"
+                    ? "inline"
+                    : selectedPlan.mode,
         fallback,
         bundled,
     };

package/dist/src/browser/reattach.js

@@ -94,7 +94,9 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
             (deps.promptPreview ? null : await readConversationTurnIndex(Runtime, logger));
         if (config?.researchMode === "deep") {
             const waitForDeepResearch = deps.waitForDeepResearchCompletion ?? waitForDeepResearchCompletion;
-            const researchResult = await withTimeout(waitForDeepResearch(Runtime, logger, timeoutMs, minTurnIndex ?? undefined, Page, client), timeoutMs + 5_000, "Reattach Deep Research response timed out");
+            const researchResult = await withTimeout(waitForDeepResearch(Runtime, logger, timeoutMs, minTurnIndex ?? undefined, Page, client, {
+                requireScopedTargetOwner: true,
+            }), timeoutMs + 5_000, "Reattach Deep Research response timed out");
             await connection.close().catch(() => undefined);
             return {
                 answerText: researchResult.text,
@@ -239,7 +241,9 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         (deps.promptPreview ? null : await readConversationTurnIndex(Runtime, logger));
     if (resolved.researchMode === "deep") {
         const waitForDeepResearch = deps.waitForDeepResearchCompletion ?? waitForDeepResearchCompletion;
-        const researchResult = await waitForDeepResearch(Runtime, logger, timeoutMs, minTurnIndex ?? undefined, Page, client);
+        const researchResult = await waitForDeepResearch(Runtime, logger, timeoutMs, minTurnIndex ?? undefined, Page, client, {
+            requireScopedTargetOwner: true,
+        });
         await cleanup();
         return {
             answerText: researchResult.text,

package/dist/src/browser/reattachability.js

@@ -1,16 +1,19 @@
-export function hasRecoverableChatGptConversation(runtime) {
-    if (!runtime) {
-        return false;
-    }
-    if (runtime.conversationId?.trim()) {
-        return true;
-    }
-    const tabUrl = runtime.tabUrl?.trim();
-    if (!tabUrl) {
+/**
+ * True when the URL points at a specific ChatGPT conversation (`/c/<id>`) on
+ * chatgpt.com or chat.openai.com. Rejects home, project shell, and external
+ * URLs — anything else would be unsafe to auto-reopen in a persistent
+ * signed-in browser profile.
+ */
+export function isRecoverableChatGptConversationUrl(candidate) {
+    const trimmed = candidate?.trim();
+    if (!trimmed) {
         return false;
     }
     try {
-        const url = new URL(tabUrl);
+        const url = new URL(trimmed);
+        if (url.protocol !== "https:" || url.port) {
+            return false;
+        }
         if (url.hostname !== "chatgpt.com" && url.hostname !== "chat.openai.com") {
             return false;
         }
@@ -20,3 +23,12 @@ export function hasRecoverableChatGptConversation(runtime) {
         return false;
     }
 }
+export function hasRecoverableChatGptConversation(runtime) {
+    if (!runtime) {
+        return false;
+    }
+    if (runtime.conversationId?.trim()) {
+        return true;
+    }
+    return isRecoverableChatGptConversationUrl(runtime.tabUrl);
+}

package/dist/src/browser/recoverConversation.js

@@ -0,0 +1,73 @@
+import { launch } from "chrome-launcher";
+import { defaultManualLoginProfileDir } from "./manualLoginProfile.js";
+import { isRecoverableChatGptConversationUrl } from "./reattachability.js";
+const DEFAULT_HYDRATION_DELAY_MS = 3_000;
+/**
+ * Picks the URL to navigate the recovered Chrome tab to.
+ *
+ * Preference order matches `resolveSessionTabRef`: `harvest.url` (post-harvest,
+ * always a ChatGPT conversation URL when present) wins over `runtime.tabUrl`
+ * (the URL the original run last navigated to, which can be stale).
+ *
+ * Both candidates are gated by `isRecoverableChatGptConversationUrl` so a stale
+ * home / project shell URL or an unrelated external URL stored in metadata
+ * cannot navigate the persistent signed-in profile to the wrong page.
+ */
+export function resolveRecoveryUrl(meta) {
+    const harvest = meta?.browser?.harvest ?? {};
+    const runtime = meta?.browser?.runtime ?? {};
+    for (const candidate of [harvest.url, runtime.tabUrl]) {
+        if (isRecoverableChatGptConversationUrl(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveProfileDir(meta) {
+    const fromMeta = meta?.browser?.config?.manualLoginProfileDir;
+    if (typeof fromMeta === "string" && fromMeta.length > 0) {
+        return fromMeta;
+    }
+    return defaultManualLoginProfileDir();
+}
+/**
+ * Re-open a previously-harvested ChatGPT conversation by relaunching Chrome
+ * with the session's persistent profile and navigating to the saved tab URL.
+ *
+ * Used as a fallback when `harvestChatGptTab` can find no live tab matching the
+ * stored target (common after the original CLI run exits and closes its
+ * browser). ChatGPT preserves attachments + history at the conversation URL,
+ * so harvesting against the relaunched tab returns the original message + any
+ * assistant response that completed after the original run gave up.
+ */
+export async function recoverConversationTab(meta, logger, options = {}) {
+    const url = resolveRecoveryUrl(meta);
+    if (!url) {
+        throw new Error("Cannot recover conversation: session metadata has no recoverable ChatGPT conversation URL " +
+            "(expected browser.harvest.url or browser.runtime.tabUrl to be a chatgpt.com/c/<id> URL).");
+    }
+    const userDataDir = resolveProfileDir(meta);
+    logger(`[browser] Recovery: relaunching Chrome with profile ${userDataDir} and navigating to ${url}`);
+    const chrome = await launch({
+        chromeFlags: [
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-features=AutomationControlled,TranslateUI",
+            "--disable-sync",
+            "--password-store=basic",
+            "--use-mock-keychain",
+            "--lang=en-US",
+            url,
+        ],
+        userDataDir,
+        handleSIGINT: false,
+    });
+    const host = "127.0.0.1";
+    const port = chrome.port;
+    const hydrationDelayMs = options.hydrationDelayMs ?? DEFAULT_HYDRATION_DELAY_MS;
+    if (hydrationDelayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, hydrationDelayMs));
+    }
+    logger(`[browser] Recovery: Chrome listening on ${host}:${port}; tab loaded.`);
+    return { host, port, url, chrome };
+}

package/dist/src/browser/sessionRunner.js

@@ -105,6 +105,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         log(chalk.dim("Chrome automation does not stream output; this may take a minute..."));
     }
     const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    const executionBrowserConfig = runOptions.browserResumeConversationUrl
+        ? { ...browserConfig, resumeConversationUrl: runOptions.browserResumeConversationUrl }
+        : browserConfig;
     let browserResult;
     try {
         browserResult = await executeBrowser({
@@ -116,7 +119,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
                     attachments: promptArtifacts.fallback.attachments,
                 }
                 : undefined,
-            config: browserConfig,
+            config: executionBrowserConfig,
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
             verbose: runOptions.verbose,

package/dist/src/cli/browserConfig.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
 import { parseDuration } from "../duration.js";
@@ -28,7 +29,10 @@ const BROWSER_MODEL_LABELS = [
     ["gpt-5.4", "Thinking 5.4"],
     ["gpt-5.2", "GPT-5.2"], // Selects "Auto" in ChatGPT UI
     ["gpt-5.1", "GPT-5.2"], // Legacy alias → Auto
-    ["gemini-3-pro", "Gemini 3 Pro"],
+    ["gemini-3.1-flash-lite", "Gemini 3.1 Flash-Lite"],
+    ["gemini-3.5-flash", "Gemini 3.5 Flash"],
+    ["gemini-3.1-pro", "Gemini 3.1 Pro"],
+    ["gemini-3-pro", "Gemini 3.1 Pro"],
     ["gemini-3-pro-deep-think", "gemini-3-deep-think"],
 ];
 export function normalizeChatGptModelForBrowser(model) {
@@ -150,7 +154,7 @@ export async function buildBrowserConfig(options) {
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
         browserTabRef: options.browserTab ?? undefined,
-        thinkingTime: options.browserThinkingTime,
+        thinkingTime: normalizeThinkingTimeLevel(options.browserThinkingTime) ?? undefined,
         researchMode: options.browserResearch === "deep" ? "deep" : "off",
         archiveConversations: options.browserArchive,
     };

package/dist/src/cli/browserDefaults.js

@@ -1,5 +1,6 @@
 import { CHATGPT_URL } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
+import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const browser = config.browser;
     if (!browser)
@@ -89,7 +90,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
         options.browserModelStrategy = browser.modelStrategy;
     }
     if (isUnset("browserThinkingTime") && browser.thinkingTime !== undefined) {
-        options.browserThinkingTime = browser.thinkingTime;
+        options.browserThinkingTime = normalizeThinkingTimeLevel(browser.thinkingTime) ?? undefined;
     }
     if (isUnset("browserResearch") && browser.researchMode !== undefined) {
         options.browserResearch = browser.researchMode;