@steipete/oracle 0.14.0 → 0.15.0

package/README.md

@@ -302,8 +302,8 @@ Browser automation can open or control Chrome, so dry-runs and live runs print a
 | `--browser-research deep`                                                      | Activate ChatGPT Deep Research for broad web research and cited reports (browser only).                                                                                                                                                                                                                                                   |
 | `--browser-follow-up <prompt>`                                                 | Browser-only multi-turn consult: submit an additional prompt in the same ChatGPT conversation after the initial answer. Repeat for challenge/revision/final-decision passes. Not supported with Deep Research mode.                                                                                                                       |
 | `--browser-archive <auto\|always\|never>`                                      | Archive completed ChatGPT browser conversations after local artifacts are saved. `auto` archives successful one-shot chats only, and skips project, Deep Research, multi-turn, failed, and incomplete sessions.                                                                                                                           |
-| `--browser-attachments <auto\|never\|always>`                                  | Control browser file delivery: `auto` pastes small text files inline and uploads larger bundles, `never` always pastes inline, and `always` uploads files as ChatGPT attachments.                                                                                                                                                         |
-| `--browser-bundle-files`, `--browser-bundle-format <text\|zip>`                | Bundle browser uploads into one attachment. `text` keeps the existing single Markdown-style text bundle; `zip` preserves individual file names inside one ZIP upload.                                                                                                                                                                     |
+| `--browser-attachments <auto\|never\|always>`                                  | Control browser file delivery: `auto` pastes small text files inline and uploads larger or raw files, `never` requires inline-compatible text files, and `always` uploads files as ChatGPT attachments.                                                                                                                                   |
+| `--browser-bundle-files`, `--browser-bundle-format <auto\|text\|zip>`          | Bundle browser uploads into one attachment. `auto` uses a text bundle for text-only inputs and a byte-preserving ZIP when bundled inputs include raw files; `text` writes a Markdown-style text bundle; `zip` archives the original file bytes.                                                                                           |
 | `--browser-port <port>`                                                        | Pin the Chrome DevTools port (WSL/Windows firewall helper).                                                                                                                                                                                                                                                                               |
 | `--browser-inline-cookies[(-file)] <payload \| path>`                          | Supply cookies without Chrome/Keychain (browser).                                                                                                                                                                                                                                                                                         |
 | `--browser-timeout`, `--browser-input-timeout`, `--browser-attachment-timeout` | Control overall/browser input/attachment readiness timeouts (supports h/m/s/ms).                                                                                                                                                                                                                                                          |

package/dist/bin/oracle-cli.js

@@ -18,7 +18,7 @@ import { DEFAULT_MODEL, MODEL_CONFIGS } from "../src/oracle/config.js";
 import { isKnownModel } from "../src/oracle/modelResolver.js";
 import { CHATGPT_URL } from "../src/browser/constants.js";
 import { applyHelpStyling } from "../src/cli/help.js";
-import { collectPaths, collectModelList, collectTextValues, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, parseDurationOption, mergePathLikeOptions, dedupePathInputs, } from "../src/cli/options.js";
+import { collectPaths, collectModelList, collectTextValues, parseFloatOption, parseIntOption, parseSearchOption, parseThinkingTimeOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, parseDurationOption, mergePathLikeOptions, dedupePathInputs, } from "../src/cli/options.js";
 import { copyToClipboard } from "../src/cli/clipboard.js";
 import { buildMarkdownBundle } from "../src/cli/markdownBundle.js";
 import { shouldDetachSession } from "../src/cli/detach.js";
@@ -325,12 +325,13 @@ program
     .addOption(new Option("--browser-no-cookie-sync", "Skip copying cookies from Chrome.").hideHelp())
     .addOption(new Option("--browser-manual-login", "Skip cookie copy; reuse a persistent automation profile and wait for manual ChatGPT login.").hideHelp())
     .addOption(new Option("--browser-manual-login-profile-dir <path>", "Persistent Chrome profile directory for manual-login browser runs.").hideHelp())
+    .addOption(new Option("--copy-profile <dir>", 'Copy a signed-in Chrome user-data dir to a throwaway profile and run browser mode against it (login-free; auto-cleanup). e.g. "$HOME/Library/Application Support/Google/Chrome".'))
     .addOption(new Option("--browser-headless", "Launch Chrome in headless mode.").hideHelp())
     .addOption(new Option("--browser-hide-window", "Hide the Chrome window after launch (macOS headful only).").hideHelp())
     .addOption(new Option("--browser-keep-browser", "Keep Chrome running after completion.").hideHelp())
     .addOption(new Option("--browser-model-strategy <mode>", "ChatGPT model picker strategy: select (default) switches to the requested model, current keeps the active model, ignore skips the picker entirely.").choices(["select", "current", "ignore"]))
-    .addOption(new Option("--browser-thinking-time <level>", "Thinking time intensity for Thinking/Pro models: light, standard, extended, heavy.")
-    .choices(["light", "standard", "extended", "heavy"])
+    .addOption(new Option("--browser-thinking-time <level>", "Thinking time intensity for Thinking/Pro models: light, standard, extended, heavy, or ChatGPT UI aliases.")
+    .argParser(parseThinkingTimeOption)
     .hideHelp())
     .addOption(new Option("--browser-research <mode>", "Browser research mode: deep activates ChatGPT Deep Research.").choices(["off", "deep"]))
     .addOption(new Option("--browser-archive <mode>", "Archive completed ChatGPT browser conversations after local artifacts are saved (auto archives successful non-project one-shots only).").choices(["auto", "always", "never"]))
@@ -338,7 +339,7 @@ program
     .argParser(collectTextValues)
     .default([]))
     .addOption(new Option("--browser-allow-cookie-errors", "Continue even if Chrome cookies cannot be copied.").hideHelp())
