@steipete/oracle 0.18.0 → 0.19.0

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

@@ -4,6 +4,7 @@ import { waitForAttachmentVisible } from "./attachments.js";
 import { delay } from "../utils.js";
 import { logDomFailure } from "../domDebug.js";
 import { transferAttachmentViaDataTransfer } from "./attachmentDataTransfer.js";
+import { beginAttachmentEvidence } from "./attachmentEvidence.js";
 /**
  * Upload file to remote Chrome by transferring content via CDP
  * Used when browser is on a different machine than CLI
@@ -28,10 +29,11 @@ export async function uploadAttachmentViaDataTransfer(deps, attachment, logger)
         await logDomFailure(runtime, logger, "file-input");
         throw new Error("Unable to locate ChatGPT file attachment input.");
     }
-    const transferResult = await transferAttachmentViaDataTransfer(runtime, attachment, fileInputSelector);
+    const evidenceId = await beginAttachmentEvidence(runtime, path.basename(attachment.path));
+    const transferResult = await transferAttachmentViaDataTransfer(runtime, attachment, fileInputSelector, deps.navigationUrl);
     logger(`File transferred: ${transferResult.fileName} (${transferResult.size} bytes)`);
     // Give ChatGPT a moment to process the file
     await delay(500);
-    await waitForAttachmentVisible(runtime, transferResult.fileName, 10_000, logger);
+    await waitForAttachmentVisible(runtime, transferResult.fileName, 10_000, logger, evidenceId);
     logger("Attachment queued");
 }

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

@@ -1,5 +1,6 @@
 import { formatElapsed } from "../../oracle/format.js";
 import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, STOP_BUTTON_SELECTORS, } from "../constants.js";
+import { buildConversationTurnListExpression } from "../conversationTurns.js";
 const THINKING_STALE_HINT_MS = 10 * 60_000;
 export function startThinkingStatusMonitor(Runtime, logger, options = {}) {
     const intervalMs = resolveThinkingStatusInterval(options.intervalMs);
@@ -438,7 +439,6 @@ const ACTIVE_THINKING_LABELS = [
 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";
@@ -446,7 +446,6 @@ function buildThinkingActivityPredicateJs(fnName, detailed) {
     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;
@@ -549,9 +548,7 @@ function buildThinkingActivityPredicateJs(fnName, detailed) {
     // 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 turns = ${buildConversationTurnListExpression()};
     const lastTurn = turns.length ? turns[turns.length - 1] : null;
     if (
       lastTurn instanceof HTMLElement &&

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

@@ -52,8 +52,8 @@ function logPickerDiagnostic(result, logger) {
 /**
  * Selects a thinking-time level in ChatGPT's composer.
  *
- * Missing controls remain best-effort except Pro Extended, which fails closed
- * unless the selected option is confirmed.
+ * Returns the UI selection observed at capturedAt, not backend attestation.
+ * Explicit Pro and Pro Extended requests still fail closed when unconfirmed.
  */
 export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
     const result = await evaluateThinkingTimeSelection(Runtime, level, desiredModel);
@@ -65,13 +65,24 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
     // own, independently of the legacy Pro-model + "extended" combination.
     const strictProEffort = level === "pro" ||
         ((targetModelKind === "pro" || observedModelKind === "pro") && level === "extended");
