@steipete/oracle 0.18.0 → 0.20.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);
         }
     }
 }
@@ -181,6 +192,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
     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 ?? ""));
+    // Astra resolves the gpt-6-pro request to this exact model-picker alias. Keep
+    // this deliberately narrow: a generic unknown model must not claim its
+    // version-prefixed effort pill whose ownership we cannot establish.
+    const targetIsAstraLatestLiteral = JSON.stringify((desiredModel ?? "").trim().toLowerCase() === "latest");
     return `(async () => {
     ${buildClickDispatcher()}
 
@@ -190,13 +205,14 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const TARGET_LEVEL = ${targetLevelLiteral};
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
     const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
+    const TARGET_IS_ASTRA_LATEST = ${targetIsAstraLatestLiteral};
 
-    // 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
@@ -205,6 +221,29 @@ function buildThinkingTimeExpression(level, desiredModel) {
     // "Instant"/"Pro" would look like a tier list. Keep it to target matching only.
     const TARGET_LEVEL_TOKENS = { ...LEVEL_TOKENS, pro: ['pro'] };
     const targetTokens = TARGET_LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
+    const normalizeAstraLabel = (value) =>
+      String(value ?? '')
+        .normalize('NFC')
+        .toLowerCase()
+        .split(String.fromCharCode(9)).join(' ')
+        .split(String.fromCharCode(10)).join(' ')
+        .split(String.fromCharCode(13)).join(' ')
+        .split(String.fromCharCode(12)).join(' ')
+        .split(' ').filter(Boolean).join(' ');
+    const isAstraLatestEffortPill = (label) =>
+      TARGET_IS_ASTRA_LATEST &&
+      Object.values(TARGET_LEVEL_TOKENS).some((tokens) =>
+        tokens.some((token) => {
+          // Do not use the generic matcher here: ownership needs an exact
+          // version prefix plus a known localized tier, not token containment.
+          const tier = normalizeAstraLabel(token);
+          const observed = normalizeAstraLabel(label);
+          return observed === '6 ' + tier || observed === '6' + tier;
+        }),
+      );
+    const isSolModelPillForLatest = (label) =>
+      TARGET_IS_ASTRA_LATEST &&
+      ['5.6 pro', '5.6pro', '5 6 pro'].includes(normalizeAstraLabel(label));
 
     const INITIAL_WAIT_MS = 150;
     const STEP_WAIT_MS = 200;
@@ -215,7 +254,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 +265,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 +294,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 +883,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 +986,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.
@@ -961,6 +1090,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
           if (seen.has(button) || !isVisible(button)) continue;
           seen.add(button);
           if (button.getAttribute?.('data-testid') === 'model-switcher-dropdown-button') continue;
+          // A 5.6 Pro model pill is not Astra Latest's 6-prefixed effort owner.
+          // Keep this rejection ahead of the generic compatibility matcher.
+          if (isSolModelPillForLatest(button.textContent ?? '')) continue;
           const label = normalize(
             (button.getAttribute?.('aria-label') ?? '') + ' ' +
             (button.getAttribute?.('data-testid') ?? '') + ' ' +
@@ -970,6 +1102,11 @@ function buildThinkingTimeExpression(level, desiredModel) {
             (TARGET_MODEL_KIND === 'pro' && hasToken(label, 'pro') && !hasToken(label, 'thinking')) ||
             (TARGET_MODEL_KIND === 'thinking' && hasToken(label, 'thinking') && !hasToken(label, 'pro')) ||
             (!TARGET_MODEL_KIND && hasToken(label, 'thinking')) ||
+            // Astra Latest prefixes a supported effort label with "6" (for
+            // example, "6 Pro" or textContent-concatenated "6Pro"). This is
+            // recognized only for the exact Latest target; selection still
+            // requires the direct slider's leading label and numeric ARIA proof.
+            isAstraLatestEffortPill(button.textContent ?? '') ||
             (button.matches?.('button.__composer-pill') && matchesAnyEffortLevel(label))
           ) {
             return button;
@@ -1056,6 +1193,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
         tokens.some((token) => normalize(token) === pillLabel),
       );
       const pillNamesEffortNotModel =
+        TARGET_IS_ASTRA_LATEST ||
         TARGET_IS_GPT56_MODEL ||
         (pillIsBareEffortTier && Boolean(document.querySelector(INTELLIGENCE_MENU_SELECTOR)));
       const composerModelKind =
@@ -1069,6 +1207,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/actions/webSearch.js

@@ -0,0 +1,96 @@
+import { BrowserAutomationError } from "../../oracle/errors.js";
+import { INPUT_SELECTORS } from "../constants.js";
+import { delay } from "../utils.js";
+import { activateComposerPlus, captureComposerNavigationUrl, assertComposerPlusStayedInPlace, } from "./attachments.js";
+import { buildComposerNavigationValidationExpression } from "./attachmentContext.js";
+import { buildClickDispatcher } from "./domEvents.js";
+export function matchesWebSearchMenuLabel(value) {
+    return [
+        "search",
+        "searchfindontheweb",
+        "websearch",
+        "websearchfindreal-timenewsandinfo",
+    ].includes(value.replace(/\s+/g, "").toLowerCase());
+}
+export function buildWebSearchVerificationExpression(prompt) {
+    return `(() => {
+    const visible = node => node instanceof HTMLElement && node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0;
+    const editor = ${JSON.stringify(INPUT_SELECTORS)}.flatMap(selector => Array.from(document.querySelectorAll(selector))).find(visible);
+    if (!editor) return { selected: false, promptMatches: false };
+    const chip = editor.querySelector('[data-inline-selection-pill][data-id="search"][data-system-hint-type="search"]');
+    const copy = editor.cloneNode(true);
+    copy.querySelectorAll('[data-inline-selection-pill], [data-inline-selection-pill-cursor-target]').forEach(node => node.remove());
+    const readText = node => {
+      if (node.nodeType === 3) return node.textContent ?? '';
+      const text = Array.from(node.childNodes).map(readText).join('');
+      return text + (['P', 'DIV', 'BR', 'LI', 'PRE'].includes(node.nodeName) ? '\\n' : '');
+    };
+    const normalize = text => String(text ?? '').replace(/[\\u200b\\ufeff]/g, '').replace(/\\s+/g, ' ').trim();
+    return { selected: Boolean(chip && visible(chip)), promptMatches: normalize(readText(copy)) === normalize(${JSON.stringify(prompt)}) };
+  })()`;
+}
+export function buildWebSearchSelectionExpression(navigationUrl) {
+    return `(() => {
+    ${buildClickDispatcher()}
+    const matchesLabel = ${matchesWebSearchMenuLabel.toString()};
+    const navigation = ${buildComposerNavigationValidationExpression(navigationUrl)};
+    if (!navigation.contextMatches || navigation.workSelected || navigation.modeUnverified) return 'context-changed';
+    const visible = node => node instanceof HTMLElement && node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0;
+    const roots = Array.from(document.querySelectorAll('main .popover, [data-radix-popper-content-wrapper], [data-floating-ui-portal], [role="menu"], [role="listbox"]')).filter(visible);
+    const candidates = roots.flatMap(root => Array.from(root.querySelectorAll('[data-radix-collection-item], [role="menuitem"], [role="option"], .__menu-item, [class*="menu-item"]')));
+    const match = candidates.find(node => {
+      if (!visible(node) || node.hasAttribute('disabled') || node.getAttribute('aria-disabled') === 'true') return false;
+      return matchesLabel(node.textContent ?? '');
+    });
+    if (!match) return 'missing';
+    dispatchClickSequence(match);
+    return 'clicked';
+  })()`;
+}
+/** Web Search is an inline editor hint, so activate it after staging text/attachments. */
+export async function activateWebSearch(runtime, input, prompt, logger) {
+    const navigationUrl = await captureComposerNavigationUrl(runtime);
+    const verify = async () => {
+        const { result, exceptionDetails } = await runtime.evaluate({
+            expression: buildWebSearchVerificationExpression(prompt),
+            returnByValue: true,
+        });
+        if (exceptionDetails)
+            return false;
+        return result?.value?.selected === true && result?.value?.promptMatches === true;
+    };
+    if (await verify())
+        return;
+    const activated = await activateComposerPlus(runtime, input, navigationUrl);
+    if (activated.method === "unavailable")
+        throw new BrowserAutomationError("Web Search requires the ChatGPT composer tools menu.", {
+            stage: "web-search-activate",
+        });
+    const deadline = Date.now() + 5_000;
+    let clicked = false;
+    while (Date.now() < deadline) {
+        const outcome = await runtime.evaluate({
+            expression: buildWebSearchSelectionExpression(navigationUrl),
+            returnByValue: true,
+        });
+        if (outcome.result?.value === "clicked") {
+            clicked = true;
+            break;
+        }
+        if (outcome.exceptionDetails || outcome.result?.value !== "missing")
+            break;
+        await delay(100);
+    }
+    if (clicked) {
+        const confirmationDeadline = Date.now() + 3_000;
+        do {
+            await assertComposerPlusStayedInPlace(runtime, navigationUrl);
+            if (await verify()) {
+                logger("Web Search selected; inline search hint and staged prompt verified.");
+                return;
+            }
+            await delay(100);
+        } while (Date.now() < confirmationDeadline);
+    }
+    throw new BrowserAutomationError("Web Search selection could not be verified; the prompt was not submitted. This pilot supports the English ChatGPT Web search control.", { stage: "web-search-activate" });
+}

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");
+}