@steipete/oracle 0.7.0 → 0.7.2

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { FILE_INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS } from '../constants.js';
+import { CONVERSATION_TURN_SELECTOR, INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 export async function uploadAttachmentFile(deps, attachment, logger) {
@@ -22,17 +22,11 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
           ),
         );
         if (chips) return true;
-        const cardTexts = Array.from(document.querySelectorAll('[aria-label="Remove file"]')).map((btn) =>
+        const cardTexts = Array.from(document.querySelectorAll('[aria-label*="Remove"],[aria-label*="remove"]')).map((btn) =>
           btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
         );
         if (cardTexts.some((text) => text.includes(expected))) return true;
 
-        const filesPill = Array.from(document.querySelectorAll('button,div')).some((node) => {
-          const text = (node?.textContent || '').toLowerCase();
-          return /\bfiles\b/.test(text) && text.includes('file');
-        });
-        if (filesPill) return true;
-
         const inputs = Array.from(document.querySelectorAll('input[type="file"]')).some((el) =>
           Array.from(el.files || []).some((f) => f?.name?.toLowerCase?.().includes(expected)),
         );
@@ -85,10 +79,21 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         logger(`Attachment already present: ${path.basename(attachment.path)}`);
         return;
     }
-    // Find a real input; prefer non-image accept fields and tag it for DOM.setFileInputFiles.
-    const markResult = await runtime.evaluate({
+    const documentNode = await dom.getDocument();
+    const candidateSetup = await runtime.evaluate({
         expression: `(() => {
-      const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
+      const promptSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+      const locateComposerRoot = () => {
+        for (const selector of promptSelectors) {
+          const node = document.querySelector(selector);
+          if (!node) continue;
+          return node.closest('form') ?? node.closest('[data-testid*="composer"]') ?? node.parentElement;
+        }
+        return document.querySelector('form') ?? document.body;
+      };
+      const root = locateComposerRoot();
+      const localInputs = root ? Array.from(root.querySelectorAll('input[type="file"]')) : [];
+      const inputs = localInputs.length > 0 ? localInputs : Array.from(document.querySelectorAll('input[type="file"]'));
       const acceptIsImageOnly = (accept) => {
         if (!accept) return false;
         const parts = String(accept)
@@ -97,73 +102,142 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
           .filter(Boolean);
         return parts.length > 0 && parts.every((p) => p.startsWith('image/'));
       };
-      const nonImage = inputs.filter((el) => !acceptIsImageOnly(el.getAttribute('accept')));
-      const target = (nonImage.length ? nonImage[nonImage.length - 1] : inputs[inputs.length - 1]) ?? null;
-      if (target) {
-        target.setAttribute('data-oracle-upload-target', 'true');
-        return true;
-      }
-      return false;
+      const chipContainer = root ?? document;
+      const chipSelector = '[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[aria-label*="Remove"],[aria-label*="remove"]';
+      const baselineChipCount = chipContainer.querySelectorAll(chipSelector).length;
+
+      // Mark candidates with stable indices so we can select them via DOM.querySelector.
+      let idx = 0;
+      const candidates = inputs.map((el) => {
+        const accept = el.getAttribute('accept') || '';
+        const score = (el.hasAttribute('multiple') ? 100 : 0) + (!acceptIsImageOnly(accept) ? 10 : 0);
+        el.setAttribute('data-oracle-upload-candidate', 'true');
+        el.setAttribute('data-oracle-upload-idx', String(idx));
+        return { idx: idx++, score };
+      });
+
+      // Prefer higher scores first.
+      candidates.sort((a, b) => b.score - a.score);
+      return { ok: candidates.length > 0, baselineChipCount, order: candidates.map((c) => c.idx) };
     })()`,
         returnByValue: true,
     });
-    const marked = Boolean(markResult?.result?.value);
-    if (!marked) {
+    const candidateValue = candidateSetup?.result?.value;
+    const candidateOrder = Array.isArray(candidateValue?.order) ? candidateValue.order : [];
+    const baselineChipCount = typeof candidateValue?.baselineChipCount === 'number' ? candidateValue.baselineChipCount : 0;
+    if (!candidateValue?.ok || candidateOrder.length === 0) {
         await logDomFailure(runtime, logger, 'file-input-missing');
         throw new Error('Unable to locate ChatGPT file attachment input.');
     }
-    const documentNode = await dom.getDocument();
-    const resultNode = await dom.querySelector({ nodeId: documentNode.root.nodeId, selector: 'input[type="file"][data-oracle-upload-target="true"]' });
-    if (!resultNode?.nodeId) {
-        await logDomFailure(runtime, logger, 'file-input-missing');
-        throw new Error('Unable to locate ChatGPT file attachment input.');
+    const dispatchEventsFor = (idx) => `(() => {
+    const el = document.querySelector('input[type="file"][data-oracle-upload-idx="${idx}"]');
+    if (el instanceof HTMLInputElement) {
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
     }
-    const resolvedNodeId = resultNode.nodeId;
-    const dispatchEvents = FILE_INPUT_SELECTORS
-        .map((selector) => `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (el instanceof HTMLInputElement) {
-          el.dispatchEvent(new Event('input', { bubbles: true }));
-          el.dispatchEvent(new Event('change', { bubbles: true }));
-        }
-      })();
-    `)
-        .join('\\n');
-    const tryFileInput = async () => {
-        await dom.setFileInputFiles({ nodeId: resolvedNodeId, files: [attachment.path] });
-        await runtime.evaluate({ expression: `(function(){${dispatchEvents} return true;})()`, returnByValue: true });
+    return true;
+  })()`;
+    const composerSnapshotFor = (idx) => `(() => {
+    const promptSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+    const locateComposerRoot = () => {
+      for (const selector of promptSelectors) {
+        const node = document.querySelector(selector);
+        if (!node) continue;
+        return node.closest('form') ?? node.closest('[data-testid*="composer"]') ?? node.parentElement;
+      }
+      return document.querySelector('form') ?? document.body;
     };
-    await tryFileInput();
-    // Snapshot the attachment state immediately after setting files so we can detect silent failures.
-    const snapshotExpr = `(() => {
-    const chips = Array.from(document.querySelectorAll('[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[aria-label="Remove file"]'))
-      .map((node) => (node?.textContent || '').trim())
-      .filter(Boolean);
-    const inputs = Array.from(document.querySelectorAll('input[type="file"]')).map((el) => ({
-      files: Array.from(el.files || []).map((f) => f?.name ?? ''),
-    }));
-    return { chips, inputs };
+    const root = locateComposerRoot();
+    const chipContainer = root ?? document;
+    const chipSelector = '[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[aria-label*="Remove"],[aria-label*="remove"]';
+    const chips = Array.from(chipContainer.querySelectorAll(chipSelector))
+      .slice(0, 20)
+      .map((node) => ({
+        text: (node.textContent || '').trim(),
+        aria: node.getAttribute?.('aria-label') ?? '',
+        title: node.getAttribute?.('title') ?? '',
+        testid: node.getAttribute?.('data-testid') ?? '',
+      }));
+    const input = document.querySelector('input[type="file"][data-oracle-upload-idx="${idx}"]');
+    const inputNames =
+      input instanceof HTMLInputElement
+        ? Array.from(input.files || []).map((f) => f?.name ?? '').filter(Boolean)
+        : [];
+    const composerText = (chipContainer.innerText || '').toLowerCase();
+    return { chipCount: chipContainer.querySelectorAll(chipSelector).length, chips, inputNames, composerText };
   })()`;
-    const snapshot = await runtime
-        .evaluate({ expression: snapshotExpr, returnByValue: true })
-        .then((res) => res?.result?.value)
-        .catch(() => undefined);
-    if (snapshot) {
-        logger?.(`Attachment snapshot after setFileInputFiles: chips=${JSON.stringify(snapshot.chips || [])} inputs=${JSON.stringify(snapshot.inputs || [])}`);
+    let finalSnapshot = null;
+    for (const idx of candidateOrder) {
+        const resultNode = await dom.querySelector({
+            nodeId: documentNode.root.nodeId,
+            selector: `input[type="file"][data-oracle-upload-idx="${idx}"]`,
+        });
+        if (!resultNode?.nodeId) {
+            continue;
+        }
+        await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [attachment.path] });
+        await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
+        const probeDeadline = Date.now() + 4000;
+        let lastPoke = 0;
+        while (Date.now() < probeDeadline) {
+            // ChatGPT's composer can take a moment to hydrate the file-input onChange handler after navigation/model switches.
+            // If the UI hasn't reacted yet, poke the input a few times to ensure the handler fires once it's mounted.
+            if (Date.now() - lastPoke > 650) {
+                lastPoke = Date.now();
+                await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
+            }
+            const snapshot = await runtime
+                .evaluate({ expression: composerSnapshotFor(idx), returnByValue: true })
+                .then((res) => res?.result?.value)
+                .catch(() => undefined);
+            if (snapshot) {
+                finalSnapshot = {
+                    chipCount: Number(snapshot.chipCount ?? 0),
+                    chips: Array.isArray(snapshot.chips) ? snapshot.chips : [],
+                    inputNames: Array.isArray(snapshot.inputNames) ? snapshot.inputNames : [],
+                    composerText: typeof snapshot.composerText === 'string' ? snapshot.composerText : '',
+                };
+                const inputHasFile = finalSnapshot.inputNames.some((name) => name.toLowerCase().includes(expectedName.toLowerCase()));
+                const expectedLower = expectedName.toLowerCase();
+                const expectedNoExt = expectedLower.replace(/\.[a-z0-9]{1,10}$/i, '');
+                const uiAcknowledged = finalSnapshot.chipCount > baselineChipCount ||
+                    (expectedNoExt.length >= 6
+                        ? finalSnapshot.composerText.includes(expectedNoExt)
+                        : finalSnapshot.composerText.includes(expectedLower));
+                if (inputHasFile && uiAcknowledged) {
+                    logger?.(`Attachment snapshot after setFileInputFiles: chips=${JSON.stringify(finalSnapshot.chips)} input=${JSON.stringify(finalSnapshot.inputNames)}`);
+                    break;
+                }
+            }
+            await delay(200);
+        }
+        const inputHasFile = finalSnapshot?.inputNames?.some((name) => name.toLowerCase().includes(expectedName.toLowerCase())) ?? false;
+        const uiAcknowledged = (finalSnapshot?.chipCount ?? 0) > baselineChipCount;
+        if (inputHasFile && uiAcknowledged) {
+            break;
+        }
     }
-    const inputHasFile = snapshot?.inputs?.some((entry) => (entry.files || []).some((name) => name?.toLowerCase?.().includes(expectedName.toLowerCase()))) ?? false;
-    if (await waitForAttachmentAnchored(runtime, expectedName, 20_000)) {
-        await waitForAttachmentVisible(runtime, expectedName, 20_000, logger);
-        logger(inputHasFile ? 'Attachment queued (file input, confirmed present)' : 'Attachment queued (file input)');
+    const inputHasFile = finalSnapshot?.inputNames?.some((name) => name.toLowerCase().includes(expectedName.toLowerCase())) ?? false;
+    const attachmentUiTimeoutMs = 25_000;
+    if (await waitForAttachmentAnchored(runtime, expectedName, attachmentUiTimeoutMs)) {
+        await waitForAttachmentVisible(runtime, expectedName, attachmentUiTimeoutMs, logger);
+        logger(inputHasFile ? 'Attachment queued (UI anchored, file input confirmed)' : 'Attachment queued (UI anchored)');
         return;
     }
+    // If ChatGPT never reflects an attachment UI chip/remove control, the file input may be the wrong target:
+    // sending in this state often drops the attachment silently.
+    if (inputHasFile) {
+        await logDomFailure(runtime, logger, 'file-upload-missing');
+        throw new Error('Attachment input accepted the file but ChatGPT did not acknowledge it in the composer UI.');
+    }
     await logDomFailure(runtime, logger, 'file-upload-missing');
     throw new Error('Attachment did not register with the ChatGPT composer in time.');
 }
 export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNames = [], logger) {
     const deadline = Date.now() + timeoutMs;
     const expectedNormalized = expectedNames.map((name) => name.toLowerCase());
+    let inputMatchSince = null;
+    let attachmentMatchSince = null;
     const expression = `(() => {
     const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
     let button = null;
@@ -185,8 +259,9 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
         if (ariaBusy === 'true' || dataState === 'loading' || dataState === 'uploading' || dataState === 'pending') {
           return true;
         }
+        // Avoid false positives from user prompts ("upload:") or generic UI copy; only treat explicit progress strings as uploading.
         const text = node.textContent?.toLowerCase?.() ?? '';
-        return text.includes('upload') || text.includes('processing') || text.includes('uploading');
+        return /\buploading\b/.test(text) || /\bprocessing\b/.test(text);
       });
     });
     const attachmentSelectors = ['[data-testid*="chip"]', '[data-testid*="attachment"]', '[data-testid*="upload"]'];
