@steipete/oracle 0.7.5 → 0.8.0

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

@@ -2,39 +2,275 @@ import path from 'node:path';
 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) {
+import { transferAttachmentViaDataTransfer } from './attachmentDataTransfer.js';
+export async function uploadAttachmentFile(deps, attachment, logger, options) {
     const { runtime, dom } = deps;
     if (!dom) {
         throw new Error('DOM domain unavailable while uploading attachments.');
     }
-    const isAttachmentPresent = async (name) => {
+    const expectedCount = typeof options?.expectedCount === 'number' && Number.isFinite(options.expectedCount)
+        ? Math.max(0, Math.floor(options.expectedCount))
+        : 0;
+    const readAttachmentSignals = async (name) => {
         const check = await runtime.evaluate({
             expression: `(() => {
-        const expected = ${JSON.stringify(name.toLowerCase())};
-        const selectors = [
+        const expected = ${JSON.stringify(name)};
+        const normalizedExpected = String(expected || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+        const expectedNoExt = normalizedExpected.replace(/\\.[a-z0-9]{1,10}$/i, '');
+        const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+        const matchesExpected = (value) => {
+          const text = normalize(value);
+          if (!text) return false;
+          if (text.includes(normalizedExpected)) return true;
+          if (expectedNoExt.length >= 6 && text.includes(expectedNoExt)) return true;
+          if (text.includes('…') || text.includes('...')) {
+            const marker = text.includes('…') ? '…' : '...';
+            const [prefixRaw, suffixRaw] = text.split(marker);
+            const prefix = normalize(prefixRaw);
+            const suffix = normalize(suffixRaw);
+            const target = expectedNoExt.length >= 6 ? expectedNoExt : normalizedExpected;
+            const matchesPrefix = !prefix || target.includes(prefix);
+            const matchesSuffix = !suffix || target.includes(suffix);
+            return matchesPrefix && matchesSuffix;
+          }
+          return false;
+        };
+
+        const promptSelectors = ${JSON.stringify(INPUT_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 sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+        const attachmentSelectors = [
+          'input[type="file"]',
           '[data-testid*="attachment"]',
-          '[data-testid*="chip"]',
-          '[data-testid*="upload"]'
+          '[data-testid*="upload"]',
+          '[aria-label*="Remove"]',
+          '[aria-label*="remove"]',
         ];
-        const chips = selectors.some((selector) =>
-          Array.from(document.querySelectorAll(selector)).some((node) =>
-            (node?.textContent || '').toLowerCase().includes(expected),
-          ),
-        );
-        if (chips) return true;
-        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 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 root = locateComposerRoot();
+        const scope = (() => {
+          if (!root) return document.body;
+          const parent = root.parentElement;
+          const parentHasSend = parent && sendSelectors.some((selector) => parent.querySelector(selector));
+          return parentHasSend ? parent : root;
+        })();
+        const rootTextRaw = root ? (root.innerText || root.textContent || '') : '';
+        const chipSelector = [
+          '[data-testid*="attachment"]',
+          '[data-testid*="chip"]',
+          '[data-testid*="upload"]',
+          '[data-testid*="file"]',
+          '[aria-label*="Remove"]',
+          'button[aria-label*="Remove"]',
+          '[aria-label*="remove"]',
+        ].join(',');
+        const localCandidates = scope ? Array.from(scope.querySelectorAll(chipSelector)) : [];
+        const globalCandidates = Array.from(document.querySelectorAll(chipSelector));
+        const matchCandidates = localCandidates.length > 0 ? localCandidates : globalCandidates;
+        const serializeChip = (node) => {
+          const text = node?.textContent ?? '';
+          const aria = node?.getAttribute?.('aria-label') ?? '';
+          const title = node?.getAttribute?.('title') ?? '';
+          const testid = node?.getAttribute?.('data-testid') ?? '';
+          return [text, aria, title, testid].map(normalize).join('|');
+        };
+        const chipSignature = localCandidates.map(serializeChip).join('||');
+        let uiMatch = false;
+        for (const node of matchCandidates) {
+          if (node?.tagName === 'INPUT' && node?.type === 'file') continue;
+          const text = node?.textContent ?? '';
+          const aria = node?.getAttribute?.('aria-label') ?? '';
+          const title = node?.getAttribute?.('title') ?? '';
+          if ([text, aria, title].some(matchesExpected)) {
+            uiMatch = true;
+            break;
+          }
+        }
+
+        if (!uiMatch) {
+          const removeScope = root ?? document;
+          const cardTexts = Array.from(removeScope.querySelectorAll('[aria-label*="Remove"],[aria-label*="remove"]')).map(
+            (btn) => btn?.parentElement?.parentElement?.innerText ?? '',
+          );
+          if (cardTexts.some(matchesExpected)) {
+            uiMatch = true;
+          }
+        }
+
+        const inputScope = scope ? Array.from(scope.querySelectorAll('input[type="file"]')) : [];
+        const inputs = [];
+        const inputSeen = new Set();
+        for (const el of [...inputScope, ...Array.from(document.querySelectorAll('input[type="file"]'))]) {
+          if (!inputSeen.has(el)) {
+            inputSeen.add(el);
+            inputs.push(el);
+          }
+        }
+        const inputNames = [];
+        let inputCount = 0;
+        for (const el of inputs) {
+          if (!(el instanceof HTMLInputElement)) continue;
+          const files = Array.from(el.files || []);
+          if (files.length > 0) {
+            inputCount += files.length;
+            for (const file of files) {
+              if (file?.name) inputNames.push(file.name);
+            }
+          }
+        }
+        const inputMatch = inputNames.some((file) => matchesExpected(file));
+        const uploadingSelectors = ${JSON.stringify(UPLOAD_STATUS_SELECTORS)};
+        const uploading = uploadingSelectors.some((selector) => {
+          return Array.from(document.querySelectorAll(selector)).some((node) => {
+            const ariaBusy = node.getAttribute?.('aria-busy');
+            const dataState = node.getAttribute?.('data-state');
+            if (ariaBusy === 'true' || dataState === 'loading' || dataState === 'uploading' || dataState === 'pending') {
+              return true;
+            }
+            const text = node.textContent?.toLowerCase?.() ?? '';
+            return /\\buploading\\b/.test(text) || /\\bprocessing\\b/.test(text);
+          });
+        });
+
+        const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+        const collectFileCount = (candidates) => {
+          let count = 0;
+          for (const node of candidates) {
+            if (!(node instanceof HTMLElement)) continue;
+            if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+            const dataTestId = node.getAttribute?.('data-testid') ?? '';
+            const aria = node.getAttribute?.('aria-label') ?? '';
+            const title = node.getAttribute?.('title') ?? '';
+            const tooltip =
+              node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+            const text = node.textContent ?? '';
+            const parent = node.parentElement;
+            const parentText = parent?.textContent ?? '';
+            const parentAria = parent?.getAttribute?.('aria-label') ?? '';
+            const parentTitle = parent?.getAttribute?.('title') ?? '';
+            const parentTooltip =
+              parent?.getAttribute?.('data-tooltip') ?? parent?.getAttribute?.('data-tooltip-content') ?? '';
+            const parentTestId = parent?.getAttribute?.('data-testid') ?? '';
+            const values = [
+              text,
+              aria,
+              title,
+              tooltip,
+              dataTestId,
+              parentText,
+              parentAria,
+              parentTitle,
+              parentTooltip,
+              parentTestId,
+            ];
+            let hasFileHint = false;
+            for (const raw of values) {
+              if (!raw) continue;
+              if (normalize(raw).includes('file')) {
+                hasFileHint = true;
+                break;
+              }
+            }
+            if (!hasFileHint) continue;
+            for (const raw of values) {
+              if (!raw) continue;
+              const match = normalize(raw).match(countRegex);
+              if (match) {
+                const parsed = Number(match[1]);
+                if (Number.isFinite(parsed)) {
+                  count = Math.max(count, parsed);
+                }
+              }
+            }
+          }
+          return count;
+        };
+        const fileCountSelectors = [
+          'button',
+          '[role="button"]',
+          '[data-testid*="file"]',
+          '[data-testid*="upload"]',
+          '[data-testid*="attachment"]',
+          '[data-testid*="chip"]',
+          '[aria-label*="file"]',
+          '[title*="file"]',
+          '[aria-label*="attachment"]',
+          '[title*="attachment"]',
+        ].join(',');
+        const fileCountScope = scope ?? root ?? document.body;
+        const localFileNodes = fileCountScope
+          ? Array.from(fileCountScope.querySelectorAll(fileCountSelectors))
+          : [];
+        const globalFileNodes = Array.from(document.querySelectorAll(fileCountSelectors));
+        let fileCount = collectFileCount(localFileNodes);
+        if (!fileCount && globalFileNodes.length > 0) {
+          fileCount = collectFileCount(globalFileNodes);
+        }
+        const hasAttachmentSignal = localCandidates.length > 0 || inputCount > 0 || fileCount > 0 || uploading;
+        if (!uiMatch && rootTextRaw && hasAttachmentSignal && matchesExpected(rootTextRaw)) {
+          uiMatch = true;
+        }
 
-        const inputs = Array.from(document.querySelectorAll('input[type="file"]')).some((el) =>
-          Array.from(el.files || []).some((f) => f?.name?.toLowerCase?.().includes(expected)),
-        );
-        return inputs;
+        return {
+          ui: uiMatch,
+          input: inputMatch,
+          inputCount,
+          chipCount: localCandidates.length,
+          chipSignature,
+          uploading,
+          fileCount,
+        };
       })()`,
             returnByValue: true,
         });
-        return Boolean(check?.result?.value);
+        const value = check?.result?.value;
+        return {
+            ui: Boolean(value?.ui),
+            input: Boolean(value?.input),
+            inputCount: typeof value?.inputCount === 'number' ? value?.inputCount : 0,
+            chipCount: typeof value?.chipCount === 'number' ? value?.chipCount : 0,
+            chipSignature: typeof value?.chipSignature === 'string' ? value?.chipSignature : '',
+            uploading: Boolean(value?.uploading),
+            fileCount: typeof value?.fileCount === 'number' ? value?.fileCount : 0,
+        };
     };
     // New ChatGPT UI hides the real file input behind a composer "+" menu; click it pre-emptively.
     await Promise.resolve(runtime.evaluate({
@@ -74,26 +310,126 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
       })()`,
         returnByValue: true,
     })).catch(() => undefined);
+    const normalizeForMatch = (value) => String(value || '')
+        .toLowerCase()
+        .replace(/\s+/g, ' ')
+        .trim();
     const expectedName = path.basename(attachment.path);
-    if (await isAttachmentPresent(expectedName)) {
+    const expectedNameLower = normalizeForMatch(expectedName);
+    const expectedNameNoExt = expectedNameLower.replace(/\.[a-z0-9]{1,10}$/i, '');
+    const matchesExpectedName = (value) => {
+        const normalized = normalizeForMatch(value);
+        if (!normalized)
+            return false;
+        if (normalized.includes(expectedNameLower))
+            return true;
+        if (expectedNameNoExt.length >= 6 && normalized.includes(expectedNameNoExt))
+            return true;
+        return false;
+    };
+    const isImageAttachment = /\.(png|jpe?g|gif|webp|bmp|svg|heic|heif)$/i.test(expectedName);
+    const attachmentUiTimeoutMs = 25_000;
+    const attachmentUiSignalWaitMs = 5_000;
+    const initialSignals = await readAttachmentSignals(expectedName);
+    let inputConfirmed = false;
+    if (initialSignals.ui) {
         logger(`Attachment already present: ${path.basename(attachment.path)}`);
-        return;
+        return true;
+    }
+    const isExpectedSatisfied = (signals) => {
+        if (expectedCount <= 0)
+            return false;
+        const fileCount = typeof signals.fileCount === 'number' ? signals.fileCount : 0;
+        const chipCount = typeof signals.chipCount === 'number' ? signals.chipCount : 0;
+        if (fileCount >= expectedCount)
+            return true;
+        return Boolean(signals.ui && chipCount >= expectedCount);
+    };
+    const initialInputSatisfied = expectedCount > 0 ? initialSignals.inputCount >= expectedCount : Boolean(initialSignals.input);
+    if (expectedCount > 0 && (initialSignals.fileCount >= expectedCount || initialSignals.inputCount >= expectedCount)) {
+        const satisfiedCount = Math.max(initialSignals.fileCount, initialSignals.inputCount);
+        logger(`Attachment already present: composer shows ${satisfiedCount} file${satisfiedCount === 1 ? '' : 's'}`);
+        return true;
+    }
+    if (initialInputSatisfied || initialSignals.input) {
+        logger(`Attachment already queued in file input: ${path.basename(attachment.path)}`);
+        return true;
     }
     const documentNode = await dom.getDocument();
     const candidateSetup = await runtime.evaluate({
         expression: `(() => {
       const promptSelectors = ${JSON.stringify(INPUT_SELECTORS)};
-      const locateComposerRoot = () => {
+      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) continue;
-          return node.closest('form') ?? node.closest('[data-testid*="composer"]') ?? node.parentElement;
+          if (node) return node;
+        }
+        return null;
+      };
+      const attachmentSelectors = [
+        'input[type="file"]',
+        '[data-testid*="attachment"]',
+        '[data-testid*="upload"]',
+        '[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 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 scope = (() => {
+        if (!root) return document.body;
+        const parent = root.parentElement;
+        const parentHasSend = parent && sendSelectors.some((selector) => parent.querySelector(selector));
+        return parentHasSend ? parent : root;
+      })();
+      const localInputs = scope ? Array.from(scope.querySelectorAll('input[type="file"]')) : [];
+      const globalInputs = Array.from(document.querySelectorAll('input[type="file"]'));
+      const inputs = [];
+      const inputSeen = new Set();
+      for (const el of [...localInputs, ...globalInputs]) {
+        if (!inputSeen.has(el)) {
+          inputSeen.add(el);
+          inputs.push(el);
+        }
+      }
+      const baselineInputCount = inputs.reduce((total, el) => {
+        if (!(el instanceof HTMLInputElement)) return total;
+        const count = Array.from(el.files || []).length;
+        return total + count;
+      }, 0);
+      const isImageAttachment = ${JSON.stringify(isImageAttachment)};
       const acceptIsImageOnly = (accept) => {
         if (!accept) return false;
         const parts = String(accept)
@@ -102,53 +438,295 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
           .filter(Boolean);
         return parts.length > 0 && parts.every((p) => p.startsWith('image/'));
       };
-      const chipContainer = root ?? document;
-      const chipSelector = '[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[aria-label*="Remove"],[aria-label*="remove"]';
+      const chipContainer = scope ?? document;
+        const chipSelector = '[data-testid*="attachment"],[data-testid*="chip"],[data-testid*="upload"],[data-testid*="file"],[aria-label*="Remove"],[aria-label*="remove"]';
       const baselineChipCount = chipContainer.querySelectorAll(chipSelector).length;
+      const baselineChips = 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 uploadingSelectors = ${JSON.stringify(UPLOAD_STATUS_SELECTORS)};
+      const baselineUploading = uploadingSelectors.some((selector) => {
+        return Array.from(document.querySelectorAll(selector)).some((node) => {
+          const ariaBusy = node.getAttribute?.('aria-busy');
+          const dataState = node.getAttribute?.('data-state');
+          if (ariaBusy === 'true' || dataState === 'loading' || dataState === 'uploading' || dataState === 'pending') {
+            return true;
+          }
+          const text = node.textContent?.toLowerCase?.() ?? '';
+          return /\\buploading\\b/.test(text) || /\\bprocessing\\b/.test(text);
+        });
+      });
+      const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+      const collectFileCount = (candidates) => {
+        let count = 0;
+        for (const node of candidates) {
+          if (!(node instanceof HTMLElement)) continue;
+          if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+          const dataTestId = node.getAttribute?.('data-testid') ?? '';
+          const aria = node.getAttribute?.('aria-label') ?? '';
+          const title = node.getAttribute?.('title') ?? '';
+          const tooltip =
+            node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+          const text = node.textContent ?? '';
+          const parent = node.parentElement;
+          const parentText = parent?.textContent ?? '';
+          const parentAria = parent?.getAttribute?.('aria-label') ?? '';
+          const parentTitle = parent?.getAttribute?.('title') ?? '';
+          const parentTooltip =
+            parent?.getAttribute?.('data-tooltip') ?? parent?.getAttribute?.('data-tooltip-content') ?? '';
+          const parentTestId = parent?.getAttribute?.('data-testid') ?? '';
+          const values = [
+            text,
+            aria,
+            title,
+            tooltip,
+            dataTestId,
+            parentText,
+            parentAria,
+            parentTitle,
+            parentTooltip,
+            parentTestId,
+          ];
+          let hasFileHint = false;
+          for (const raw of values) {
+            if (!raw) continue;
+            if (String(raw).toLowerCase().includes('file')) {
+              hasFileHint = true;
+              break;
+            }
+          }
+          if (!hasFileHint) continue;
+          for (const raw of values) {
+            if (!raw) continue;
+            const match = String(raw).toLowerCase().match(countRegex);
+            if (match) {
+              const parsed = Number(match[1]);
+              if (Number.isFinite(parsed)) {
+                count = Math.max(count, parsed);
+              }
+            }
+          }
+        }
+        return count;
+      };
+      const fileCountSelectors = [
+        'button',
+        '[role="button"]',
+        '[data-testid*="file"]',
+        '[data-testid*="upload"]',
+        '[data-testid*="attachment"]',
+        '[data-testid*="chip"]',
+        '[aria-label*="file"]',
+        '[title*="file"]',
+        '[aria-label*="attachment"]',
+        '[title*="attachment"]',
+      ].join(',');
+      const fileCountScope = scope ?? root ?? document.body;
+      const localFileNodes = fileCountScope
+        ? Array.from(fileCountScope.querySelectorAll(fileCountSelectors))
+        : [];
+      const globalFileNodes = Array.from(document.querySelectorAll(fileCountSelectors));
+      let baselineFileCount = collectFileCount(localFileNodes);
+      if (!baselineFileCount && globalFileNodes.length > 0) {
+        baselineFileCount = collectFileCount(globalFileNodes);
+      }
 
       // Mark candidates with stable indices so we can select them via DOM.querySelector.
       let idx = 0;
-      const candidates = inputs.map((el) => {
+      let candidates = inputs.map((el) => {
         const accept = el.getAttribute('accept') || '';
-        const score = (el.hasAttribute('multiple') ? 100 : 0) + (!acceptIsImageOnly(accept) ? 10 : 0);
+        const imageOnly = acceptIsImageOnly(accept);
+        const score =
+          (el.hasAttribute('multiple') ? 100 : 0) +
+          (!imageOnly ? 20 : isImageAttachment ? 15 : -500);
         el.setAttribute('data-oracle-upload-candidate', 'true');
         el.setAttribute('data-oracle-upload-idx', String(idx));
-        return { idx: idx++, score };
+        return { idx: idx++, score, imageOnly };
       });
+      if (!isImageAttachment) {
+        const nonImage = candidates.filter((candidate) => !candidate.imageOnly);
+        if (nonImage.length > 0) {
+          candidates = nonImage;
+        }
+      }
 
       // Prefer higher scores first.
       candidates.sort((a, b) => b.score - a.score);
-      return { ok: candidates.length > 0, baselineChipCount, order: candidates.map((c) => c.idx) };
+      return {
+        ok: candidates.length > 0,
+        baselineChipCount,
+        baselineChips,
+        baselineUploading,
+        baselineFileCount,
+        baselineInputCount,
+        order: candidates.map((c) => c.idx),
+      };
     })()`,
         returnByValue: true,
     });
     const candidateValue = candidateSetup?.result?.value;
     const candidateOrder = Array.isArray(candidateValue?.order) ? candidateValue.order : [];
     const baselineChipCount = typeof candidateValue?.baselineChipCount === 'number' ? candidateValue.baselineChipCount : 0;
+    const baselineChips = Array.isArray(candidateValue?.baselineChips) ? candidateValue.baselineChips : [];
+    const baselineUploading = Boolean(candidateValue?.baselineUploading);
+    const baselineFileCount = typeof candidateValue?.baselineFileCount === 'number' ? candidateValue.baselineFileCount : 0;
+    const baselineInputCount = typeof candidateValue?.baselineInputCount === 'number' ? candidateValue.baselineInputCount : 0;
+    const serializeChips = (chips) => chips
+        .map((chip) => [chip.text, chip.aria, chip.title, chip.testid]
+        .map((value) => String(value || '').toLowerCase().replace(/\s+/g, ' ').trim())
+        .join('|'))
+        .join('||');
+    const baselineChipSignature = serializeChips(baselineChips);
     if (!candidateValue?.ok || candidateOrder.length === 0) {
         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 hasChipDelta = (signals) => {
+        const chipCount = typeof signals.chipCount === 'number' ? signals.chipCount : 0;
+        const chipSignature = typeof signals.chipSignature === 'string' ? signals.chipSignature : '';
+        if (chipCount > baselineChipCount)
+            return true;
+        if (baselineChipSignature && chipSignature && chipSignature !== baselineChipSignature)
+            return true;
+        return false;
+    };
+    const hasInputDelta = (signals) => (typeof signals.inputCount === 'number' ? signals.inputCount : 0) > baselineInputCount;
+    const hasUploadDelta = (signals) => Boolean(signals.uploading && !baselineUploading);
+    const hasFileCountDelta = (signals) => (typeof signals.fileCount === 'number' ? signals.fileCount : 0) > baselineFileCount;
+    const waitForAttachmentUiSignal = async (timeoutMs) => {
+        const deadline = Date.now() + timeoutMs;
+        let sawInputSignal = false;
+        let latest = null;
+        while (Date.now() < deadline) {
+            const signals = await readAttachmentSignals(expectedName);
+            const chipDelta = hasChipDelta(signals);
+            const inputDelta = hasInputDelta(signals) || signals.input;
+            const uploadDelta = hasUploadDelta(signals);
+            const fileCountDelta = hasFileCountDelta(signals);
+            const expectedSatisfied = isExpectedSatisfied(signals);
+            if (inputDelta) {
+                sawInputSignal = true;
+            }
+            latest = { signals, chipDelta, inputDelta: sawInputSignal, uploadDelta, fileCountDelta, expectedSatisfied };
+            if (signals.ui || chipDelta || uploadDelta || fileCountDelta || expectedSatisfied) {
+                return latest;
+            }
+            await delay(250);
+        }
+        return latest;
+    };
+    const inputSnapshotFor = (idx) => `(() => {
+    const input = document.querySelector('input[type="file"][data-oracle-upload-idx="${idx}"]');
+    if (!(input instanceof HTMLInputElement)) {
+      return { names: [], value: '', count: 0 };
     }
-    return true;
+    return {
+      names: Array.from(input.files || []).map((file) => file?.name ?? '').filter(Boolean),
+      value: input.value || '',
+      count: Array.from(input.files || []).length,
+    };
   })()`;
+    const parseInputSnapshot = (value) => {
+        const snapshot = value;
+        const names = Array.isArray(snapshot?.names) ? snapshot?.names ?? [] : [];
+        const valueText = typeof snapshot?.value === 'string' ? snapshot.value : '';
+        const count = typeof snapshot?.count === 'number' ? snapshot.count : names.length;
+        return {
+            names,
+            value: valueText,
+            count: Number.isFinite(count) ? count : names.length,
+        };
+    };
+    const readInputSnapshot = async (idx) => {
+        const snapshot = await runtime
+            .evaluate({ expression: inputSnapshotFor(idx), returnByValue: true })
+            .then((res) => parseInputSnapshot(res?.result?.value))
+            .catch(() => parseInputSnapshot(undefined));
+        return snapshot;
+    };
+    const snapshotMatchesExpected = (snapshot) => {
+        const nameMatch = snapshot.names.some((name) => matchesExpectedName(name));
+        return nameMatch || Boolean(snapshot.value && matchesExpectedName(snapshot.value));
+    };
+    const inputSignalsFor = (baseline, current) => {
+        const baselineCount = baseline.count ?? baseline.names.length;
+        const currentCount = current.count ?? current.names.length;
+        const countDelta = currentCount > baselineCount;
+        const valueDelta = Boolean(current.value) && current.value !== baseline.value;
+        const baselineEmpty = baselineCount === 0 && !baseline.value;
+        const nameMatch = current.names.some((name) => matchesExpectedName(name)) ||
+            (current.value && matchesExpectedName(current.value));
+        const touched = nameMatch || countDelta || (baselineEmpty && valueDelta);
+        return {
+            touched,
+            nameMatch,
+            countDelta,
+            valueDelta,
+        };
+    };
     const composerSnapshotFor = (idx) => `(() => {
     const promptSelectors = ${JSON.stringify(INPUT_SELECTORS)};
-    const locateComposerRoot = () => {
+    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) continue;
-        return node.closest('form') ?? node.closest('[data-testid*="composer"]') ?? node.parentElement;
+        if (node) return node;
+      }
+      return null;
+    };
+    const composerAttachmentSelectors = [
+      'input[type="file"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="upload"]',
+      '[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 = composerAttachmentSelectors.some((selector) => current.querySelector(selector));
+            if (hasAttachment) {
+              return current;
+            }
+          }
+          current = current.parentElement;
+        }
+        return fallback ?? initial;
       }
       return document.querySelector('form') ?? document.body;
     };
     const root = locateComposerRoot();
