@steipete/oracle 0.15.2 → 0.16.0

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

@@ -404,6 +404,234 @@ function buildThinkingStatusExpression() {
     return null;
   })()`;
 }
+// Present-tense/gerund status labels that mean the model is ACTIVELY working. The
+// past-tense "thought for Xs" summary is deliberately excluded: it persists in the DOM
+// on every completed reasoning turn (and on reattach), so treating its mere presence as
+// "still thinking" would veto completion forever and hang the call. Kept in sync with
+// THINKING_STATUS_LABELS in assistantResponse.ts (the connector phases "searching the
+// web"/"reading"/"finalizing answer" are exactly the GPT-5.5 Pro gaps that produce the
+// preamble->answer window this predicate must cover).
+const ACTIVE_THINKING_LABELS = [
+    "thinking",
+    "pro thinking",
+    "thinking longer for a better answer",
+    "reasoning",
+    "finalizing answer",
+    "finalizing",
+    "analyzing",
+    "researching",
+    "working on it",
+    "working",
+    "planning",
+    "searching the web",
+    "searching",
+    "reading",
+];
+// buildThinkingActivePredicateJs: a SIDE-EFFECT-FREE injected predicate `${fnName}()` that
+// returns true iff the model is ACTIVELY generating/thinking right now. Unlike
+// buildThinkingStatusExpression it never clicks a disclosure and never keys on the mere
+// PRESENCE of a reasoning container ([data-testid*="reasoning"] persists after completion);
+// it keys only on ACTIVITY signals: a visible stop/interrupt control, a visible animated
+// loading-shimmer skeleton, aria-busy, a visible thinking sidecar panel with live progress,
+// or a visible ACTIVE (present-tense) thinking status label. Used as a completion VETO so a
+// settled preamble is never finalized while the reasoning/tool phase is still running.
+function buildThinkingActivityPredicateJs(fnName, detailed) {
+    const stopLiteral = JSON.stringify(STOP_BUTTON_SELECTORS.join(", "));
+    const activeLabelsLiteral = JSON.stringify(ACTIVE_THINKING_LABELS);
+    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
+    const strong = detailed ? "{ active: true, strong: true }" : "true";
+    const weak = detailed ? "{ active: true, strong: false }" : "true";
+    const idle = detailed ? "{ active: false, strong: false }" : "false";
+    return `const ${fnName} = () => {
+    const STOP_SELECTOR = ${stopLiteral};
+    const ACTIVE_LABELS = ${activeLabelsLiteral};
+    const CONVERSATION_SELECTOR = ${conversationLiteral};
+    const ASSISTANT_SELECTOR = ${assistantLiteral};
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(node);
+      if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        (style.opacity !== '' && Number(style.opacity) === 0)
+      ) {
+        return false;
+      }
+      return true;
+    };
+    const some = (selector, pred) => {
+      let nodes;
+      try { nodes = document.querySelectorAll(selector); } catch { return false; }
+      return Array.from(nodes).some((node) => pred(node));
+    };
+    // 1) Stop/interrupt control visible -> generation is active (language-independent).
+    if (some(STOP_SELECTOR, isVisible)) return ${strong};
+    // 2-3) Shimmer/aria-busy are checked only inside the current turn or verified thinking
+    // panel below. Page-global busy UI (history/sidebar/upload) is not model activity.
+    const hasBusyIndicator = (scope) => {
+      let nodes;
+      try {
+        nodes = scope.querySelectorAll(
+          'span.loading-shimmer, .loading-shimmer, [class*="loading-shimmer"], [aria-busy="true"]',
+        );
+      } catch { return false; }
+      return Array.from(nodes).some((node) => isVisible(node));
+    };
+    // 4) Active (present-tense) thinking status label near a status/reasoning node.
+    const norm = (value) =>
+      String(value || '')
+        .normalize('NFD')
+        .replace(/[\\u0300-\\u036f]/g, '')
+        .toLowerCase()
+        .replace(/\\s+/g, ' ')
+        .trim();
+    // Completed reasoning summary: the whole visible label must be a duration summary. Anchoring
+    // prevents an early live trace such as "Thought for 2s: Searching the web" from being
+    // mistaken for completion before the trace grows beyond an arbitrary length threshold.
+    const isCompletedSummary = (text) =>
+      /^(?:(?:reasoning|pro thinking)\\s*)?thought for (?:\\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)(?:\\s+\\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours))*|(?:a|an) [a-z]+(?: [a-z]+){0,2})(?: edit)?$/.test(text);
+    const isActiveLabel = (raw) => {
+      const text = norm(raw);
+      if (!text || text.length > 60) return false;
+      if (isCompletedSummary(text)) return false;
+      return ACTIVE_LABELS.some((label) => text === label || text.startsWith(label + ' '));
+    };
+    const statusNodes = (() => {
+      try {
+        return Array.from(
+          document.querySelectorAll(
+            '[data-testid*="thinking"], [data-testid*="reasoning"]',
+          ),
+        );
+      } catch {
+        return [];
+      }
+    })();
+    for (const node of statusNodes) {
+      if (!(node instanceof HTMLElement) || !isVisible(node)) continue;
+      const testId = norm(node.getAttribute('data-testid'));
+      const verifiedThinkingChrome = testId.includes('thinking') || testId.includes('reasoning');
+      const matches =
+        verifiedThinkingChrome &&
+        (isActiveLabel(node.textContent) || isActiveLabel(node.getAttribute('aria-label')));
+      if (matches) return ${strong};
+    }
+    // 5) A live progress bar (determinate or indeterminate) is active generation, even when no
+    //    label or shimmer is present (some connector/tool phases surface only a progress bar).
+    const hasLiveProgress = (scope) => {
+      let nodes;
+      // Only genuine progress indicators — NOT generic [aria-valuenow] range widgets (sliders,
+      // spinbuttons), which are not liveness signals and would falsely veto completion forever.
+      try {
+        nodes = scope.querySelectorAll('progress, [role="progressbar"]');
+      } catch { return false; }
+      return Array.from(nodes).some((n) => {
+        if (!(n instanceof HTMLElement) || !isVisible(n)) return false;
+        if (n instanceof HTMLProgressElement) {
+          // Determinate <progress> is active only while it has not reached its max.
+          if (Number.isFinite(n.value) && Number.isFinite(n.max) && n.max > 0) return n.value < n.max;
+          return true; // indeterminate
+        }
+        const rawNow = n.getAttribute('aria-valuenow');
+        if (rawNow != null) {
+          const now = Number(rawNow);
+          const rawMax = n.getAttribute('aria-valuemax');
+          const max = rawMax != null && Number.isFinite(Number(rawMax)) ? Number(rawMax) : 100;
+          return Number.isFinite(now) ? now < max : true;
+        }
+        return true; // role=progressbar with no value -> indeterminate -> active
+      });
+    };
+    // Scoped to the CURRENT assistant turn, not the whole document: unrelated page UI can keep
+    // a visible progress bar mounted indefinitely (review P1), and a document-wide veto would
+    // then hold thinkingActive true until the watchdog timeout on a completed response. The
+    // sidecar check below covers verified reasoning panels; here only the latest turn counts.
+    const turns = (() => {
+      try { return document.querySelectorAll(CONVERSATION_SELECTOR); } catch { return []; }
+    })();
+    const lastTurn = turns.length ? turns[turns.length - 1] : null;
+    if (
+      lastTurn instanceof HTMLElement &&
+      (hasBusyIndicator(lastTurn) || hasLiveProgress(lastTurn))
+    ) return ${strong};
+    // 6) A visible thinking/reasoning sidecar panel (the connector/reasoning phase is often
+    //    exposed ONLY through a right-side panel with no inline label). Match the existing
+    //    thinking-monitor heuristic: a right-side panel that looks like thinking, or any such
+    //    container that carries a live progress bar. Presence alone is NOT enough (a collapsed
+    //    reasoning summary persists post-completion); require the thinking cue or live progress.
+    const looksLikeThinking = (node) => {
+      // Judge completion on the panel's VISIBLE text only: data-testid values like
+      // "reasoning-panel" would otherwise taint the completed-summary check, and a live trace
+      // is judged by its full rendered length, not by fragments of it.
+      const visible = norm(node.textContent) || norm(node.getAttribute?.('aria-label'));
+      if (isCompletedSummary(visible)) return false;
+      if (visible.includes('thought for ')) return true;
+      const label = norm([
+        node.textContent,
+        node.getAttribute?.('aria-label'),
+        node.getAttribute?.('data-testid'),
+      ].filter(Boolean).join(' '));
+      return label.includes('thinking') || label.includes('reasoning') || label.includes('pro thinking');
+    };
+    let panels;
+    try {
+      panels = document.querySelectorAll(
+        'aside, [role="complementary"], [role="dialog"], [data-testid*="thinking"], [data-testid*="reasoning"], [class*="sidecar"], [class*="sidebar"]',
+      );
+    } catch { panels = []; }
+    for (const node of Array.from(panels)) {
+      if (!(node instanceof HTMLElement) || !isVisible(node)) continue;
+      const rect = node.getBoundingClientRect();
+      const rightSide = rect.left >= window.innerWidth * 0.35 && rect.width >= 180 && rect.height >= 120;
+      const panelLabel = norm([
+        node.getAttribute?.('aria-label'),
+        node.getAttribute?.('data-testid'),
+        node.className,
+      ].filter(Boolean).join(' '));
+      const verifiedThinkingPanel =
+        panelLabel.includes('thinking') ||
+        panelLabel.includes('reasoning') ||
+        panelLabel.includes('sidecar');
+      if ((hasBusyIndicator(node) || hasLiveProgress(node)) && verifiedThinkingPanel) return ${strong};
+      // A text-only sidecar match is intentionally weak: completed turns can retain a mounted
+      // reasoning panel whose shape/text heuristics still look active. The terminal gate may
+      // override only this weak evidence after a stable, debounced finished-action bar.
+      if (rightSide && looksLikeThinking(node)) return ${weak};
+    }
+    return ${idle};
+  };`;
+}
+export function buildThinkingActivePredicateJs(fnName) {
+    return buildThinkingActivityPredicateJs(fnName, false);
+}
+export function buildThinkingActivityDetailsPredicateJs(fnName) {
+    return buildThinkingActivityPredicateJs(fnName, true);
+}
+export async function readThinkingActivity(Runtime) {
+    try {
+        const { result } = await Runtime.evaluate({
+            expression: `(() => {
+        ${buildThinkingActivityDetailsPredicateJs("readThinkingActivity")}
+        return readThinkingActivity();
+      })()`,
+            returnByValue: true,
+        });
+        const value = result?.value;
+        return { active: Boolean(value?.active), strong: Boolean(value?.strong) };
+    }
+    catch {
+        return { active: false, strong: false };
+    }
+}
+export async function isThinkingActive(Runtime) {
+    return (await readThinkingActivity(Runtime)).active;
+}
 export const startThinkingStatusMonitorForTest = startThinkingStatusMonitor;
 export const readThinkingStatusForTest = readThinkingStatus;
 export const buildThinkingStatusExpressionForTest = buildThinkingStatusExpression;
+export const buildThinkingActivePredicateJsForTest = buildThinkingActivePredicateJs;
+export const buildThinkingActivityDetailsPredicateJsForTest = buildThinkingActivityDetailsPredicateJs;
+export { ACTIVE_THINKING_LABELS };

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

@@ -124,6 +124,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const modelButtonLiteral = JSON.stringify(MODEL_BUTTON_SELECTOR);
     const targetLevelLiteral = JSON.stringify(level.toLowerCase());
     const targetModelKindLiteral = JSON.stringify(inferThinkingTargetModelKind(desiredModel));
+    const targetIsGpt56ModelLiteral = JSON.stringify(/(?:^|[^0-9])5[._ -]6(?:[^0-9]|$)/i.test(desiredModel ?? ""));
     return `(async () => {
     ${buildClickDispatcher()}
 
@@ -132,13 +133,14 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const MODEL_BUTTON_SELECTOR = ${modelButtonLiteral};
     const TARGET_LEVEL = ${targetLevelLiteral};
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
+    const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
 
     // Bilingual matchers: English level token + observed Chinese variants.
     const LEVEL_TOKENS = {
-      light: ['light', 'instant', '轻'],
-      standard: ['standard', 'medium', '标准'],
-      extended: ['extended', 'high', '扩展', '深度', '加强'],
-      heavy: ['heavy', 'extra high', '重度', '加重', '高'],
+      light: ['light', 'instant', '轻', '极速'],
+      standard: ['standard', 'medium', '标准', '中'],
+      extended: ['extended', 'high', '扩展', '深度', '加强', '高'],
+      heavy: ['heavy', 'extra high', '重度', '加重', '极高'],
     };
     const targetTokens = LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
 
@@ -166,6 +168,13 @@ function buildThinkingTimeExpression(level, desiredModel) {
         if (!token) return false;
         if (token === 'high') return hasToken(t, 'high') && !hasToken(t, 'extra');
         if (token === 'extra high') return hasToken(t, 'extra') && hasToken(t, 'high');
+        if (token === '极速') {
+          const suffix = t.slice(token.length);
+          return t === token || hasToken(t, token) || /^[0-9]/.test(suffix);
+        }
+        if (['中', '高', '极高'].includes(token)) {
+          return t === token || hasToken(t, token);
+        }
         return t === token || hasToken(t, token) || t.includes(token);
       });
     };
