@steipete/oracle 0.7.0 → 0.7.2

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

@@ -18,7 +18,13 @@ export async function ensureModelSelection(Runtime, desiredModel, logger) {
         }
         case 'option-not-found': {
             await logDomFailure(Runtime, logger, 'model-switcher-option');
-            throw new Error(`Unable to find model option matching "${desiredModel}" in the model switcher.`);
+            const isTemporary = result.hint?.temporaryChat ?? false;
+            const available = (result.hint?.availableOptions ?? []).filter(Boolean);
+            const availableHint = available.length > 0 ? ` Available: ${available.join(', ')}.` : '';
+            const tempHint = isTemporary && /\bpro\b/i.test(desiredModel)
+                ? ' You are in Temporary Chat mode; Pro models are not available there. Remove "temporary-chat=true" from --chatgpt-url or use a non-Pro model (e.g. gpt-5.2).'
+                : '';
+            throw new Error(`Unable to find model option matching "${desiredModel}" in the model switcher.${availableHint}${tempHint}`);
         }
         default: {
             await logDomFailure(Runtime, logger, 'model-switcher-button');
@@ -63,12 +69,41 @@ function buildModelSelectionExpression(targetModel) {
       .map((token) => normalizeText(token))
       .filter(Boolean);
     const targetWords = normalizedTarget.split(' ').filter(Boolean);
+    const desiredVersion = normalizedTarget.includes('5 2')
+      ? '5-2'
+      : normalizedTarget.includes('5 1')
+        ? '5-1'
+        : normalizedTarget.includes('5 0')
+          ? '5-0'
+          : null;
+    const wantsPro = normalizedTarget.includes(' pro') || normalizedTarget.endsWith(' pro') || normalizedTokens.includes('pro');
+    const wantsInstant = normalizedTarget.includes('instant');
+    const wantsThinking = normalizedTarget.includes('thinking');
 
     const button = document.querySelector(BUTTON_SELECTOR);
     if (!button) {
       return { status: 'button-missing' };
     }
 
+    const getButtonLabel = () => (button.textContent ?? '').trim();
+    const buttonMatchesTarget = () => {
+      const normalizedLabel = normalizeText(getButtonLabel());
+      if (!normalizedLabel) return false;
+      if (desiredVersion) {
+        if (desiredVersion === '5-2' && !normalizedLabel.includes('5 2')) return false;
+        if (desiredVersion === '5-1' && !normalizedLabel.includes('5 1')) return false;
+        if (desiredVersion === '5-0' && !normalizedLabel.includes('5 0')) return false;
+      }
+      if (wantsPro && !normalizedLabel.includes(' pro')) return false;
+      if (wantsInstant && !normalizedLabel.includes('instant')) return false;
+      if (wantsThinking && !normalizedLabel.includes('thinking')) return false;
+      return true;
+    };
+
+    if (buttonMatchesTarget()) {
+      return { status: 'already-selected', label: getButtonLabel() };
+    }
+
     let lastPointerClick = 0;
     const pointerClick = () => {
       if (dispatchClickSequence(button)) {
@@ -106,8 +141,46 @@ function buildModelSelectionExpression(targetModel) {
       }
       let score = 0;
       const normalizedTestId = (testid ?? '').toLowerCase();
-      if (normalizedTestId && TEST_IDS.some((id) => normalizedTestId.includes(id))) {
-        score += 1000;
+      if (normalizedTestId) {
+        if (desiredVersion) {
+          // data-testid strings have been observed with both dotted and dashed versions (e.g. gpt-5.2-pro vs gpt-5-2-pro).
+          const has52 =
+            normalizedTestId.includes('5-2') ||
+            normalizedTestId.includes('5.2') ||
+            normalizedTestId.includes('gpt-5-2') ||
+            normalizedTestId.includes('gpt-5.2') ||
+            normalizedTestId.includes('gpt52');
+          const has51 =
+            normalizedTestId.includes('5-1') ||
+            normalizedTestId.includes('5.1') ||
+            normalizedTestId.includes('gpt-5-1') ||
+            normalizedTestId.includes('gpt-5.1') ||
+            normalizedTestId.includes('gpt51');
+          const has50 =
+            normalizedTestId.includes('5-0') ||
+            normalizedTestId.includes('5.0') ||
+            normalizedTestId.includes('gpt-5-0') ||
+            normalizedTestId.includes('gpt-5.0') ||
+            normalizedTestId.includes('gpt50');
+          const candidateVersion = has52 ? '5-2' : has51 ? '5-1' : has50 ? '5-0' : null;
+          // If a candidate advertises a different version, ignore it entirely.
+          if (candidateVersion && candidateVersion !== desiredVersion) {
+            return 0;
+          }
+          // When targeting an explicit version, avoid selecting submenu wrappers that can contain legacy models.
+          if (normalizedTestId.includes('submenu') && candidateVersion === null) {
+            return 0;
+          }
+        }
+        const matches = TEST_IDS.filter((id) => id && normalizedTestId.includes(id));
+        if (matches.length > 0) {
+          // Prefer the most specific match (longest token) instead of treating any hit as equal.
+          // This prevents generic tokens (e.g. "pro") from outweighing version-specific targets.
+          const best = matches.reduce((acc, token) => (token.length > acc.length ? token : acc), '');
+          score += 200 + Math.min(900, best.length * 25);
+          if (best.startsWith('model-switcher-')) score += 120;
+          if (best.includes('gpt-')) score += 60;
+        }
       }
       if (normalizedText && normalizedTarget) {
         if (normalizedText === normalizedTarget) {
@@ -134,6 +207,14 @@ function buildModelSelectionExpression(targetModel) {
         }
         score -= missing * 12;
       }
+      // If the caller didn't explicitly ask for Pro, prefer non-Pro options when both exist.
+      if (wantsPro) {
+        if (!normalizedText.includes(' pro')) {
+          score -= 80;
+        }
+      } else if (normalizedText.includes(' pro')) {
+        score -= 40;
+      }
       return Math.max(score, 0);
     };
 
@@ -153,7 +234,7 @@ function buildModelSelectionExpression(targetModel) {
           }
           const label = getOptionLabel(option);
           if (!bestMatch || score > bestMatch.score) {
-            bestMatch = { node: option, label, score };
+            bestMatch = { node: option, label, score, testid, normalizedText };
           }
         }
       }
@@ -162,6 +243,28 @@ function buildModelSelectionExpression(targetModel) {
 
     return new Promise((resolve) => {
       const start = performance.now();
+      const detectTemporaryChat = () => {
+        try {
+          const url = new URL(window.location.href);
+          const flag = (url.searchParams.get('temporary-chat') ?? '').toLowerCase();
+          if (flag === 'true' || flag === '1' || flag === 'yes') return true;
+        } catch {}
+        const title = (document.title || '').toLowerCase();
+        if (title.includes('temporary chat')) return true;
+        const body = (document.body?.innerText || '').toLowerCase();
+        return body.includes('temporary chat');
+      };
+      const collectAvailableOptions = () => {
+        const menuRoots = Array.from(document.querySelectorAll(${menuContainerLiteral}));
+        const nodes = menuRoots.length > 0
+          ? menuRoots.flatMap((root) => Array.from(root.querySelectorAll(${menuItemLiteral})))
+          : Array.from(document.querySelectorAll(${menuItemLiteral}));
+        const labels = nodes
+          .map((node) => (node?.textContent ?? '').trim())
+          .filter(Boolean)
+          .filter((label, index, arr) => arr.indexOf(label) === index);
+        return labels.slice(0, 12);
+      };
       const ensureMenuOpen = () => {
         const menuOpen = document.querySelector('[role="menu"], [data-radix-collection-root]');
         if (!menuOpen && performance.now() - lastPointerClick > REOPEN_INTERVAL_MS) {
@@ -182,15 +285,32 @@ function buildModelSelectionExpression(targetModel) {
         const match = findBestOption();
         if (match) {
           if (optionIsSelected(match.node)) {
-            resolve({ status: 'already-selected', label: match.label });
+            resolve({ status: 'already-selected', label: getButtonLabel() || match.label });
             return;
           }
           dispatchClickSequence(match.node);
-          resolve({ status: 'switched', label: match.label });
+          // Submenus (e.g. "Legacy models") need a second pass to pick the actual model option.
+          // Keep scanning once the submenu opens instead of treating the submenu click as a final switch.
+          const isSubmenu = (match.testid ?? '').toLowerCase().includes('submenu');
+          if (isSubmenu) {
+            setTimeout(attempt, REOPEN_INTERVAL_MS / 2);
+            return;
+          }
+          // Wait for the top bar label to reflect the requested model; otherwise keep scanning.
+          setTimeout(() => {
+            if (buttonMatchesTarget()) {
+              resolve({ status: 'switched', label: getButtonLabel() || match.label });
+              return;
+            }
+            attempt();
+          }, Math.max(120, INITIAL_WAIT_MS));
           return;
         }
         if (performance.now() - start > MAX_WAIT_MS) {
-          resolve({ status: 'option-not-found' });
+          resolve({
+            status: 'option-not-found',
+            hint: { temporaryChat: detectTemporaryChat(), availableOptions: collectAvailableOptions() },
+          });
           return;
         }
         setTimeout(attempt, REOPEN_INTERVAL_MS / 2);

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

@@ -135,7 +135,6 @@ export async function submitPrompt(deps, prompt, logger) {
         logger('Clicked send button');
     }
     await verifyPromptCommitted(runtime, prompt, 30_000, logger);
-    await clickAnswerNowIfPresent(runtime, logger);
 }
 export async function clearPromptComposer(Runtime, logger) {
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
@@ -186,6 +185,43 @@ async function waitForDomReady(Runtime, logger) {
     }
     logger?.('Page did not reach ready/composer state within 10s; continuing cautiously.');
 }
+function buildAttachmentReadyExpression(attachmentNames) {
+    const namesLiteral = JSON.stringify(attachmentNames.map((name) => name.toLowerCase()));
+    return `(() => {
+    const names = ${namesLiteral};
+    const composer =
+      document.querySelector('[data-testid*="composer"]') ||
+      document.querySelector('form') ||
+      document.body ||
+      document;
+    const match = (node, name) => (node?.textContent || '').toLowerCase().includes(name);
+
+    // Restrict to attachment affordances; never scan generic div/span nodes (prompt text can contain the file name).
+    const attachmentSelectors = [
+      '[data-testid*="chip"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="upload"]',
+      '[aria-label="Remove file"]',
+      'button[aria-label="Remove file"]',
+    ];
+
+    const chipsReady = names.every((name) =>
+      Array.from(composer.querySelectorAll(attachmentSelectors.join(','))).some((node) => match(node, name)),
+    );
+    const inputsReady = names.every((name) =>
+      Array.from(composer.querySelectorAll('input[type="file"]')).some((el) =>
+        Array.from((el instanceof HTMLInputElement ? el.files : []) || []).some((file) =>
+          file?.name?.toLowerCase?.().includes(name),
+        ),
+      ),
+    );
+
+    return chipsReady || inputsReady;
+  })()`;
+}
+export function buildAttachmentReadyExpressionForTest(attachmentNames) {
+    return buildAttachmentReadyExpression(attachmentNames);
+}
 async function attemptSendButton(Runtime, _logger, attachmentNames) {
     const script = `(() => {
     ${buildClickDispatcher()}
@@ -215,19 +251,7 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
         const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
         if (needAttachment) {
             const ready = await Runtime.evaluate({
-                expression: `(() => {
-          const names = ${JSON.stringify(attachmentNames.map((n) => n.toLowerCase()))};
-          const match = (n, name) => (n?.textContent || '').toLowerCase().includes(name);
-          const chipsReady = names.every((name) =>
-            Array.from(document.querySelectorAll('[data-testid*="chip"],[data-testid*="attachment"],a,div,span')).some((node) => match(node, name)),
-          );
-          const inputsReady = names.every((name) =>
-            Array.from(document.querySelectorAll('input[type="file"]')).some((el) =>
-              Array.from(el.files || []).some((f) => f?.name?.toLowerCase?.().includes(name)),
-            ),
-          );
-          return chipsReady || inputsReady;
-        })()`,
+                expression: buildAttachmentReadyExpression(attachmentNames),
                 returnByValue: true,
             });
             if (!ready?.result?.value) {
@@ -246,57 +270,34 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
     }
     return false;
 }
-async function clickAnswerNowIfPresent(Runtime, logger) {
-    const script = `(() => {
-    ${buildClickDispatcher()}
-    const matchesText = (el) => (el?.textContent || '').trim().toLowerCase() === 'answer now';
-    const candidate = Array.from(document.querySelectorAll('button,span')).find(matchesText);
-    if (!candidate) return 'missing';
-    const button = candidate.closest('button') ?? candidate;
-    const style = window.getComputedStyle(button);
-    const disabled =
-      button.hasAttribute('disabled') ||
-      button.getAttribute('aria-disabled') === 'true' ||
-      style.pointerEvents === 'none' ||
-      style.display === 'none';
-    if (disabled) return 'disabled';
-    dispatchClickSequence(button);
-    return 'clicked';
-  })()`;
-    const deadline = Date.now() + 3_000;
-    while (Date.now() < deadline) {
-        const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
-        const status = result.value;
-        if (status === 'clicked') {
-            logger?.('Clicked "Answer now" gate');
-            await delay(500);
-            return;
-        }
-        if (status === 'missing')
-            return;
-        await delay(100);
-    }
-}
 async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
     const deadline = Date.now() + timeoutMs;
     const encodedPrompt = JSON.stringify(prompt.trim());
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
     const script = `(() => {
-    const editor = document.querySelector(${primarySelectorLiteral});
-    const fallback = document.querySelector(${fallbackSelectorLiteral});
-    const normalize = (value) => value?.toLowerCase?.().replace(/\\s+/g, ' ').trim() ?? '';
-    const normalizedPrompt = normalize(${encodedPrompt});
-    const normalizedPromptPrefix = normalizedPrompt.slice(0, 120);
-    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
-    const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
-    const normalizedTurns = articles.map((node) => normalize(node?.innerText));
-    const userMatched = normalizedTurns.some((text) => text.includes(normalizedPrompt));
-    const prefixMatched =
-      normalizedPromptPrefix.length > 30 &&
-      normalizedTurns.some((text) => text.includes(normalizedPromptPrefix));
-    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
-    return {
+	    const editor = document.querySelector(${primarySelectorLiteral});
+	    const fallback = document.querySelector(${fallbackSelectorLiteral});
+	    const normalize = (value) => {
+	      let text = value?.toLowerCase?.() ?? '';
+	      // Strip markdown *markers* but keep content (ChatGPT renders fence markers differently).
+	      text = text.replace(/\`\`\`[^\\n]*\\n([\\s\\S]*?)\`\`\`/g, ' $1 ');
+	      text = text.replace(/\`\`\`/g, ' ');
+	      text = text.replace(/\`([^\`]*)\`/g, '$1');
+	      return text.replace(/\\s+/g, ' ').trim();
+	    };
+	    const normalizedPrompt = normalize(${encodedPrompt});
+	    const normalizedPromptPrefix = normalizedPrompt.slice(0, 120);
+	    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
+	    const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+	    const normalizedTurns = articles.map((node) => normalize(node?.innerText));
+	    const userMatched =
+	      normalizedPrompt.length > 0 && normalizedTurns.some((text) => text.includes(normalizedPrompt));
+	    const prefixMatched =
+	      normalizedPromptPrefix.length > 30 &&
+	      normalizedTurns.some((text) => text.includes(normalizedPromptPrefix));
+	    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
+	    return {
       userMatched,
       prefixMatched,
       fallbackValue: fallback?.value ?? '',

package/dist/src/browser/config.js

@@ -1,5 +1,5 @@
 import { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
-import { normalizeChatgptUrl } from './utils.js';
+import { isTemporaryChatUrl, normalizeChatgptUrl } from './utils.js';
 import os from 'node:os';
 import path from 'node:path';
 export const DEFAULT_BROWSER_CONFIG = {
@@ -32,6 +32,11 @@ export function resolveBrowserConfig(config) {
         (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? '').trim() === '1';
     const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
     const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
+    const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
+    if (isTemporaryChatUrl(normalizedUrl) && /\bpro\b/i.test(desiredModel)) {
+        throw new Error('Temporary Chat mode does not expose Pro models in the ChatGPT model picker. ' +
+            'Remove "temporary-chat=true" from your browser URL, or use a non-Pro model label (e.g. "GPT-5.2").');
+    }
     const isWindows = process.platform === 'win32';
     const manualLogin = config?.manualLogin ?? (isWindows ? true : DEFAULT_BROWSER_CONFIG.manualLogin);
     const cookieSyncDefault = isWindows ? false : DEFAULT_BROWSER_CONFIG.cookieSync;
@@ -53,7 +58,7 @@ export function resolveBrowserConfig(config) {
         headless: config?.headless ?? DEFAULT_BROWSER_CONFIG.headless,
         keepBrowser: config?.keepBrowser ?? DEFAULT_BROWSER_CONFIG.keepBrowser,
         hideWindow: config?.hideWindow ?? DEFAULT_BROWSER_CONFIG.hideWindow,
-        desiredModel: config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel,
+        desiredModel,
         chromeProfile: config?.chromeProfile ?? DEFAULT_BROWSER_CONFIG.chromeProfile,
         chromePath: config?.chromePath ?? DEFAULT_BROWSER_CONFIG.chromePath,
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,

package/dist/src/browser/constants.js

@@ -1,5 +1,5 @@
 export const CHATGPT_URL = 'https://chatgpt.com/';
-export const DEFAULT_MODEL_TARGET = 'ChatGPT 5.2';
+export const DEFAULT_MODEL_TARGET = 'GPT-5.2 Pro';
 export const COOKIE_URLS = ['https://chatgpt.com', 'https://chat.openai.com', 'https://atlas.openai.com'];
 export const INPUT_SELECTORS = [
     'textarea[data-id="prompt-textarea"]',
@@ -13,13 +13,17 @@ export const INPUT_SELECTORS = [
 ];
 export const ANSWER_SELECTORS = [
     'article[data-testid^="conversation-turn"][data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"][data-turn="assistant"]',
     'article[data-testid^="conversation-turn"] [data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"] [data-turn="assistant"]',
     'article[data-testid^="conversation-turn"] .markdown',
     '[data-message-author-role="assistant"] .markdown',
+    '[data-turn="assistant"] .markdown',
     '[data-message-author-role="assistant"]',
+    '[data-turn="assistant"]',
 ];
 export const CONVERSATION_TURN_SELECTOR = 'article[data-testid^="conversation-turn"]';
-export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"]';
+export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"], [data-turn="assistant"]';
 export const CLOUDFLARE_SCRIPT_SELECTOR = 'script[src*="/challenge-platform/"]';
 export const CLOUDFLARE_TITLE = 'just a moment';
 export const PROMPT_PRIMARY_SELECTOR = '#prompt-textarea';

package/dist/src/browser/index.js

@@ -5,7 +5,7 @@ import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
-import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
 import { ensureExtendedThinking } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
@@ -14,7 +14,7 @@ import { CHATGPT_URL } from './constants.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
 import { cleanupStaleProfileState, readChromePid, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
 export { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
-export { parseDuration, delay, normalizeChatgptUrl } from './utils.js';
+export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
@@ -285,11 +285,18 @@ export async function runBrowserMode(options) {
                     logger(`Uploading attachment: ${attachment.displayPath}`);
                     await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
                 }
-                const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+                // Scale timeout based on number of files: base 30s + 15s per additional file
+                const baseTimeout = config.inputTimeoutMs ?? 30_000;
+                const perFileTimeout = 15_000;
+                const waitBudget = Math.max(baseTimeout, 30_000) + (submissionAttachments.length - 1) * perFileTimeout;
                 await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
                 logger('All attachments uploaded');
             }
             await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+            if (attachmentNames.length > 0) {
+                await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger);
+                logger('Verified attachments present on sent user message');
+            }
         };
         try {
             await raceWithDisconnect(submitOnce(promptText, attachments));
@@ -327,10 +334,13 @@ export async function runBrowserMode(options) {
             },
         })).catch(() => null);
         answerMarkdown = copiedMarkdown ?? answerText;
+        // Helper to normalize text for echo detection (collapse whitespace, lowercase)
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
         // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
         const finalSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
         const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
-        if (finalText &&
+        if (!copiedMarkdown &&
+            finalText &&
             finalText !== answerMarkdown.trim() &&
             finalText !== promptText.trim() &&
             finalText.length >= answerMarkdown.trim().length) {
@@ -338,14 +348,26 @@ export async function runBrowserMode(options) {
             answerText = finalText;
             answerMarkdown = finalText;
         }
-        if (answerMarkdown.trim() === promptText.trim()) {
+        // Detect prompt echo using normalized comparison (whitespace-insensitive)
+        const normalizedAnswer = normalizeForComparison(answerMarkdown);
+        const normalizedPrompt = normalizeForComparison(promptText);
+        const promptPrefix = normalizedPrompt.length >= 80
+            ? normalizedPrompt.slice(0, Math.min(200, normalizedPrompt.length))
+            : '';
+        const isPromptEcho = normalizedAnswer === normalizedPrompt || (promptPrefix.length > 0 && normalizedAnswer.startsWith(promptPrefix));
+        if (isPromptEcho) {
+            logger('Detected prompt echo in response; waiting for actual assistant response...');
             const deadline = Date.now() + 8_000;
             let bestText = null;
             let stableCount = 0;
             while (Date.now() < deadline) {
                 const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
                 const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
-                if (text && text !== promptText.trim()) {
+                const normalizedText = normalizeForComparison(text);
+                const isStillEcho = !text ||
+                    normalizedText === normalizedPrompt ||
+                    (promptPrefix.length > 0 && normalizedText.startsWith(promptPrefix));
+                if (!isStillEcho) {
                     if (!bestText || text.length > bestText.length) {
                         bestText = text;
                         stableCount = 0;
@@ -661,7 +683,10 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                     logger(`Uploading attachment: ${attachment.displayPath}`);
                     await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
                 }
-                const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+                // Scale timeout based on number of files: base 30s + 15s per additional file
+                const baseTimeout = config.inputTimeoutMs ?? 30_000;
+                const perFileTimeout = 15_000;
+                const waitBudget = Math.max(baseTimeout, 30_000) + (submissionAttachments.length - 1) * perFileTimeout;
                 await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
                 logger('All attachments uploaded');
             }
@@ -703,6 +728,58 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             },
         }).catch(() => null);
         answerMarkdown = copiedMarkdown ?? answerText;
+        // Helper to normalize text for echo detection (collapse whitespace, lowercase)
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
+        const finalSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+        const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
+        if (finalText &&
+            finalText !== answerMarkdown.trim() &&
+            finalText !== promptText.trim() &&
+            finalText.length >= answerMarkdown.trim().length) {
+            logger('Refreshed assistant response via final DOM snapshot');
+            answerText = finalText;
+            answerMarkdown = finalText;
+        }
+        // Detect prompt echo using normalized comparison (whitespace-insensitive)
+        const normalizedAnswer = normalizeForComparison(answerMarkdown);
+        const normalizedPrompt = normalizeForComparison(promptText);
+        const promptPrefix = normalizedPrompt.length >= 80
+            ? normalizedPrompt.slice(0, Math.min(200, normalizedPrompt.length))
+            : '';
+        const isPromptEcho = normalizedAnswer === normalizedPrompt || (promptPrefix.length > 0 && normalizedAnswer.startsWith(promptPrefix));
+        if (isPromptEcho) {
+            logger('Detected prompt echo in response; waiting for actual assistant response...');
+            const deadline = Date.now() + 8_000;
+            let bestText = null;
+            let stableCount = 0;
+            while (Date.now() < deadline) {
+                const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                const normalizedText = normalizeForComparison(text);
+                const isStillEcho = !text ||
+                    normalizedText === normalizedPrompt ||
+                    (promptPrefix.length > 0 && normalizedText.startsWith(promptPrefix));
+                if (!isStillEcho) {
+                    if (!bestText || text.length > bestText.length) {
+                        bestText = text;
+                        stableCount = 0;
+                    }
+                    else if (text === bestText) {
+                        stableCount += 1;
+                    }
+                    if (stableCount >= 2) {
+                        break;
+                    }
+                }
+                await new Promise((resolve) => setTimeout(resolve, 300));
+            }
+            if (bestText) {
+                logger('Recovered assistant response after detecting prompt echo');
+                answerText = bestText;
+                answerMarkdown = bestText;
+            }
+        }
         stopThinkingMonitor?.();
         const durationMs = Date.now() - startedAt;
         const answerChars = answerText.length;

package/dist/src/browser/pageActions.js

@@ -1,5 +1,5 @@
 export { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady } from './actions/navigation.js';
 export { ensureModelSelection } from './actions/modelSelection.js';
 export { submitPrompt, clearPromptComposer } from './actions/promptComposer.js';
-export { uploadAttachmentFile, waitForAttachmentCompletion } from './actions/attachments.js';
+export { uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments } from './actions/attachments.js';
 export { waitForAssistantResponse, readAssistantSnapshot, captureAssistantMarkdown, buildAssistantExtractorForTest, buildConversationDebugExpressionForTest, } from './actions/assistantResponse.js';

package/dist/src/browser/utils.js

@@ -110,3 +110,13 @@ export function normalizeChatgptUrl(raw, fallback) {
     // Preserve user-provided path/query; URL#toString will normalize trailing slashes appropriately.
     return parsed.toString();
 }
+export function isTemporaryChatUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const value = (parsed.searchParams.get('temporary-chat') ?? '').trim().toLowerCase();
+        return value === 'true' || value === '1' || value === 'yes';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/browserMode.js

@@ -1 +1 @@
-export { runBrowserMode, CHATGPT_URL, DEFAULT_MODEL_TARGET, parseDuration, normalizeChatgptUrl, } from './browser/index.js';
+export { runBrowserMode, CHATGPT_URL, DEFAULT_MODEL_TARGET, parseDuration, normalizeChatgptUrl, isTemporaryChatUrl, } from './browser/index.js';