-    const chipContainer = root ?? document;
+    const scope = (() => {
+      if (!root) return document.body;
+      const parent = root.parentElement;
+      const parentHasSend = parent && sendSelectors.some((selector) => parent.querySelector(selector));
+      return parentHasSend ? parent : root;
+    })();
+    const chipContainer = scope ?? 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)
@@ -158,92 +736,392 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         title: node.getAttribute?.('title') ?? '',
         testid: node.getAttribute?.('data-testid') ?? '',
       }));
+    const uploadingSelectors = ${JSON.stringify(UPLOAD_STATUS_SELECTORS)};
+    const uploading = uploadingSelectors.some((selector) => {
+      return Array.from(document.querySelectorAll(selector)).some((node) => {
+        const ariaBusy = node.getAttribute?.('aria-busy');
+        const dataState = node.getAttribute?.('data-state');
+        if (ariaBusy === 'true' || dataState === 'loading' || dataState === 'uploading' || dataState === 'pending') {
+          return true;
+        }
+        const text = node.textContent?.toLowerCase?.() ?? '';
+        return /\\buploading\\b/.test(text) || /\\bprocessing\\b/.test(text);
+      });
+    });
     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 };
+    return {
+      chipCount: chipContainer.querySelectorAll(chipSelector).length,
+      chips,
+      inputNames,
+      composerText,
+      uploading,
+    };
   })()`;
+    let confirmedAttachment = false;
+    let lastInputNames = [];
+    let lastInputValue = '';
     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;
+    const resolveInputNameCandidates = () => {
+        const snapshot = finalSnapshot;
+        const snapshotNames = snapshot?.inputNames;
+        if (Array.isArray(snapshotNames) && snapshotNames.length > 0) {
+            return snapshotNames;
         }
-        await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [attachment.path] });
-        await runtime.evaluate({ expression: dispatchEventsFor(idx), returnByValue: true }).catch(() => undefined);
-        await delay(350);
-        const probeDeadline = Date.now() + 6500;
-        const pokeIntervalMs = 1200;
-        let lastPoke = 0;
-        let seenInputHasFile = false;
-        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 (!seenInputHasFile && Date.now() - lastPoke > pokeIntervalMs) {
-                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()));
-                seenInputHasFile = seenInputHasFile || inputHasFile;
-                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;
+        return lastInputNames;
+    };
+    if (!inputConfirmed) {
+        for (let orderIndex = 0; orderIndex < candidateOrder.length; orderIndex += 1) {
+            const idx = candidateOrder[orderIndex];
+            const queuedSignals = await readAttachmentSignals(expectedName);
+            if (queuedSignals.ui ||
+                isExpectedSatisfied(queuedSignals) ||
+                hasChipDelta(queuedSignals) ||
+                hasUploadDelta(queuedSignals) ||
+                hasFileCountDelta(queuedSignals)) {
+                confirmedAttachment = true;
+                break;
+            }
+            if (queuedSignals.input || hasInputDelta(queuedSignals)) {
+                inputConfirmed = true;
+                break;
+            }
+            const resultNode = await dom.querySelector({
+                nodeId: documentNode.root.nodeId,
+                selector: `input[type="file"][data-oracle-upload-idx="${idx}"]`,
+            });
+            if (!resultNode?.nodeId) {
+                continue;
+            }
+            const baselineInputSnapshot = await readInputSnapshot(idx);
+            const gatherSignals = async () => {
+                const signalResult = await waitForAttachmentUiSignal(attachmentUiSignalWaitMs);
+                const postInputSnapshot = await readInputSnapshot(idx);
+                const postInputSignals = inputSignalsFor(baselineInputSnapshot, postInputSnapshot);
+                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 : '',
+                        uploading: Boolean(snapshot.uploading),
+                    };
+                }
+                lastInputNames = postInputSnapshot.names;
+                lastInputValue = postInputSnapshot.value;
+                return { signalResult, postInputSignals };
+            };
+            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) {
+                    return { status: 'ui' };
+                }
+                const postSignals = await readAttachmentSignals(expectedName);
+                if (postSignals.ui ||
+                    isExpectedSatisfied(postSignals) ||
+                    hasChipDelta(postSignals) ||
+                    hasUploadDelta(postSignals) ||
+                    hasFileCountDelta(postSignals)) {
+                    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) ||
+                    Boolean(signalResult?.inputDelta) ||
+                    inputHasFile ||
+                    postSignals.input ||
+                    hasInputDelta(postSignals);
+                if (inputSignal) {
+                    return { status: 'input' };
                 }
+                return { status: 'none' };
+            };
+            const runInputAttempt = async (mode) => {
+                let immediateInputSnapshot = await readInputSnapshot(idx);
+                let hasExpectedFile = snapshotMatchesExpected(immediateInputSnapshot);
+                if (!hasExpectedFile) {
+                    if (mode === 'set') {
+                        await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [attachment.path] });
+                    }
+                    else {
+                        const selector = `input[type="file"][data-oracle-upload-idx="${idx}"]`;
+                        try {
+                            await transferAttachmentViaDataTransfer(runtime, attachment, selector);
+                        }
+                        catch (error) {
+                            logger(`Attachment data transfer failed: ${error?.message ?? String(error)}`);
+                        }
+                    }
+                    immediateInputSnapshot = await readInputSnapshot(idx);
+                    hasExpectedFile = snapshotMatchesExpected(immediateInputSnapshot);
+                }
+                const immediateSignals = inputSignalsFor(baselineInputSnapshot, immediateInputSnapshot);
+                lastInputNames = immediateInputSnapshot.names;
+                lastInputValue = immediateInputSnapshot.value;
+                const immediateInputMatch = immediateSignals.touched || hasExpectedFile;
+                if (immediateInputMatch) {
+                    inputConfirmed = true;
+                }
+                const signalState = await gatherSignals();
+                const evaluation = await evaluateSignals(signalState.signalResult, signalState.postInputSignals, immediateInputMatch);
+                return { evaluation, signalState, immediateInputMatch };
+            };
+            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;
+            }
+            const lateSignals = await readAttachmentSignals(expectedName);
+            if (lateSignals.ui ||
+                isExpectedSatisfied(lateSignals) ||
+                hasChipDelta(lateSignals) ||
+                hasUploadDelta(lateSignals) ||
+                hasFileCountDelta(lateSignals)) {
+                confirmedAttachment = true;
+                break;
+            }
+            if (lateSignals.input || hasInputDelta(lateSignals)) {
+                logger('Attachment input set; proceeding without UI confirmation.');
+                inputConfirmed = true;
+                break;
+            }
+            logger('Attachment not acknowledged after file input set; retrying with data transfer.');
+            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;
+            }
+            if (orderIndex < candidateOrder.length - 1) {
+                await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [] }).catch(() => undefined);
+                await delay(150);
             }
-            await delay(250);
-        }
-        const inputHasFile = finalSnapshot?.inputNames?.some((name) => name.toLowerCase().includes(expectedName.toLowerCase())) ?? false;
-        const uiAcknowledged = (finalSnapshot?.chipCount ?? 0) > baselineChipCount;
-        if (inputHasFile && uiAcknowledged) {
-            break;
         }
     }
-    const inputHasFile = finalSnapshot?.inputNames?.some((name) => name.toLowerCase().includes(expectedName.toLowerCase())) ?? false;
-    const attachmentUiTimeoutMs = 25_000;
+    if (confirmedAttachment) {
+        const inputNameCandidates = resolveInputNameCandidates();
+        const inputHasFile = inputNameCandidates.some((name) => matchesExpectedName(name)) ||
+            (lastInputValue && matchesExpectedName(lastInputValue));
+        await waitForAttachmentVisible(runtime, expectedName, attachmentUiTimeoutMs, logger);
+        logger(inputHasFile ? 'Attachment queued (UI anchored, file input confirmed)' : 'Attachment queued (UI anchored)');
+        return true;
+    }
+    const inputNameCandidates = resolveInputNameCandidates();
+    const inputHasFile = inputNameCandidates.some((name) => matchesExpectedName(name)) ||
+        (lastInputValue && matchesExpectedName(lastInputValue));
     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;
+        return true;
     }
-    // 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.');
+    if (inputConfirmed || inputHasFile) {
+        logger('Attachment input accepted the file but UI did not acknowledge it; continuing with input confirmation only.');
+        return true;
     }
     await logDomFailure(runtime, logger, 'file-upload-missing');
     throw new Error('Attachment did not register with the ChatGPT composer in time.');
 }
+export async function clearComposerAttachments(Runtime, timeoutMs, logger) {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    const expression = `(() => {
+    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*="upload"]',
+      '[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 root = locateComposerRoot();
+    const scope = (() => {
+      if (!root) return document.body;
+      const parent = root.parentElement;
+      const parentHasSend = parent && sendSelectors.some((selector) => parent.querySelector(selector));
+      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"]',
+    ];
+    const visible = (el) => {
+      if (!(el instanceof HTMLElement)) return false;
+      const rect = el.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0;
+    };
+    const removeButtons = scope
+      ? Array.from(scope.querySelectorAll(removeSelectors.join(','))).filter(visible)
+      : [];
+    for (const button of removeButtons.slice(0, 20)) {
+      try { 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 inputs = scope ? Array.from(scope.querySelectorAll('input[type="file"]')) : [];
+    let inputCount = 0;
+    for (const input of inputs) {
+      if (!(input instanceof HTMLInputElement)) continue;
+      inputCount += Array.from(input.files || []).length;
+      try { input.value = ''; } catch {}
+    }
+    const hadAttachments = chipCount > 0 || inputCount > 0 || removeButtons.length > 0;
+    return { removeClicks: removeButtons.length, chipCount, inputCount, hadAttachments };
+  })()`;
+    let sawAttachments = false;
+    let lastState = null;
+    while (Date.now() < deadline) {
+        const response = await Runtime.evaluate({ expression, returnByValue: true });
+        const value = response.result?.value;
+        if (value?.hadAttachments) {
+            sawAttachments = true;
+        }
+        const chipCount = typeof value?.chipCount === 'number' ? value.chipCount : 0;
+        const inputCount = typeof value?.inputCount === 'number' ? value.inputCount : 0;
+        lastState = { chipCount, inputCount };
+        if (chipCount === 0 && inputCount === 0) {
+            return;
+        }
+        await delay(250);
+    }
+    if (sawAttachments) {
+        logger?.(`Attachment cleanup timed out; still saw ${lastState?.chipCount ?? 0} chips and ${lastState?.inputCount ?? 0} inputs.`);
+        throw new Error('Existing attachments still present in composer; aborting to avoid duplicate uploads.');
+    }
+}
 export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNames = [], logger) {
     const deadline = Date.now() + timeoutMs;
     const expectedNormalized = expectedNames.map((name) => name.toLowerCase());
     let inputMatchSince = null;
+    let sawInputMatch = false;
     let attachmentMatchSince = null;
+    let lastVerboseLog = 0;
     const expression = `(() => {
     const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+    const promptSelectors = ${JSON.stringify(INPUT_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*="upload"]',
+      '[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();
+    const composerScope = (() => {
+      if (!composerRoot) return document;
+      const parent = composerRoot.parentElement;
+      const parentHasSend = parent && sendSelectors.some((selector) => parent.querySelector(selector));
+      return parentHasSend ? parent : composerRoot;
+    })();
     let button = null;
     for (const selector of sendSelectors) {
       button = document.querySelector(selector);
@@ -268,39 +1146,168 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
         return /\buploading\b/.test(text) || /\bprocessing\b/.test(text);
       });
     });
-    const attachmentSelectors = ['[data-testid*="chip"]', '[data-testid*="attachment"]', '[data-testid*="upload"]'];
+    const attachmentChipSelectors = [
+      '[data-testid*="chip"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="upload"]',
+      '[data-testid*="file"]',
+      '[aria-label*="Remove"]',
+      'button[aria-label*="Remove"]',
+    ];
     const attachedNames = [];
-    for (const selector of attachmentSelectors) {
-      for (const node of Array.from(document.querySelectorAll(selector))) {
-        const text = node?.textContent?.toLowerCase?.();
-        if (text) attachedNames.push(text);
+    for (const selector of attachmentChipSelectors) {
+      for (const node of Array.from(composerScope.querySelectorAll(selector))) {
+        if (!node) continue;
+        const text = node.textContent ?? '';
+        const aria = node.getAttribute?.('aria-label') ?? '';
+        const title = node.getAttribute?.('title') ?? '';
+        const parentText = node.parentElement?.parentElement?.innerText ?? '';
+        for (const value of [text, aria, title, parentText]) {
+          const normalized = value?.toLowerCase?.();
+          if (normalized) attachedNames.push(normalized);
+        }
       }
     }
-    const cardTexts = Array.from(document.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
+    const cardTexts = Array.from(composerScope.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"]'))) {
+    const inputScope = composerScope ? Array.from(composerScope.querySelectorAll('input[type="file"]')) : [];
+    const inputNodes = [];
+    const inputSeen = new Set();
+    for (const el of [...inputScope, ...Array.from(document.querySelectorAll('input[type="file"]'))]) {
+      if (!inputSeen.has(el)) {
+        inputSeen.add(el);
+        inputNodes.push(el);
+      }
+    }
+    for (const input of inputNodes) {
       if (!(input instanceof HTMLInputElement) || !input.files?.length) continue;
       for (const file of Array.from(input.files)) {
         if (file?.name) inputNames.push(file.name.toLowerCase());
       }
     }
-    const filesAttached = attachedNames.length > 0;
-    return { state: button ? (disabled ? 'disabled' : 'ready') : 'missing', uploading, filesAttached, attachedNames, inputNames };
+    const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+    const fileCountSelectors = [
+      'button',
+      '[role="button"]',
+      '[data-testid*="file"]',
+      '[data-testid*="upload"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="chip"]',
+      '[aria-label*="file"]',
+      '[title*="file"]',
+      '[aria-label*="attachment"]',
+      '[title*="attachment"]',
+    ].join(',');
+    const collectFileCount = (nodes) => {
+      let count = 0;
+      for (const node of nodes) {
+        if (!(node instanceof HTMLElement)) continue;
+        if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+        const dataTestId = node.getAttribute?.('data-testid') ?? '';
+        const aria = node.getAttribute?.('aria-label') ?? '';
+        const title = node.getAttribute?.('title') ?? '';
+        const tooltip =
+          node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+        const text = node.textContent ?? '';
+        const parent = node.parentElement;
+        const parentText = parent?.textContent ?? '';
+        const parentAria = parent?.getAttribute?.('aria-label') ?? '';
+        const parentTitle = parent?.getAttribute?.('title') ?? '';
+        const parentTooltip =
+          parent?.getAttribute?.('data-tooltip') ?? parent?.getAttribute?.('data-tooltip-content') ?? '';
+        const parentTestId = parent?.getAttribute?.('data-testid') ?? '';
+        const candidates = [
+          text,
+          aria,
+          title,
+          tooltip,
+          dataTestId,
+          parentText,
+          parentAria,
+          parentTitle,
+          parentTooltip,
+          parentTestId,
+        ];
+        let hasFileHint = false;
+        for (const raw of candidates) {
+          if (!raw) continue;
+          if (String(raw).toLowerCase().includes('file')) {
+            hasFileHint = true;
+            break;
+          }
+        }
+        if (!hasFileHint) continue;
+        for (const raw of candidates) {
+          if (!raw) continue;
+          const match = String(raw).toLowerCase().match(countRegex);
+          if (match) {
+            const parsed = Number(match[1]);
+            if (Number.isFinite(parsed)) {
+              count = Math.max(count, parsed);
+            }
+          }
+        }
+      }
+      return count;
+    };
+    const localFileCountNodes = composerScope
+      ? Array.from(composerScope.querySelectorAll(fileCountSelectors))
+      : [];
+    let fileCount = collectFileCount(localFileCountNodes);
+    if (!fileCount) {
+      fileCount = collectFileCount(Array.from(document.querySelectorAll(fileCountSelectors)));
+    }
+    const filesAttached = attachedNames.length > 0 || fileCount > 0;
+    return {
+      state: button ? (disabled ? 'disabled' : 'ready') : 'missing',
+      uploading,
+      filesAttached,
+      attachedNames,
+      inputNames,
+      fileCount,
+    };
   })()`;
     while (Date.now() < deadline) {
-        const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+        const response = await Runtime.evaluate({ expression, returnByValue: true });
+        const { result } = response;
         const value = result?.value;
+        if (!value && logger?.verbose) {
+            const exception = response
+                ?.exceptionDetails;
+            if (exception) {
+                const details = [exception.text, exception.exception?.description]
+                    .filter((part) => Boolean(part))
+                    .join(' - ');
+                logger(`Attachment wait eval failed: ${details || 'unknown error'}`);
+            }
+        }
         if (value) {
+            if (logger?.verbose) {
+                const now = Date.now();
+                if (now - lastVerboseLog > 3000) {
+                    lastVerboseLog = now;
+                    logger(`Attachment wait state: ${JSON.stringify({
+                        state: value.state,
+                        uploading: value.uploading,
+                        filesAttached: value.filesAttached,
+                        attachedNames: (value.attachedNames ?? []).slice(0, 3),
+                        inputNames: (value.inputNames ?? []).slice(0, 3),
+                        fileCount: value.fileCount ?? 0,
+                    })}`);
+                }
+            }
             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 fileCount = typeof value.fileCount === 'number' ? value.fileCount : 0;
+            const fileCountSatisfied = expectedNormalized.length > 0 && fileCount >= expectedNormalized.length;
             const matchesExpected = (expected) => {
                 const baseName = expected.split('/').pop()?.split('\\').pop() ?? expected;
                 const normalizedExpected = baseName.toLowerCase().replace(/\s+/g, ' ').trim();
@@ -311,38 +1318,36 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
                     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;
-                        }
+                        const marker = raw.includes('…') ? '…' : '...';
+                        const [prefixRaw, suffixRaw] = raw.split(marker);
+                        const prefix = prefixRaw.trim();
+                        const suffix = suffixRaw.trim();
+                        const target = expectedNoExt.length >= 6 ? expectedNoExt : normalizedExpected;
+                        const matchesPrefix = !prefix || target.includes(prefix);
+                        const matchesSuffix = !suffix || target.includes(suffix);
+                        return matchesPrefix && matchesSuffix;
                     }
                     return false;
                 });
             };
             const missing = expectedNormalized.filter((expected) => !matchesExpected(expected));
-            if (missing.length === 0) {
+            if (missing.length === 0 || fileCountSatisfied) {
                 const stableThresholdMs = value.uploading ? 3000 : 1500;
-                if (value.state === 'ready') {
-                    if (attachmentMatchSince === null) {
-                        attachmentMatchSince = Date.now();
-                    }
-                    if (Date.now() - attachmentMatchSince > stableThresholdMs) {
-                        return;
-                    }
+                if (attachmentMatchSince === null) {
+                    attachmentMatchSince = Date.now();
                 }
-                else {
-                    attachmentMatchSince = null;
+                const stable = Date.now() - attachmentMatchSince > stableThresholdMs;
+                if (stable && value.state === 'ready') {
+                    return;
+                }
+                if (stable && value.state === 'disabled' && !value.uploading) {
+                    return;
                 }
-                if (value.state === 'missing' && value.filesAttached) {
+                if (value.state === 'missing' && (value.filesAttached || fileCountSatisfied)) {
                     return;
                 }
                 // If files are attached but button isn't ready yet, give it more time but don't fail immediately.
-                if (value.filesAttached) {
+                if (value.filesAttached || fileCountSatisfied) {
                     await delay(500);
                     continue;
                 }
@@ -358,16 +1363,19 @@ 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)));
             });
-            if (inputMissing.length === 0 && (value.state === 'ready' || value.state === 'missing')) {
-                const stableThresholdMs = value.uploading ? 3000 : 1500;
+            const inputStateOk = value.state === 'ready' || value.state === 'missing' || value.state === 'disabled';
+            const inputSeenNow = inputMissing.length === 0 || fileCountSatisfied;
+            const stableThresholdMs = value.uploading ? 3000 : 1500;
+            if (inputSeenNow && inputStateOk) {
                 if (inputMatchSince === null) {
                     inputMatchSince = Date.now();
                 }
-                if (Date.now() - inputMatchSince > stableThresholdMs) {
-                    return;
-                }
+                sawInputMatch = true;
             }
-            else {
+            if (inputMatchSince !== null && inputStateOk && Date.now() - inputMatchSince > stableThresholdMs) {
+                return;
+            }
+            if (!inputSeenNow && !sawInputMatch) {
                 inputMatchSince = null;
             }
         }
@@ -379,7 +1387,7 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, expectedNa
 }
 export async function waitForUserTurnAttachments(Runtime, expectedNames, timeoutMs, logger) {
     if (!expectedNames || expectedNames.length === 0) {
-        return;
+        return true;
     }
     const expectedNormalized = expectedNames.map((name) => name.toLowerCase());
     const conversationSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
@@ -399,9 +1407,55 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
       const title = el.getAttribute('title') || '';
       return (aria + ' ' + title).trim().toLowerCase();
     }).filter(Boolean);
-    return { ok: true, text, attrs };
+    const attachmentSelectors = [
+      '[data-testid*="attachment"]',
+      '[data-testid*="upload"]',
+      '[data-testid*="chip"]',
+      '[aria-label*="file"]',
+      '[aria-label*="attachment"]',
+      '[title*="file"]',
+      '[title*="attachment"]',
+    ];
+    const hasAttachmentUi =
+      lastUser.querySelectorAll(attachmentSelectors.join(',')).length > 0 ||
+      attrs.some((attr) => attr.includes('file') || attr.includes('attachment'));
+    const countRegex = /(?:^|\\b)(\\d+)\\s+files?\\b/;
+    const fileCountNodes = Array.from(lastUser.querySelectorAll('button,span,div,[aria-label],[title]'));
+    let fileCount = 0;
+    for (const node of fileCountNodes) {
+      if (!(node instanceof HTMLElement)) continue;
+      if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+      const dataTestId = node.getAttribute?.('data-testid') ?? '';
+      const aria = node.getAttribute?.('aria-label') ?? '';
+      const title = node.getAttribute?.('title') ?? '';
+      const tooltip =
+        node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+      const nodeText = node.textContent ?? '';
+      const candidates = [nodeText, aria, title, tooltip, dataTestId];
+      let hasFileHint = false;
+      for (const raw of candidates) {
+        if (!raw) continue;
+        if (String(raw).toLowerCase().includes('file')) {
+          hasFileHint = true;
+          break;
+        }
+      }
+      if (!hasFileHint) continue;
+      for (const raw of candidates) {
+        if (!raw) continue;
+        const match = String(raw).toLowerCase().match(countRegex);
+        if (match) {
+          const count = Number(match[1]);
+          if (Number.isFinite(count)) {
+            fileCount = Math.max(fileCount, count);
+          }
+        }
+      }
+    }
+    return { ok: true, text, attrs, fileCount, hasAttachmentUi };
   })()`;
     const deadline = Date.now() + timeoutMs;
+    let sawAttachmentUi = false;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression, returnByValue: true });
         const value = result?.value;
@@ -409,7 +1463,12 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
             await delay(200);
             continue;
         }
+        if (value.hasAttachmentUi) {
+            sawAttachmentUi = true;
+        }
         const haystack = [value.text ?? '', ...(value.attrs ?? [])].join('\n');
+        const fileCount = typeof value.fileCount === 'number' ? value.fileCount : 0;
+        const fileCountSatisfied = fileCount >= 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();
@@ -420,11 +1479,15 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
                 return false;
             return true;
         });
