@steipete/oracle 0.18.0 → 0.19.0

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

@@ -1,9 +1,16 @@
+import { withoutBrowserCancellation } from "../cancellation.js";
+import { randomUUID } from "node:crypto";
 import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, STOP_BUTTON_SELECTOR, ASSISTANT_ROLE_SELECTOR, } from "../constants.js";
 import { buildConversationTurnCountExpression, buildConversationTurnListExpression, } from "../conversationTurns.js";
 import { delay } from "../utils.js";
 import { logDomFailure } from "../domDebug.js";
+import { assertComposerNavigationSnapshot, assertComposerPlusStayedInPlace, buildAttachmentNamePattern, composerNavigationIdentityFromUrl, } from "./attachments.js";
+import { buildComposerNavigationValidationExpression } from "./attachmentContext.js";
 import { buildClickDispatcher } from "./domEvents.js";
+import { stageAttachmentPrompt } from "./attachmentPrompt.js";
 import { BrowserAutomationError } from "../../oracle/errors.js";
+import { buildAttachmentEvidenceExpression } from "./attachmentEvidence.js";
+import { buildAttachmentProgressExpression } from "./attachmentProgress.js";
 const ENTER_KEY_EVENT = {
     key: "Enter",
     code: "Enter",
@@ -11,12 +18,33 @@ const ENTER_KEY_EVENT = {
     nativeVirtualKeyCode: 13,
 };
 const ENTER_KEY_TEXT = "\r";
+const ESCAPE_KEY_EVENT = {
+    key: "Escape",
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27,
+};
 export async function submitPrompt(deps, prompt, logger) {
     const { runtime, input } = deps;
+    const hasAttachments = Array.isArray(deps.attachmentNames) && deps.attachmentNames.length > 0;
+    if (hasAttachments && !deps.attachmentNavigationUrl) {
+        throw new BrowserAutomationError("Oracle cannot safely submit attachments without the pre-upload ChatGPT page identity.", {
+            stage: "submit-prompt",
+            code: "attachment-navigation-identity-unavailable",
+        });
+    }
+    if (hasAttachments) {
+        await assertComposerPlusStayedInPlace(runtime, deps.attachmentNavigationUrl);
+    }
     await waitForDomReady(runtime, logger, deps.inputTimeoutMs ?? undefined);
-    const encodedPrompt = JSON.stringify(prompt);
-    const focusResult = await runtime.evaluate({
-        expression: `(() => {
+    let observedLength;
+    if (hasAttachments) {
+        observedLength = await stageAttachmentPrompt(runtime, prompt, deps.attachmentNavigationUrl);
+    }
+    else {
+        const encodedPrompt = JSON.stringify(prompt);
+        const focusResult = await runtime.evaluate({
+            expression: `(() => {
       ${buildClickDispatcher()}
       const SELECTORS = ${JSON.stringify(INPUT_SELECTORS)};
       const isVisible = (node) => {
@@ -60,21 +88,21 @@ export async function submitPrompt(deps, prompt, logger) {
       }
       return { focused: false };
     })()`,
-        returnByValue: true,
-        awaitPromise: true,
-    });
-    if (!focusResult.result?.value?.focused) {
-        await logDomFailure(runtime, logger, "focus-textarea");
-        throw new Error("Failed to focus prompt textarea");
-    }
-    await input.insertText({ text: prompt });
-    // Some pages (notably ChatGPT when subscriptions/widgets load) need a brief settle
-    // before the send button becomes enabled; give it a short breather to avoid races.
-    await delay(500);
-    const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
-    const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
-    const verification = await runtime.evaluate({
-        expression: `(() => {
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        if (!focusResult.result?.value?.focused) {
+            await logDomFailure(runtime, logger, "focus-textarea");
+            throw new Error("Failed to focus prompt textarea");
+        }
+        await input.insertText({ text: prompt });
+        // Some pages (notably ChatGPT when subscriptions/widgets load) need a brief settle
+        // before the send button becomes enabled; give it a short breather to avoid races.
+        await delay(500);
+        const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
+        const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+        const verification = await runtime.evaluate({
+            expression: `(() => {
       const editor = document.querySelector(${primarySelectorLiteral});
       const fallback = document.querySelector(${fallbackSelectorLiteral});
       const inputSelectors = ${JSON.stringify(INPUT_SELECTORS)};
@@ -98,18 +126,18 @@ export async function submitPrompt(deps, prompt, logger) {
         activeValue: active ? readValue(active) : '',
       };
     })()`,
-        returnByValue: true,
-    });
-    const editorTextRaw = verification.result?.value?.editorText ?? "";
-    const fallbackValueRaw = verification.result?.value?.fallbackValue ?? "";
-    const activeValueRaw = verification.result?.value?.activeValue ?? "";
-    const editorTextTrimmed = editorTextRaw?.trim?.() ?? "";
-    const fallbackValueTrimmed = fallbackValueRaw?.trim?.() ?? "";
-    const activeValueTrimmed = activeValueRaw?.trim?.() ?? "";
-    if (!editorTextTrimmed && !fallbackValueTrimmed && !activeValueTrimmed) {
-        // Learned: occasionally Input.insertText doesn't land in the editor; force textContent/value + input events.
-        await runtime.evaluate({
-            expression: `(() => {
+            returnByValue: true,
+        });
+        const editorTextRaw = verification.result?.value?.editorText ?? "";
+        const fallbackValueRaw = verification.result?.value?.fallbackValue ?? "";
+        const activeValueRaw = verification.result?.value?.activeValue ?? "";
+        const editorTextTrimmed = editorTextRaw?.trim?.() ?? "";
+        const fallbackValueTrimmed = fallbackValueRaw?.trim?.() ?? "";
+        const activeValueTrimmed = activeValueRaw?.trim?.() ?? "";
+        if (!editorTextTrimmed && !fallbackValueTrimmed && !activeValueTrimmed) {
+            // Learned: occasionally Input.insertText doesn't land in the editor; force textContent/value + input events.
+            await runtime.evaluate({
+                expression: `(() => {
         const fallback = document.querySelector(${fallbackSelectorLiteral});
         if (fallback) {
           fallback.value = ${encodedPrompt};
@@ -123,11 +151,10 @@ export async function submitPrompt(deps, prompt, logger) {
           editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${encodedPrompt}, inputType: 'insertFromPaste' }));
         }
       })()`,
-        });
-    }
-    const promptLength = prompt.length;
-    const postVerification = await runtime.evaluate({
-        expression: `(() => {
+            });
+        }
+        const postVerification = await runtime.evaluate({
+            expression: `(() => {
       const editor = document.querySelector(${primarySelectorLiteral});
       const fallback = document.querySelector(${fallbackSelectorLiteral});
       const inputSelectors = ${JSON.stringify(INPUT_SELECTORS)};
@@ -151,12 +178,14 @@ export async function submitPrompt(deps, prompt, logger) {
         activeValue: active ? readValue(active) : '',
       };
     })()`,
-        returnByValue: true,
-    });
-    const observedEditor = postVerification.result?.value?.editorText ?? "";
-    const observedFallback = postVerification.result?.value?.fallbackValue ?? "";
-    const observedActive = postVerification.result?.value?.activeValue ?? "";
-    const observedLength = Math.max(observedEditor.length, observedFallback.length, observedActive.length);
+            returnByValue: true,
+        });
+        const observedEditor = postVerification.result?.value?.editorText ?? "";
+        const observedFallback = postVerification.result?.value?.fallbackValue ?? "";
+        const observedActive = postVerification.result?.value?.activeValue ?? "";
+        observedLength = Math.max(observedEditor.length, observedFallback.length, observedActive.length);
+    }
+    const promptLength = prompt.length;
     if (promptLength >= 50_000 && observedLength > 0 && observedLength < promptLength - 2_000) {
         // Learned: very large prompts can truncate silently; fail fast so we can fall back to file uploads.
         await logDomFailure(runtime, logger, "prompt-too-large");
@@ -167,28 +196,31 @@ export async function submitPrompt(deps, prompt, logger) {
             observedLength,
         });
     }
-    const clicked = await attemptSendButton(runtime, input, logger, deps?.attachmentNames, deps?.attachmentTimeoutMs);
+    const clicked = await attemptSendButton(runtime, input, logger, deps?.attachmentNames, deps?.attachmentTimeoutMs, deps?.page, deps?.attachmentNavigationUrl);
     if (!clicked) {
-        await input.dispatchKeyEvent({
-            type: "keyDown",
-            ...ENTER_KEY_EVENT,
-            text: ENTER_KEY_TEXT,
-            unmodifiedText: ENTER_KEY_TEXT,
-        });
-        await input.dispatchKeyEvent({
-            type: "keyUp",
-            ...ENTER_KEY_EVENT,
-        });
+        await dispatchEnterKey(input);
         logger("Submitted prompt via Enter key");
     }
     else {
-        logger("Clicked send button");
+        logger("Activated send button");
     }
     await deps.onPromptSubmitted?.();
     const commitTimeoutMs = Math.max(60_000, deps.inputTimeoutMs ?? 0);
     // Learned: the send button can succeed but the turn doesn't appear immediately; verify commit via turns/stop button.
     return await verifyPromptCommitted(runtime, prompt, commitTimeoutMs, logger, deps.baselineTurns ?? undefined);
 }
+async function dispatchEnterKey(Input) {
+    await Input.dispatchKeyEvent({
+        type: "keyDown",
+        ...ENTER_KEY_EVENT,
+        text: ENTER_KEY_TEXT,
+        unmodifiedText: ENTER_KEY_TEXT,
+    });
+    await Input.dispatchKeyEvent({
+        type: "keyUp",
+        ...ENTER_KEY_EVENT,
+    });
+}
 export async function clearPromptComposer(Runtime, logger) {
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
@@ -287,11 +319,12 @@ function buildAttachmentReadyExpression(attachmentNames) {
     const attachmentExpectations = attachmentNames.map((attachment) => {
         const name = typeof attachment === "string" ? attachment : attachment.name;
         const normalized = name.toLowerCase().replace(/\s+/g, " ").trim();
+        const generatedBundle = typeof attachment === "object" && attachment.generatedBundle === true;
         return {
             name: normalized,
             stem: normalized.replace(/\.[a-z0-9]{1,10}$/i, ""),
-            extension: normalized.match(/(\.[a-z0-9]{1,10})$/i)?.[1] ?? "",
-            generatedBundle: typeof attachment === "object" && attachment.generatedBundle === true,
+            namePattern: buildAttachmentNamePattern(normalized, generatedBundle)?.source ?? "",
+            generatedBundle,
         };
     });
     const namesLiteral = JSON.stringify(attachmentExpectations);
@@ -299,74 +332,13 @@ function buildAttachmentReadyExpression(attachmentNames) {
     const expected = ${namesLiteral};
     const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
     const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
-    const hasNameBoundary = (text, name) => {
-      if (!name) return false;
-      let from = 0;
-      while (from < text.length) {
-        const index = text.indexOf(name, from);
-        if (index === -1) return false;
-        const previous = text[index - 1] || '';
-        const next = text[index + name.length] || '';
-        const previousOk = !previous || !/[a-z0-9._-]/.test(previous);
-        const nextOk = !next || !/[a-z0-9._-]/.test(next);
-        if (previousOk && nextOk) return true;
-        from = index + name.length;
-      }
-      return false;
-    };
-    const hasStemFileBoundary = (text, stem) => {
-      if (!stem) return false;
-      let from = 0;
-      while (from < text.length) {
-        const index = text.indexOf(stem, from);
-        if (index === -1) return false;
-        const previous = text[index - 1] || '';
-        const next = text[index + stem.length] || '';
-        const previousOk = !previous || !/[a-z0-9._-]/.test(previous);
-        const nextOk = !next || !/[a-z0-9._-]/.test(next);
-        if (previousOk && nextOk) return true;
-        from = index + stem.length;
-      }
-      return false;
-    };
-    const hasBareStemBoundary = (text, stem) => {
-      if (!stem) return false;
-      let from = 0;
-      while (from < text.length) {
-        const index = text.indexOf(stem, from);
-        if (index === -1) return false;
-        const previous = text[index - 1] || '';
-        const next = text[index + stem.length] || '';
-        const previousOk = !previous || !/[a-z0-9._-]/.test(previous);
-        const nextOk = !next || !/[a-z0-9._(-]/.test(next);
-        if (previousOk && nextOk) return true;
-        from = index + stem.length;
-      }
-      return false;
-    };
-    const hasExtensionBoundary = (text, extension) => {
-      if (!extension) return false;
-      let from = 0;
-      while (from < text.length) {
-        const index = text.indexOf(extension, from);
-        if (index === -1) return false;
-        const next = text[index + extension.length] || '';
-        if (!next || !/[a-z0-9]/.test(next)) return true;
-        from = index + extension.length;
-      }
-      return false;
-    };
     const matchesExpected = (value, item) => {
       const text = normalize(value);
       if (!text) return false;
-      if (hasNameBoundary(text, item.name)) return true;
-      if (item.generatedBundle && hasBareStemBoundary(text, item.stem)) return true;
+      const namePattern = item.namePattern ? new RegExp(item.namePattern, 'iu') : null;
       if (
-        item.stem &&
-        item.stem.length >= 4 &&
-        item.extension &&
-        text.includes(item.stem + '(') &&
-        hasExtensionBoundary(text, item.extension)
+        namePattern &&
+        String(value || '').split('\\n').some((candidate) => namePattern.test(normalize(candidate)))
       ) {
         return true;
       }
@@ -465,7 +437,7 @@ function buildAttachmentReadyExpression(attachmentNames) {
       };
       pushAttrs(node);
       pushText(node);
-      return pieces.join(' ').toLowerCase();
+      return pieces.join('\\n').toLowerCase();
     };
     const collectLabelHaystack = (node) => {
       if (!node) return '';
@@ -478,7 +450,7 @@ function buildAttachmentReadyExpression(attachmentNames) {
       push(parent);
       const grandparent = parent?.parentElement;
       push(grandparent);
-      return pieces.join(' ').toLowerCase();
+      return pieces.join('\\n').toLowerCase();
     };
     const attachmentRoots = Array.from(new Set([composer])).filter(Boolean);
     const collectChipNodes = () => {
@@ -499,32 +471,11 @@ function buildAttachmentReadyExpression(attachmentNames) {
     };
     const chipNodes = collectChipNodes();
     const chipLabels = chipNodes.map((node) => collectLabelHaystack(node));
-    const chipOwnLabels = chipNodes.map((node) => collectOwnLabelHaystack(node));
-    const hasEllipsisSuffix = (label) => {
-      const marker = label.includes('…') ? '…' : label.includes('...') ? '...' : '';
-      if (!marker) return false;
-      return normalize(label.split(marker)[1] || '').length > 0;
-    };
-    const chipOwnLabelsWithVisibleNames = chipOwnLabels.filter((label) =>
-      /\\.[a-z][a-z0-9]{0,9}(?:\\b|$)/i.test(label) ||
-      hasEllipsisSuffix(label),
-    );
-    const visibleExtensionLabelsMatchExpected = chipOwnLabelsWithVisibleNames.every((label) =>
-      expected.some((item) => matchesExpected(label, item)),
-    );
-    const visibleStemOnlyMismatch = chipOwnLabels.some((label) =>
-      expected.some(
-        (item) =>
-          !item.generatedBundle &&
-          item.stem &&
-          hasStemFileBoundary(label, item.stem) &&
-          !matchesExpected(label, item),
-      ),
-    );
-
+    const uploadEvidence = ${buildAttachmentEvidenceExpression(attachmentExpectations.map((item) => item.name))};
     const chipsReady = (() => {
       const used = new Set();
-      return expected.every((item) => {
+      return expected.every((item, expectedIndex) => {
+        if (uploadEvidence[expectedIndex]) return true;
         const index = chipLabels.findIndex((label, candidateIndex) =>
           !used.has(candidateIndex) && matchesExpected(label, item),
         );
@@ -542,42 +493,20 @@ function buildAttachmentReadyExpression(attachmentNames) {
         ),
       ),
     );
-    // Count-based fallback: if we cannot match names individually (ChatGPT may strip
-    // the filename out of attribute-readable text into a deeply nested span), but we
-    // do see at least as many distinct "Remove" affordances as attachments we
-    // uploaded, trust the upload without double-counting nested chip/remove nodes.
-    const removeAffordances = [];
-    const removeSeen = new Set();
-    for (const root of attachmentRoots) {
-      for (const node of Array.from(root.querySelectorAll(
-        '[aria-label*="Remove" i], [aria-label*="remove" i], button[aria-label*="Remove" i], button[aria-label*="remove" i]',
-      ))) {
-        if (!(node instanceof HTMLElement)) continue;
-        if (node.closest('textarea,[contenteditable="true"]')) continue;
-        const aria = (node.getAttribute?.('aria-label') ?? '').toLowerCase();
-        const fileSpecific = aria.includes('remove file') || aria.includes('remove attachment');
-        const attachmentOwner = node.closest(
-          '[data-testid*="chip"], [data-testid*="attachment"], [data-testid*="upload"], [data-testid*="file"]',
-        );
-        if (!fileSpecific && !attachmentOwner) continue;
-        if (removeSeen.has(node)) continue;
-        removeSeen.add(node);
-        removeAffordances.push(node);
-      }
-    }
-    const countReady =
-      !visibleStemOnlyMismatch &&
-      visibleExtensionLabelsMatchExpected &&
-      removeAffordances.length >= expected.length;
-
-    return chipsReady || inputsReady || countReady;
+    return (chipsReady || inputsReady) && !${buildAttachmentProgressExpression("composer")};
   })()`;
 }
 export function buildAttachmentReadyExpressionForTest(attachmentNames) {
     return buildAttachmentReadyExpression(attachmentNames);
 }
-async function attemptSendButton(Runtime, Input, _logger, attachmentNames, attachmentTimeoutMs) {
+async function attemptSendButton(Runtime, Input, logger, attachmentNames, attachmentTimeoutMs, Page, attachmentNavigationUrl) {
     const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
+    if (needAttachment && !attachmentNavigationUrl) {
+        throw new BrowserAutomationError("Oracle cannot safely submit attachments without the pre-upload ChatGPT page identity.", {
+            stage: "submit-prompt",
+            code: "attachment-navigation-identity-unavailable",
+        });
+    }
     const script = `(() => {
     ${buildClickDispatcher()}
     const selectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
@@ -606,10 +535,19 @@ async function attemptSendButton(Runtime, Input, _logger, attachmentNames, attac
     }
     const button = candidates.find((node) => isVisible(node) && isEnabled(node)) || null;
     if (!button) return { status: 'missing' };
-    button.scrollIntoView({ block: 'center', inline: 'center' });
     const rect = button.getBoundingClientRect();
     if (rect.width > 0 && rect.height > 0) {
-      return { status: 'point', x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+      const x = rect.left + rect.width / 2;
+      const y = rect.top + rect.height / 2;
+      // Scrolling an already-visible composer can trigger ChatGPT's layout snap.
+      // If scrolling is necessary, discard these coordinates and measure later.
+      if (x < 0 || y < 0 || x >= window.innerWidth || y >= window.innerHeight) {
+        button.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
+        return { status: 'settling' };
+      }
+      const hit = document.elementFromPoint(x, y);
+      if (!hit || !button.contains(hit)) return { status: 'settling' };
+      return { status: 'point', x, y };
     }
     // Last-resort fallback for unusual DOMs where the button is visible but has no useful rect.
     dispatchClickSequence(button);
@@ -620,6 +558,10 @@ async function attemptSendButton(Runtime, Input, _logger, attachmentNames, attac
     // shorter historical deadline.
     const timeoutMs = sendButtonTimeoutMs(attachmentNames, attachmentTimeoutMs);
     const deadline = Date.now() + timeoutMs;
+    let previousPoint;
+    let activated = false;
+    let foundButton = false;
+    let attachmentMenuChecked = !needAttachment;
     while (Date.now() < deadline) {
         if (needAttachment) {
             const ready = await Runtime.evaluate({
@@ -631,13 +573,45 @@ async function attemptSendButton(Runtime, Input, _logger, attachmentNames, attac
                 continue;
             }
         }
+        if (!attachmentMenuChecked) {
+            await activatePageForTrustedInput(Page, logger);
+            activated = true;
+            await dismissOpenComposerPlusMenu(Runtime, Input, logger);
+            attachmentMenuChecked = true;
+            previousPoint = undefined;
+            await delay(150);
+            continue;
+        }
+        if (needAttachment) {
+            if (await activateExactAttachmentSendButton(Runtime, Input, logger, attachmentNavigationUrl, attachmentNames)) {
+                return true;
+            }
+            previousPoint = undefined;
+            await delay(100);
+            continue;
+        }
+        // Activating the target can trigger a final compositor/layout pass. Do it before
+        // measuring the button so the trusted click never uses stale coordinates.
+        if (!activated) {
+            await activatePageForTrustedInput(Page, logger);
+            activated = true;
+        }
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
         const value = result.value;
         const status = typeof value === "string" ? value : value?.status;
+        if (status === "point" || status === "settling")
+            foundButton = true;
         if (status === "point" &&
             typeof value === "object" &&
             typeof value.x === "number" &&
             typeof value.y === "number") {
+            if (!previousPoint ||
+                Math.abs(previousPoint.x - value.x) > 1 ||
+                Math.abs(previousPoint.y - value.y) > 1) {
+                previousPoint = { x: value.x, y: value.y };
+                await delay(150);
+                continue;
+            }
             await clickTrustedPoint(Runtime, Input, value.x, value.y);
             return true;
         }
@@ -647,18 +621,223 @@ async function attemptSendButton(Runtime, Input, _logger, attachmentNames, attac
         if (status === "missing") {
             break;
         }
+        previousPoint = undefined;
         await delay(100);
     }
     if (Array.isArray(attachmentNames) && attachmentNames.length > 0) {
-        throw new BrowserAutomationError(`Attachments never reached a clickable send button after ${Math.ceil(timeoutMs / 1000)}s; tune --browser-attachment-timeout.`, {
+        throw new BrowserAutomationError(`Attachments never reached the exact ready send button after ${Math.ceil(timeoutMs / 1000)}s; tune --browser-attachment-timeout.`, {
             stage: "submit-prompt",
             code: "attachment-send-not-ready",
             attachmentNames,
             timeoutMs,
         });
     }
+    if (foundButton) {
+        throw new BrowserAutomationError("Send button did not settle before input timeout.", {
+            stage: "submit-prompt",
+            code: "send-button-unstable",
+        });
+    }
     return false;
 }
+async function activateExactAttachmentSendButton(Runtime, Input, logger, attachmentNavigationUrl, attachmentNames = []) {
+    const probe = await Runtime.evaluate({
+        expression: `(() => {
+      const button = document.querySelector('button[data-testid="send-button"]');
+      if (!(button instanceof HTMLElement)) return { status: 'absent' };
+      const rect = button.getBoundingClientRect();
+      const style = window.getComputedStyle(button);
+      const enabled = !button.hasAttribute('disabled') &&
+        button.getAttribute('aria-disabled') !== 'true' &&
+        button.getAttribute('data-disabled') !== 'true' &&
+        style.pointerEvents !== 'none' &&
+        style.display !== 'none' &&
+        style.visibility !== 'hidden';
+      if (rect.width <= 0 || rect.height <= 0 || !enabled) return { status: 'unavailable' };
+      button.focus({ preventScroll: true });
+      return { status: document.activeElement === button ? 'focused' : 'unavailable' };
+    })()`,
+        returnByValue: true,
+    });
+    const status = probe?.result?.value?.status;
+    if (status !== "focused") {
+        return false;
+    }
+    if (!Input || typeof Input.dispatchKeyEvent !== "function") {
+        throw new BrowserAutomationError("ChatGPT's attachment send button is ready but Oracle cannot activate it safely.", {
+            stage: "submit-prompt",
+            code: "attachment-send-keyboard-unavailable",
+        });
+    }
+    const expectedIdentity = composerNavigationIdentityFromUrl(attachmentNavigationUrl ?? "");
+    if (!expectedIdentity || !attachmentNavigationUrl) {
+        throw new BrowserAutomationError("Attachment page identity is unavailable before dispatch.", {
+            stage: "submit-prompt",
+            code: "attachment-navigation-identity-unavailable",
+        });
+    }
+    const guardId = randomUUID();
+    // Recheck at event delivery too: a SPA can navigate after the CDP probe returns.
+    let delivery;
+    try {
+        const boundary = await Runtime.evaluate({
+            expression: `(() => {
+        const button = document.querySelector('button[data-testid="send-button"]');
+        const check = () => {
+          const navigation = ${buildComposerNavigationValidationExpression(attachmentNavigationUrl)};
+          const rect = button?.getBoundingClientRect();
+          const style = button ? window.getComputedStyle(button) : null;
+          return {
+            ...navigation,
+            focused: button instanceof HTMLElement && document.activeElement === button &&
+              document.querySelector('button[data-testid="send-button"]') === button &&
+              !button.hasAttribute('disabled') && button.getAttribute('aria-disabled') !== 'true' &&
+              button.getAttribute('data-disabled') !== 'true' && rect.width > 0 && rect.height > 0 &&
+              style.display !== 'none' && style.visibility !== 'hidden' && style.pointerEvents !== 'none',
+            attachmentsReady: ${buildAttachmentReadyExpression(attachmentNames)},
+          };
+        };
+        const safeCheck = () => {
+          try { return check(); } catch { return { currentUrl: location.href, contextMatches: false, focused: false, attachmentsReady: false }; }
+        };
+        const snapshot = safeCheck();
+        if (!snapshot.contextMatches || !snapshot.focused || !snapshot.attachmentsReady) return snapshot;
+        const existing = window.__oracleAttachmentDispatchGuard;
+        if (existing && !existing.finished) return { ...snapshot, focused: false };
+        existing?.cleanup?.();
+        const guard = { id: ${JSON.stringify(guardId)}, sawKeyDown: false, blocked: null, finished: false };
+        const detach = () => {
+          window.removeEventListener('keydown', onKeyDown, true);
+          window.removeEventListener('keyup', onKeyUp, true);
+          window.removeEventListener('click', onClick, true);
+          guard.finished = true;
+        };
+        const cancel = (event, state) => {
+          event.preventDefault(); event.stopImmediatePropagation(); guard.blocked = state;
+        };
+        const onKeyDown = event => {
+          if (event.key !== 'Enter' || !event.isTrusted) return;
+          guard.sawKeyDown = true;
+          const state = safeCheck();
+          if (!state.contextMatches || !state.focused || !state.attachmentsReady) cancel(event, state);
+        };
+        const onKeyUp = event => {
+          if (event.key === 'Enter' && event.isTrusted && guard.blocked) { cancel(event, guard.blocked); detach(); }
+        };
+        const onClick = event => {
+          if (!guard.sawKeyDown || !(event.target instanceof Node) ||
+              !(button.contains(event.target) || event.target instanceof Element && event.target.closest('button[data-testid="send-button"]'))) return;
+          const state = safeCheck();
+          if (guard.blocked || !state.contextMatches || !state.focused || !state.attachmentsReady) cancel(event, guard.blocked ?? state);
+          detach();
+        };
+        guard.cleanup = () => { detach(); if (window.__oracleAttachmentDispatchGuard === guard) delete window.__oracleAttachmentDispatchGuard; };
+        window.__oracleAttachmentDispatchGuard = guard;
+        window.addEventListener('keydown', onKeyDown, true);
+        window.addEventListener('keyup', onKeyUp, true);
+        window.addEventListener('click', onClick, true);
+        return snapshot;
+      })()`,
+            returnByValue: true,
+        });
+        const snapshot = boundary?.result?.value;
+        assertComposerNavigationSnapshot(attachmentNavigationUrl, snapshot);
+        if (snapshot?.focused !== true || snapshot.attachmentsReady !== true)
+            return false;
+        await Input.dispatchKeyEvent({
+            type: "keyDown",
+            ...ENTER_KEY_EVENT,
+            text: ENTER_KEY_TEXT,
+            unmodifiedText: ENTER_KEY_TEXT,
+        });
+        await Input.dispatchKeyEvent({ type: "keyUp", ...ENTER_KEY_EVENT });
+    }
+    finally {
+        const result = await withoutBrowserCancellation(() => Runtime.evaluate({
+            expression: `(() => {
+        const guard = window.__oracleAttachmentDispatchGuard;
+        if (guard?.id !== ${JSON.stringify(guardId)}) return null;
+        const summary = { sawKeyDown: guard.sawKeyDown, blocked: guard.blocked };
+        guard.cleanup(); return summary;
+      })()`,
+            returnByValue: true,
+        }).catch(() => undefined));
+        delivery = result?.result?.value;
+    }
+    if (delivery?.blocked) {
+        assertComposerNavigationSnapshot(attachmentNavigationUrl, delivery.blocked);
+        throw new BrowserAutomationError("Attachment focus or upload readiness changed at dispatch; the send was stopped.", {
+            stage: "submit-prompt",
+            code: "attachment-send-not-ready",
+        });
+    }
+    if (delivery?.sawKeyDown !== true) {
+        throw new BrowserAutomationError("Attachment input delivery could not be verified; do not retry automatically.", {
+            stage: "submit-prompt",
+            code: "attachment-send-ambiguous",
+        });
+    }
+    logger?.("Activated exact attachment send button via keyboard");
+    return true;
+}
+async function dismissOpenComposerPlusMenu(Runtime, Input, logger) {
+    const probe = await Runtime.evaluate({
+        expression: `(() => {
+      const selectors = ['#composer-plus-btn', 'button[data-testid="composer-plus-btn"]'];
+      const button = selectors
+        .map(selector => document.querySelector(selector))
+        .find(node => node instanceof HTMLElement && node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0);
+      if (!(button instanceof HTMLElement)) return { status: 'absent' };
+      if (button.getAttribute('aria-expanded') !== 'true') return { status: 'closed' };
+      button.focus({ preventScroll: true });
+      return { status: 'open', focused: document.activeElement === button };
+    })()`,
+        returnByValue: true,
+    });
+    const status = probe?.result?.value?.status;
+    if (status !== "open") {
+        return false;
+    }
+    if (!Input || typeof Input.dispatchKeyEvent !== "function") {
+        throw new BrowserAutomationError("ChatGPT's attachment menu is still open and Oracle cannot dismiss it safely before sending.", {
+            stage: "submit-prompt",
+            code: "attachment-menu-dismiss-unavailable",
+        });
+    }
+    await Input.dispatchKeyEvent({ type: "keyDown", ...ESCAPE_KEY_EVENT });
+    await Input.dispatchKeyEvent({ type: "keyUp", ...ESCAPE_KEY_EVENT });
+    const deadline = Date.now() + 2_000;
+    while (Date.now() < deadline) {
+        const state = await Runtime.evaluate({
+            expression: `(() => {
+        const selectors = ['#composer-plus-btn', 'button[data-testid="composer-plus-btn"]'];
+        return !selectors.some(selector =>
+          document.querySelector(selector)?.getAttribute?.('aria-expanded') === 'true'
+        );
+      })()`,
+            returnByValue: true,
+        });
+        if (state?.result?.value === true) {
+            logger?.("Closed attachment menu before send");
+            return true;
+        }
+        await delay(50);
+    }
+    throw new BrowserAutomationError("ChatGPT's attachment menu did not close before send; prompt was left staged.", {
+        stage: "submit-prompt",
+        code: "attachment-menu-stuck-open",
+    });
+}
+async function activatePageForTrustedInput(Page, logger) {
+    if (!Page || typeof Page.bringToFront !== "function") {
+        return;
+    }
+    await Page.bringToFront().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger?.(`[browser] Could not bring ChatGPT target to front before trusted click: ${message}`);
+    });
+    await delay(150);
+}
 async function clickTrustedPoint(Runtime, Input, x, y) {
     if (Input && typeof Input.dispatchMouseEvent === "function") {
         await Input.dispatchMouseEvent({ type: "mouseMoved", x, y });
@@ -814,14 +993,8 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
         logger(`Prompt commit check failed; latest state: ${probe ? JSON.stringify(probe) : "unavailable"}`);
         await logDomFailure(Runtime, logger, "prompt-commit");
     }
-    if (prompt.trim().length >= 50_000) {
-        throw new BrowserAutomationError("Prompt did not appear in conversation before timeout (likely too large).", {
-            stage: "submit-prompt",
-            code: "prompt-too-large",
-            promptLength: prompt.trim().length,
-            timeoutMs,
-        });
-    }
+    // Input was already dispatched. Even a large staged prompt may commit late;
+    // classifying this as truncation would let the runner submit an upload fallback.
     throw new BrowserAutomationError("Prompt did not appear in conversation before timeout (send may have failed)", {
         stage: "submit-prompt",
         code: "prompt-commit-timeout",
@@ -849,7 +1022,9 @@ function summarizeCommitProbe(probe) {
 }
 // biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
 export const __test__ = {
+    activateExactAttachmentSendButton,
     attemptSendButton,
+    dismissOpenComposerPlusMenu,
     sendButtonTimeoutMs,
     verifyPromptCommitted,
 };