@@ -197,32 +272,99 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
         if (text) attachedNames.push(text);
       }
     }
+    const cardTexts = Array.from(document.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
+      btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
+    );
+    attachedNames.push(...cardTexts.filter(Boolean));
+
+    const inputNames = [];
     for (const input of Array.from(document.querySelectorAll('input[type="file"]'))) {
       if (!(input instanceof HTMLInputElement) || !input.files?.length) continue;
       for (const file of Array.from(input.files)) {
-        if (file?.name) attachedNames.push(file.name.toLowerCase());
+        if (file?.name) inputNames.push(file.name.toLowerCase());
       }
     }
-    const cardTexts = Array.from(document.querySelectorAll('[aria-label="Remove file"]')).map((btn) =>
-      btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
-    );
-    attachedNames.push(...cardTexts.filter(Boolean));
     const filesAttached = attachedNames.length > 0;
-    return { state: button ? (disabled ? 'disabled' : 'ready') : 'missing', uploading, filesAttached, attachedNames };
+    return { state: button ? (disabled ? 'disabled' : 'ready') : 'missing', uploading, filesAttached, attachedNames, inputNames };
   })()`;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression, returnByValue: true });
         const value = result?.value;
-        if (value && !value.uploading) {
-            const attached = new Set((value.attachedNames ?? []).map((name) => name.toLowerCase()));
-            const missing = expectedNormalized.filter((name) => !attached.has(name));
+        if (value) {
+            const attachedNames = (value.attachedNames ?? [])
+                .map((name) => name.toLowerCase().replace(/\s+/g, ' ').trim())
+                .filter(Boolean);
+            const inputNames = (value.inputNames ?? [])
+                .map((name) => name.toLowerCase().replace(/\s+/g, ' ').trim())
+                .filter(Boolean);
+            const matchesExpected = (expected) => {
+                const baseName = expected.split('/').pop()?.split('\\').pop() ?? expected;
+                const normalizedExpected = baseName.toLowerCase().replace(/\s+/g, ' ').trim();
+                const expectedNoExt = normalizedExpected.replace(/\.[a-z0-9]{1,10}$/i, '');
+                return attachedNames.some((raw) => {
+                    if (raw.includes(normalizedExpected))
+                        return true;
+                    if (expectedNoExt.length >= 6 && raw.includes(expectedNoExt))
+                        return true;
+                    if (raw.includes('…') || raw.includes('...')) {
+                        const escaped = raw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        const pattern = escaped.replace(/\\…|\\\.\\\.\\\./g, '.*');
+                        try {
+                            const re = new RegExp(pattern);
+                            return re.test(normalizedExpected) || (expectedNoExt.length >= 6 && re.test(expectedNoExt));
+                        }
+                        catch {
+                            return false;
+                        }
+                    }
+                    return false;
+                });
+            };
+            const missing = expectedNormalized.filter((expected) => !matchesExpected(expected));
             if (missing.length === 0) {
+                const stableThresholdMs = value.uploading ? 3000 : 1500;
                 if (value.state === 'ready') {
-                    return;
+                    if (attachmentMatchSince === null) {
+                        attachmentMatchSince = Date.now();
+                    }
+                    if (Date.now() - attachmentMatchSince > stableThresholdMs) {
+                        return;
+                    }
+                }
+                else {
+                    attachmentMatchSince = null;
                 }
                 if (value.state === 'missing' && value.filesAttached) {
                     return;
                 }
+                // If files are attached but button isn't ready yet, give it more time but don't fail immediately.
+                if (value.filesAttached) {
+                    await delay(500);
+                    continue;
+                }
+            }
+            else {
+                attachmentMatchSince = null;
+            }
+            // Fallback: if the file input has the expected names, allow progress once that condition is stable.
+            // Some ChatGPT surfaces only render the filename after sending the message.
+            const inputMissing = expectedNormalized.filter((expected) => {
+                const baseName = expected.split('/').pop()?.split('\\').pop() ?? expected;
+                const normalizedExpected = baseName.toLowerCase().replace(/\s+/g, ' ').trim();
+                const expectedNoExt = normalizedExpected.replace(/\.[a-z0-9]{1,10}$/i, '');
+                return !inputNames.some((raw) => raw.includes(normalizedExpected) || (expectedNoExt.length >= 6 && raw.includes(expectedNoExt)));
+            });
+            if (inputMissing.length === 0 && (value.state === 'ready' || value.state === 'missing')) {
+                const stableThresholdMs = value.uploading ? 3000 : 1500;
+                if (inputMatchSince === null) {
+                    inputMatchSince = Date.now();
+                }
+                if (Date.now() - inputMatchSince > stableThresholdMs) {
+                    return;
+                }
+            }
+            else {
+                inputMatchSince = null;
             }
         }
         await delay(250);
@@ -231,6 +373,58 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
     await logDomFailure(Runtime, logger ?? (() => { }), 'file-upload-timeout');
     throw new Error('Attachments did not finish uploading before timeout.');
 }
+export async function waitForUserTurnAttachments(Runtime, expectedNames, timeoutMs, logger) {
+    if (!expectedNames || expectedNames.length === 0) {
+        return;
+    }
+    const expectedNormalized = expectedNames.map((name) => name.toLowerCase());
+    const conversationSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const expression = `(() => {
+    const CONVERSATION_SELECTOR = ${conversationSelectorLiteral};
+    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const userTurns = turns.filter((node) => {
+      const attr = (node.getAttribute('data-message-author-role') || node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
+      if (attr === 'user') return true;
+      return Boolean(node.querySelector('[data-message-author-role="user"]'));
+    });
+    const lastUser = userTurns[userTurns.length - 1];
+    if (!lastUser) return { ok: false };
+    const text = (lastUser.innerText || '').toLowerCase();
+    const attrs = Array.from(lastUser.querySelectorAll('[aria-label],[title]')).map((el) => {
+      const aria = el.getAttribute('aria-label') || '';
+      const title = el.getAttribute('title') || '';
+      return (aria + ' ' + title).trim().toLowerCase();
+    }).filter(Boolean);
+    return { ok: true, text, attrs };
+  })()`;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+        const value = result?.value;
+        if (!value?.ok) {
+            await delay(200);
+            continue;
+        }
+        const haystack = [value.text ?? '', ...(value.attrs ?? [])].join('\n');
+        const missing = expectedNormalized.filter((expected) => {
+            const baseName = expected.split('/').pop()?.split('\\').pop() ?? expected;
+            const normalizedExpected = baseName.toLowerCase().replace(/\s+/g, ' ').trim();
+            const expectedNoExt = normalizedExpected.replace(/\.[a-z0-9]{1,10}$/i, '');
+            if (haystack.includes(normalizedExpected))
+                return false;
+            if (expectedNoExt.length >= 6 && haystack.includes(expectedNoExt))
+                return false;
+            return true;
+        });
+        if (missing.length === 0) {
+            return;
+        }
+        await delay(250);
+    }
+    logger?.('Sent user message did not show expected attachment names in time.');
+    await logDomFailure(Runtime, logger ?? (() => { }), 'attachment-missing-user-turn');
+    throw new Error('Attachment was not present on the sent user message.');
+}
 export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs, logger) {
     // Attachments can take a few seconds to render in the composer (headless/remote Chrome is slower),
     // so respect the caller-provided timeout instead of capping at 2s.
@@ -238,6 +432,7 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
     const expression = `(() => {
     const expected = ${JSON.stringify(expectedName)};
     const normalized = expected.toLowerCase();
+    const normalizedNoExt = normalized.replace(/\\.[a-z0-9]{1,10}$/i, '');
     const matchNode = (node) => {
       if (!node) return false;
       const text = (node.textContent || '').toLowerCase();
@@ -245,63 +440,26 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
       const title = node.getAttribute?.('title')?.toLowerCase?.() ?? '';
       const testId = node.getAttribute?.('data-testid')?.toLowerCase?.() ?? '';
       const alt = node.getAttribute?.('alt')?.toLowerCase?.() ?? '';
-      return [text, aria, title, testId, alt].some((value) => value.includes(normalized));
+      const candidates = [text, aria, title, testId, alt].filter(Boolean);
+      return candidates.some((value) => value.includes(normalized) || (normalizedNoExt.length >= 6 && value.includes(normalizedNoExt)));
     };
 
-    const turns = Array.from(document.querySelectorAll('article[data-testid^="conversation-turn"]'));
-    const userTurns = turns.filter((node) => node.querySelector('[data-message-author-role="user"]'));
-    const lastUser = userTurns[userTurns.length - 1];
-    if (lastUser) {
-      const turnMatch = Array.from(lastUser.querySelectorAll('*')).some(matchNode);
-      if (turnMatch) return { found: true, userTurns: userTurns.length, source: 'turn' };
-    }
-
-    const composerSelectors = [
-      '[data-testid*="composer"]',
-      'form textarea',
-      'form [data-testid*="attachment"]',
-      '[data-testid*="upload"]',
-      '[data-testid*="chip"]',
-      'form',
-      'button',
-      'label'
-    ];
-    const composerMatch = composerSelectors.some((selector) =>
-      Array.from(document.querySelectorAll(selector)).some(matchNode),
-    );
-    if (composerMatch) {
-      return { found: true, userTurns: userTurns.length, source: 'composer' };
-    }
-
     const attachmentSelectors = ['[data-testid*="attachment"]','[data-testid*="chip"]','[data-testid*="upload"]'];
     const attachmentMatch = attachmentSelectors.some((selector) =>
       Array.from(document.querySelectorAll(selector)).some(matchNode),
     );
     if (attachmentMatch) {
-      return { found: true, userTurns: userTurns.length, source: 'attachments' };
+      return { found: true, source: 'attachments' };
     }
 
-    const cardTexts = Array.from(document.querySelectorAll('[aria-label="Remove file"]')).map((btn) =>
+    const cardTexts = Array.from(document.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
       btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
     );
-    if (cardTexts.some((text) => text.includes(normalized))) {
-      return { found: true, userTurns: userTurns.length, source: 'attachment-cards' };
-    }
-
-    const attrMatch = Array.from(document.querySelectorAll('[aria-label], [title], [data-testid]')).some(matchNode);
-    if (attrMatch) {
-      return { found: true, userTurns: userTurns.length, source: 'attrs' };
+    if (cardTexts.some((text) => text.includes(normalized) || (normalizedNoExt.length >= 6 && text.includes(normalizedNoExt)))) {
+      return { found: true, source: 'attachment-cards' };
     }
 
-    const bodyMatch = (document.body?.innerText || '').toLowerCase().includes(normalized);
-    if (bodyMatch) {
-      return { found: true, userTurns: userTurns.length, source: 'body' };
-    }
-
-    const inputHit = Array.from(document.querySelectorAll('input[type="file"]')).some((el) =>
-      Array.from(el.files || []).some((file) => file?.name?.toLowerCase?.().includes(normalized)),
-    );
-    return { found: inputHit, userTurns: userTurns.length, source: inputHit ? 'input' : undefined };
+    return { found: false };
   })()`;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression, returnByValue: true });
@@ -319,28 +477,47 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     const expression = `(() => {
     const normalized = ${JSON.stringify(expectedName.toLowerCase())};
-    const selectors = ['[data-testid*="attachment"]','[data-testid*="chip"]','[data-testid*="upload"]'];
+    const normalizedNoExt = normalized.replace(/\\.[a-z0-9]{1,10}$/i, '');
+    const matchesExpected = (value) => {
+      const text = (value ?? '').toLowerCase();
+      if (!text) return false;
+      if (text.includes(normalized)) return true;
+      if (normalizedNoExt.length >= 6 && text.includes(normalizedNoExt)) return true;
+      if (text.includes('…') || text.includes('...')) {
+        const escaped = text.replace(/[.*+?^$\\{\\}()|[\\]\\\\]/g, '\\\\$&');
+        const pattern = escaped.replaceAll('…', '.*').replaceAll('...', '.*');
+        try {
+          const re = new RegExp(pattern);
+          return re.test(normalized) || (normalizedNoExt.length >= 6 && re.test(normalizedNoExt));
+        } catch {
+          return false;
+        }
+      }
+      return false;
+    };
+
+    const selectors = [
+      '[data-testid*="attachment"]',
+      '[data-testid*="chip"]',
+      '[data-testid*="upload"]',
+      '[aria-label*="Remove"]',
+      'button[aria-label*="Remove"]',
+    ];
     for (const selector of selectors) {
       for (const node of Array.from(document.querySelectorAll(selector))) {
-        const text = (node?.textContent || '').toLowerCase();
-        if (text.includes(normalized)) {
-          return { found: true, text };
+        const text = node?.textContent || '';
+        const aria = node?.getAttribute?.('aria-label') || '';
+        const title = node?.getAttribute?.('title') || '';
+        if ([text, aria, title].some(matchesExpected)) {
+          return { found: true, text: (text || aria || title).toLowerCase() };
         }
       }
     }
-    const cards = Array.from(document.querySelectorAll('[aria-label="Remove file"]')).map((btn) =>
+    const cards = Array.from(document.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
       btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
     );
-    if (cards.some((text) => text.includes(normalized))) {
-      return { found: true, text: cards.find((t) => t.includes(normalized)) };
-    }
-
-    // As a last resort, treat file inputs that hold the target name as anchored. Some UIs delay chip rendering.
-    const inputHit = Array.from(document.querySelectorAll('input[type="file"]')).some((el) =>
-      Array.from(el.files || []).some((file) => file?.name?.toLowerCase?.().includes(normalized)),
-    );
-    if (inputHit) {
-      return { found: true, text: 'input-only' };
+    if (cards.some(matchesExpected)) {
+      return { found: true, text: cards.find(matchesExpected) };
     }
     return { found: false };
   })()`;