@steipete/oracle 0.7.6 → 0.8.1

package/dist/src/browser/index.js

@@ -5,15 +5,16 @@ 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, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
+import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
 import { ensureThinkingTime } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
-import { CHATGPT_URL } from './constants.js';
+import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } 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';
+import { alignPromptEchoPair, buildPromptEchoMatcher } from './reattachHelpers.js';
+import { cleanupStaleProfileState, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
+export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
@@ -87,13 +88,14 @@ export async function runBrowserMode(options) {
         ? manualProfileDir
         : await mkdtemp(path.join(await resolveUserDataBaseDir(), 'oracle-browser-'));
     if (manualLogin) {
+        // Learned: manual login reuses a persistent profile so cookies/SSO survive.
         await mkdir(userDataDir, { recursive: true });
         logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
     }
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
     }
-    const effectiveKeepBrowser = config.keepBrowser || manualLogin;
+    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     const reusedChrome = manualLogin ? await maybeReuseRunningChrome(userDataDir, logger) : null;
     const chrome = reusedChrome ??
         (await launchChrome({
@@ -113,6 +115,7 @@ export async function runBrowserMode(options) {
         removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
             isInFlight: () => runStatus !== 'complete',
             emitRuntimeHint,
+            preserveUserDataDir: manualLogin,
         });
     }
     catch {
@@ -158,14 +161,19 @@ export async function runBrowserMode(options) {
         if (!manualLogin) {
             await Network.clearBrowserCookies();
         }
-        const cookieSyncEnabled = config.cookieSync && !manualLogin;
+        const manualLoginCookieSync = manualLogin && Boolean(config.manualLoginCookieSync);
+        const cookieSyncEnabled = config.cookieSync && (!manualLogin || manualLoginCookieSync);
         if (cookieSyncEnabled) {
+            if (manualLoginCookieSync) {
+                logger('Manual login mode: seeding persistent profile with cookies from your Chrome profile.');
+            }
             if (!config.inlineCookies) {
                 logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.');
             }
             else {
                 logger('Applying inline cookies (skipping Chrome profile read and Keychain prompt)');
             }
+            // Learned: always sync cookies before the first navigation so /backend-api/me succeeds.
             const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
                 allowErrors: config.allowCookieErrors ?? false,
                 filterNames: config.cookieNames ?? undefined,
@@ -190,13 +198,15 @@ export async function runBrowserMode(options) {
                 : 'Skipping Chrome cookie sync (--browser-no-cookie-sync)');
         }
         if (cookieSyncEnabled && !manualLogin && (appliedCookies ?? 0) === 0 && !config.inlineCookies) {
+            // Learned: if the profile has no ChatGPT cookies, browser mode will just bounce to login.
+            // Fail early so the user knows to sign in.
             throw new BrowserAutomationError('No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. ' +
-                'Make sure ChatGPT is signed in in the selected profile or rebuild the keytar native module if it failed to load.', {
+                'Make sure ChatGPT is signed in in the selected profile, or use --browser-manual-login / inline cookies.', {
                 stage: 'execute-browser',
                 details: {
                     profile: config.chromeProfile ?? 'Default',
                     cookiePath: config.chromeCookiePath ?? null,
-                    hint: 'Rebuild keytar: PYTHON=/usr/bin/python3 /Users/steipete/Projects/oracle/runner npx node-gyp rebuild (run inside the keytar path from the error), then retry.',
+                    hint: 'If macOS Keychain prompts or denies access, run oracle from a GUI session or use --copy/--render for the manual flow.',
                 },
             });
         }
@@ -205,6 +215,7 @@ export async function runBrowserMode(options) {
         // then hop to the requested URL if it differs.
         await raceWithDisconnect(navigateToChatGPT(Page, Runtime, baseUrl, logger));
         await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
+        // Learned: login checks must happen on the base domain before jumping into project URLs.
         await raceWithDisconnect(waitForLogin({ runtime: Runtime, logger, appliedCookies, manualLogin, timeoutMs: config.timeoutMs }));
         if (config.url !== baseUrl) {
             await raceWithDisconnect(navigateToChatGPT(Page, Runtime, config.url, logger));
@@ -235,6 +246,9 @@ export async function runBrowserMode(options) {
             catch {
                 // ignore
             }
+            if (lastUrl) {
+                logger(`[browser] url = ${lastUrl}`);
+            }
             if (chrome?.port) {
                 const suffix = lastTargetId ? ` target=${lastTargetId}` : '';
                 if (lastUrl) {
@@ -246,9 +260,45 @@ export async function runBrowserMode(options) {
                 await emitRuntimeHint();
             }
         };
+        let conversationHintInFlight = null;
+        const updateConversationHint = async (label, timeoutMs = 10_000) => {
+            if (!chrome?.port) {
+                return false;
+            }
+            const start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                try {
+                    const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+                    if (typeof result?.value === 'string' && result.value.includes('/c/')) {
+                        lastUrl = result.value;
+                        logger(`[browser] conversation url (${label}) = ${lastUrl}`);
+                        await emitRuntimeHint();
+                        return true;
+                    }
+                }
+                catch {
+                    // ignore; keep polling until timeout
+                }
+                await delay(250);
+            }
+            return false;
+        };
+        const scheduleConversationHint = (label, timeoutMs) => {
+            if (conversationHintInFlight) {
+                return;
+            }
+            // Learned: the /c/ URL can update after the answer; emit hints in the background.
+            // Run in the background so prompt submission/streaming isn't blocked by slow URL updates.
+            conversationHintInFlight = updateConversationHint(label, timeoutMs)
+                .catch(() => false)
+                .finally(() => {
+                conversationHintInFlight = null;
+            });
+        };
         await captureRuntimeSnapshot();
-        if (config.desiredModel) {
-            await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger), {
+        const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
+        if (config.desiredModel && modelStrategy !== 'ignore') {
+            await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -266,6 +316,9 @@ export async function runBrowserMode(options) {
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
+        else if (modelStrategy === 'ignore') {
+            logger('Model picker: skipped (strategy=ignore)');
+        }
         // Handle thinking time selection if specified
         const thinkingTime = config.thinkingTime;
         if (thinkingTime) {
@@ -280,14 +333,22 @@ export async function runBrowserMode(options) {
             }));
         }
         const submitOnce = async (prompt, submissionAttachments) => {
+            const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+            const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
+            let inputOnlyAttachments = false;
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
                     throw new Error('Chrome DOM domain unavailable while uploading attachments.');
                 }
-                for (const attachment of submissionAttachments) {
+                await clearComposerAttachments(Runtime, 5_000, logger);
+                for (let attachmentIndex = 0; attachmentIndex < submissionAttachments.length; attachmentIndex += 1) {
+                    const attachment = submissionAttachments[attachmentIndex];
                     logger(`Uploading attachment: ${attachment.displayPath}`);
-                    await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+                    const uiConfirmed = await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger, { expectedCount: attachmentIndex + 1 });
+                    if (!uiConfirmed) {
+                        inputOnlyAttachments = true;
+                    }
                     await delay(500);
                 }
                 // Scale timeout based on number of files: base 30s + 15s per additional file
@@ -297,30 +358,103 @@ export async function runBrowserMode(options) {
                 await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
                 logger('All attachments uploaded');
             }
-            await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+            let baselineTurns = await readConversationTurnCount(Runtime, logger);
+            // Learned: return baselineTurns so assistant polling can ignore earlier content.
+            const committedTurns = await submitPrompt({
+                runtime: Runtime,
+                input: Input,
+                attachmentNames,
+                baselineTurns: baselineTurns ?? undefined,
+                inputTimeoutMs: config.inputTimeoutMs ?? undefined,
+            }, prompt, logger);
+            if (typeof committedTurns === 'number' && Number.isFinite(committedTurns)) {
+                if (baselineTurns === null || committedTurns > baselineTurns) {
+                    baselineTurns = Math.max(0, committedTurns - 1);
+                }
+            }
             if (attachmentNames.length > 0) {
-                await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger);
-                logger('Verified attachments present on sent user message');
+                if (inputOnlyAttachments) {
+                    logger('Attachment UI did not render before send; skipping user-turn attachment verification.');
+                }
+                else {
+                    const verified = await waitForUserTurnAttachments(Runtime, attachmentNames, 20_000, logger);
+                    if (verified) {
+                        logger('Verified attachments present on sent user message');
+                    }
+                }
             }
+            // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
+            scheduleConversationHint('post-submit', config.timeoutMs ?? 120_000);
+            return { baselineTurns, baselineAssistantText };
         };
+        let baselineTurns = null;
+        let baselineAssistantText = null;
         try {
-            await raceWithDisconnect(submitOnce(promptText, attachments));
+            const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
+            baselineTurns = submission.baselineTurns;
+            baselineAssistantText = submission.baselineAssistantText;
         }
         catch (error) {
             const isPromptTooLarge = error instanceof BrowserAutomationError &&
                 error.details?.code === 'prompt-too-large';
             if (fallbackSubmission && isPromptTooLarge) {
+                // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
                 logger('[browser] Inline prompt too large; retrying with file uploads.');
                 await raceWithDisconnect(clearPromptComposer(Runtime, logger));
                 await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
-                await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+                const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+                baselineTurns = submission.baselineTurns;
+                baselineAssistantText = submission.baselineAssistantText;
             }
             else {
                 throw error;
             }
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
-        const answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger));
+        // Helper to normalize text for echo detection (collapse whitespace, lowercase)
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        const waitForFreshAssistantResponse = async (baselineNormalized, timeoutMs) => {
+            const baselinePrefix = baselineNormalized.length >= 80
+                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+                : '';
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
+                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                if (text) {
+                    const normalized = normalizeForComparison(text);
+                    const isBaseline = normalized === baselineNormalized || (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
+                    if (!isBaseline) {
+                        return {
+                            text,
+                            html: snapshot?.html ?? undefined,
+                            meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+                        };
+                    }
+                }
+                await delay(350);
+            }
+            return null;
+        };
+        let answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
+        // Ensure we store the final conversation URL even if the UI updated late.
+        await updateConversationHint('post-response', 15_000);
+        const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
+        if (baselineNormalized) {
+            const normalizedAnswer = normalizeForComparison(answer.text ?? '');
+            const baselinePrefix = baselineNormalized.length >= 80
+                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+                : '';
+            const isBaseline = normalizedAnswer === baselineNormalized ||
+                (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
+            if (isBaseline) {
+                logger('Detected stale assistant response; waiting for new response...');
+                const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
+                if (refreshed) {
+                    answer = refreshed;
+                }
+            }
+        }
         answerText = answer.text;
         answerHtml = answer.html ?? '';
         const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
@@ -339,39 +473,41 @@ 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();
+        const promptEchoMatcher = buildPromptEchoMatcher(promptText);
         // 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 finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
         const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
-        if (!copiedMarkdown &&
-            finalText &&
-            finalText !== answerMarkdown.trim() &&
-            finalText !== promptText.trim() &&
-            finalText.length >= answerMarkdown.trim().length) {
-            logger('Refreshed assistant response via final DOM snapshot');
-            answerText = finalText;
-            answerMarkdown = finalText;
+        if (finalText && finalText !== promptText.trim()) {
+            const trimmedMarkdown = answerMarkdown.trim();
+            const finalIsEcho = promptEchoMatcher ? promptEchoMatcher.isEcho(finalText) : false;
+            const lengthDelta = finalText.length - trimmedMarkdown.length;
+            const missingCopy = !copiedMarkdown && lengthDelta >= 0;
+            const likelyTruncatedCopy = copiedMarkdown &&
+                trimmedMarkdown.length > 0 &&
+                lengthDelta >= Math.max(12, Math.floor(trimmedMarkdown.length * 0.75));
+            if ((missingCopy || likelyTruncatedCopy) && !finalIsEcho && finalText !== trimmedMarkdown) {
+                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));
+        // Detect prompt echo using normalized comparison (whitespace-insensitive).
+        const alignedEcho = alignPromptEchoPair(answerText, answerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
+            text: 'Aligned assistant response text to copied markdown after prompt echo',
+            markdown: 'Aligned assistant markdown to response text after prompt echo',
+        });
+        answerText = alignedEcho.answerText;
+        answerMarkdown = alignedEcho.answerMarkdown;
+        const isPromptEcho = alignedEcho.isEcho;
         if (isPromptEcho) {
             logger('Detected prompt echo in response; waiting for actual assistant response...');
-            const deadline = Date.now() + 8_000;
+            const deadline = Date.now() + 15_000;
             let bestText = null;
             let stableCount = 0;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).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));
+                const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
                 if (!isStillEcho) {
                     if (!bestText || text.length > bestText.length) {
                         bestText = text;
@@ -392,6 +528,36 @@ export async function runBrowserMode(options) {
                 answerMarkdown = bestText;
             }
         }
+        const minAnswerChars = 16;
+        if (answerText.trim().length > 0 && answerText.trim().length < minAnswerChars) {
+            const deadline = Date.now() + 12_000;
+            let bestText = answerText.trim();
+            let stableCycles = 0;
+            while (Date.now() < deadline) {
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
+                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                if (text && text.length > bestText.length) {
+                    bestText = text;
+                    stableCycles = 0;
+                }
+                else {
+                    stableCycles += 1;
+                }
+                if (stableCycles >= 3 && bestText.length >= minAnswerChars) {
+                    break;
+                }
+                await delay(400);
+            }
+            if (bestText.length > answerText.trim().length) {
+                logger('Refreshed short assistant response from latest DOM snapshot');
+                answerText = bestText;
+                answerMarkdown = bestText;
+            }
+        }
+        if (connectionClosedUnexpectedly) {
+            // Bail out on mid-run disconnects so the session stays reattachable.
+            throw new Error('Chrome disconnected before completion');
+        }
         stopThinkingMonitor?.();
         runStatus = 'complete';
         const durationMs = Date.now() - startedAt;
@@ -462,7 +628,19 @@ export async function runBrowserMode(options) {
                     // ignore kill failures
                 }
             }
-            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+            if (manualLogin) {
+                const shouldCleanup = await shouldCleanupManualLoginProfileState(userDataDir, logger.verbose ? logger : undefined, {
+                    connectionClosedUnexpectedly,
+                    host: chromeHost,
+                });
+                if (shouldCleanup) {
+                    // Preserve the persistent manual-login profile, but clear stale reattach hints.
+                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'never' }).catch(() => undefined);
+                }
+            }
+            else {
+                await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+            }
             if (!connectionClosedUnexpectedly) {
                 const totalSeconds = (Date.now() - startedAt) / 1000;
                 logger(`Cleanup ${runStatus} • ${totalSeconds.toFixed(1)}s total`);
@@ -653,8 +831,9 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         catch {
             // ignore
         }
-        if (config.desiredModel) {
-            await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger), {
+        const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
+        if (config.desiredModel && modelStrategy !== 'ignore') {
+            await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -666,6 +845,9 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
+        else if (modelStrategy === 'ignore') {
+            logger('Model picker: skipped (strategy=ignore)');
+        }
         // Handle thinking time selection if specified
         const thinkingTime = config.thinkingTime;
         if (thinkingTime) {
@@ -680,11 +862,14 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             });
         }
         const submitOnce = async (prompt, submissionAttachments) => {
+            const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+            const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
             const attachmentNames = submissionAttachments.map((a) => path.basename(a.path));
             if (submissionAttachments.length > 0) {
                 if (!DOM) {
                     throw new Error('Chrome DOM domain unavailable while uploading attachments.');
                 }
+                await clearComposerAttachments(Runtime, 5_000, logger);
                 // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
                 for (const attachment of submissionAttachments) {
                     logger(`Uploading attachment: ${attachment.displayPath}`);
@@ -698,10 +883,27 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 await waitForAttachmentCompletion(Runtime, waitBudget, attachmentNames, logger);
                 logger('All attachments uploaded');
             }
-            await submitPrompt({ runtime: Runtime, input: Input, attachmentNames }, prompt, logger);
+            let baselineTurns = await readConversationTurnCount(Runtime, logger);
+            const committedTurns = await submitPrompt({
+                runtime: Runtime,
+                input: Input,
+                attachmentNames,
+                baselineTurns: baselineTurns ?? undefined,
+                inputTimeoutMs: config.inputTimeoutMs ?? undefined,
+            }, prompt, logger);
+            if (typeof committedTurns === 'number' && Number.isFinite(committedTurns)) {
+                if (baselineTurns === null || committedTurns > baselineTurns) {
+                    baselineTurns = Math.max(0, committedTurns - 1);
+                }
+            }
+            return { baselineTurns, baselineAssistantText };
         };
+        let baselineTurns = null;
+        let baselineAssistantText = null;
         try {
-            await submitOnce(promptText, attachments);
+            const submission = await submitOnce(promptText, attachments);
+            baselineTurns = submission.baselineTurns;
+            baselineAssistantText = submission.baselineAssistantText;
         }
         catch (error) {
             const isPromptTooLarge = error instanceof BrowserAutomationError &&
@@ -710,14 +912,57 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 logger('[browser] Inline prompt too large; retrying with file uploads.');
                 await clearPromptComposer(Runtime, logger);
                 await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
-                await submitOnce(options.fallbackSubmission.prompt, options.fallbackSubmission.attachments);
+                const submission = await submitOnce(options.fallbackSubmission.prompt, options.fallbackSubmission.attachments);
+                baselineTurns = submission.baselineTurns;
+                baselineAssistantText = submission.baselineAssistantText;
             }
             else {
                 throw error;
             }
         }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
-        const answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger);
+        // Helper to normalize text for echo detection (collapse whitespace, lowercase)
+        const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+        const waitForFreshAssistantResponse = async (baselineNormalized, timeoutMs) => {
+            const baselinePrefix = baselineNormalized.length >= 80
+                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+                : '';
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
+                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                if (text) {
+                    const normalized = normalizeForComparison(text);
+                    const isBaseline = normalized === baselineNormalized || (baselinePrefix.length > 0 && normalized.startsWith(baselinePrefix));
+                    if (!isBaseline) {
+                        return {
+                            text,
+                            html: snapshot?.html ?? undefined,
+                            meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+                        };
+                    }
+                }
+                await delay(350);
+            }
+            return null;
+        };
+        let answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
+        const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
+        if (baselineNormalized) {
+            const normalizedAnswer = normalizeForComparison(answer.text ?? '');
+            const baselinePrefix = baselineNormalized.length >= 80
+                ? baselineNormalized.slice(0, Math.min(200, baselineNormalized.length))
+                : '';
+            const isBaseline = normalizedAnswer === baselineNormalized ||
+                (baselinePrefix.length > 0 && normalizedAnswer.startsWith(baselinePrefix));
+            if (isBaseline) {
+                logger('Detected stale assistant response; waiting for new response...');
+                const refreshed = await waitForFreshAssistantResponse(baselineNormalized, 15_000);
+                if (refreshed) {
+                    answer = refreshed;
+                }
+            }
+        }
         answerText = answer.text;
         answerHtml = answer.html ?? '';
         const copiedMarkdown = await withRetries(async () => {
@@ -736,10 +981,8 @@ 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 finalSnapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).catch(() => null);
         const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
         if (finalText &&
             finalText !== answerMarkdown.trim() &&
@@ -749,25 +992,24 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             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));
+        // Detect prompt echo using normalized comparison (whitespace-insensitive).
+        const promptEchoMatcher = buildPromptEchoMatcher(promptText);
+        const alignedEcho = alignPromptEchoPair(answerText, answerMarkdown, promptEchoMatcher, copiedMarkdown ? logger : undefined, {
+            text: 'Aligned assistant response text to copied markdown after prompt echo',
+            markdown: 'Aligned assistant markdown to response text after prompt echo',
+        });
+        answerText = alignedEcho.answerText;
+        answerMarkdown = alignedEcho.answerMarkdown;
+        const isPromptEcho = alignedEcho.isEcho;
         if (isPromptEcho) {
             logger('Detected prompt echo in response; waiting for actual assistant response...');
-            const deadline = Date.now() + 8_000;
+            const deadline = Date.now() + 15_000;
             let bestText = null;
             let stableCount = 0;
             while (Date.now() < deadline) {
-                const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+                const snapshot = await readAssistantSnapshot(Runtime, baselineTurns ?? undefined).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));
+                const isStillEcho = !text || Boolean(promptEchoMatcher?.isEcho(text));
                 if (!isStillEcho) {
                     if (!bestText || text.length > bestText.length) {
                         bestText = text;
@@ -867,9 +1109,9 @@ export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
     const statusLabel = message ? ` — ${message}` : '';
     return `${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
 }
-async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger) {
+async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, minTurnIndex) {
     try {
-        return await waitForAssistantResponse(Runtime, timeoutMs, logger);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
     }
     catch (error) {
         if (!shouldReloadAfterAssistantError(error)) {
@@ -882,14 +1124,17 @@ async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logg
         logger('Assistant response stalled; reloading conversation and retrying once');
         await Page.navigate({ url: conversationUrl });
         await delay(1000);
-        return await waitForAssistantResponse(Runtime, timeoutMs, logger);
+        return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
     }
 }
 function shouldReloadAfterAssistantError(error) {
     if (!(error instanceof Error))
         return false;
     const message = error.message.toLowerCase();
-    return message.includes('assistant-response') || message.includes('watchdog') || message.includes('timeout');
+    return (message.includes('assistant-response') ||
+        message.includes('watchdog') ||
+        message.includes('timeout') ||
+        message.includes('capture assistant response'));
 }
 async function readConversationUrl(Runtime) {
     try {
@@ -900,6 +1145,34 @@ async function readConversationUrl(Runtime) {
         return null;
     }
 }
+async function readConversationTurnCount(Runtime, logger) {
+    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const attempts = 4;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            const { result } = await Runtime.evaluate({
+                expression: `document.querySelectorAll(${selectorLiteral}).length`,
+                returnByValue: true,
+            });
+            const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+            if (!Number.isFinite(raw)) {
+                throw new Error('Turn count not numeric');
+            }
+            return Math.max(0, Math.floor(raw));
+        }
+        catch (error) {
+            if (attempt < attempts - 1) {
+                await delay(150);
+                continue;
+            }
+            if (logger?.verbose) {
+                logger(`Failed to read conversation turn count: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return null;
+        }
+    }
+    return null;
+}
 function isConversationUrl(url) {
     return /\/c\/[a-z0-9-]+/i.test(url);
 }