+    const evidence = (status, resolvedLabel) => ({
+        requestedLevel: level,
+        status,
+        resolvedLabel,
+        verified: status === "already-selected" || status === "switched",
+        strictFailClosed: strictProEffort,
+        targetModelKind: targetModelKind ?? null,
+        observedModelKind: observedModelKind ?? null,
+        source: "chatgpt-thinking-picker",
+        capturedAt: new Date().toISOString(),
+    });
     switch (result?.status) {
         case "already-selected":
             logger(formatBrowserThinkingLog(`${result.label ?? capitalizedLevel} (already selected)`));
-            return;
+            return evidence("already-selected", result.label ?? null);
         case "switched":
             logger(formatBrowserThinkingLog(result.label ?? capitalizedLevel));
-            return;
+            return evidence("switched", result.label ?? null);
         case "option-disabled": {
             await logDomFailure(Runtime, logger, "thinking-option-disabled");
             logPickerDiagnostic(result, logger);
@@ -82,7 +93,7 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
             // strict error's "refusing to submit" wording: the request really is sent,
             // at whatever effort ChatGPT already had selected.
             logger(formatBrowserThinkingLog(`${result.label ?? capitalizedLevel} is unavailable on this account (${result.notice ?? "no reason given"}); keeping the effort already selected in ChatGPT.`));
-            return;
+            return evidence("unverified", null);
         }
         case "chip-not-found":
         case "menu-not-found":
@@ -108,7 +119,7 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
                 ? "the effort in ChatGPT is unconfirmed"
                 : "keeping the effort already selected in ChatGPT";
             logger(formatBrowserThinkingLog(`${message}; ${outcome}.`));
-            return;
+            return evidence("unverified", null);
         }
         default: {
             await logDomFailure(Runtime, logger, "thinking-time-unknown");
@@ -118,7 +129,7 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
                 throw new Error(`Thinking time: unknown outcome selecting ${capitalizedLevel}; refusing to submit without confirmed ${target}.`);
             }
             logger(formatBrowserThinkingLog(`unknown outcome selecting ${capitalizedLevel}; continuing with ChatGPT default.`));
-            return;
+            return evidence("unverified", null);
         }
     }
 }
@@ -191,12 +202,12 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
     const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
 
-    // Multilingual matchers: English level token + observed German/Japanese/Chinese variants.
+    // Multilingual matchers: English level token + observed localized variants.
     const LEVEL_TOKENS = {
-      light: ['light', 'instant', 'sofort', 'leicht', '最速', '轻', '极速'],
-      standard: ['standard', 'medium', 'mittel', '中程度', '标准', '中'],
-      extended: ['extended', 'high', 'hoch', 'erweitert', '高い', '扩展', '深度', '加强', '高'],
-      'extra-high': ['extra high', 'sehr hoch', '非常に高い', '极高'],
+      light: ['light', 'instant', 'sofort', 'leicht', '最速', '轻', '极速', '즉시'],
+      standard: ['standard', 'medium', 'mittel', '中程度', '标准', '中', '중간'],
+      extended: ['extended', 'high', 'hoch', 'erweitert', '高い', '扩展', '深度', '加强', '高', '높음'],
+      'extra-high': ['extra high', 'sehr hoch', '非常に高い', '极高', '매우 높음'],
       heavy: ['heavy', 'schwer', '重度', '加重'],
     };
     // Pro is a tier you can request, but it is also a MODEL name, so it must never
@@ -215,7 +226,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const INTELLIGENCE_WAIT_MS = 2500;
 
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-    // Keep CJK characters, including Japanese kana, so localized labels survive
+    // Keep CJK characters, including Japanese kana and Hangul, so labels survive
     // normalization before being matched against LEVEL_TOKENS and picker controls.
     const normalize = (value) => (value || '')
       // Compose first so NFD umlauts fold too, then map them onto ASCII before
@@ -226,7 +237,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
       .replace(/ö/g, 'o')
       .replace(/ü/g, 'u')
       .replace(/ß/g, 'ss')
-      .replace(/[^a-z0-9\\u3040-\\u30ff\\u4e00-\\u9fff]+/g, ' ')
+      .replace(/[^a-z0-9\\u3040-\\u30ff\\u4e00-\\u9fff\\uac00-\\ud7af]+/g, ' ')
       .replace(/\\s+/g, ' ')
       .trim();
     const hasToken = (text, token) => normalize(text).split(' ').includes(token);