-    .addOption(new Option("--browser-attachments <mode>", "How to deliver --file inputs in browser mode: auto (default) pastes inline up to ~60k chars then uploads; never always paste inline; always always upload.")
+    .addOption(new Option("--browser-attachments <mode>", "How to deliver --file inputs in browser mode: auto (default) pastes text inline up to ~60k chars then uploads; never requires inline-compatible text files; always uploads.")
     .choices(["auto", "never", "always"])
     .default("auto"))
     .addOption(new Option("--remote-chrome <host:port>", "Connect to remote Chrome DevTools Protocol, or when combined with --browser-attach-running use this host:port as the local attach hint."))
@@ -347,9 +348,9 @@ program
     .addOption(new Option("--remote-token <token>", "Access token for the remote `oracle serve` instance."))
     .addOption(new Option("--browser-inline-files", "Alias for --browser-attachments never (force pasting file contents inline).").default(false))
     .addOption(new Option("--browser-bundle-files", "Bundle all attachments into a single archive before uploading.").default(false))
-    .addOption(new Option("--browser-bundle-format <format>", "Bundle format for browser uploads when files are bundled: text (default) or zip.")
-    .choices(["text", "zip"])
-    .default("text"))
+    .addOption(new Option("--browser-bundle-format <format>", "Bundle format for browser uploads when files are bundled: auto (default), text, or zip.")
+    .choices(["auto", "text", "zip"])
+    .default("auto"))
     .addOption(new Option("--youtube <url>", "YouTube video URL to analyze (Gemini web/cookie mode only; uses your signed-in Chrome cookies for gemini.google.com)."))
     .addOption(new Option("--generate-image <file>", "Generate image and save to file (Gemini browser mode; ChatGPT browser mode saves downloadable image artifacts when present)."))
     .addOption(new Option("--edit-image <file>", "Edit existing image (Gemini browser mode; for ChatGPT attach source images with --file and use --generate-image for output)."))
@@ -689,7 +690,7 @@ function buildRunOptions(options, overrides = {}) {
             "auto",
         browserInlineFiles: overrides.browserInlineFiles ?? options.browserInlineFiles ?? false,
         browserBundleFiles: overrides.browserBundleFiles ?? options.browserBundleFiles ?? false,
-        browserBundleFormat: overrides.browserBundleFormat ?? options.browserBundleFormat ?? "text",
+        browserBundleFormat: overrides.browserBundleFormat ?? options.browserBundleFormat ?? "auto",
         generateImage: overrides.generateImage ?? options.generateImage,
         outputPath: overrides.outputPath ?? options.output,
         browserFollowUps: overrides.browserFollowUps ?? options.browserFollowUp ?? [],
@@ -1301,6 +1302,7 @@ async function runRootCommand(options) {
         const { buildBrowserConfig, resolveBrowserModelLabel } = await import("../src/cli/browserConfig.js");
         const config = await buildBrowserConfig({
             ...options,
+            remoteHost: remoteHost ?? undefined,
             model: activeModel,
             browserModelLabel: resolveBrowserModelLabel(cliModelArg, activeModel),
         });

package/dist/docs-site/browser-mode.html

@@ -336,11 +336,12 @@ body:not(.home) .doc>h1:first-child{display:none}
 <li><code>--browser-port &lt;port&gt;</code> (alias: <code>--browser-debug-port</code>; env: <code>ORACLE_BROWSER_PORT</code>/<code>ORACLE_BROWSER_DEBUG_PORT</code>): pin the DevTools port (handy on WSL/Windows firewalls). When omitted, a random open port is chosen.</li>
 <li><code>ORACLE_CHATGPT_ACCOUNT_EMAIL</code>: exact saved-account email to select if ChatGPT shows its “Welcome back” account picker. Set it on the machine running browser automation. Oracle never logs the address; without it, Oracle selects only a single unambiguous saved account and fails closed when several are present.</li>
 <li><code>--browser-no-cookie-sync</code>, <code>--browser-manual-login</code> (persistent automation profile + user-driven login), <code>--browser-headless</code>, <code>--browser-hide-window</code>, <code>--browser-keep-browser</code>, and the global <code>-v/--verbose</code> flag for detailed automation logs.</li>
+<li><code>--copy-profile &lt;dir&gt;</code>: copy a signed-in Chrome user-data directory (e.g. <code>&quot;$HOME/Library/Application Support/Google/Chrome&quot;</code>) to a throwaway profile and run against it, reusing your live ChatGPT session with no manual sign-in. Oracle copies the profile recorded as active in <code>Local State</code>; pass <code>--browser-chrome-profile &lt;name&gt;</code> to select another direct child profile. The copy is launched with the real Keychain (not mocked) so its encrypted cookies decrypt, and is always deleted afterward—including setup/launch failures, incomplete captures, Cloudflare challenges, and interrupts. Copied-profile runs cannot be kept or reattached. Not compatible with <code>--browser-keep-browser</code>, <code>--browser-manual-login</code>, <code>--browser-attach-running</code>, <code>--remote-chrome</code>, or <code>--remote-host</code>, and fails fast if the required <code>Local State</code> cannot be copied. macOS/Linux; requires <code>rsync</code>.</li>
 <li><code>--browser-url</code>: override ChatGPT base URL if needed.</li>
-<li><code>--browser-attachments &lt;auto|never|always&gt;</code>: control how <code>--file</code> inputs are delivered in browser mode. Default <code>auto</code> pastes file contents inline up to ~60k characters and switches to uploads above that.</li>
+<li><code>--browser-attachments &lt;auto|never|always&gt;</code>: control how <code>--file</code> inputs are delivered in browser mode. Default <code>auto</code> pastes text contents inline up to ~60k characters and uploads larger or raw files. <code>never</code> requires inline-compatible text inputs and rejects raw/binary files.</li>
 <li><code>--browser-inline-files</code>: alias for <code>--browser-attachments never</code> (forces inline paste; never uploads attachments).</li>
 <li><code>--browser-bundle-files</code>: bundle all resolved attachments into a single temp file before uploading (only used when uploads are enabled/selected).</li>
-<li><code>--browser-bundle-format &lt;text|zip&gt;</code>: choose the bundle format. <code>text</code> keeps the existing single Markdown-style text bundle; <code>zip</code> preserves individual file names in one uploaded archive.</li>
+<li><code>--browser-bundle-format &lt;auto|text|zip&gt;</code>: choose the bundle format. <code>auto</code> uses a text bundle for text-only inputs and a byte-preserving ZIP when bundled inputs include raw files; <code>text</code> keeps the single Markdown-style text bundle; <code>zip</code> archives the original file bytes. ZIP bundle inputs are capped at 128 MiB because bundle creation is in-memory.</li>
 <li>sqlite bindings: automatic rebuilds now require <code>ORACLE_ALLOW_SQLITE_REBUILD=1</code>. Without it, the CLI logs instructions instead of running <code>pnpm rebuild</code> on your behalf.</li>
 <li><code>--model</code>: the same flag used for API runs is accepted, but the ChatGPT automation path supports GPT-5.5, GPT-5.4, and GPT-5.2 variants. Use <code>gpt-5.5-pro</code>, <code>gpt-5.5</code>, <code>gpt-5.5-instant</code>, <code>gpt-5.4-pro</code>, <code>gpt-5.4</code>, <code>gpt-5.2</code>, <code>gpt-5.2-thinking</code>, <code>gpt-5.2-instant</code>, or <code>gpt-5.2-pro</code>. Legacy Pro aliases still resolve to the latest Pro picker target.</li>
 <li>Cookie sync is mandatory—if we can’t copy cookies from Chrome, the run exits early. By default Oracle copies a small ChatGPT auth/Cloudflare allowlist to avoid oversized request headers; use <code>--browser-cookie-names</code> only when you need to override that set. Use the hidden <code>--browser-allow-cookie-errors</code> flag only when you’re intentionally running logged out (it skips the early exit but still warns).</li>

package/dist/docs-site/cli-reference.html

@@ -264,7 +264,7 @@ body:not(.home) .doc>h1:first-child{display:none}
 <table><thead><tr><th>Flag</th><th>Purpose</th></tr></thead><tbody><tr><td><code>--base-url &lt;url&gt;</code></td><td>LiteLLM / Azure / OpenRouter / proxy.</td></tr><tr><td><code>--provider &lt;mode&gt;</code></td><td>API route: <code>auto</code>, <code>openai</code>, or <code>azure</code>.</td></tr><tr><td><code>--no-azure</code></td><td>Ignore Azure env/config for this run.</td></tr><tr><td><code>--route</code></td><td>Print redacted API route plan, then exit.</td></tr><tr><td><code>--azure-endpoint</code></td><td>Azure OpenAI endpoint.</td></tr><tr><td><code>--azure-deployment</code></td><td>Azure deployment name.</td></tr><tr><td><code>--azure-api-version</code></td><td>Azure API version.</td></tr></tbody></table>
 <p>See <a href="openai-endpoints.html">OpenAI / Azure / OpenRouter</a> and <a href="openrouter.html">OpenRouter</a>.</p>
 <h2 id="browser-mode"><a class="anchor" href="#browser-mode" aria-label="Anchor link">#</a>Browser mode</h2>
-<table><thead><tr><th>Flag</th><th>Purpose</th></tr></thead><tbody><tr><td><code>--chatgpt-url &lt;url&gt;</code></td><td>Target a ChatGPT workspace / project folder.</td></tr><tr><td><code>--browser-model-strategy &lt;select|current|ignore&gt;</code></td><td>Control ChatGPT model picker.</td></tr><tr><td><code>--browser-manual-login</code></td><td>Use persistent profile + manual login (no Keychain).</td></tr><tr><td><code>--browser-attach-running</code></td><td>Attach to your already-running Chrome via DevTools.</td></tr><tr><td><code>--browser-tab &lt;ref&gt;</code></td><td>Reuse an existing tab (<code>current</code>, id, URL, title substring).</td></tr><tr><td><code>--browser-thinking-time &lt;light|standard|extended|heavy&gt;</code></td><td>Pro / Thinking model intensity.</td></tr><tr><td><code>--browser-research deep</code></td><td>Activate Deep Research mode.</td></tr><tr><td><code>--browser-follow-up &lt;prompt&gt;</code></td><td>Multi-turn in the same ChatGPT conversation.</td></tr><tr><td><code>--browser-port &lt;port&gt;</code></td><td>Pin Chrome DevTools port.</td></tr><tr><td><code>--browser-inline-cookies[(-file)] &lt;…&gt;</code></td><td>Supply cookies inline (no Keychain / Chrome).</td></tr><tr><td><code>--browser-timeout</code>, <code>--browser-input-timeout</code>, <code>--browser-attachment-timeout</code></td><td>Overall / input / attachment readiness timeouts (h/m/s/ms).</td></tr><tr><td><code>--browser-recheck-delay</code>, <code>--browser-recheck-timeout</code></td><td>Delayed retry after a timeout.</td></tr><tr><td><code>--browser-auto-reattach-delay/-interval/-timeout</code></td><td>Poll the existing tab when ChatGPT redirects mid-load.</td></tr><tr><td><code>--browser-reuse-wait</code></td><td>Wait for shared Chrome profile before launching.</td></tr><tr><td><code>--browser-profile-lock-timeout</code></td><td>Wait for the manual-login profile lock.</td></tr><tr><td><code>--browser-max-concurrent-tabs</code></td><td>Soft limit for shared-profile parallel runs (default 3).</td></tr><tr><td><code>--browser-keep-browser</code></td><td>Keep the browser open after the run.</td></tr><tr><td><code>--browser-headless</code>, <code>--browser-hide-window</code></td><td>Visibility controls.</td></tr><tr><td><code>--browser-attachments &lt;auto|never|always&gt;</code></td><td>Attach files inline vs upload.</td></tr><tr><td><code>--browser-bundle-files</code>, <code>--browser-bundle-format &lt;text|zip&gt;</code></td><td>Bundle browser uploads as text or ZIP.</td></tr><tr><td><code>--browser-chrome-path</code>, <code>--browser-cookie-path</code></td><td>Override Chrome / cookie store discovery (Linux / Windows).</td></tr></tbody></table>
+<table><thead><tr><th>Flag</th><th>Purpose</th></tr></thead><tbody><tr><td><code>--chatgpt-url &lt;url&gt;</code></td><td>Target a ChatGPT workspace / project folder.</td></tr><tr><td><code>--browser-model-strategy &lt;select|current|ignore&gt;</code></td><td>Control ChatGPT model picker.</td></tr><tr><td><code>--browser-manual-login</code></td><td>Use persistent profile + manual login (no Keychain).</td></tr><tr><td><code>--browser-attach-running</code></td><td>Attach to your already-running Chrome via DevTools.</td></tr><tr><td><code>--browser-tab &lt;ref&gt;</code></td><td>Reuse an existing tab (<code>current</code>, id, URL, title substring).</td></tr><tr><td><code>--browser-thinking-time &lt;light|standard|extended|heavy&gt;</code></td><td>Pro / Thinking model intensity.</td></tr><tr><td><code>--browser-research deep</code></td><td>Activate Deep Research mode.</td></tr><tr><td><code>--browser-follow-up &lt;prompt&gt;</code></td><td>Multi-turn in the same ChatGPT conversation.</td></tr><tr><td><code>--browser-port &lt;port&gt;</code></td><td>Pin Chrome DevTools port.</td></tr><tr><td><code>--browser-inline-cookies[(-file)] &lt;…&gt;</code></td><td>Supply cookies inline (no Keychain / Chrome).</td></tr><tr><td><code>--browser-timeout</code>, <code>--browser-input-timeout</code>, <code>--browser-attachment-timeout</code></td><td>Overall / input / attachment readiness timeouts (h/m/s/ms).</td></tr><tr><td><code>--browser-recheck-delay</code>, <code>--browser-recheck-timeout</code></td><td>Delayed retry after a timeout.</td></tr><tr><td><code>--browser-auto-reattach-delay/-interval/-timeout</code></td><td>Poll the existing tab when ChatGPT redirects mid-load.</td></tr><tr><td><code>--browser-reuse-wait</code></td><td>Wait for shared Chrome profile before launching.</td></tr><tr><td><code>--browser-profile-lock-timeout</code></td><td>Wait for the manual-login profile lock.</td></tr><tr><td><code>--browser-max-concurrent-tabs</code></td><td>Soft limit for shared-profile parallel runs (default 3).</td></tr><tr><td><code>--browser-keep-browser</code></td><td>Keep the browser open after the run.</td></tr><tr><td><code>--browser-headless</code>, <code>--browser-hide-window</code></td><td>Visibility controls.</td></tr><tr><td><code>--browser-attachments &lt;auto|never|always&gt;</code></td><td>Attach files inline vs upload.</td></tr><tr><td><code>--browser-bundle-files</code>, <code>--browser-bundle-format &lt;auto|text|zip&gt;</code></td><td>Bundle browser uploads as text or byte-preserving ZIP.</td></tr><tr><td><code>--browser-chrome-path</code>, <code>--browser-cookie-path</code></td><td>Override Chrome / cookie store discovery (Linux / Windows).</td></tr></tbody></table>
 <p>See <a href="browser-mode.html">Browser Mode</a> for usage.</p>
 <h2 id="remote-browser"><a class="anchor" href="#remote-browser" aria-label="Anchor link">#</a>Remote browser</h2>
 <table><thead><tr><th>Flag</th><th>Purpose</th></tr></thead><tbody><tr><td><code>--remote-host &lt;host:port&gt;</code></td><td>Use a remote <code>oracle serve</code> host.</td></tr><tr><td><code>--remote-token &lt;secret&gt;</code></td><td>Auth for the remote host.</td></tr><tr><td><code>--remote-chrome &lt;host:port&gt;</code></td><td>Attach to an existing remote Chrome session.</td></tr></tbody></table>

package/dist/docs-site/mcp.html

@@ -266,7 +266,7 @@ body:not(.home) .doc>h1:first-child{display:none}
 <ul>
 <li>Inputs: <code>prompt</code> (required), <code>files?: string[]</code> (globs), <code>model?: string</code> (defaults to CLI), <code>engine?: &quot;api&quot; | &quot;browser&quot;</code> (optional; Oracle follows CLI defaults: <code>ORACLE_ENGINE</code> and the effective config first, then API when <code>OPENAI_API_KEY</code> is set, otherwise browser), <code>slug?: string</code>.</li>
 <li>Presets: <code>preset?: &quot;chatgpt-pro-heavy&quot;</code> applies browser mode + current Pro model alias + extended thinking, unless the request overrides those fields.</li>
-<li>Browser-only extras: <code>browserAttachments?: &quot;auto&quot;|&quot;never&quot;|&quot;always&quot;</code>, <code>browserBundleFiles?: boolean</code>, <code>browserBundleFormat?: &quot;text&quot;|&quot;zip&quot;</code>, <code>browserThinkingTime?: &quot;light&quot;|&quot;standard&quot;|&quot;extended&quot;|&quot;heavy&quot;</code>, <code>browserResearchMode?: &quot;deep&quot;</code>, <code>browserFollowUps?: string[]</code>, <code>browserArchive?: &quot;auto&quot;|&quot;always&quot;|&quot;never&quot;</code>, <code>browserKeepBrowser?: boolean</code>, <code>browserModelLabel?: string</code>, <code>browserModelStrategy?: &quot;select&quot;|&quot;current&quot;|&quot;ignore&quot;</code>, <code>generateImage?: string</code>, <code>outputPath?: string</code>.</li>
+<li>Browser-only extras: <code>browserAttachments?: &quot;auto&quot;|&quot;never&quot;|&quot;always&quot;</code>, <code>browserBundleFiles?: boolean</code>, <code>browserBundleFormat?: &quot;auto&quot;|&quot;text&quot;|&quot;zip&quot;</code>, <code>browserThinkingTime?: &quot;light&quot;|&quot;standard&quot;|&quot;extended&quot;|&quot;heavy&quot;</code>, <code>browserResearchMode?: &quot;deep&quot;</code>, <code>browserFollowUps?: string[]</code>, <code>browserArchive?: &quot;auto&quot;|&quot;always&quot;|&quot;never&quot;</code>, <code>browserKeepBrowser?: boolean</code>, <code>browserModelLabel?: string</code>, <code>browserModelStrategy?: &quot;select&quot;|&quot;current&quot;|&quot;ignore&quot;</code>, <code>generateImage?: string</code>, <code>outputPath?: string</code>.</li>
 <li>Dry runs: set <code>dryRun: true</code> to preview the resolved request without creating a session or touching the browser.</li>
 <li>Behavior: starts a session, runs it with the chosen engine, returns final output + metadata. Background/foreground follows the CLI (e.g., GPT‑5 Pro detaches by default). If API mode fails because <code>OPENAI_API_KEY</code> is missing and you have ChatGPT Pro, retry with <code>engine: &quot;browser&quot;</code> or <code>preset: &quot;chatgpt-pro-heavy&quot;</code> to use your signed-in ChatGPT session instead of an API key.</li>
 <li>Logging: emits MCP logs (<code>info</code> per line, <code>debug</code> for streamed chunks with byte sizes). If browser prerequisites are missing, returns an error payload instead of running.</li>

package/dist/src/browser/actions/assistantResponse.js

@@ -857,7 +857,8 @@ function buildAssistantExtractor(functionName) {
         !normalizedText ||
         normalizedText === 'edit' ||
         normalizedText === 'stopped thinking' ||
-        normalizedText === 'stopped thinking edit';
+        normalizedText === 'stopped thinking edit' ||
+        /^thought for \\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\\s+edit$/.test(normalizedText);
       if (generatedImages.length > 0 && imageOnlyChrome) {
         const label = generatedImages.length === 1 ? 'Generated image.' : \`Generated \${generatedImages.length} images.\`;
         return { text: label, html: messageRoot?.innerHTML ?? html, messageId, turnId, turnIndex: index };

package/dist/src/browser/actions/deepResearch.js

@@ -1,5 +1,6 @@
 import { DEEP_RESEARCH_PLUS_BUTTON, DEEP_RESEARCH_DROPDOWN_ITEM_TEXT, DEEP_RESEARCH_PILL_LABEL, DEEP_RESEARCH_POLL_INTERVAL_MS, DEEP_RESEARCH_AUTO_CONFIRM_WAIT_MS, DEEP_RESEARCH_DEFAULT_TIMEOUT_MS, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTOR, CONVERSATION_TURN_SELECTOR, } from "../constants.js";
 import { delay } from "../utils.js";
+import { isDeepResearchIncompleteText } from "../deepResearchResult.js";
 import { buildClickDispatcher } from "./domEvents.js";
 import { captureAssistantMarkdown, readAssistantSnapshot } from "./assistantResponse.js";
 import { BrowserAutomationError } from "../../oracle/errors.js";
@@ -116,7 +117,10 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
         : -1;
     const scopedToNewTurns = minTurnLiteral >= 0;
     const ignoredTargetKeys = new Set(options?.ignoredTargetKeys ?? []);
-    const requireScopedTargetOwner = options?.requireScopedTargetOwner === true;
+    const requireScopedTargetOwner = options?.requireScopedTargetOwner === true ||
+        (scopedToNewTurns && options?.targetBaselineCaptured !== true);
+    let observedResearchEvidence = false;
+    let loggedIncompleteResult = false;
     logger(`Monitoring Deep Research (timeout: ${Math.round(timeoutMs / 60_000)}min)...`);
     while (Date.now() - start < timeoutMs) {
         const { result } = await Runtime.evaluate({
@@ -127,7 +131,6 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
         if (val?.accountBlocked) {
             throw new BrowserAutomationError("ChatGPT account security block detected during Deep Research. Open chatgpt.com in Chrome, secure the account, then rerun Oracle.", { stage: "chatgpt-account-blocked", code: "chatgpt-account-blocked" });
         }
-        const activeScopedResearch = Boolean(val?.hasActiveScopedResearch);
         // ChatGPT renders the Deep Research report inside an out-of-process,
         // sandboxed iframe (connector_openai_deep_research.*.oaiusercontent.com),
         // doubly nested and same-origin. That OOPIF does NOT appear in the main
@@ -136,24 +139,27 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
         // (readDeepResearchTargetResult) attaches to the iframe's own CDP target and
         // walks its nested frames, so it CAN read the report. Prefer the target path
         // and fall back to the in-page frame path for legacy/inline rendering.
-        const targetResult = client
+        const rawTargetResult = client
             ? ((await readDeepResearchTargetResult(client, ignoredTargetKeys, requireScopedTargetOwner ? minTurnLiteral : -1).catch(() => null))?.read ?? null)
             : null;
+        const targetResult = filterIncompleteDeepResearchRead(rawTargetResult);
         // A completed target read is authoritative. If the target read is missing or
         // only in-progress, still try the in-page frame path so an incomplete target
         // read does not suppress a completed report there (legacy/inline rendering).
-        const inPageResult = !targetResult?.completed && Page
-            ? await readDeepResearchFrameResult(Runtime, Page).catch(() => null)
+        const inPageScan = !targetResult?.completed && Page
+            ? await readDeepResearchFrameResult(Runtime, Page, client, scopedToNewTurns ? minTurnLiteral : -1).catch(() => null)
             : null;
+        const rawInPageResult = inPageScan?.read ?? null;
+        const inPageResult = filterIncompleteDeepResearchRead(rawInPageResult);
         const read = pickPreferredDeepResearchRead(targetResult, inPageResult);
-        // A target-confirmed completion read the live connector iframe directly, so
-        // it is authoritative even when the main DOM exposes no assistant turn (the
-        // report lives entirely in the OOPIF). The main-DOM hasActiveScopedResearch
-        // heuristic no longer holds in that case, so don't gate on it.
-        const completedFromTarget = Boolean(targetResult?.completed);
-        if (read?.completed &&
-            read.text &&
-            (completedFromTarget || !scopedToNewTurns || activeScopedResearch)) {
+        // Target keys captured before submission are ignored, so a target result is
+        // tied to this run. Main-page iframes are not: old reports can remain in the
+        // conversation and must never authorize a new normal-response fallback.
+        observedResearchEvidence ||= Boolean(rawTargetResult ||
+            (scopedToNewTurns && rawInPageResult) ||
+            val?.researchActivity ||
+            val?.hasActiveScopedResearch);
+        if (read?.completed && read.text) {
             logger(`Deep Research completed (${Math.round((Date.now() - start) / 1000)}s elapsed)`);
             return {
                 text: read.text,
@@ -163,9 +169,18 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
         }
         // Completion detected
         if (val?.finished) {
+            if (!observedResearchEvidence) {
+                throw new BrowserAutomationError("ChatGPT returned a completed response without starting Deep Research. The Deep Research selection may have silently fallen back to a normal response.", { stage: "deep-research-not-started", code: "deep-research-not-started" });
+            }
             logger(`Deep Research completed (${Math.round((Date.now() - start) / 1000)}s elapsed)`);
             return await extractDeepResearchResult(Runtime, logger, minTurnIndex ?? undefined);
         }
+        const incompleteFrameResult = Boolean((rawTargetResult?.completed && !targetResult?.completed) ||
+            (rawInPageResult?.completed && !inPageResult?.completed));
+        if ((val?.incompleteResult || incompleteFrameResult) && !loggedIncompleteResult) {
+            logger("Deep Research interim status detected; waiting for the final report");
+            loggedIncompleteResult = true;
+        }
         // Progress logging every 60 seconds
         const now = Date.now();
         if (now - lastLogTime >= 60_000) {
@@ -204,24 +219,26 @@ export async function extractDeepResearchResult(Runtime, logger, minTurnIndex) {
     };
     // Try the copy-button approach first for clean markdown
     const markdown = await captureAssistantMarkdown(Runtime, meta, logger);
-    if (markdown && !isDeepResearchPlaceholderText(markdown)) {
+    if (markdown && !isDeepResearchIncompleteText(markdown)) {
         return { text: markdown, html: snapshot?.html ?? undefined, meta };
     }
     // Fall back to snapshot text
-    if (snapshot?.text && !isDeepResearchPlaceholderText(snapshot.text)) {
+    if (snapshot?.text && !isDeepResearchIncompleteText(snapshot.text)) {
         return { text: snapshot.text, html: snapshot.html ?? undefined, meta };
     }
     throw new BrowserAutomationError("Deep Research completed but failed to extract the response text.", { stage: "deep-research-extract", code: "extraction-failed" });
 }
-function isDeepResearchPlaceholderText(text) {
-    const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
-    return (normalized === "called tool" ||
-        normalized === "used tool" ||
-        normalized === "użyto narzędzia" ||
-        normalized === "narzędzie wywołane");
-}
 export function isDeepResearchPlaceholderTextForTest(text) {
-    return isDeepResearchPlaceholderText(text);
+    return isDeepResearchIncompleteText(text);
+}
+function filterIncompleteDeepResearchRead(result) {
+    if (!result?.completed || !result.text || !isDeepResearchIncompleteText(result.text)) {
+        return result;
+    }
+    return { ...result, completed: false, inProgress: true };
+}
+export function filterIncompleteDeepResearchReadForTest(result) {
+    return filterIncompleteDeepResearchRead(result);
 }
 /**
  * Choose the authoritative Deep Research read between the target-attach result
@@ -243,37 +260,64 @@ function pickPreferredDeepResearchRead(targetResult, inPageResult) {
 export function pickPreferredDeepResearchReadForTest(targetResult, inPageResult) {
     return pickPreferredDeepResearchRead(targetResult, inPageResult);
 }
-async function readDeepResearchFrameResult(Runtime, Page) {
+async function readDeepResearchFrameResult(Runtime, Page, client, minTurnIndex = -1) {
     const pageWithFrames = Page;
     if (typeof pageWithFrames.getFrameTree !== "function" ||
         typeof pageWithFrames.createIsolatedWorld !== "function") {
         return null;
     }
     const frameTree = (await pageWithFrames.getFrameTree())?.frameTree;
-    const frameId = findDeepResearchFrameId(frameTree);
-    if (!frameId) {
+    const frameIds = collectPageDeepResearchFrameIds(frameTree);
+    if (frameIds.length === 0) {
         return null;
     }
-    const world = await pageWithFrames.createIsolatedWorld({
-        frameId,
-        worldName: "oracle-deep-research",
-        grantUniveralAccess: true,
-    });
-    if (typeof world.executionContextId !== "number") {
-        return null;
+    const rawClient = client;
+    if (minTurnIndex >= 0) {
+        if (typeof rawClient?.send !== "function") {
+            return null;
+        }
     }
-    const { result } = await Runtime.evaluate({
-        expression: buildDeepResearchFrameStatusExpression(),
-        contextId: world.executionContextId,
-        returnByValue: true,
-    });
-    return result?.value ?? null;
+    let best = null;
+    for (const frameId of frameIds) {
+        let ownerTurnIndex = null;
+        if (minTurnIndex >= 0 && rawClient?.send) {
+            ownerTurnIndex = await readDeepResearchTargetOwnerTurnIndex(rawClient, frameId, rawClient.oraclePageSessionId);
+            if (ownerTurnIndex === null || ownerTurnIndex < minTurnIndex) {
+                continue;
+            }
+        }
+        const world = await pageWithFrames.createIsolatedWorld({
+            frameId,
+            worldName: "oracle-deep-research",
+            grantUniveralAccess: true,
+        });
+        if (typeof world.executionContextId !== "number") {
+            continue;
+        }
+        const { result } = await Runtime.evaluate({
+            expression: buildDeepResearchFrameStatusExpression(),
+            contextId: world.executionContextId,
+            returnByValue: true,
+        });
+        const read = result?.value ?? null;
+        if (!read) {
+            continue;
+        }
+        best = { read, ownerTurnIndex };
+        if (read.completed) {
+            return best;
+        }
+    }
+    return best;
 }
 async function readDeepResearchTargetResult(client, ignoredTargetKeys = new Set(), minTurnIndex = -1) {
     const rawClient = client;
     if (typeof rawClient.send !== "function") {
         return null;
     }
+    if (typeof client.on !== "function") {
+        return null;
+    }
     // On the browser-WSEndpoint path, `client` is a session-bound wrapper whose
     // domain methods target the page session but whose raw `send` is the
     // browser-level send. We must therefore pass the page session id explicitly so
@@ -299,7 +343,7 @@ async function readDeepResearchTargetResult(client, ignoredTargetKeys = new Set(
             ownedSessionIds.add(eventSessionId);
         }
     };
-    client.on?.("Target.attachedToTarget", onAttached);
+    client.on("Target.attachedToTarget", onAttached);
     try {
         // Scope discovery to the current Oracle-controlled page. `client` is
         // connected to the conversation page target, so enabling auto-attach on this
@@ -311,13 +355,16 @@ async function readDeepResearchTargetResult(client, ignoredTargetKeys = new Set(
         // would surface another tab's completed Deep Research report and let it be
         // saved into the current session (cross-tab leak). Only auto-attached,
         // page-scoped sessions are treated as belonging to this run.
-        await rawClient
+        const autoAttachEnabled = await rawClient
             .send("Target.setAutoAttach", {
             autoAttach: true,
             waitForDebuggerOnStart: false,
             flatten: true,
         }, pageSessionId)
-            .catch(() => undefined);
+            .then(() => true, () => false);
+        if (!autoAttachEnabled) {
+            return null;
+        }
         await delay(100);
         if (minTurnIndex >= 0) {
             await rawClient.send("DOM.enable", {}, pageSessionId).catch(() => undefined);
@@ -374,7 +421,11 @@ async function readDeepResearchTargetResult(client, ignoredTargetKeys = new Set(
     }
 }
 export async function captureDeepResearchTargetKeys(client) {
-    return (await readDeepResearchTargetResult(client))?.targetKeys ?? [];
+    const scan = await readDeepResearchTargetResult(client);
+    if (!scan) {
+        throw new Error("Deep Research target baseline capture unavailable");
+    }
+    return scan.targetKeys;
 }
 async function readDeepResearchTargetOwnerTurnIndex(rawClient, frameId, pageSessionId) {
     const owner = (await rawClient
@@ -419,7 +470,7 @@ async function readDeepResearchTargetSession(rawClient, sessionId, targetUrl) {
     const frameTree = (await rawClient
         .send("Page.getFrameTree", {}, sessionId)
         .catch(() => null));
-    const frameId = frameTree?.frameTree?.frame?.id;
+    const ownerFrameId = frameTree?.frameTree?.frame?.id;
     if (!isConfirmedDeepResearchTarget(targetUrl, frameTree?.frameTree)) {
         return { confirmed: false, read: null };
     }
@@ -438,7 +489,7 @@ async function readDeepResearchTargetSession(rawClient, sessionId, targetUrl) {
         }
         const value = await evaluateDeepResearchFrameStatus(rawClient, sessionId, world.executionContextId);
         if (value?.completed) {
-            return { confirmed: true, read: value, frameId };
+            return { confirmed: true, read: value, frameId: ownerFrameId };
         }
         if ((value?.textLength ?? 0) > (best?.textLength ?? 0) || value?.inProgress) {
             best = value;
@@ -446,12 +497,12 @@ async function readDeepResearchTargetSession(rawClient, sessionId, targetUrl) {
     }
     const topFrameValue = await evaluateDeepResearchFrameStatus(rawClient, sessionId);
     if (topFrameValue?.completed) {
-        return { confirmed: true, read: topFrameValue, frameId };
+        return { confirmed: true, read: topFrameValue, frameId: ownerFrameId };
     }
     if ((topFrameValue?.textLength ?? 0) > (best?.textLength ?? 0) || topFrameValue?.inProgress) {
         best = topFrameValue;
     }
-    return { confirmed: true, read: best, frameId };
+    return { confirmed: true, read: best, frameId: ownerFrameId };
 }
 async function evaluateDeepResearchFrameStatus(rawClient, sessionId, contextId) {
     const response = (await rawClient
@@ -474,21 +525,20 @@ function isDeepResearchFrameDescriptor(url, name = "") {
     return (descriptor.includes("connector_openai_deep_research") || descriptor.includes("deep-research"));
 }
 function findDeepResearchFrameId(tree) {
+    return collectPageDeepResearchFrameIds(tree)[0] ?? null;
+}
+function collectPageDeepResearchFrameIds(tree) {
     if (!tree?.frame) {
-        return null;
+        return [];
     }
-    const url = tree.frame.url ?? "";
-    const name = tree.frame.name ?? "";
-    if (isDeepResearchFrameDescriptor(url, name)) {
-        return tree.frame.id ?? null;
+    const ids = [];
+    if (tree.frame.id && isDeepResearchFrameDescriptor(tree.frame.url ?? "", tree.frame.name ?? "")) {
+        ids.push(tree.frame.id);
     }
     for (const child of tree.childFrames ?? []) {
-        const match = findDeepResearchFrameId(child);
-        if (match) {
-            return match;
-        }
+        ids.push(...collectPageDeepResearchFrameIds(child));
     }
-    return null;
+    return ids;
 }
 function collectDeepResearchFrameIds(tree) {
     if (!tree?.frame) {
@@ -644,20 +694,41 @@ function buildDeepResearchCompletionPollExpression(minTurnIndex) {
     const text = (lastTurn?.textContent || '').trim();
     const normalized = text.toLowerCase().replace(/\\s+/g, ' ').trim();
     const textLength = text.length;
+    const lines = text.split(/\\n+/).map(line => line.trim()).filter(Boolean);
+    const tailIsPlanningPanel = text.length <= 1500 &&
+      lines.length >= 4 &&
+      lines.length <= 20 &&
+      /^update$/i.test(lines[1] || '') &&
+      /^stop research$/i.test(lines[lines.length - 1] || '') &&
+      /^determining steps for creating a report(?:\\.\\.\\.)?$/i.test(lines[lines.length - 2] || '');
     const isToolStub = normalized === 'called tool' ||
       normalized === 'used tool' ||
       normalized === 'użyto narzędzia' ||
       normalized === 'narzędzie wywołane';
+    const incompleteResult = isToolStub ||
+      normalized === 'planning' ||
+      normalized === 'researching' ||
+      normalized === 'searching the web' ||
+      (text.trimStart().startsWith('<system-reminder>') &&
+        /<system-reminder>[\\s\\S]*#\\s*plan mode\\b/i.test(text)) ||
+      tailIsPlanningPanel;
     const finished = Boolean(lastTurn?.querySelector(${finishedSelector})) &&
       textLength >= 40 &&
-      !isToolStub;
+      !incompleteResult;
     const hasIframe = Array.from(document.querySelectorAll('iframe')).some(f => {
       const rect = f.getBoundingClientRect();
       return rect.width > 200 && rect.height > 200;
     });
-    const hasActiveScopedResearch = scopedToNewTurns && Boolean(lastTurn) && hasIframe &&
-      (textLength < 40 || isToolStub || /chatgpt\\s+said:?$/i.test(text));
-    return { finished, stopVisible, textLength, hasIframe, isToolStub, hasActiveScopedResearch, accountBlocked };
+    const hasScopedDeepResearchIframe = Array.from(lastTurn?.querySelectorAll?.('iframe') || []).some(f => {
+      const rect = f.getBoundingClientRect();
+      const descriptor = String(f.getAttribute('src') || '') + ' ' + String(f.getAttribute('name') || '');
+      return rect.width > 200 && rect.height > 200 &&
+        /connector_openai_deep_research|deep-research/i.test(descriptor);
+    });
+    const hasActiveScopedResearch = scopedToNewTurns && Boolean(lastTurn) &&
+      hasScopedDeepResearchIframe &&
+      (textLength < 40 || isToolStub || tailIsPlanningPanel || /chatgpt\\s+said:?$/i.test(text));
+    return { finished, stopVisible, textLength, hasIframe, isToolStub, incompleteResult, researchActivity: tailIsPlanningPanel || (isToolStub && hasScopedDeepResearchIframe), hasActiveScopedResearch, accountBlocked };
   })()`;
 }
 export function buildDeepResearchStatusExpressionForTest() {