-        if (missing.length === 0) {
-            return;
+        if (missing.length === 0 || fileCountSatisfied) {
+            return true;
         }
         await delay(250);
     }
+    if (!sawAttachmentUi) {
+        logger?.('Sent user message did not expose attachment UI; skipping attachment verification.');
+        return false;
+    }
     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.');
@@ -439,6 +1502,7 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
     const normalizedNoExt = normalized.replace(/\\.[a-z0-9]{1,10}$/i, '');
     const matchNode = (node) => {
       if (!node) return false;
+      if (node.tagName === 'INPUT' && node.type === 'file') return false;
       const text = (node.textContent || '').toLowerCase();
       const aria = node.getAttribute?.('aria-label')?.toLowerCase?.() ?? '';
       const title = node.getAttribute?.('title')?.toLowerCase?.() ?? '';
@@ -448,7 +1512,7 @@ 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"]'];
+    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),
     );
@@ -463,6 +1527,77 @@ export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs,
       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;
+    })();
+    let fileCount = 0;
+    for (const node of fileCountNodes) {
+      if (!(node instanceof HTMLElement)) continue;
+      if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+      const dataTestId = node.getAttribute?.('data-testid') ?? '';
+      const aria = node.getAttribute?.('aria-label') ?? '';
+      const title = node.getAttribute?.('title') ?? '';
+      const tooltip =
+        node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+      const text = node.textContent ?? '';
+      const parent = node.parentElement;
+      const parentText = parent?.textContent ?? '';
+      const parentAria = parent?.getAttribute?.('aria-label') ?? '';
+      const parentTitle = parent?.getAttribute?.('title') ?? '';
+      const parentTooltip =
+        parent?.getAttribute?.('data-tooltip') ?? parent?.getAttribute?.('data-tooltip-content') ?? '';
+      const parentTestId = parent?.getAttribute?.('data-testid') ?? '';
+      const candidates = [
+        text,
+        aria,
+        title,
+        tooltip,
+        dataTestId,
+        parentText,
+        parentAria,
+        parentTitle,
+        parentTooltip,
+        parentTestId,
+      ];
+      let hasFileHint = false;
+      for (const raw of candidates) {
+        if (!raw) continue;
+        if (String(raw).toLowerCase().includes('file')) {
+          hasFileHint = true;
+          break;
+        }
+      }
+      if (!hasFileHint) continue;
+      for (const raw of candidates) {
+        if (!raw) continue;
+        const match = String(raw).toLowerCase().match(countRegex);
+        if (match) {
+          const count = Number(match[1]);
+          if (Number.isFinite(count)) {
+            fileCount = Math.max(fileCount, count);
+          }
+        }
+      }
+    }
+    if (fileCount > 0) {
+      return { found: true, source: 'file-count' };
+    }
+
     return { found: false };
   })()`;
     while (Date.now() < deadline) {
@@ -488,14 +1623,14 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
       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;
-        }
+        const marker = text.includes('…') ? '…' : '...';
+        const [prefixRaw, suffixRaw] = text.split(marker);
+        const prefix = (prefixRaw ?? '').toLowerCase();
+        const suffix = (suffixRaw ?? '').toLowerCase();
+        const target = normalizedNoExt.length >= 6 ? normalizedNoExt : normalized;
+        const matchesPrefix = !prefix || target.includes(prefix);
+        const matchesSuffix = !suffix || target.includes(suffix);
+        return matchesPrefix && matchesSuffix;
       }
       return false;
     };
@@ -509,6 +1644,7 @@ async function waitForAttachmentAnchored(Runtime, expectedName, timeoutMs) {
     ];
     for (const selector of selectors) {
       for (const node of Array.from(document.querySelectorAll(selector))) {
+        if (node?.tagName === 'INPUT' && node?.type === 'file') continue;
         const text = node?.textContent || '';
         const aria = node?.getAttribute?.('aria-label') || '';
         const title = node?.getAttribute?.('title') || '';
@@ -523,6 +1659,76 @@ 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 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;
+    })();
+    let fileCount = 0;
+    for (const node of fileCountNodes) {
+      if (!(node instanceof HTMLElement)) continue;
+      if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+      const dataTestId = node.getAttribute?.('data-testid') ?? '';
+      const aria = node.getAttribute?.('aria-label') ?? '';
+      const title = node.getAttribute?.('title') ?? '';
+      const tooltip =
+        node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+      const text = node.textContent ?? '';
+      const parent = node.parentElement;
+      const parentText = parent?.textContent ?? '';
+      const parentAria = parent?.getAttribute?.('aria-label') ?? '';
+      const parentTitle = parent?.getAttribute?.('title') ?? '';
+      const parentTooltip =
+        parent?.getAttribute?.('data-tooltip') ?? parent?.getAttribute?.('data-tooltip-content') ?? '';
+      const parentTestId = parent?.getAttribute?.('data-testid') ?? '';
+      const candidates = [
+        text,
+        aria,
+        title,
+        tooltip,
+        dataTestId,
+        parentText,
+        parentAria,
+        parentTitle,
+        parentTooltip,
+        parentTestId,
+      ];
+      let hasFileHint = false;
+      for (const raw of candidates) {
+        if (!raw) continue;
+        if (String(raw).toLowerCase().includes('file')) {
+          hasFileHint = true;
+          break;
+        }
+      }
+      if (!hasFileHint) continue;
+      for (const raw of candidates) {
+        if (!raw) continue;
+        const match = String(raw).toLowerCase().match(countRegex);
+        if (match) {
+          const count = Number(match[1]);
+          if (Number.isFinite(count)) {
+            fileCount = Math.max(fileCount, count);
+          }
+        }
+      }
+    }
+    if (fileCount > 0) {
+      return { found: true, text: 'file-count' };
+    }
     return { found: false };
   })()`;
     while (Date.now() < deadline) {