@@ -334,6 +343,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
       if (menu?.getAttribute?.('data-testid') === 'composer-intelligence-picker-content') {
         return true;
       }
+      if (menu?.querySelector?.(INTELLIGENCE_MENU_SELECTOR)) {
+        return true;
+      }
       const label = menu?.querySelector?.('.__menu-label, [class*="menu-label"]');
       return normalize(label?.textContent ?? '').includes('intelligence');
     };
@@ -347,6 +359,21 @@ function buildThinkingTimeExpression(level, desiredModel) {
       const items = Array.from(menu.querySelectorAll(MENU_ITEM_SELECTOR));
       const modelKind = modelKindOverride || effectiveTargetModelKind();
       if (modelKind === 'pro') {
+        // GPT-5.6's unified Intelligence picker exposes Pro as the highest
+        // effort radio directly. It no longer has a nested "Pro Extended"
+        // row, so preserve the legacy request semantics by selecting Pro.
+        if (
+          TARGET_LEVEL === 'extended' &&
+          isIntelligenceEffortMenu(menu) &&
+          !document.querySelector(PRO_EFFORT_TRIGGER_SELECTOR)
+        ) {
+          for (const item of items) {
+            const itemText = normalize(
+              (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
+            );
+            if (itemText === 'pro') return item;
+          }
+        }
         for (const item of items) {
           const itemText = normalize(
             (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
@@ -367,7 +394,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
         const itemText = normalize(
           (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
         );
-        if (modelKind && modelKind !== 'pro' && hasToken(itemText, 'pro')) {
+        if (modelKind !== 'pro' && hasToken(itemText, 'pro')) {
           continue;
         }
         if (
@@ -377,6 +404,16 @@ function buildThinkingTimeExpression(level, desiredModel) {
           return item;
         }
       }
+      if (TARGET_LEVEL === 'heavy') {
+        // Older Chinese layouts used bare 高 for the highest effort. Keep it
+        // only as a second-pass exact fallback so a current 高 row can never
+        // win before the primary 极高 row.
+        for (const item of items) {
+          const itemText = normalize(item.textContent ?? '');
+          const ariaLabel = normalize(item.getAttribute?.('aria-label') ?? '');
+          if (itemText === '高' || ariaLabel === '高') return item;
+        }
+      }
       return null;
     };
     const countEffortLevels = (menu) => {
@@ -390,6 +427,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const isEffortMenu = (menu) => {
       if (!isVisible(menu)) return false;
       if (menu.getAttribute?.('data-testid') === 'composer-intelligence-picker-content') return true;
+      if (menu.querySelector?.(INTELLIGENCE_MENU_SELECTOR)) return true;
       const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
       const labelText = normalize(label?.textContent ?? '');
       return (
@@ -450,8 +488,16 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       return null;
     };
+    const freshComposerTrigger = (trigger) => {
+      if (!trigger?.matches?.('button.__composer-pill')) return null;
+      // React can replace the composer pill after an effort click. Keep using
+      // the captured node while it is live, but re-query once it is detached so
+      // verification does not read its stale pre-click label.
+      if (trigger.isConnected !== false) return trigger;
+      return findComposerEffortPill() || findModelButton() || trigger;
+    };
     const currentProEffortPillMatchesTarget = (trigger, modelKindOverride = null) => {
-      const button = trigger?.matches?.('button.__composer-pill') ? trigger : findModelButton();
+      const button = freshComposerTrigger(trigger) || findModelButton();
       if ((modelKindOverride || TARGET_MODEL_KIND || modelKindFromNode(button)) !== 'pro') {
         return false;
       }
@@ -466,7 +512,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     };
     const currentEffortPillMatchesTarget = (trigger, modelKindOverride = null) => {
       if (currentProEffortPillMatchesTarget(trigger, modelKindOverride)) return true;
-      const button = trigger?.matches?.('button.__composer-pill') ? trigger : findModelButton();
+      const button = freshComposerTrigger(trigger) || findModelButton();
       if ((modelKindOverride || TARGET_MODEL_KIND || modelKindFromNode(button)) === 'pro') {
         return false;
       }
@@ -499,8 +545,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
         return { status: 'switched', label };
       }
 
-      if (!refreshed && trigger && trigger.getAttribute?.('aria-expanded') !== 'true') {
-        dispatchClickSequence(trigger);
+      const reopenTrigger = freshComposerTrigger(trigger) || trigger;
+      if (!refreshed && reopenTrigger?.getAttribute?.('aria-expanded') !== 'true') {
+        dispatchClickSequence(reopenTrigger);
         await sleep(INITIAL_WAIT_MS);
       }
       const deadline = performance.now() + 2000;
@@ -556,6 +603,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     ];
     const findComposerEffortPill = () => {
       const seen = new Set();
+      let gpt56Fallback = null;
       for (const selector of COMPOSER_EFFORT_PILL_SELECTORS) {
         for (const button of document.querySelectorAll(selector)) {
           if (seen.has(button) || !isVisible(button)) continue;
@@ -574,9 +622,16 @@ function buildThinkingTimeExpression(level, desiredModel) {
           ) {
             return button;
           }
+          if (
+            TARGET_IS_GPT56_MODEL &&
+            button.matches?.('button.__composer-pill') &&
+            normalize(button.textContent ?? '') === 'pro'
+          ) {
+            gpt56Fallback ||= button;
+          }
         }
       }
-      return null;
+      return gpt56Fallback;
     };
     let composerEffortPill = findComposerEffortPill();
     let modelBtn = findModelButton();
@@ -634,7 +689,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
     }
     if (composerEffortPill) {
       if (attemptedModelButton && attemptedModelButton !== composerEffortPill) closeOpenMenus();
-      const composerModelKind = TARGET_MODEL_KIND || modelKindFromNode(composerEffortPill);
+      const composerModelKind =
+        TARGET_MODEL_KIND ||
+        (TARGET_IS_GPT56_MODEL ? 'versioned' : modelKindFromNode(composerEffortPill));
       if (composerEffortPill.getAttribute?.('aria-expanded') !== 'true') {
         dispatchClickSequence(composerEffortPill);
         await sleep(INITIAL_WAIT_MS);

package/dist/src/browser/chromeLifecycle.js

@@ -2,18 +2,15 @@ import { rm } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import os from "node:os";
 import net from "node:net";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import CDP from "chrome-remote-interface";
 import { launch, Launcher } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
-const execFileAsync = promisify(execFile);
 export async function launchChrome(config, userDataDir, logger) {
     const connectHost = resolveRemoteDebugHost();
     const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
     const debugPort = config.debugPort ?? parseDebugPortEnv();
-    const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress);
+    const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress, config.hideWindow ?? false);
     const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
     // copy-profile reuses a copied signed-in profile whose cookies are
     // Keychain-encrypted, so it must launch with the real Keychain (not mocked):
@@ -46,6 +43,24 @@ export async function launchChrome(config, userDataDir, logger) {
     logger(`Launched Chrome${pidLabel} on port ${launcher.port}${hostLabel}`);
     return Object.assign(launcher, { host: connectHost ?? "127.0.0.1" });
 }
+export async function positionChromeWindowOffscreen(client, logger) {
+    if (process.platform !== "darwin") {
+        logger("Window hiding is only supported on macOS");
+        return;
+    }
+    try {
+        const { windowId } = await client.Browser.getWindowForTarget();
+        await client.Browser.setWindowBounds({
+            windowId,
+            bounds: { left: -32_000, top: -32_000, windowState: "normal" },
+        });
+        logger("Chrome window positioned off-screen");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to position Chrome window off-screen: ${message}`);
+    }
+}
 export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger, opts) {
     const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
     let handling;
@@ -110,29 +125,6 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
         }
     };
 }
-export async function hideChromeWindow(chrome, logger) {
-    if (process.platform !== "darwin") {
-        logger("Window hiding is only supported on macOS");
-        return;
-    }
-    if (!chrome.pid) {
-        logger("Unable to hide window: missing Chrome PID");
-        return;
-    }
-    const script = `tell application "System Events"
-    try
-      set visible of (first process whose unix id is ${chrome.pid}) to false
-    end try
-  end tell`;
-    try {
-        await execFileAsync("osascript", ["-e", script]);
-        logger("Chrome window hidden (Cmd-H)");
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger(`Failed to hide Chrome window: ${message}`);
-    }
-}
 export async function connectToChrome(port, logger, host) {
     const client = await CDP({ port, host });
     logger("Connected to Chrome DevTools protocol");
@@ -459,7 +451,7 @@ function isBlankPageTarget(target) {
     const url = (target.url ?? "").trim().toLowerCase();
     return url === "about:blank" || url === "chrome://newtab/" || url === "chrome://new-tab-page/";
 }
-function buildChromeFlags(headless, debugBindAddress) {
+function buildChromeFlags(headless, debugBindAddress, hideWindow = false) {
     const flags = [
         "--disable-background-networking",
         "--disable-background-timer-throttling",
@@ -489,8 +481,17 @@ function buildChromeFlags(headless, debugBindAddress) {
     if (headless) {
         flags.push("--headless=new");
     }
+    else if (hideWindow && process.platform === "darwin") {
+        // Cmd-H stops macOS Chrome from compositing the page, which can swallow
+        // trusted CDP clicks and retain the prompt as a draft. Keeping the window
+        // off-screen avoids desktop disruption while preserving normal rendering.
+        flags.push("--window-position=-32000,-32000");
+    }
     return flags;
 }
+export function buildChromeFlagsForTest(headless, debugBindAddress, hideWindow = false) {
+    return buildChromeFlags(headless, debugBindAddress, hideWindow);
+}
 function resolveChromeLaunchOptions(chromeFlags, usingCopiedProfile) {
     if (!usingCopiedProfile) {
         return { chromeFlags, ignoreDefaultFlags: false };

package/dist/src/browser/config.js

@@ -61,6 +61,7 @@ export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
     const envAllowCookieErrors = (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim().toLowerCase() === "true" ||
         (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim() === "1";
+    const envMaxConcurrentTabs = parseMaxConcurrentTabs(process.env.ORACLE_BROWSER_MAX_CONCURRENT_TABS);
     const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
     const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
     const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
@@ -87,7 +88,7 @@ export function resolveBrowserConfig(config) {
         assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
         reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
         profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
-        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
+        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? envMaxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
         autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
         autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
         autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
@@ -134,6 +135,18 @@ function parseDebugPort(raw) {
     }
     return value;
 }
+function parseMaxConcurrentTabs(raw) {
+    if (!raw)
+        return null;
+    const trimmed = raw.trim();
+    if (!/^\d+$/.test(trimmed))
+        return null;
+    const value = Number(trimmed);
+    if (!Number.isInteger(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
 function resolveManualLoginProfileDir(...candidates) {
     for (const candidate of candidates) {
         const profileDir = candidate?.trim();

package/dist/src/browser/constants.js

@@ -64,10 +64,14 @@ export const UPLOAD_STATUS_SELECTORS = [
     '[aria-live="assertive"]',
 ];
 export const STOP_BUTTON_SELECTOR = '[data-testid="stop-button"]';
+// The aria-label fallback exists for data-testid drift, but a document-wide match makes ANY
+// visible "stop" control (read-aloud, voice/dictation) read as "still generating", which blocks
+// completion until the response timeout. Scope it to the composer form and exclude the known
+// non-generation stop controls that legitimately live there.
 export const STOP_BUTTON_SELECTORS = [
     STOP_BUTTON_SELECTOR,
     '[data-testid="composer-stop-button"]',
-    'button[aria-label*="stop" i]',
+    'form button[aria-label*="stop" i]:not([aria-label*="dictat" i]):not([aria-label*="voice" i]):not([aria-label*="read" i])',
 ];
 export const SEND_BUTTON_SELECTORS = [
     'button[data-testid="send-button"]',

package/dist/src/browser/controlPlan.js

@@ -45,13 +45,13 @@ export function describeBrowserControlPlan(config = {}) {
         };
     }
     if (config.hideWindow) {
-        guidance.push("Chrome may briefly focus while launching before Oracle hides it.");
+        guidance.push("On macOS, Oracle launches Chrome off-screen while keeping the page rendered.");
         guidance.push("For the calmest shared-desktop flow, prefer --browser-attach-running or --remote-chrome.");
         return {
             mode: "hidden-window",
             launchesChrome: true,
             mayFocusWindow: true,
-            summary: "launch Chrome and hide the window after startup",
+            summary: "launch Chrome in hidden-window mode",
             guidance,
         };
     }