@steipete/oracle 0.15.1 → 0.16.0

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

@@ -1,4 +1,5 @@
-import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, CONVERSATION_TURN_SELECTOR, STOP_BUTTON_SELECTOR, ASSISTANT_ROLE_SELECTOR, } from "../constants.js";
+import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, STOP_BUTTON_SELECTOR, ASSISTANT_ROLE_SELECTOR, } from "../constants.js";
+import { buildConversationTurnCountExpression, buildConversationTurnListExpression, } from "../conversationTurns.js";
 import { delay } from "../utils.js";
 import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
@@ -691,14 +692,13 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
     const inputSelectorsLiteral = JSON.stringify(INPUT_SELECTORS);
     const stopSelectorLiteral = JSON.stringify(STOP_BUTTON_SELECTOR);
     const assistantSelectorLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
-    const turnSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     let baseline = typeof baselineTurns === "number" && Number.isFinite(baselineTurns) && baselineTurns >= 0
         ? Math.floor(baselineTurns)
         : null;
     if (baseline === null) {
         try {
             const { result } = await Runtime.evaluate({
-                expression: `document.querySelectorAll(${turnSelectorLiteral}).length`,
+                expression: buildConversationTurnCountExpression(),
                 returnByValue: true,
             });
             const raw = typeof result?.value === "number" ? result.value : Number(result?.value);
@@ -726,8 +726,7 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
 	    };
 	    const normalizedPrompt = normalize(${encodedPrompt});
 	    const normalizedPromptPrefix = normalizedPrompt.slice(0, 120);
-	    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
-	    const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+	    const articles = ${buildConversationTurnListExpression()};
 	    const normalizedTurns = articles.map((node) => normalize(node?.innerText));
 	    const readValue = (node) => {
 	      if (!node) return '';

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/chatgptFiles.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "./constants.js";
+import { ASSISTANT_ROLE_SELECTOR } from "./constants.js";
+import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { computeFileSha256, resolveSessionArtifactsDir, sanitizeArtifactFilename, validateArtifactFile, writeBinaryBrowserArtifact, } from "./artifacts.js";
 const CHATGPT_DOWNLOAD_BASE_URL = "https://chatgpt.com/";
 const DOWNLOAD_BUTTON_WAIT_MS = 15_000;
@@ -272,11 +273,9 @@ function buildAssistantDownloadableFilesExpression(minTurnIndex) {
     const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
         : -1;
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     return `(() => {
     const MIN_TURN_INDEX = ${minTurnLiteral};
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isAssistantTurn = (node) => {
       if (!(node instanceof HTMLElement)) return false;
@@ -385,7 +384,7 @@ function buildAssistantDownloadableFilesExpression(minTurnIndex) {
       ].join(',')))
         .map(serializeCandidate)
         .filter(Boolean);
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     const files = [];
     for (let index = turns.length - 1; index >= 0; index -= 1) {
       const turn = turns[index];
@@ -626,7 +625,6 @@ function buildClickAssistantDownloadButtonsExpression(minTurnIndex, expectedLabe
     const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
         : -1;
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     const expectedLabelsLiteral = JSON.stringify(expectedLabels);
     const allowGenericDownloadLabelsLiteral = JSON.stringify(allowGenericDownloadLabels);
@@ -639,7 +637,6 @@ function buildClickAssistantDownloadButtonsExpression(minTurnIndex, expectedLabe
         : 0;
     return `(() => {
     const MIN_TURN_INDEX = ${minTurnLiteral};
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const EXPECTED_LABELS = ${expectedLabelsLiteral};
     const ALLOW_GENERIC_DOWNLOAD_LABELS = ${allowGenericDownloadLabelsLiteral};
@@ -762,7 +759,7 @@ function buildClickAssistantDownloadButtonsExpression(minTurnIndex, expectedLabe
     const genericBehaviorButton = (info) =>
       ALLOW_GENERIC_DOWNLOAD_LABELS && info.className.includes('behavior-btn') && hasDownloadIntent(info);
     const genericFallbackButton = (info) => ALLOW_GENERIC_DOWNLOAD_LABELS && hasDownloadIntent(info);
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     const expectedMatches = new Set();
     const genericBehaviorMatches = new Set();
     const genericFallbackMatches = new Set();

package/dist/src/browser/chatgptImages.js

@@ -1,7 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "./constants.js";
+import { ASSISTANT_ROLE_SELECTOR } from "./constants.js";
+import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { delay } from "./utils.js";
 import { readAssistantSnapshot } from "./pageActions.js";
 import { getOracleHomeDir } from "../oracleHome.js";
@@ -61,11 +62,9 @@ function buildAssistantImageExpression(minTurnIndex) {
     const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
         : -1;
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     return `(() => {
     const MIN_TURN_INDEX = ${minTurnLiteral};
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isGeneratedImage = (img) => {
       const url = new URL(img?.src || '', location.origin || 'https://chatgpt.com');
@@ -101,7 +100,7 @@ function buildAssistantImageExpression(minTurnIndex) {
       if (testId.includes('assistant')) return true;
       return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
     };
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     for (let index = turns.length - 1; index >= 0; index -= 1) {
       const turn = turns[index];
       if (!isAssistantTurn(turn)) continue;

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");
@@ -367,6 +359,7 @@ function createSessionBoundChromeClient(browser, sessionId) {
         Runtime: bindDomain("Runtime"),
         Input: bindDomain("Input"),
         DOM: bindDomain("DOM"),
+        Emulation: bindDomain("Emulation"),
         on: browserWithEvents.on.bind(browserWithEvents),
         once: browserWithEvents.once.bind(browserWithEvents),
         off: browserWithEvents.off?.bind(browserWithEvents) ??
@@ -458,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",
@@ -488,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 };