@steipete/oracle 0.17.3 → 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

@@ -1,6 +1,35 @@
 import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from "../constants.js";
 import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
+import { BrowserAutomationError } from "../../oracle/errors.js";
+export class ThinkingTierUnavailableError extends BrowserAutomationError {
+    requestedLevel;
+    requestedLabel;
+    optionLabel;
+    notice;
+    confirmedTarget;
+    constructor(requestedLevel, requestedLabel, optionLabel, notice, confirmedTarget) {
+        const message = `Thinking time: ${optionLabel ?? requestedLabel} is unavailable on this account (${notice ?? "no reason given"}); refusing to submit without confirmed ${confirmedTarget}.`;
+        super(message, {
+            stage: "thinking-tier-unavailable",
+            requestedLevel,
+            requestedLabel,
+            optionLabel,
+            notice,
+            confirmedTarget,
+        });
+        this.name = "ThinkingTierUnavailableError";
+        this.requestedLevel = requestedLevel;
+        this.requestedLabel = requestedLabel;
+        this.optionLabel = optionLabel;
+        this.notice = notice;
+        this.confirmedTarget = confirmedTarget;
+    }
+}
+function confirmedThinkingTarget(level, capitalizedLevel, targetModelKind, observedModelKind) {
+    const strictModelKind = targetModelKind ?? observedModelKind;
+    return level === "pro" ? "Pro" : strictModelKind === "pro" ? "Pro Extended" : capitalizedLevel;
+}
 const BROWSER_THINKING_LOG_PREFIX = "[browser] Thinking time:";
 function formatBrowserThinkingLog(message) {
     return `${BROWSER_THINKING_LOG_PREFIX} ${message.replace(/^Thinking time:\s*/, "")}`;
@@ -23,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);
@@ -36,13 +65,36 @@ 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);
+            if (strictProEffort) {
+                throw new ThinkingTierUnavailableError(level, capitalizedLevel, result.label ?? null, result.notice ?? null, confirmedThinkingTarget(level, capitalizedLevel, targetModelKind, observedModelKind));
+            }
+            // A non-strict caller goes on to submit, so this log must not borrow the
+            // 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 evidence("unverified", null);
+        }
         case "chip-not-found":
         case "menu-not-found":
         case "option-not-found":
@@ -67,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");
@@ -77,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);
         }
     }
 }
@@ -97,6 +149,9 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger, desi
             case "switched":
                 logger(formatBrowserThinkingLog(result.label ?? capitalizedLevel));
                 return true;
+            case "option-disabled":
+                logger(formatBrowserThinkingLog(`${result.label ?? capitalizedLevel} is unavailable on this account (${result.notice ?? "no reason given"}); keeping the effort already selected in ChatGPT.`));
+                return false;
             case "chip-not-found":
             case "menu-not-found":
             case "option-not-found":
@@ -147,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
@@ -171,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
@@ -182,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);
@@ -211,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);
         }
@@ -292,6 +349,21 @@ function buildThinkingTimeExpression(level, desiredModel) {
         .replace(/\\s+/g, ' ')
         .trim()
         .slice(0, maxLength);
+    const isOptionDisabled = (node) => {
+      if (!node || typeof node.getAttribute !== 'function') return false;
+      // data-disabled is Radix's valueless-presence convention, but an explicit
+      // "false" must not read as disabled: that would refuse a perfectly usable
+      // tier and report it as unavailable.
+      const dataDisabled = node.getAttribute('data-disabled');
+      const dataDisabledOn = dataDisabled !== null && String(dataDisabled).toLowerCase() !== 'false';
+      return (
+        node.getAttribute('aria-disabled') === 'true' ||
+        dataDisabledOn ||
+        (node.getAttribute('data-state') || '').toLowerCase() === 'disabled' ||
+        Boolean(node.disabled) ||
+        node.getAttribute('disabled') !== null
+      );
+    };
     const describeNode = (el) => {
       if (!el || typeof el.getAttribute !== 'function') return null;
       let rect = null;
@@ -314,7 +386,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
         ariaChecked: el.getAttribute('aria-checked'),
         ariaSelected: el.getAttribute('aria-selected'),
         ariaHaspopup: el.getAttribute('aria-haspopup'),
+        ariaDisabled: el.getAttribute('aria-disabled'),
+        dataDisabled: el.getAttribute('data-disabled'),
         dataState: el.getAttribute('data-state'),
+        disabled: isOptionDisabled(el),
         text: redactDiagnosticText(el.textContent, 80),
         rect,
       };
@@ -590,6 +665,77 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       return matchesLevel(normalizedLabel);
     };
