@steipete/oracle 0.8.1 → 0.8.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Peter Steinberger
+\g<1>2026 Peter Steinberger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -18,7 +18,7 @@ Oracle bundles your prompt and files so another AI can answer with real context.
 Install globally: `npm install -g @steipete/oracle`
 Homebrew: `brew install steipete/tap/oracle`
 
-Requires Node 22+. Prefer `npx -y @steipete/oracle …` (pnpx can be quirky with ESM caching).
+Requires Node 22+. Or use `npx -y @steipete/oracle …` (or pnpx).
 
 ```bash
 # Copy the bundle and paste into ChatGPT
@@ -149,7 +149,7 @@ Advanced flags
 
 | Area | Flags |
 | --- | --- |
-| Browser | `--browser-manual-login`, `--browser-thinking-time`, `--browser-timeout`, `--browser-input-timeout`, `--browser-inline-cookies[(-file)]`, `--browser-attachments`, `--browser-inline-files`, `--browser-bundle-files`, `--browser-keep-browser`, `--browser-headless`, `--browser-hide-window`, `--browser-no-cookie-sync`, `--browser-allow-cookie-errors`, `--browser-chrome-path`, `--browser-cookie-path`, `--chatgpt-url` |
+| Browser | `--browser-manual-login`, `--browser-thinking-time`, `--browser-timeout`, `--browser-input-timeout`, `--browser-cookie-wait`, `--browser-inline-cookies[(-file)]`, `--browser-attachments`, `--browser-inline-files`, `--browser-bundle-files`, `--browser-keep-browser`, `--browser-headless`, `--browser-hide-window`, `--browser-no-cookie-sync`, `--browser-allow-cookie-errors`, `--browser-chrome-path`, `--browser-cookie-path`, `--chatgpt-url` |
 | Azure/OpenAI | `--azure-endpoint`, `--azure-deployment`, `--azure-api-version`, `--base-url` |
 
 Remote browser example

package/dist/bin/oracle-cli.js

@@ -163,6 +163,7 @@ program
     .addOption(new Option('--browser-url <url>', `Alias for --chatgpt-url (default ${CHATGPT_URL}).`).hideHelp())
     .addOption(new Option('--browser-timeout <ms|s|m>', 'Maximum time to wait for an answer (default 1200s / 20m).').hideHelp())
     .addOption(new Option('--browser-input-timeout <ms|s|m>', 'Maximum time to wait for the prompt textarea (default 30s).').hideHelp())
+    .addOption(new Option('--browser-cookie-wait <ms|s|m>', 'Wait before retrying cookie sync when Chrome cookies are empty or locked.').hideHelp())
     .addOption(new Option('--browser-port <port>', 'Use a fixed Chrome DevTools port (helpful on WSL firewalls).')
     .argParser(parseIntOption))
     .addOption(new Option('--browser-debug-port <port>', '(alias) Use a fixed Chrome DevTools port.').argParser(parseIntOption).hideHelp())
@@ -926,6 +927,7 @@ function printDebugHelp(cliName) {
         ['--browser-url <url>', 'Alias for --chatgpt-url.'],
         ['--browser-timeout <ms|s|m>', 'Cap total wait time for the assistant response.'],
         ['--browser-input-timeout <ms|s|m>', 'Cap how long we wait for the composer textarea.'],
+        ['--browser-cookie-wait <ms|s|m>', 'Wait before retrying cookie sync when Chrome cookies are empty or locked.'],
         ['--browser-no-cookie-sync', 'Skip copying cookies from your main profile.'],
         ['--browser-manual-login', 'Skip cookie copy; reuse a persistent automation profile and log in manually.'],
         ['--browser-headless', 'Launch Chrome in headless mode.'],

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

@@ -4,7 +4,7 @@ import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 import { transferAttachmentViaDataTransfer } from './attachmentDataTransfer.js';
 export async function uploadAttachmentFile(deps, attachment, logger, options) {
-    const { runtime, dom } = deps;
+    const { runtime, dom, input } = deps;
     if (!dom) {
         throw new Error('DOM domain unavailable while uploading attachments.');
     }
@@ -170,7 +170,7 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
           });
         });
 
-        const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+        const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
         const collectFileCount = (candidates) => {
           let count = 0;
           for (const node of candidates) {
@@ -204,7 +204,8 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
             let hasFileHint = false;
             for (const raw of values) {
               if (!raw) continue;
-              if (normalize(raw).includes('file')) {
+              const normalized = normalize(raw);
+              if (normalized.includes('file') || normalized.includes('attachment')) {
                 hasFileHint = true;
                 break;
               }
@@ -273,43 +274,70 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
         };
     };
     // New ChatGPT UI hides the real file input behind a composer "+" menu; click it pre-emptively.
-    await Promise.resolve(runtime.evaluate({
-        expression: `(() => {
-        const selectors = [
-          '#composer-plus-btn',
-          'button[data-testid="composer-plus-btn"]',
-          '[data-testid*="plus"]',
-          'button[aria-label*="add"]',
-          'button[aria-label*="attachment"]',
-          'button[aria-label*="file"]',
-        ];
-        for (const selector of selectors) {
-          const el = document.querySelector(selector);
-          if (el instanceof HTMLElement) {
-            el.click();
-            return true;
+    // Learned: synthetic `.click()` is sometimes ignored (isTrusted checks). Prefer a CDP mouse click when possible.
+    const clickPlusTrusted = async () => {
+        if (!input || typeof input.dispatchMouseEvent !== 'function')
+            return false;
+        const locate = await runtime
+            .evaluate({
+            expression: `(() => {
+          const selectors = [
+            '#composer-plus-btn',
+            'button[data-testid="composer-plus-btn"]',
+            '[data-testid*="plus"]',
+            'button[aria-label*="add"]',
+            'button[aria-label*="attachment"]',
+            'button[aria-label*="file"]',
+          ];
+          for (const selector of selectors) {
+            const el = document.querySelector(selector);
+            if (!(el instanceof HTMLElement)) continue;
+            const rect = el.getBoundingClientRect();
+            if (rect.width <= 0 || rect.height <= 0) continue;
+            el.scrollIntoView({ block: 'center', inline: 'center' });
+            const nextRect = el.getBoundingClientRect();
+            return { ok: true, x: nextRect.left + nextRect.width / 2, y: nextRect.top + nextRect.height / 2 };
           }
-        }
-        return false;
-      })()`,
-        returnByValue: true,
-    })).catch(() => undefined);
-    await delay(250);
-    // Helper to click the upload menu item (if present) to reveal the real attachment input.
-    await Promise.resolve(runtime.evaluate({
-        expression: `(() => {
-        const menuItems = Array.from(document.querySelectorAll('[data-testid*="upload"],[data-testid*="attachment"], [role="menuitem"], [data-radix-collection-item]'));
-        for (const el of menuItems) {
-          const text = (el.textContent || '').toLowerCase();
-          const tid = el.getAttribute?.('data-testid')?.toLowerCase?.() || '';
-          if (tid.includes('upload') || tid.includes('attachment') || text.includes('upload') || text.includes('file')) {
-            if (el instanceof HTMLElement) { el.click(); return true; }
+          return { ok: false };
+        })()`,
+            returnByValue: true,
+        })
+            .then((res) => res?.result?.value)
+            .catch(() => undefined);
+        if (!locate?.ok || typeof locate.x !== 'number' || typeof locate.y !== 'number')
+            return false;
+        const x = locate.x;
+        const y = locate.y;
+        await input.dispatchMouseEvent({ type: 'mouseMoved', x, y });
+        await input.dispatchMouseEvent({ type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+        await input.dispatchMouseEvent({ type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+        return true;
+    };
+    const clickedTrusted = await clickPlusTrusted().catch(() => false);
+    if (!clickedTrusted) {
+        await Promise.resolve(runtime.evaluate({
+            expression: `(() => {
+          const selectors = [
+            '#composer-plus-btn',
+            'button[data-testid="composer-plus-btn"]',
+            '[data-testid*="plus"]',
+            'button[aria-label*="add"]',
+            'button[aria-label*="attachment"]',
+            'button[aria-label*="file"]',
+          ];
+          for (const selector of selectors) {
+            const el = document.querySelector(selector);
+            if (el instanceof HTMLElement) {
+              el.click();
+              return true;
+            }
           }
-        }
-        return false;
-      })()`,
-        returnByValue: true,
-    })).catch(() => undefined);
+          return false;
+        })()`,
+            returnByValue: true,
+        })).catch(() => undefined);
+    }
+    await delay(350);
     const normalizeForMatch = (value) => String(value || '')
         .toLowerCase()
         .replace(/\s+/g, ' ')
@@ -461,7 +489,7 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
           return /\\buploading\\b/.test(text) || /\\bprocessing\\b/.test(text);
         });
       });
-      const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+      const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
       const collectFileCount = (candidates) => {
         let count = 0;
         for (const node of candidates) {
@@ -495,7 +523,8 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
           let hasFileHint = false;
           for (const raw of values) {
             if (!raw) continue;
-            if (String(raw).toLowerCase().includes('file')) {
+            const lowered = String(raw).toLowerCase();
+            if (lowered.includes('file') || lowered.includes('attachment')) {
               hasFileHint = true;
               break;
             }
@@ -537,17 +566,28 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
       }
 
       // Mark candidates with stable indices so we can select them via DOM.querySelector.
+      // Learned: ChatGPT sometimes renders a zero-sized file input that does *not* trigger uploads;
+      // keep it as a fallback, but strongly prefer visible (even sr-only 1x1) inputs.
+      const localSet = new Set(localInputs);
       let idx = 0;
       let candidates = inputs.map((el) => {
         const accept = el.getAttribute('accept') || '';
         const imageOnly = acceptIsImageOnly(accept);
+        const rect = el instanceof HTMLElement ? el.getBoundingClientRect() : { width: 0, height: 0 };
+        const visible = rect.width > 0 && rect.height > 0;
+        const local = localSet.has(el);
         const score =
           (el.hasAttribute('multiple') ? 100 : 0) +
-          (!imageOnly ? 20 : isImageAttachment ? 15 : -500);
+          (local ? 40 : 0) +
+          (visible ? 30 : -200) +
+          (!imageOnly ? 30 : isImageAttachment ? 20 : 5);
         el.setAttribute('data-oracle-upload-candidate', 'true');
         el.setAttribute('data-oracle-upload-idx', String(idx));
         return { idx: idx++, score, imageOnly };
       });
+
+      // When the attachment isn't an image, avoid inputs that only accept images.
+      // Some ChatGPT surfaces expose multiple file inputs (e.g. image-only vs generic upload).
       if (!isImageAttachment) {
         const nonImage = candidates.filter((candidate) => !candidate.imageOnly);
         if (nonImage.length > 0) {
@@ -798,8 +838,8 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
                 continue;
             }
             const baselineInputSnapshot = await readInputSnapshot(idx);
-            const gatherSignals = async () => {
-                const signalResult = await waitForAttachmentUiSignal(attachmentUiSignalWaitMs);
+            const gatherSignals = async (waitMs = attachmentUiSignalWaitMs) => {
+                const signalResult = await waitForAttachmentUiSignal(waitMs);
                 const postInputSnapshot = await readInputSnapshot(idx);
                 const postInputSignals = inputSignalsFor(baselineInputSnapshot, postInputSnapshot);
                 const snapshot = await runtime
@@ -822,25 +862,25 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
             const evaluateSignals = async (signalResult, postInputSignals, immediateInputMatch) => {
                 const expectedSatisfied = Boolean(signalResult?.expectedSatisfied) ||
                     (signalResult?.signals ? isExpectedSatisfied(signalResult.signals) : false);
-                const uiAcknowledged = Boolean(signalResult?.signals?.ui) ||
-                    Boolean(signalResult?.chipDelta) ||
-                    Boolean(signalResult?.uploadDelta) ||
-                    Boolean(signalResult?.fileCountDelta) ||
-                    expectedSatisfied;
-                if (uiAcknowledged) {
+                const inputNameCandidates = resolveInputNameCandidates();
+                const inputHasFile = inputNameCandidates.some((name) => matchesExpectedName(name)) ||
+                    (lastInputValue && matchesExpectedName(lastInputValue));
+                const inputEvidence = immediateInputMatch ||
+                    postInputSignals.touched ||
+                    Boolean(signalResult?.signals?.input) ||
+                    Boolean(signalResult?.inputDelta) ||
+                    inputHasFile;
+                const uiDirect = Boolean(signalResult?.signals?.ui) || expectedSatisfied;
+                const uiDelta = Boolean(signalResult?.chipDelta) || Boolean(signalResult?.uploadDelta) || Boolean(signalResult?.fileCountDelta);
+                if (uiDirect || (uiDelta && inputEvidence)) {
                     return { status: 'ui' };
                 }
                 const postSignals = await readAttachmentSignals(expectedName);
                 if (postSignals.ui ||
                     isExpectedSatisfied(postSignals) ||
-                    hasChipDelta(postSignals) ||
-                    hasUploadDelta(postSignals) ||
-                    hasFileCountDelta(postSignals)) {
+                    ((hasChipDelta(postSignals) || hasUploadDelta(postSignals) || hasFileCountDelta(postSignals)) && inputEvidence)) {
                     return { status: 'ui' };
                 }
-                const inputNameCandidates = resolveInputNameCandidates();
-                const inputHasFile = inputNameCandidates.some((name) => matchesExpectedName(name)) ||
-                    (lastInputValue && matchesExpectedName(lastInputValue));
                 const inputSignal = immediateInputMatch ||
                     postInputSignals.touched ||
                     Boolean(signalResult?.signals?.input) ||
@@ -883,15 +923,56 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
                 const evaluation = await evaluateSignals(signalState.signalResult, signalState.postInputSignals, immediateInputMatch);
                 return { evaluation, signalState, immediateInputMatch };
             };
+            const dispatchInputEvents = async () => {
+                await runtime
+                    .evaluate({
+                    expression: `(() => {
+              const input = document.querySelector('input[type="file"][data-oracle-upload-idx="${idx}"]');
+              if (!(input instanceof HTMLInputElement)) return false;
+              try {
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                input.dispatchEvent(new Event('change', { bubbles: true }));
+                return true;
+              } catch {
+                return false;
+              }
+            })()`,
+                    returnByValue: true,
+                })
+                    .catch(() => undefined);
+            };
             let result = await runInputAttempt('set');
             if (result.evaluation.status === 'ui') {
                 confirmedAttachment = true;
                 break;
             }
             if (result.evaluation.status === 'input') {
-                logger('Attachment input set; proceeding without UI confirmation.');
-                inputConfirmed = true;
-                break;
+                await dispatchInputEvents();
+                await delay(150);
+                const forcedState = await gatherSignals(1_500);
+                const forcedEvaluation = await evaluateSignals(forcedState.signalResult, forcedState.postInputSignals, result.immediateInputMatch);
+                if (forcedEvaluation.status === 'ui') {
+                    confirmedAttachment = true;
+                    break;
+                }
+                if (forcedEvaluation.status === 'input') {
+                    logger('Attachment input set; proceeding without UI confirmation.');
+                    inputConfirmed = true;
+                    break;
+                }
+                logger('Attachment input set; retrying with data transfer to trigger ChatGPT upload.');
+                await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [] }).catch(() => undefined);
+                await delay(150);
+                result = await runInputAttempt('transfer');
+                if (result.evaluation.status === 'ui') {
+                    confirmedAttachment = true;
+                    break;
+                }
+                if (result.evaluation.status === 'input') {
+                    logger('Attachment input set; proceeding without UI confirmation.');
+                    inputConfirmed = true;
+                    break;
+                }
             }
             const lateSignals = await readAttachmentSignals(expectedName);
             if (lateSignals.ui ||
@@ -1007,12 +1088,12 @@ export async function clearComposerAttachments(Runtime, timeoutMs, logger) {
       return parentHasSend ? parent : root;
     })();
     const removeSelectors = [
-      '[aria-label*="Remove"]',
-      '[aria-label*="remove"]',
-      'button[aria-label*="Remove"]',
-      'button[aria-label*="remove"]',
-      '[data-testid*="remove"]',
-      '[data-testid*="delete"]',
+      '[aria-label="Remove file"]',
+      'button[aria-label="Remove file"]',
+      '[aria-label*="Remove file"]',
+      '[aria-label*="remove file"]',
+      '[data-testid*="remove-attachment"]',
+      '[data-testid*="attachment-remove"]',
     ];
     const visible = (el) => {
       if (!(el instanceof HTMLElement)) return false;
@@ -1023,10 +1104,15 @@ export async function clearComposerAttachments(Runtime, timeoutMs, logger) {
       ? Array.from(scope.querySelectorAll(removeSelectors.join(','))).filter(visible)
       : [];
     for (const button of removeButtons.slice(0, 20)) {
-      try { button.click(); } catch {}
+      try {
+        if (button instanceof HTMLButtonElement) {
+          // Ensure remove buttons never submit the composer form.
+          button.type = 'button';
+        }
+        button.click();
+      } catch {}
     }
-    const chipSelector = '[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[aria-label*="Remove"],[aria-label*="remove"]';
-    const chipCount = scope ? scope.querySelectorAll(chipSelector).length : 0;
+    const chipCount = removeButtons.length;
     const inputs = scope ? Array.from(scope.querySelectorAll('input[type="file"]')) : [];
     let inputCount = 0;
     for (const input of inputs) {
@@ -1189,7 +1275,7 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
         if (file?.name) inputNames.push(file.name.toLowerCase());
       }
     }
-    const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+    const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
     const fileCountSelectors = [
       'button',
       '[role="button"]',
@@ -1235,7 +1321,8 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
         let hasFileHint = false;
         for (const raw of candidates) {
           if (!raw) continue;
-          if (String(raw).toLowerCase().includes('file')) {
+          const lowered = String(raw).toLowerCase();
+          if (lowered.includes('file') || lowered.includes('attachment')) {
             hasFileHint = true;
             break;
           }
@@ -1340,9 +1427,8 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
                 if (stable && value.state === 'ready') {
                     return;
                 }
-                if (stable && value.state === 'disabled' && !value.uploading) {
-                    return;
-                }
+                // Don't treat disabled button as complete - wait for it to become 'ready'.
+                // The spinner detection is unreliable, so a disabled button likely means upload is in progress.
                 if (value.state === 'missing' && (value.filesAttached || fileCountSatisfied)) {
                     return;
                 }
@@ -1363,16 +1449,18 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
                 const expectedNoExt = normalizedExpected.replace(/\.[a-z0-9]{1,10}$/i, '');
                 return !inputNames.some((raw) => raw.includes(normalizedExpected) || (expectedNoExt.length >= 6 && raw.includes(expectedNoExt)));
             });
-            const inputStateOk = value.state === 'ready' || value.state === 'missing' || value.state === 'disabled';
+            // Don't include 'disabled' - a disabled button likely means upload is still in progress.
+            const inputStateOk = value.state === 'ready' || value.state === 'missing';
             const inputSeenNow = inputMissing.length === 0 || fileCountSatisfied;
+            const inputEvidenceOk = Boolean(value.filesAttached) || Boolean(value.uploading) || fileCountSatisfied;
             const stableThresholdMs = value.uploading ? 3000 : 1500;
-            if (inputSeenNow && inputStateOk) {
+            if (inputSeenNow && inputStateOk && inputEvidenceOk) {
                 if (inputMatchSince === null) {
                     inputMatchSince = Date.now();
                 }
                 sawInputMatch = true;
             }
-            if (inputMatchSince !== null && inputStateOk && Date.now() - inputMatchSince > stableThresholdMs) {
+            if (inputMatchSince !== null && inputStateOk && inputEvidenceOk && Date.now() - inputMatchSince > stableThresholdMs) {
                 return;
             }
             if (!inputSeenNow && !sawInputMatch) {
@@ -1416,10 +1504,10 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
       '[title*="file"]',
       '[title*="attachment"]',
     ];
+    const attachmentUiCount = lastUser.querySelectorAll(attachmentSelectors.join(',')).length;
     const hasAttachmentUi =
-      lastUser.querySelectorAll(attachmentSelectors.join(',')).length > 0 ||
-      attrs.some((attr) => attr.includes('file') || attr.includes('attachment'));
-    const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+      attachmentUiCount > 0 || attrs.some((attr) => attr.includes('file') || attr.includes('attachment'));
+    const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
     const fileCountNodes = Array.from(lastUser.querySelectorAll('button,span,div,[aria-label],[title]'));
     let fileCount = 0;
     for (const node of fileCountNodes) {
@@ -1435,7 +1523,8 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
       let hasFileHint = false;
       for (const raw of candidates) {
         if (!raw) continue;
-        if (String(raw).toLowerCase().includes('file')) {
+        const lowered = String(raw).toLowerCase();
+        if (lowered.includes('file') || lowered.includes('attachment')) {
           hasFileHint = true;
           break;
         }
@@ -1452,7 +1541,7 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
         }
       }
     }
-    return { ok: true, text, attrs, fileCount, hasAttachmentUi };
+    return { ok: true, text, attrs, fileCount, hasAttachmentUi, attachmentUiCount };
   })()`;
     const deadline = Date.now() + timeoutMs;
     let sawAttachmentUi = false;
@@ -1468,7 +1557,9 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
         }
         const haystack = [value.text ?? '', ...(value.attrs ?? [])].join('\n');
         const fileCount = typeof value.fileCount === 'number' ? value.fileCount : 0;
+        const attachmentUiCount = typeof value.attachmentUiCount === 'number' ? value.attachmentUiCount : 0;
         const fileCountSatisfied = fileCount >= expectedNormalized.length && expectedNormalized.length > 0;
+        const attachmentUiSatisfied = attachmentUiCount >= expectedNormalized.length && expectedNormalized.length > 0;
         const missing = expectedNormalized.filter((expected) => {
             const baseName = expected.split('/').pop()?.split('\\').pop() ?? expected;
             const normalizedExpected = baseName.toLowerCase().replace(/\s+/g, ' ').trim();
@@ -1479,7 +1570,7 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
                 return false;
             return true;
         });
-        if (missing.length === 0 || fileCountSatisfied) {
+        if (missing.length === 0 || fileCountSatisfied || attachmentUiSatisfied) {
             return true;
         }
         await delay(250);
@@ -1500,6 +1591,12 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
     const expected = ${JSON.stringify(expectedName)};
     const normalized = expected.toLowerCase();
     const normalizedNoExt = normalized.replace(/\\.[a-z0-9]{1,10}$/i, '');
+    const matchesExpectedFileName = (value) => {
+      const text = String(value || '').toLowerCase();
+      if (!text) return false;
+      if (text.includes(normalized)) return true;
+      return normalizedNoExt.length >= 6 && text.includes(normalizedNoExt);
+    };
     const matchNode = (node) => {
       if (!node) return false;
       if (node.tagName === 'INPUT' && node.type === 'file') return false;
@@ -1512,39 +1609,96 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
       return candidates.some((value) => value.includes(normalized) || (normalizedNoExt.length >= 6 && value.includes(normalizedNoExt)));
     };
 
-    const attachmentSelectors = ['[data-testid*="attachment"]','[data-testid*="chip"]','[data-testid*="upload"]','[data-testid*="file"]'];
-    const attachmentMatch = attachmentSelectors.some((selector) =>
-      Array.from(document.querySelectorAll(selector)).some(matchNode),
+    const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
+    for (const input of inputs) {
+      if (!(input instanceof HTMLInputElement)) continue;
+      const files = Array.from(input.files || []);
+      if (files.some((file) => matchesExpectedFileName(file?.name))) {
+        return { found: true, source: 'file-input' };
+      }
+    }
+
+    const promptSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+    const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+    const findPromptNode = () => {
+      for (const selector of promptSelectors) {
+        const nodes = Array.from(document.querySelectorAll(selector));
+        for (const node of nodes) {
+          if (!(node instanceof HTMLElement)) continue;
+          const rect = node.getBoundingClientRect();
+          if (rect.width > 0 && rect.height > 0) return node;
+        }
+      }
+      for (const selector of promptSelectors) {
+        const node = document.querySelector(selector);
+        if (node) return node;
+      }
+      return null;
+    };
+    const attachmentSelectors = [
+      'input[type="file"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="chip"]',
+      '[data-testid*="upload"]',
+      '[data-testid*="file"]',
+      '[aria-label*="Remove"]',
+      '[aria-label*="remove"]',
+    ];
+    const locateComposerRoot = () => {
+      const promptNode = findPromptNode();
+      if (promptNode) {
+        const initial =
+          promptNode.closest('[data-testid*="composer"]') ??
+          promptNode.closest('form') ??
+          promptNode.parentElement ??
+          document.body;
+        let current = initial;
+        let fallback = initial;
+        while (current && current !== document.body) {
+          const hasSend = sendSelectors.some((selector) => current.querySelector(selector));
+          if (hasSend) {
+            fallback = current;
+            const hasAttachment = attachmentSelectors.some((selector) => current.querySelector(selector));
+            if (hasAttachment) return current;
+          }
+          current = current.parentElement;
+        }
+        return fallback ?? initial;
+      }
+      return document.querySelector('form') ?? document.body;
+    };
+    const composerRoot = locateComposerRoot() ?? document.body;
+
+    const attachmentMatch = ['[data-testid*="attachment"]','[data-testid*="chip"]','[data-testid*="upload"]','[data-testid*="file"]'].some((selector) =>
+      Array.from(composerRoot.querySelectorAll(selector)).some(matchNode),
     );
     if (attachmentMatch) {
       return { found: true, source: 'attachments' };
     }
 
-    const cardTexts = Array.from(document.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
+    const removeButtons = Array.from(
+      (composerRoot ?? document).querySelectorAll('[aria-label*="Remove"],[aria-label*="remove"]'),
+    );
+    const visibleRemove = removeButtons.some((btn) => {
+      if (!(btn instanceof HTMLElement)) return false;
+      const rect = btn.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(btn);
+      return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
+    });
+    if (visibleRemove) {
+      return { found: true, source: 'remove-button' };
+    }
+
+    const cardTexts = Array.from(composerRoot.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
       btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
     );
     if (cardTexts.some((text) => text.includes(normalized) || (normalizedNoExt.length >= 6 && text.includes(normalizedNoExt)))) {
       return { found: true, source: 'attachment-cards' };
     }
 
-    const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
-    const fileCountNodes = (() => {
-      const nodes = [];
-      const seen = new Set();
-      const add = (node) => {
-        if (!node || seen.has(node)) return;
-        seen.add(node);
-        nodes.push(node);
-      };
-      const root =
-        document.querySelector('[data-testid*="composer"]') || document.querySelector('form') || document.body;
-      const localNodes = root ? Array.from(root.querySelectorAll('button,span,div,[aria-label],[title]')) : [];
-      for (const node of localNodes) add(node);
-      for (const node of Array.from(document.querySelectorAll('button,span,div,[aria-label],[title]'))) {
-        add(node);
-      }
-      return nodes;
-    })();
+    const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
+    const fileCountNodes = Array.from(composerRoot.querySelectorAll('button,span,div,[aria-label],[title]'));
     let fileCount = 0;
     for (const node of fileCountNodes) {
       if (!(node instanceof HTMLElement)) continue;
@@ -1577,7 +1731,8 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
       let hasFileHint = false;
       for (const raw of candidates) {
         if (!raw) continue;
-        if (String(raw).toLowerCase().includes('file')) {
+        const lowered = String(raw).toLowerCase();
+        if (lowered.includes('file') || lowered.includes('attachment')) {
           hasFileHint = true;
           break;
         }
@@ -1635,12 +1790,24 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
       return false;
     };
 
+    const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
+    for (const input of inputs) {
+      if (!(input instanceof HTMLInputElement)) continue;
+      for (const file of Array.from(input.files || [])) {
+        if (file?.name && matchesExpected(file.name)) {
+          return { found: true, text: 'file-input' };
+        }
+      }
+    }
+
     const selectors = [
       '[data-testid*="attachment"]',
       '[data-testid*="chip"]',
       '[data-testid*="upload"]',
       '[aria-label*="Remove"]',
       'button[aria-label*="Remove"]',
+      '[aria-label*="remove"]',
+      'button[aria-label*="remove"]',
     ];
     for (const selector of selectors) {
       for (const node of Array.from(document.querySelectorAll(selector))) {
@@ -1659,7 +1826,7 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
     if (cards.some(matchesExpected)) {
       return { found: true, text: cards.find(matchesExpected) };
     }
-    const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+    const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
     const fileCountNodes = (() => {
       const nodes = [];
       const seen = new Set();
@@ -1709,7 +1876,8 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
       let hasFileHint = false;
       for (const raw of candidates) {
         if (!raw) continue;
-        if (String(raw).toLowerCase().includes('file')) {
+        const lowered = String(raw).toLowerCase();
+        if (lowered.includes('file') || lowered.includes('attachment')) {
           hasFileHint = true;
           break;
         }

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

@@ -1,11 +1,126 @@
 import { CLOUDFLARE_SCRIPT_SELECTOR, CLOUDFLARE_TITLE, INPUT_SELECTORS, } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
+export function installJavaScriptDialogAutoDismissal(Page, logger) {
+    const pageAny = Page;
+    if (typeof pageAny.on !== 'function' || typeof pageAny.handleJavaScriptDialog !== 'function') {
+        return () => { };
+    }
+    const handler = async (params) => {
+        const type = typeof params?.type === 'string' ? params.type : 'unknown';
+        const message = typeof params?.message === 'string' ? params.message : '';
+        logger(`[nav] dismissing JS dialog (${type})${message ? `: ${message.slice(0, 140)}` : ''}`);
+        try {
+            await pageAny.handleJavaScriptDialog?.({ accept: true, promptText: '' });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger(`[nav] failed to dismiss JS dialog: ${msg}`);
+        }
+    };
+    pageAny.on('javascriptDialogOpening', handler);
+    return () => {
+        try {
+            pageAny.off?.('javascriptDialogOpening', handler);
+        }
+        catch {
+            try {
+                pageAny.removeListener?.('javascriptDialogOpening', handler);
+            }
+            catch {
+                // ignore
+            }
+        }
+    };
+}
 export async function navigateToChatGPT(Page, Runtime, url, logger) {
     logger(`Navigating to ${url}`);
     await Page.navigate({ url });
     await waitForDocumentReady(Runtime, 45_000);
 }
+async function dismissBlockingUi(Runtime, logger) {
+    const outcome = await Runtime.evaluate({
+        expression: `(() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const rect = el.getBoundingClientRect();
+        if (rect.width <= 0 || rect.height <= 0) return false;
+        const style = window.getComputedStyle(el);
+        if (!style) return false;
+        if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+        return true;
+      };
+      const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+      const labelFor = (el) => normalize(el?.textContent || el?.getAttribute?.('aria-label') || el?.getAttribute?.('title'));
+      const buttonCandidates = (root) =>
+        Array.from(root.querySelectorAll('button,[role="button"],a')).filter((el) => isVisible(el));
+
+      const roots = [
+        ...Array.from(document.querySelectorAll('[role="dialog"],dialog')),
+        document.body,
+      ].filter(Boolean);
+      for (const root of roots) {
+        const buttons = buttonCandidates(root);
+        const close = buttons.find((el) => labelFor(el).includes('close'));
+        if (close) {
+          (close).click();
+          return { dismissed: true, action: 'close' };
+        }
+        const okLike = buttons.find((el) => {
+          const label = labelFor(el);
+          return (
+            label === 'ok' ||
+            label === 'got it' ||
+            label === 'dismiss' ||
+            label === 'continue' ||
+            label === 'back' ||
+            label.includes('back to chatgpt') ||
+            label.includes('go to chatgpt') ||
+            label.includes('return') ||
+            label.includes('take me')
+          );
+        });
+        if (okLike) {
+          (okLike).click();
+          return { dismissed: true, action: 'confirm' };
+        }
+      }
+      return { dismissed: false };
+    })()`,
+        returnByValue: true,
+    }).catch(() => null);
+    const value = outcome?.result?.value;
+    if (value?.dismissed) {
+        logger(`[nav] dismissed blocking UI (${value.action ?? 'unknown'})`);
+        return true;
+    }
+    return false;
+}
+export async function navigateToPromptReadyWithFallback(Page, Runtime, options, deps = {}) {
+    const { url, fallbackUrl, timeoutMs, fallbackTimeoutMs, headless, logger, } = options;
+    const navigate = deps.navigateToChatGPT ?? navigateToChatGPT;
+    const ensureBlocked = deps.ensureNotBlocked ?? ensureNotBlocked;
+    const ensureReady = deps.ensurePromptReady ?? ensurePromptReady;
+    await navigate(Page, Runtime, url, logger);
+    await ensureBlocked(Runtime, headless, logger);
+    await dismissBlockingUi(Runtime, logger).catch(() => false);
+    try {
+        await ensureReady(Runtime, timeoutMs, logger);
+        return { usedFallback: false };
+    }
+    catch (error) {
+        if (!fallbackUrl || fallbackUrl === url) {
+            throw error;
+        }
+        const fallbackTimeout = fallbackTimeoutMs ?? Math.max(timeoutMs * 2, 120_000);
+        logger(`Prompt not ready after ${Math.round(timeoutMs / 1000)}s on ${url}; retrying ${fallbackUrl} with ${Math.round(fallbackTimeout / 1000)}s timeout.`);
+        await navigate(Page, Runtime, fallbackUrl, logger);
+        await ensureBlocked(Runtime, headless, logger);
+        await dismissBlockingUi(Runtime, logger).catch(() => false);
+        await ensureReady(Runtime, fallbackTimeout, logger);
+        return { usedFallback: true };
+    }
+}
 export async function ensureNotBlocked(Runtime, headless, logger) {
     if (await isCloudflareInterstitial(Runtime)) {
         const message = headless

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

@@ -110,6 +110,8 @@ function buildThinkingTimeExpression(level) {
       for (const selector of CHIP_SELECTORS) {
         const buttons = document.querySelectorAll(selector);
         for (const btn of buttons) {
+          // Skip toggle buttons (no haspopup) - only click dropdown triggers to avoid disabling Pro mode
+          if (btn.getAttribute?.('aria-haspopup') !== 'menu') continue;
           const aria = normalize(btn.getAttribute?.('aria-label') ?? '');
           const text = normalize(btn.textContent ?? '');
           if (aria.includes('thinking') || text.includes('thinking')) {

package/dist/src/browser/chromeLifecycle.js

@@ -172,6 +172,8 @@ function buildChromeFlags(headless, debugBindAddress) {
         '--disable-features=TranslateUI,AutomationControlled',
         '--mute-audio',
         '--window-size=1280,720',
+        '--lang=en-US',
+        '--accept-lang=en-US,en',
     ];
     if (process.platform !== 'win32' && !isWsl()) {
         flags.push('--password-store=basic', '--use-mock-keychain');

package/dist/src/browser/config.js

@@ -14,6 +14,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     inputTimeoutMs: 60_000,
     cookieSync: true,
     cookieNames: null,
+    cookieSyncWaitMs: 0,
     inlineCookies: null,
     inlineCookiesSource: null,
     headless: false,
@@ -58,6 +59,7 @@ export function resolveBrowserConfig(config) {
         inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
         cookieSync: config?.cookieSync ?? cookieSyncDefault,
         cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
+        cookieSyncWaitMs: config?.cookieSyncWaitMs ?? DEFAULT_BROWSER_CONFIG.cookieSyncWaitMs,
         inlineCookies: config?.inlineCookies ?? DEFAULT_BROWSER_CONFIG.inlineCookies,
         inlineCookiesSource: config?.inlineCookiesSource ?? DEFAULT_BROWSER_CONFIG.inlineCookiesSource,
         headless: config?.headless ?? DEFAULT_BROWSER_CONFIG.headless,

package/dist/src/browser/cookies.js

@@ -1,14 +1,15 @@
 import { COOKIE_URLS } from './constants.js';
+import { delay } from './utils.js';
 import { getCookies } from '@steipete/sweet-cookie';
 export class ChromeCookieSyncError extends Error {
 }
 export async function syncCookies(Network, url, profile, logger, options = {}) {
-    const { allowErrors = false, filterNames, inlineCookies, cookiePath } = options;
+    const { allowErrors = false, filterNames, inlineCookies, cookiePath, waitMs = 0 } = options;
     try {
         // Learned: inline cookies are the most deterministic (avoid Keychain + profile ambiguity).
         const cookies = inlineCookies?.length
             ? normalizeInlineCookies(inlineCookies, new URL(url).hostname)
-            : await readChromeCookies(url, profile, filterNames ?? undefined, cookiePath ?? undefined);
+            : await readChromeCookiesWithWait(url, profile, filterNames ?? undefined, cookiePath ?? undefined, waitMs, logger);
         if (!cookies.length) {
             return 0;
         }
@@ -38,6 +39,32 @@ export async function syncCookies(Network, url, profile, logger, options = {}) {
         throw error instanceof ChromeCookieSyncError ? error : new ChromeCookieSyncError(message);
     }
 }
+async function readChromeCookiesWithWait(url, profile, filterNames, cookiePath, waitMs, logger) {
+    if (waitMs <= 0) {
+        return readChromeCookies(url, profile, filterNames, cookiePath);
+    }
+    let cookies = [];
+    let firstError;
+    try {
+        cookies = await readChromeCookies(url, profile, filterNames, cookiePath);
+    }
+    catch (error) {
+        firstError = error;
+    }
+    if (cookies.length > 0 && !firstError) {
+        return cookies;
+    }
+    const waitLabel = waitMs >= 1000 ? `${Math.round(waitMs / 1000)}s` : `${waitMs}ms`;
+    const message = firstError instanceof Error ? firstError.message : String(firstError ?? '');
+    if (firstError) {
+        logger(`[cookies] Cookie read failed (${message}); waiting ${waitLabel} then retrying once.`);
+    }
+    else {
+        logger(`[cookies] No cookies found; waiting ${waitLabel} then retrying once.`);
+    }
+    await delay(waitMs);
+    return readChromeCookies(url, profile, filterNames, cookiePath);
+}
 async function readChromeCookies(url, profile, filterNames, cookiePath) {
     const origins = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
     const chromeProfile = cookiePath ?? profile ?? undefined;

package/dist/src/browser/index.js

@@ -5,7 +5,7 @@ import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
 import { ensureThinkingTime } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
@@ -129,6 +129,7 @@ export async function runBrowserMode(options) {
     let runStatus = 'attempted';
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
+    let removeDialogHandler = null;
     let appliedCookies = 0;
     try {
         try {
@@ -158,6 +159,7 @@ export async function runBrowserMode(options) {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
+        removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         if (!manualLogin) {
             await Network.clearBrowserCookies();
         }
@@ -179,6 +181,7 @@ export async function runBrowserMode(options) {
                 filterNames: config.cookieNames ?? undefined,
                 inlineCookies: config.inlineCookies ?? undefined,
                 cookiePath: config.chromeCookiePath ?? undefined,
+                waitMs: config.cookieSyncWaitMs ?? 0,
             });
             appliedCookies = cookieCount;
             if (config.inlineCookies && cookieCount === 0) {
@@ -201,7 +204,8 @@ export async function runBrowserMode(options) {
             // Learned: if the profile has no ChatGPT cookies, browser mode will just bounce to login.
             // Fail early so the user knows to sign in.
             throw new BrowserAutomationError('No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. ' +
-                'Make sure ChatGPT is signed in in the selected profile, or use --browser-manual-login / inline cookies.', {
+                'Make sure ChatGPT is signed in in the selected profile, use --browser-manual-login / inline cookies, ' +
+                'or retry with --browser-cookie-wait 5s if Keychain prompts are slow.', {
                 stage: 'execute-browser',
                 details: {
                     profile: config.chromeProfile ?? 'Default',
@@ -218,10 +222,17 @@ export async function runBrowserMode(options) {
         // Learned: login checks must happen on the base domain before jumping into project URLs.
         await raceWithDisconnect(waitForLogin({ runtime: Runtime, logger, appliedCookies, manualLogin, timeoutMs: config.timeoutMs }));
         if (config.url !== baseUrl) {
-            await raceWithDisconnect(navigateToChatGPT(Page, Runtime, config.url, logger));
-            await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
+            await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
+                url: config.url,
+                fallbackUrl: baseUrl,
+                timeoutMs: config.inputTimeoutMs,
+                headless: config.headless,
+                logger,
+            }));
+        }
+        else {
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
         }
-        await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         const captureRuntimeSnapshot = async () => {
             try {
@@ -336,6 +347,7 @@ export async function runBrowserMode(options) {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
             const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            let attachmentWaitTimedOut = false;
             let inputOnlyAttachments = false;
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
@@ -345,25 +357,38 @@ export async function runBrowserMode(options) {
                 for (let attachmentIndex = 0; attachmentIndex < submissionAttachments.length; attachmentIndex += 1) {
                     const attachment = submissionAttachments[attachmentIndex];
                     logger(`Uploading attachment: ${attachment.displayPath}`);
-                    const uiConfirmed = await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger, { expectedCount: attachmentIndex + 1 });
+                    const uiConfirmed = await uploadAttachmentFile({ runtime: Runtime, dom: DOM, input: Input }, attachment, logger, { expectedCount: attachmentIndex + 1 });
                     if (!uiConfirmed) {
                         inputOnlyAttachments = true;
                     }
                     await delay(500);
                 }
-                // Scale timeout based on number of files: base 30s + 15s per additional file
+                // Scale timeout based on number of files: base 45s + 20s per additional file.
                 const baseTimeout = config.inputTimeoutMs ?? 30_000;
-                const perFileTimeout = 15_000;
-                const waitBudget = Math.max(baseTimeout, 30_000) + (submissionAttachments.length - 1) * perFileTimeout;
-                await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
-                logger('All attachments uploaded');
+                const perFileTimeout = 20_000;
+                const waitBudget = Math.max(baseTimeout, 45_000) + (submissionAttachments.length - 1) * perFileTimeout;
+                try {
+                    await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
+                    logger('All attachments uploaded');
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (/Attachments did not finish uploading before timeout/i.test(message)) {
+                        attachmentWaitTimedOut = true;
+                        logger(`[browser] Attachment upload timed out after ${Math.round(waitBudget / 1000)}s; continuing without confirmation.`);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
             }
             let baselineTurns = await readConversationTurnCount(Runtime, logger);
             // Learned: return baselineTurns so assistant polling can ignore earlier content.
+            const sendAttachmentNames = attachmentWaitTimedOut ? [] : attachmentNames;
             const committedTurns = await submitPrompt({
                 runtime: Runtime,
                 input: Input,
-                attachmentNames,
+                attachmentNames: sendAttachmentNames,
                 baselineTurns: baselineTurns ?? undefined,
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
             }, prompt, logger);
@@ -373,14 +398,18 @@ export async function runBrowserMode(options) {
                 }
             }
             if (attachmentNames.length > 0) {
-                if (inputOnlyAttachments) {
+                if (attachmentWaitTimedOut) {
+                    logger('Attachment confirmation timed out; skipping user-turn attachment verification.');
+                }
+                else if (inputOnlyAttachments) {
                     logger('Attachment UI did not render before send; skipping user-turn attachment verification.');
                 }
                 else {
                     const verified = await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger);
-                    if (verified) {
-                        logger('Verified attachments present on sent user message');
+                    if (!verified) {
+                        throw new Error('Sent user message did not expose attachment UI after upload.');
                     }
+                    logger('Verified attachments present on sent user message');
                 }
             }
             // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
@@ -618,6 +647,7 @@ export async function runBrowserMode(options) {
         catch {
             // ignore
         }
+        removeDialogHandler?.();
         removeTerminationHooks?.();
         if (!effectiveKeepBrowser) {
             if (!connectionClosedUnexpectedly) {
@@ -796,6 +826,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let answerHtml = '';
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
+    let removeDialogHandler = null;
     try {
         const connection = await connectToRemoteChrome(host, port, logger, config.url);
         client = connection.client;
@@ -811,6 +842,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
+        removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         // Skip cookie sync for remote Chrome - it already has cookies
         logger('Skipping cookie sync for remote Chrome (using existing session)');
         await navigateToChatGPT(Page, Runtime, config.url, logger);
@@ -1082,6 +1114,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         catch {
             // ignore
         }
+        removeDialogHandler?.();
         await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
         // Don't kill remote Chrome - it's not ours to manage
         const totalSeconds = (Date.now() - startedAt) / 1000;

package/dist/src/browser/pageActions.js

@@ -1,4 +1,4 @@
-export { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady } from './actions/navigation.js';
+export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, } from './actions/navigation.js';
 export { ensureModelSelection } from './actions/modelSelection.js';
 export { submitPrompt, clearPromptComposer } from './actions/promptComposer.js';
 export { clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, } from './actions/attachments.js';

package/dist/src/browser/reattach.js

@@ -114,6 +114,7 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
             filterNames: resolved.cookieNames ?? undefined,
             inlineCookies: resolved.inlineCookies ?? undefined,
             cookiePath: resolved.chromeCookiePath ?? undefined,
+            waitMs: resolved.cookieSyncWaitMs ?? 0,
         });
     }
     await navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger);

package/dist/src/cli/browserConfig.js

@@ -82,6 +82,7 @@ export async function buildBrowserConfig(options) {
         inputTimeoutMs: options.browserInputTimeout
             ? parseDuration(options.browserInputTimeout, DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
             : undefined,
+        cookieSyncWaitMs: options.browserCookieWait ? parseDuration(options.browserCookieWait, 0) : undefined,
         cookieSync: options.browserNoCookieSync ? false : undefined,
         cookieNames,
         inlineCookies: inline?.cookies,

package/dist/src/cli/browserDefaults.js

@@ -33,6 +33,9 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset('browserInputTimeout') && typeof browser.inputTimeoutMs === 'number') {
         options.browserInputTimeout = String(browser.inputTimeoutMs);
     }
+    if (isUnset('browserCookieWait') && typeof browser.cookieSyncWaitMs === 'number') {
+        options.browserCookieWait = String(browser.cookieSyncWaitMs);
+    }
     if (isUnset('browserHeadless') && browser.headless !== undefined) {
         options.browserHeadless = browser.headless;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.8.1",
+  "version": "0.8.4",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.2 Pro (via gpt-5.1-pro alias), GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -23,6 +23,7 @@
     "test:mcp:mcporter": "npx -y mcporter list oracle-local --schema --config config/mcporter.json && npx -y mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
     "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
     "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
+    "test:live:fast": "ORACLE_LIVE_TEST=1 ORACLE_LIVE_TEST_FAST=1 vitest run tests/live/browser-fast-live.test.ts",
     "test:pro": "ORACLE_LIVE_TEST=1 vitest run tests/live/openai-live.test.ts",
     "test:coverage": "vitest run --coverage",
     "prepare": "pnpm run build",
@@ -79,14 +80,15 @@
     "markdansi": "0.2.0",
     "openai": "^6.15.0",
     "osc-progress": "^0.2.0",
+    "qs": "^6.14.1",
     "shiki": "^3.20.0",
     "toasted-notifier": "^10.1.0",
     "tokentally": "^0.1.1",
-    "zod": "^4.2.1"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@biomejs/biome": "^2.3.10",
+    "@biomejs/biome": "^2.3.11",
     "@cdktf/node-pty-prebuilt-multiarch": "0.10.2",
     "@types/chrome-remote-interface": "^0.33.0",
     "@types/inquirer": "^9.0.9",