@@ -255,6 +266,8 @@ function buildThinkingTimeExpression(level, desiredModel) {
         if (token === 'extra high') return hasPhrase(t, 'extra high');
         if (token === 'hoch') return hasPhrase(t, 'hoch') && !hasPhrase(t, 'sehr hoch');
         if (token === 'sehr hoch') return hasPhrase(t, 'sehr hoch');
+        if (token === '높음') return hasPhrase(t, '높음') && !hasPhrase(t, '매우 높음');
+        if (token === '매우 높음') return hasPhrase(t, '매우 높음');
         if (token === '高い' || token === '非常に高い') {
           return t === token || hasToken(t, token);
         }
@@ -842,11 +855,11 @@ function buildThinkingTimeExpression(level, desiredModel) {
     // token matching cannot be used here — substring is deliberate, as in
     // countEffortLevels above.
     const ADVANCED_WORDS = [
-      'advanced', 'erweitert', '高级', '詳細設定', '詳細表示',
+      'advanced', 'erweitert', '高级', '詳細設定', '詳細表示', '고급',
       'avanzado', 'avancado', 'avance',
     ];
     const EFFORT_WORDS = [
-      'effort', 'aufwand', '强度', '努力', '推論レベル',
+      'effort', 'aufwand', '强度', '努力', '推論レベル', '思考量', '추론 수준',
       'esfuerzo', 'esforco', 'sforzo', 'inspanning', 'wysilek',
     ];
     const containsAny = (label, words) => words.some((word) => label.includes(word));
@@ -945,6 +958,94 @@ function buildThinkingTimeExpression(level, desiredModel) {
       return null;
     };
 
+    // The direct-slider rollout removes the Effort submenu entirely. Its keyboard
+    // owner announces the actual tier via aria-describedby; neither the pill nor
+    // the slider's maximum position alone proves that Pro was selected.
+    const selectDirectEffortSlider = async (menu) => {
+      const view = menu.querySelector?.('[data-model-selection-view="true"]');
+      const simple = view?.querySelector?.('[data-testid="composer-model-picker-slider-simple-view"]');
+      if (!simple || simple.getAttribute('data-active') !== 'true' || !isVisible(simple)) return null;
+      const resolve = () => {
+        const currentView = menu.querySelector?.('[data-model-selection-view="true"]');
+        const currentSimple = currentView?.querySelector?.('[data-testid="composer-model-picker-slider-simple-view"]');
+        if (currentSimple?.getAttribute('data-active') !== 'true') return null;
+        const slider = currentSimple.querySelector('[data-model-reasoning-effort-slider]');
+        const control = slider?.closest?.('[role="menuitem"]');
+        const thumb = slider?.querySelector?.('[role="slider"]');
+        if (!control || !thumb || !isVisible(control)) return null;
+        const levels = ['light', 'standard', 'extended', 'extra-high', 'pro'];
+        // The selected label leads localized aria-describedby prose, while punctuation
+        // and ordinal grammar vary by locale. Match only that leading label and let
+        // the thumb's numeric ARIA state independently prove its position.
+        const readLeadingLevel = (description) => {
+          const value = (description ?? '').normalize('NFC').trim();
+          if (!value) return null;
+          const matches = levels.flatMap((level, index) => {
+            const token = [...TARGET_LEVEL_TOKENS[level]]
+              .sort((left, right) => right.length - left.length)
+              .find((candidate) => {
+                const normalizedCandidate = candidate.normalize('NFC');
+                const prefix = value.slice(0, normalizedCandidate.length);
+                if (normalize(prefix) !== normalize(normalizedCandidate)) return false;
+                // normalize() erases Unicode letters and marks; inspect the boundary intact.
+                const suffix = value.slice(prefix.length);
+                return !suffix || /^[\\s\\p{P}]/u.test(suffix);
+              });
+            return token
+              ? [{ level, index, label: value.slice(0, token.normalize('NFC').length) }]
+              : [];
+          });
+          return matches.length === 1 ? matches[0] : null;
+        };
+        const selections = describedIds(control)
+          .map((id) => readLeadingLevel(document.getElementById?.(id)?.textContent ?? ''))
+          .filter(Boolean);
+        if (selections.length !== 1) return null;
+        const { label, index, level } = selections[0];
+        // This adapter owns the observed five-tier layout only. A different range
+        // or contradictory announcement must not turn a numeric guess into proof.
+        if (thumb.getAttribute('aria-valuemin') !== '0' || thumb.getAttribute('aria-valuemax') !== '4' ||
+            thumb.getAttribute('aria-valuenow') !== String(index)) return null;
+        return { control, label, index, level };
+      };
+      let current = resolve();
+      const finish = (result) => { closeOpenMenus(); return result; };
+      // The picker can expose its simple view before the keyboard owner is mounted or visible.
+      const readyDeadline = performance.now() + MAX_WAIT_MS;
+      while (!current && performance.now() < readyDeadline) {
+        await sleep(100);
+        current = resolve();
+      }
+      if (!current) return finish(failure('selection-unverified'));
+      // Preserve the legacy Pro-model + extended contract on unified pickers.
+      const target = TARGET_MODEL_KIND === 'pro' && TARGET_LEVEL === 'extended' ? 'pro' : TARGET_LEVEL;
+      const targetIndex = ['light', 'standard', 'extended', 'extra-high', 'pro'].indexOf(target);
+      if (targetIndex < 0) {
+        if (TARGET_IS_GPT56_MODEL && TARGET_LEVEL === 'heavy' && current.level === 'pro') {
+          return finish({ status: 'already-selected', label: current.label });
+        }
+        return finish(failure('option-not-found'));
+      }
+      if (current.level === target) return finish({ status: 'already-selected', label: current.label });
+      const deadline = performance.now() + MAX_WAIT_MS;
+      for (let attempt = 0; attempt < 4 && performance.now() < deadline; attempt += 1) {
+        if (isOptionDisabled(current.control)) return finish(failure('option-disabled', { label: current.label }));
+        const previousIndex = current.index;
+        const key = targetIndex > previousIndex ? 'ArrowRight' : 'ArrowLeft';
+        current.control.focus?.();
+        current.control.dispatchEvent(new KeyboardEvent('keydown', { key, code: key, bubbles: true, cancelable: true }));
+        current = null;
+        while (performance.now() < deadline) {
+          await sleep(100);
+          const next = resolve();
+          if (next && next.index !== previousIndex) { current = next; break; }
+        }
+        if (!current) return finish(failure('selection-unverified'));
+        if (current.level === target) return finish({ status: 'switched', label: current.label });
+      }
+      return finish(failure('selection-unverified'));
+    };
+
     // Current ChatGPT exposes a standalone Pro or Thinking composer pill whose
     // controlled menu contains the effort levels. Prefer this ownership boundary
     // before probing older model-picker layouts.
@@ -1069,6 +1170,8 @@ function buildThinkingTimeExpression(level, desiredModel) {
       while (performance.now() < deadline) {
         const menu = findVisibleEffortMenu(composerEffortPill);
         if (menu) {
+          const sliderResult = await selectDirectEffortSlider(menu);
+          if (sliderResult) return sliderResult;
           const proEffortResult = await selectProEffortFromSubmenu();
           if (proEffortResult) {
             return proEffortResult;

package/dist/src/browser/attachRunning.js

@@ -1,4 +1,4 @@
-import { discoverDevToolsActivePortCandidates, } from "./detect.js";
+import { discoverDevToolsActivePortCandidates, formatWebSocketHost, resolveDevToolsActivePortDiscoveryRoots, } from "./detect.js";
 export async function resolveAttachRunningConnection(config, logger) {
     const host = config.remoteChrome?.host ?? "127.0.0.1";
     const port = config.remoteChrome?.port ?? 9222;
@@ -12,7 +12,17 @@ export async function resolveAttachRunningConnection(config, logger) {
         .filter((candidate) => candidate.port === port)
         .sort(compareDevToolsCandidates);
     if (candidates.length === 0) {
-        throw new Error(`No running browser with attach metadata matched ${host}:${port}. Enable remote debugging in chrome://inspect/#remote-debugging first.`);
+        const probe = await probeDevToolsBrowserWSEndpoint({ host, port });
+        if (probe.ok) {
+            return {
+                host,
+                port,
+                browserWSEndpoint: probe.browserWSEndpoint,
+                profileRoot: null,
+            };
+        }
+        const discoveryRoots = resolveDevToolsActivePortDiscoveryRoots();
+        throw new Error(`No running browser matched ${host}:${port}. DevToolsActivePort discovery searched ${discoveryRoots.join(", ") || "no roots"}, and endpoint probe http://${formatWebSocketHost(host)}:${port}/json/version failed: ${probe.error}.`);
     }
     const candidate = candidates[0];
     logger(`Selected attach-running browser metadata from ${candidate.path}`);
@@ -23,6 +33,40 @@ export async function resolveAttachRunningConnection(config, logger) {
         profileRoot: candidate.profileRoot,
     };
 }
+async function probeDevToolsBrowserWSEndpoint({ host, port, attempts = 2, timeoutMs = 1000, }) {
+    const versionUrl = `http://${formatWebSocketHost(host)}:${port}/json/version`;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(versionUrl, { signal: controller.signal });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const version = (await response.json());
+                if (typeof version.webSocketDebuggerUrl !== "string" || !version.webSocketDebuggerUrl) {
+                    throw new Error("response did not include webSocketDebuggerUrl");
+                }
+                return { ok: true, browserWSEndpoint: version.webSocketDebuggerUrl };
+            }
+            finally {
+                // Headers can arrive before a stalled body; bound and clean up the whole request.
+                clearTimeout(timeout);
+                controller.abort();
+            }
+        }
+        catch (error) {
+            if (attempt < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    return { ok: false, error: "unreachable" };
+}
 function compareDevToolsCandidates(left, right) {
     if (right.mtimeMs !== left.mtimeMs) {
         return right.mtimeMs - left.mtimeMs;

package/dist/src/browser/attachmentValidation.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+function compareStrings(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+export function findAttachmentBasenameCollisions(attachments) {
+    const attachmentsByBasename = new Map();
+    for (const attachment of attachments) {
+        const basename = path.basename(attachment.path);
+        const matchingAttachments = attachmentsByBasename.get(basename) ?? [];
+        matchingAttachments.push(attachment);
+        attachmentsByBasename.set(basename, matchingAttachments);
+    }
+    return [...attachmentsByBasename.entries()]
+        .filter(([, matchingAttachments]) => matchingAttachments.length > 1)
+        .sort(([leftBasename], [rightBasename]) => compareStrings(leftBasename, rightBasename))
+        .map(([basename, matchingAttachments]) => ({
+        basename,
+        attachments: [...matchingAttachments].sort((left, right) => compareStrings(left.displayPath, right.displayPath) ||
+            compareStrings(left.path, right.path)),
+    }));
+}
+export function buildAttachmentBasenameCollisionDetails(collisions, displayFile) {
+    const collisionDetails = collisions.map((collision) => ({
+        basename: collision.basename,
+        files: collision.attachments.map(displayFile),
+    }));
+    return {
+        collisions: collisionDetails,
+        files: collisionDetails.flatMap((collision) => collision.files),
+    };
+}
+export function formatAttachmentBasenameCollisionMessage(subject, collisions) {
+    const collisionLines = collisions.length === 1
+        ? [
+            `${subject} cannot safely include multiple files named "${collisions[0].basename}":`,
+            ...collisions[0].files.map((file) => `- ${file}`),
+        ]
+        : [
+            `${subject} cannot safely include files with colliding basenames:`,
+            ...collisions.flatMap((collision) => [
+                `Files named "${collision.basename}":`,
+                ...collision.files.map((file) => `- ${file}`),
+            ]),
+        ];
+    return [
+        ...collisionLines,
+        "Use --browser-bundle-files (and --browser-bundle-format zip for raw or binary files), or choose unique names before retrying.",
+    ].join("\n");
+}

package/dist/src/browser/cancellation.js

@@ -0,0 +1,105 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { BrowserRunCancelledError } from "../oracle/errors.js";
+const context = new AsyncLocalStorage();
+const cleanupContext = new AsyncLocalStorage();
+export const currentBrowserAbortSignal = () => context.getStore();
+export const withoutBrowserCancellation = (task) => cleanupContext.run(true, () => context.run(undefined, task));
+/** Per-run cancellation, including polling and resources that arrive after their caller left. */
+export class BrowserCancellation {
+    signal;
+    log;
+    aborted;
+    onAbort;
+    proxies = new WeakMap();
+    constructor(signal, log = () => { }) {
+        this.signal = signal;
+        this.log = log;
+        if (signal) {
+            let rejectAbort;
+            this.aborted = new Promise((_, reject) => {
+                rejectAbort = reject;
+            });
+            this.aborted.catch(() => undefined);
+            this.onAbort = () => rejectAbort(new BrowserRunCancelledError());
+            if (signal.aborted)
+                this.onAbort();
+            else
+                signal.addEventListener("abort", this.onAbort, { once: true });
+        }
+    }
+    check() {
+        if (this.signal?.aborted)
+            throw new BrowserRunCancelledError();
+    }
+    run(task) {
+        return cleanupContext.run(false, () => context.run(this.signal, task));
+    }
+    dispose() {
+        if (this.onAbort)
+            this.signal?.removeEventListener("abort", this.onAbort);
+    }
+    race(pending) {
+        return this.aborted ? Promise.race([pending, this.aborted]) : pending;
+    }
+    call(create) {
+        this.check();
+        return this.race(create());
+    }
+    acquire(create, releaseLate) {
+        this.check();
+        const pending = create().then(async (resource) => {
+            if (this.signal?.aborted) {
+                await withoutBrowserCancellation(() => releaseLate(resource)).catch((error) => {
+                    this.log(`[browser] Late cancelled resource cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                throw new BrowserRunCancelledError();
+            }
+            return resource;
+        });
+        return this.race(pending);
+    }
+    client(client) {
+        if (!this.signal)
+            return client;
+        const wrap = (target) => {
+            const cached = this.proxies.get(target);
+            if (cached)
+                return cached;
+            const proxy = new Proxy(target, {
+                get: (object, key) => {
+                    const value = Reflect.get(object, key);
+                    if (typeof value === "function") {
+                        if ([
+                            "on",
+                            "once",
+                            "off",
+                            "emit",
+                            "removeListener",
+                            "removeAllListeners",
+                            "addListener",
+                            "close",
+                        ].includes(String(key)))
+                            return value.bind(object);
+                        return (...args) => {
+                            // CDP event subscriptions are synchronous and must remain removable during cleanup.
+                            if (typeof args[0] === "function")
+                                return Reflect.apply(value, object, args);
+                            if (cleanupContext.getStore())
+                                return Reflect.apply(value, object, args);
+                            if (this.signal?.aborted)
+                                return Promise.reject(new BrowserRunCancelledError());
+                            const result = Reflect.apply(value, object, args);
+                            return result && typeof result.then === "function"
+                                ? this.race(Promise.resolve(result))
+                                : result;
+                        };
+                    }
+                    return value && typeof value === "object" ? wrap(value) : value;
+                },
+            });
+            this.proxies.set(target, proxy);
+            return proxy;
+        };
+        return wrap(client);
+    }
+}

package/dist/src/browser/chatgptImages.js

@@ -5,6 +5,7 @@ import { ASSISTANT_ROLE_SELECTOR } from "./constants.js";
 import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { delay } from "./utils.js";
 import { readAssistantSnapshot } from "./pageActions.js";
+import { throwIfAssistantUiError } from "./actions/assistantResponse.js";
 import { getOracleHomeDir } from "../oracleHome.js";
 import { resolveSessionArtifactsDir } from "./artifacts.js";
 import { saveAssistantDownloadButtonArtifacts } from "./chatgptFiles.js";
@@ -456,6 +457,7 @@ export async function collectGeneratedImageArtifacts(params) {
                 break;
             }
             const latestSnapshot = await readAssistantSnapshot(params.Runtime, params.minTurnIndex ?? undefined).catch(() => null);
+            throwIfAssistantUiError(latestSnapshot);
             const snapshotText = typeof latestSnapshot?.text === "string" ? latestSnapshot.text.trim() : "";
             if (snapshotText) {
                 latestAnswerText = snapshotText;

package/dist/src/browser/chatgptThrottle.js

@@ -0,0 +1,104 @@
+import { BrowserAutomationError } from "../oracle/errors.js";
+/**
+ * Detection for ChatGPT's own rate-limit notice.
+ *
+ * When ChatGPT decides a session is asking for too much at once it puts a modal
+ * over the page — "Too many requests … We've temporarily limited access to your
+ * conversations … Please wait a few minutes" — with a single "Got it" button.
+ *
+ * The modal is not marked as an error anywhere a DOM scrape would notice. It is
+ * a dialog full of ordinary text, so a menu reader walking the page finds its
+ * button and reports it as an available option. That is how a throttle came to be
+ * reported as `Unable to find model option matching "Thinking 5.5". Available:
+ * Got it` — a message that sends the reader looking for a model-naming bug that
+ * does not exist, when the correct response is to wait a few minutes.
+ *
+ * Observed live: six ChatGPT conversations opened at once triggered it
+ * repeatedly, while five did not, and the limit cleared on its own after a
+ * pause. Runs must therefore treat this as a transient, recoverable state rather
+ * than a failure of the request they were making.
+ */
+const THROTTLE_PHRASES = [
+    "too many requests",
+    "making requests too quickly",
+    "temporarily limited access to your conversations",
+];
+/** True when the text carries ChatGPT's rate-limit wording. */
+export function matchesThrottleNotice(text) {
+    if (!text) {
+        return false;
+    }
+    const normalized = text.toLowerCase();
+    return THROTTLE_PHRASES.some((phrase) => normalized.includes(phrase));
+}
+export function buildThrottleProbeExpression() {
+    return `(() => {
+    const PHRASES = ${JSON.stringify(THROTTLE_PHRASES)};
+    const matches = (value) => {
+      const text = (value || '').toLowerCase();
+      return PHRASES.some((phrase) => text.includes(phrase));
+    };
+    // Dialogs first, because that is what this notice is; the body sweep is a
+    // fallback for a variant that does not carry the role.
+    const dialogs = Array.from(document.querySelectorAll('[role="dialog"], [role="alertdialog"]'));
+    for (const dialog of dialogs) {
+      const text = (dialog.innerText || '').trim();
+      if (matches(text)) return { message: text.slice(0, 400) };
+    }
+    const body = (document.body && document.body.innerText) || '';
+    if (matches(body)) {
+      const line = body
+        .split('\\n')
+        .map((entry) => entry.trim())
+        .find((entry) => matches(entry));
+      return { message: (line || 'ChatGPT is rate limiting this session.').slice(0, 400) };
+    }
+    return null;
+  })()`;
+}
+/**
+ * Looks for the rate-limit notice. Never throws: this runs on paths that are
+ * already reporting a different failure, and a probe that failed must not
+ * replace the original diagnosis with its own.
+ */
+export async function detectChatGptThrottleNotice(Runtime) {
+    try {
+        const evaluated = await Runtime.evaluate({
+            expression: buildThrottleProbeExpression(),
+            returnByValue: true,
+        });
+        const value = evaluated.result?.value;
+        if (value && typeof value.message === "string" && value.message.trim()) {
+            return { message: value.message.trim() };
+        }
+    }
+    catch {
+        // fall through: no notice detected
+    }
+    return null;
+}
+export function buildThrottleError(notice, context) {
+    return new BrowserAutomationError(`ChatGPT is rate limiting this session: ${notice.message} ` +
+        "This is a temporary limit on the account, not a problem with the request — " +
+        "wait a few minutes and retry, and reduce how many conversations are started at once.", {
+        stage: "chatgpt-throttled",
+        details: {
+            // Named so a caller can branch on it rather than parsing the message.
+            retryable: true,
+            origin: context.stage,
+            notice: notice.message,
+        },
+    });
+}
+/**
+ * Replaces a misleading failure with the real one when the page is throttled.
+ * Returns nothing when it is not, leaving the caller's own error intact.
+ */
+export async function throwIfThrottled(Runtime, context, logger) {
+    const notice = await detectChatGptThrottleNotice(Runtime);
+    if (!notice) {
+        return;
+    }
+    logger?.(`[browser] ChatGPT rate limit detected during ${context.stage}: ${notice.message}`);
+    throw buildThrottleError(notice, context);
+}