+    const nonEmptyNotice = (value) => {
+      const text = redactDiagnosticText(value, 160);
+      return text || null;
+    };
+    // The notice must be ROW-OWNED, and preferably this hover's own.
+    //
+    // NOTE: no backticks in this comment — it lives inside the injected template
+    // literal, where a backtick would terminate the string.
+    //
+    // A document-wide role=tooltip scan is what this must never become: novelty is
+    // not causality, and an unrelated control with an armed open-delay can mount its
+    // tooltip inside this hover's window. Every pass below is anchored on the row.
+    //
+    // Preference order, strongest provenance first:
+    //   1. an id this hover ADDED whose target is role=tooltip — Radix keeps an
+    //      application-supplied description and APPENDS its tooltip id when opening,
+    //      so the delta is what separates the real notice from a permanent blurb;
+    //   2. any other id this hover added;
+    //   3. an already-associated role=tooltip target, for a tooltip that was open
+    //      before the probe arrived;
+    //   4. the row's static title, only once the poll has expired.
+    //
+    // Passes 3 and 4 are row-owned but NOT causal: a page that permanently points a
+    // disabled row at generic role=tooltip help, or gives it a generic title, will
+    // have that text reported. That is accepted deliberately — the value is an opaque
+    // notice for a human or a caller to interpret, not a parsed reset time — and the
+    // verified live target has neither at rest.
+    const describedIds = (option) =>
+      (option?.getAttribute?.('aria-describedby') || '').split(/\\s+/).filter(Boolean);
+    const isTooltipNode = (node) => node?.getAttribute?.('role') === 'tooltip';
+    const readDisabledNotice = (option, priorIds, allowTitle) => {
+      const ids = describedIds(option);
+      const prior = priorIds instanceof Set ? priorIds : new Set();
+      const fresh = ids.filter((id) => !prior.has(id));
+      for (const pass of [
+        fresh.filter((id) => isTooltipNode(document.getElementById?.(id))),
+        fresh,
+        ids.filter((id) => isTooltipNode(document.getElementById?.(id))),
+      ]) {
+        for (const id of pass) {
+          const notice = nonEmptyNotice(document.getElementById?.(id)?.textContent);
+          if (notice) return notice;
+        }
+      }
+      if (!allowTitle) return null;
+      return nonEmptyNotice(option?.getAttribute?.('title'));
+    };
+    const waitForDisabledNotice = async (option, priorIds) => {
+      const deadline = performance.now() + 400;
+      while (performance.now() < deadline) {
+        const notice = readDisabledNotice(option, priorIds, false);
+        if (notice) return notice;
+        await sleep(50);
+      }
+      // Only now may a static title speak: the association had its full window.
+      return readDisabledNotice(option, priorIds, true);
+    };
+    // Opening a tooltip stacks another Radix dismissable layer over the menu, and
+    // the topmost layer eats the Escape. One blind Escape therefore leaves the
+    // effort menu open, which matters for the non-strict caller that goes on to
+    // submit. Dismiss, let the layer unmount, and only Escape again while a menu is
+    // still there — never two unconditional Escapes, which could close an unrelated
+    // outer surface.
+    const closeMenusAfterTooltip = async () => {
+      closeOpenMenus();
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        await sleep(50);
+        if (!Array.from(document.querySelectorAll(MENU_CONTAINER_SELECTOR)).some(isVisible)) return;
+        closeOpenMenus();
+      }
+    };
     const selectAndVerify = async (trigger, findOption, modelKindOverride = null) => {
       const triggerModelKind =
         modelKindOverride ||
@@ -615,6 +761,22 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       if (!option) return failure('option-not-found', { modelKind: triggerModelKind });
       const label = option.textContent?.trim?.() || null;
+      if (isOptionDisabled(option)) {
+        // Captured BEFORE the hover: the ids already here describe the row for other
+        // reasons and cannot be this hover's reason.
+        const priorIds = new Set(describedIds(option));
+        dispatchHoverSequence(option);
+        const notice = await waitForDisabledNotice(option, priorIds);
+        const result = failure('option-disabled', {
+          // The label is page text that reaches logs and diagnostics, so it is
+          // redacted like every other reported string.
+          label: redactDiagnosticText(option.textContent, 80) || null,
+          notice,
+          modelKind: triggerModelKind,
+        });
+        await closeMenusAfterTooltip();
+        return result;
+      }
       if (optionIsSelected(option)) {
         closeOpenMenus();
         return { status: 'already-selected', label };
@@ -693,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));
@@ -796,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.
@@ -920,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");
+}